agg::path_base< VertexContainer > Class Template Reference

#include <src/agg/agg_path_storage.h>

Public Types
typedef VertexContainer	container_type
typedef path_base< VertexContainer >	self_type

Public Member Functions
	path_base ()
void	remove_all ()
void	free_all ()
unsigned	start_new_path ()
void	move_to (double x, double y)
void	move_rel (double dx, double dy)
void	line_to (double x, double y)
void	line_rel (double dx, double dy)
void	hline_to (double x)
void	hline_rel (double dx)
void	vline_to (double y)
void	vline_rel (double dy)
void	arc_to (double rx, double ry, double angle, bool large_arc_flag, bool sweep_flag, double x, double y)
void	arc_rel (double rx, double ry, double angle, bool large_arc_flag, bool sweep_flag, double dx, double dy)
void	curve3 (double x_ctrl, double y_ctrl, double x_to, double y_to)
void	curve3_rel (double dx_ctrl, double dy_ctrl, double dx_to, double dy_to)
void	curve3 (double x_to, double y_to)
void	curve3_rel (double dx_to, double dy_to)
void	curve4 (double x_ctrl1, double y_ctrl1, double x_ctrl2, double y_ctrl2, double x_to, double y_to)
void	curve4_rel (double dx_ctrl1, double dy_ctrl1, double dx_ctrl2, double dy_ctrl2, double dx_to, double dy_to)
void	curve4 (double x_ctrl2, double y_ctrl2, double x_to, double y_to)
void	curve4_rel (double x_ctrl2, double y_ctrl2, double x_to, double y_to)
void	end_poly (unsigned flags=path_flags_close)
void	close_polygon (unsigned flags=path_flags_none)
const container_type &	vertices () const
container_type &	vertices ()
unsigned	total_vertices () const
void	rel_to_abs (double *x, double *y) const
unsigned	last_vertex (double *x, double *y) const
unsigned	prev_vertex (double *x, double *y) const
double	last_x () const
double	last_y () const
unsigned	vertex (unsigned idx, double *x, double *y) const
unsigned	command (unsigned idx) const
void	modify_vertex (unsigned idx, double x, double y)
void	modify_vertex (unsigned idx, double x, double y, unsigned cmd)
void	modify_command (unsigned idx, unsigned cmd)
void	rewind (unsigned path_id)
unsigned	vertex (double *x, double *y)
unsigned	arrange_polygon_orientation (unsigned start, path_flags_e orientation)
unsigned	arrange_orientations (unsigned path_id, path_flags_e orientation)
void	arrange_orientations_all_paths (path_flags_e orientation)
void	invert_polygon (unsigned start)
void	flip_x (double x1, double x2)
void	flip_y (double y1, double y2)
template<class VertexSource >
void	concat_path (VertexSource &vs, unsigned path_id=0)
template<class VertexSource >
void	join_path (VertexSource &vs, unsigned path_id=0)
template<class T >
void	concat_poly (const T *data, unsigned num_points, bool closed)
template<class T >
void	join_poly (const T *data, unsigned num_points, bool closed)
void	translate (double dx, double dy, unsigned path_id=0)
void	translate_all_paths (double dx, double dy)
template<class Trans >
void	transform (const Trans &trans, unsigned path_id=0)
template<class Trans >
void	transform_all_paths (const Trans &trans)
unsigned	align_path (unsigned idx=0)
void	align_all_paths ()

Private Member Functions
unsigned	perceive_polygon_orientation (unsigned start, unsigned end)
void	invert_polygon (unsigned start, unsigned end)

Private Attributes
VertexContainer	m_vertices
unsigned	m_iterator

Detailed Description

template<class VertexContainer>
class agg::path_base< VertexContainer >

Member Typedef Documentation

container_type

template<class VertexContainer >

typedef VertexContainer agg::path_base< VertexContainer >::container_type

self_type

template<class VertexContainer >

typedef path_base<VertexContainer> agg::path_base< VertexContainer >::self_type

Constructor & Destructor Documentation

path_base()

template<class VertexContainer >

agg::path_base< VertexContainer >::path_base ( )

inline

: m_vertices(), m_iterator(0) {}

Member Function Documentation

align_all_paths()

template<class VertexContainer >

void agg::path_base< VertexContainer >::align_all_paths ( )

inline

        {
            for (unsigned i = 0; i < total_vertices(); i = align_path(i));
        }

References agg::path_base< VertexContainer >::align_path(), and agg::path_base< VertexContainer >::total_vertices().

Here is the call graph for this function:

align_path()

template<class VertexContainer >

unsigned agg::path_base< VertexContainer >::align_path ( unsigned  idx = 0 )

inline

        {
            if (idx >= total_vertices() || !is_move_to(command(idx))) 
            {
                return total_vertices();
            }
 
            double start_x, start_y;
            for (; idx < total_vertices() && is_move_to(command(idx)); ++idx)
            {
                vertex(idx, &start_x, &start_y);
            }
            while (idx < total_vertices() && is_drawing(command(idx)))
                ++idx;
 
            double x, y;
            if (is_drawing(vertex(idx - 1, &x, &y)) &&
                is_equal_eps(x, start_x, 1e-8) &&
                is_equal_eps(y, start_y, 1e-8))
            {
                modify_vertex(idx - 1, start_x, start_y);
            }
 
            while (idx < total_vertices() && !is_move_to(command(idx)))
                ++idx;
            return idx;
        }

References agg::is_drawing(), agg::is_equal_eps(), agg::is_move_to(), agg::path_base< VertexContainer >::modify_vertex(), agg::path_base< VertexContainer >::total_vertices(), and agg::path_base< VertexContainer >::vertex().

Referenced by agg::path_base< VertexContainer >::align_all_paths().

Here is the call graph for this function:

Here is the caller graph for this function:

arc_rel()

template<class VC >

void agg::path_base< VC >::arc_rel	(	double	rx,
		double	ry,
		double	angle,
		bool	large_arc_flag,
		bool	sweep_flag,
		double	dx,
		double	dy
	)

    {
        rel_to_abs(&dx, &dy);
        arc_to(rx, ry, angle, large_arc_flag, sweep_flag, dx, dy);
    }

arc_to()

template<class VC >

void agg::path_base< VC >::arc_to	(	double	rx,
		double	ry,
		double	angle,
		bool	large_arc_flag,
		bool	sweep_flag,
		double	x,
		double	y
	)

    {
        if(m_vertices.total_vertices() && is_vertex(m_vertices.last_command()))
        {
            const double epsilon = 1e-30;
            double x0 = 0.0;
            double y0 = 0.0;
            m_vertices.last_vertex(&x0, &y0);
 
            rx = fabs(rx);
            ry = fabs(ry);
 
            // Ensure radii are valid
            //-------------------------
            if(rx < epsilon || ry < epsilon) 
            {
                line_to(x, y);
                return;
            }
 
            if(calc_distance(x0, y0, x, y) < epsilon)
            {
                // If the endpoints (x, y) and (x0, y0) are identical, then this
                // is equivalent to omitting the elliptical arc segment entirely.
                return;
            }
            bezier_arc_svg a(x0, y0, rx, ry, angle, large_arc_flag, sweep_flag, x, y);
            if(a.radii_ok())
            {
                join_path(a);
            }
            else
            {
                line_to(x, y);
            }
        }
        else
        {
            move_to(x, y);
        }
    }

References agg::calc_distance(), and agg::is_vertex().

Here is the call graph for this function:

arrange_orientations()

template<class VC >

unsigned agg::path_base< VC >::arrange_orientations	(	unsigned	path_id,
		path_flags_e	orientation
	)

    {
        if(orientation != path_flags_none)
        {
            while(start < m_vertices.total_vertices())
            {
                start = arrange_polygon_orientation(start, orientation);
                if(is_stop(m_vertices.command(start)))
                {
                    ++start;
                    break;
                }
            }
        }
        return start;
    }

References agg::is_stop(), and agg::path_flags_none.

Here is the call graph for this function:

arrange_orientations_all_paths()

template<class VC >

void agg::path_base< VC >::arrange_orientations_all_paths

(

path_flags_e

orientation

)

    {
        if(orientation != path_flags_none)
        {
            unsigned start = 0;
            while(start < m_vertices.total_vertices())
            {
                start = arrange_orientations(start, orientation);
            }
        }
    }

References agg::path_flags_none.

arrange_polygon_orientation()

template<class VC >

unsigned agg::path_base< VC >::arrange_polygon_orientation	(	unsigned	start,
		path_flags_e	orientation
	)

    {
        if(orientation == path_flags_none) return start;
        
        // Skip all non-vertices at the beginning
        while(start < m_vertices.total_vertices() && 
              !is_vertex(m_vertices.command(start))) ++start;
 
        // Skip all insignificant move_to
        while(start+1 < m_vertices.total_vertices() && 
              is_move_to(m_vertices.command(start)) &&
              is_move_to(m_vertices.command(start+1))) ++start;
 
        // Find the last vertex
        unsigned end = start + 1;
        while(end < m_vertices.total_vertices() && 
              !is_next_poly(m_vertices.command(end))) ++end;
 
        if(end - start > 2)
        {
            if(perceive_polygon_orientation(start, end) != unsigned(orientation))
            {
                // Invert polygon, set orientation flag, and skip all end_poly
                invert_polygon(start, end);
                unsigned cmd;
                while(end < m_vertices.total_vertices() && 
                      is_end_poly(cmd = m_vertices.command(end)))
                {
                    m_vertices.modify_command(end++, set_orientation(cmd, orientation));
                }
            }
        }
        return end;
    }

References cmd, agg::is_end_poly(), agg::is_move_to(), agg::is_next_poly(), agg::is_vertex(), agg::path_flags_none, and agg::set_orientation().

Here is the call graph for this function:

close_polygon()

template<class VC >

void agg::path_base< VC >::close_polygon ( unsigned  flags = path_flags_none )

inline

    {
        end_poly(path_flags_close | flags);
    }

References agg::path_flags_close.

command()

template<class VC >

unsigned agg::path_base< VC >::command ( unsigned  idx ) const

inline

    {
        return m_vertices.command(idx);
    }

concat_path()

template<class VertexContainer >

template<class VertexSource >

void agg::path_base< VertexContainer >::concat_path ( VertexSource &  vs, unsigned  path_id = 0  )

inline

        {
            double x, y;
            unsigned cmd;
            vs.rewind(path_id);
            while(!is_stop(cmd = vs.vertex(&x, &y)))
            {
                m_vertices.add_vertex(x, y, cmd);
            }
        }

References cmd, agg::is_stop(), and agg::path_base< VertexContainer >::m_vertices.

Referenced by agg::path_base< VertexContainer >::concat_poly().

Here is the call graph for this function:

Here is the caller graph for this function:

concat_poly()

template<class VertexContainer >

template<class T >

void agg::path_base< VertexContainer >::concat_poly ( const T *  data, unsigned  num_points, bool  closed  )

inline

        {
            poly_plain_adaptor<T> poly(data, num_points, closed);
            concat_path(poly);
        }

References agg::path_base< VertexContainer >::concat_path().

Here is the call graph for this function:

curve3() [1/2]

template<class VC >

void agg::path_base< VC >::curve3	(	double	x_ctrl,
		double	y_ctrl,
		double	x_to,
		double	y_to
	)

    {
        m_vertices.add_vertex(x_ctrl, y_ctrl, path_cmd_curve3);
        m_vertices.add_vertex(x_to,   y_to,   path_cmd_curve3);
    }

References agg::path_cmd_curve3.

curve3() [2/2]

template<class VC >

void agg::path_base< VC >::curve3	(	double	x_to,
		double	y_to
	)

    {
        double x0;
        double y0;
        if(is_vertex(m_vertices.last_vertex(&x0, &y0)))
        {
            double x_ctrl;
            double y_ctrl; 
            unsigned cmd = m_vertices.prev_vertex(&x_ctrl, &y_ctrl);
            if(is_curve(cmd))
            {
                x_ctrl = x0 + x0 - x_ctrl;
                y_ctrl = y0 + y0 - y_ctrl;
            }
            else
            {
                x_ctrl = x0;
                y_ctrl = y0;
            }
            curve3(x_ctrl, y_ctrl, x_to, y_to);
        }
    }

References cmd, agg::is_curve(), and agg::is_vertex().

Here is the call graph for this function:

curve3_rel() [1/2]

template<class VC >

void agg::path_base< VC >::curve3_rel	(	double	dx_ctrl,
		double	dy_ctrl,
		double	dx_to,
		double	dy_to
	)

    {
        rel_to_abs(&dx_ctrl, &dy_ctrl);
        rel_to_abs(&dx_to,   &dy_to);
        m_vertices.add_vertex(dx_ctrl, dy_ctrl, path_cmd_curve3);
        m_vertices.add_vertex(dx_to,   dy_to,   path_cmd_curve3);
    }

References agg::path_cmd_curve3.

curve3_rel() [2/2]

template<class VC >

void agg::path_base< VC >::curve3_rel	(	double	dx_to,
		double	dy_to
	)

    {
        rel_to_abs(&dx_to, &dy_to);
        curve3(dx_to, dy_to);
    }

curve4() [1/2]

template<class VC >

void agg::path_base< VC >::curve4	(	double	x_ctrl1,
		double	y_ctrl1,
		double	x_ctrl2,
		double	y_ctrl2,
		double	x_to,
		double	y_to
	)

    {
        m_vertices.add_vertex(x_ctrl1, y_ctrl1, path_cmd_curve4);
        m_vertices.add_vertex(x_ctrl2, y_ctrl2, path_cmd_curve4);
        m_vertices.add_vertex(x_to,    y_to,    path_cmd_curve4);
    }

References agg::path_cmd_curve4.

curve4() [2/2]

template<class VC >

void agg::path_base< VC >::curve4	(	double	x_ctrl2,
		double	y_ctrl2,
		double	x_to,
		double	y_to
	)

    {
        double x0;
        double y0;
        if(is_vertex(last_vertex(&x0, &y0)))
        {
            double x_ctrl1;
            double y_ctrl1; 
            unsigned cmd = prev_vertex(&x_ctrl1, &y_ctrl1);
            if(is_curve(cmd))
            {
                x_ctrl1 = x0 + x0 - x_ctrl1;
                y_ctrl1 = y0 + y0 - y_ctrl1;
            }
            else
            {
                x_ctrl1 = x0;
                y_ctrl1 = y0;
            }
            curve4(x_ctrl1, y_ctrl1, x_ctrl2, y_ctrl2, x_to, y_to);
        }
    }

References cmd, agg::is_curve(), and agg::is_vertex().

Here is the call graph for this function:

curve4_rel() [1/2]

template<class VC >

void agg::path_base< VC >::curve4_rel	(	double	dx_ctrl1,
		double	dy_ctrl1,
		double	dx_ctrl2,
		double	dy_ctrl2,
		double	dx_to,
		double	dy_to
	)

    {
        rel_to_abs(&dx_ctrl1, &dy_ctrl1);
        rel_to_abs(&dx_ctrl2, &dy_ctrl2);
        rel_to_abs(&dx_to,    &dy_to);
        m_vertices.add_vertex(dx_ctrl1, dy_ctrl1, path_cmd_curve4);
        m_vertices.add_vertex(dx_ctrl2, dy_ctrl2, path_cmd_curve4);
        m_vertices.add_vertex(dx_to,    dy_to,    path_cmd_curve4);
    }

References agg::path_cmd_curve4.

curve4_rel() [2/2]

template<class VC >

void agg::path_base< VC >::curve4_rel	(	double	x_ctrl2,
		double	y_ctrl2,
		double	x_to,
		double	y_to
	)

    {
        rel_to_abs(&dx_ctrl2, &dy_ctrl2);
        rel_to_abs(&dx_to,    &dy_to);
        curve4(dx_ctrl2, dy_ctrl2, dx_to, dy_to);
    }

end_poly()

template<class VC >

void agg::path_base< VC >::end_poly ( unsigned  flags = path_flags_close )

inline

    {
        if(is_vertex(m_vertices.last_command()))
        {
            m_vertices.add_vertex(0.0, 0.0, path_cmd_end_poly | flags);
        }
    }

References agg::is_vertex(), and agg::path_cmd_end_poly.

Here is the call graph for this function:

flip_x()

template<class VC >

void agg::path_base< VC >::flip_x	(	double	x1,
		double	x2
	)

    {
        unsigned i;
        double x, y;
        for(i = 0; i < m_vertices.total_vertices(); i++)
        {
            unsigned cmd = m_vertices.vertex(i, &x, &y);
            if(is_vertex(cmd))
            {
                m_vertices.modify_vertex(i, x2 - x + x1, y);
            }
        }
    }

References cmd, and agg::is_vertex().

Referenced by Slic3r::sla::AGGRaster< PixelRenderer, Renderer, Rasterizer, Scanline >::flipx().

Here is the call graph for this function:

Here is the caller graph for this function:

flip_y()

template<class VC >

void agg::path_base< VC >::flip_y	(	double	y1,
		double	y2
	)

    {
        unsigned i;
        double x, y;
        for(i = 0; i < m_vertices.total_vertices(); i++)
        {
            unsigned cmd = m_vertices.vertex(i, &x, &y);
            if(is_vertex(cmd))
            {
                m_vertices.modify_vertex(i, x, y2 - y + y1);
            }
        }
    }

References cmd, and agg::is_vertex().

Referenced by Slic3r::sla::AGGRaster< PixelRenderer, Renderer, Rasterizer, Scanline >::flipy().

Here is the call graph for this function:

Here is the caller graph for this function:

free_all()

template<class VertexContainer >

void agg::path_base< VertexContainer >::free_all ( )

inline

{ m_vertices.free_all();   m_iterator = 0; }

References agg::path_base< VertexContainer >::m_iterator, and agg::path_base< VertexContainer >::m_vertices.

hline_rel()

template<class VC >

void agg::path_base< VC >::hline_rel ( double  dx )

inline

    {
        double dy = 0;
        rel_to_abs(&dx, &dy);
        m_vertices.add_vertex(dx, dy, path_cmd_line_to);
    }

References agg::path_cmd_line_to.

hline_to()

template<class VC >

void agg::path_base< VC >::hline_to ( double  x )

inline

    {
        m_vertices.add_vertex(x, last_y(), path_cmd_line_to);
    }

References agg::path_cmd_line_to.

invert_polygon() [1/2]

template<class VC >

void agg::path_base< VC >::invert_polygon

(

unsigned

start

)

    {
        // Skip all non-vertices at the beginning
        while(start < m_vertices.total_vertices() && 
              !is_vertex(m_vertices.command(start))) ++start;
 
        // Skip all insignificant move_to
        while(start+1 < m_vertices.total_vertices() && 
              is_move_to(m_vertices.command(start)) &&
              is_move_to(m_vertices.command(start+1))) ++start;
 
        // Find the last vertex
        unsigned end = start + 1;
        while(end < m_vertices.total_vertices() && 
              !is_next_poly(m_vertices.command(end))) ++end;
 
        invert_polygon(start, end);
    }

References agg::is_move_to(), agg::is_next_poly(), and agg::is_vertex().

Here is the call graph for this function:

invert_polygon() [2/2]

template<class VC >

void agg::path_base< VC >::invert_polygon ( unsigned  start, unsigned  end  )

private

    {
        unsigned i;
        unsigned tmp_cmd = m_vertices.command(start);
        
        --end; // Make "end" inclusive
 
        // Shift all commands to one position
        for(i = start; i < end; i++)
        {
            m_vertices.modify_command(i, m_vertices.command(i + 1));
        }
 
        // Assign starting command to the ending command
        m_vertices.modify_command(end, tmp_cmd);
 
        // Reverse the polygon
        while(end > start)
        {
            m_vertices.swap_vertices(start++, end--);
        }
    }

join_path()

template<class VertexContainer >

template<class VertexSource >

void agg::path_base< VertexContainer >::join_path ( VertexSource &  vs, unsigned  path_id = 0  )

inline

        {
            double x, y;
            unsigned cmd;
            vs.rewind(path_id);
            cmd = vs.vertex(&x, &y);
            if(!is_stop(cmd))
            {
                if(is_vertex(cmd))
                {
                    double x0, y0;
                    unsigned cmd0 = last_vertex(&x0, &y0);
                    if(is_vertex(cmd0))
                    {
                        if(calc_distance(x, y, x0, y0) > vertex_dist_epsilon)
                        {
                            if(is_move_to(cmd)) cmd = path_cmd_line_to;
                            m_vertices.add_vertex(x, y, cmd);
                        }
                    }
                    else
                    {
                        if(is_stop(cmd0))
                        {
                            cmd = path_cmd_move_to;
                        }
                        else
                        {
                            if(is_move_to(cmd)) cmd = path_cmd_line_to;
                        }
                        m_vertices.add_vertex(x, y, cmd);
                    }
                }
                while(!is_stop(cmd = vs.vertex(&x, &y)))
                {
                    m_vertices.add_vertex(x, y, is_move_to(cmd) ? 
                                                    unsigned(path_cmd_line_to) : 
                                                    cmd);
                }
            }
        }

References agg::calc_distance(), cmd, agg::is_move_to(), agg::is_stop(), agg::is_vertex(), agg::path_base< VertexContainer >::last_vertex(), agg::path_base< VertexContainer >::m_vertices, agg::path_cmd_line_to, agg::path_cmd_move_to, and agg::vertex_dist_epsilon.

Referenced by agg::path_base< VertexContainer >::join_poly().

Here is the call graph for this function:

Here is the caller graph for this function:

join_poly()

template<class VertexContainer >

template<class T >

void agg::path_base< VertexContainer >::join_poly ( const T *  data, unsigned  num_points, bool  closed  )

inline

        {
            poly_plain_adaptor<T> poly(data, num_points, closed);
            join_path(poly);
        }

References agg::path_base< VertexContainer >::join_path().

Here is the call graph for this function:

last_vertex()

template<class VC >

unsigned agg::path_base< VC >::last_vertex ( double *  x, double *  y  ) const

inline

    {
        return m_vertices.last_vertex(x, y);
    }

Referenced by agg::path_base< VertexContainer >::join_path().

Here is the caller graph for this function:

last_x()

template<class VC >

double agg::path_base< VC >::last_x

inline

    {
        return m_vertices.last_x();
    }

last_y()

template<class VC >

double agg::path_base< VC >::last_y

inline

    {
        return m_vertices.last_y();
    }

line_rel()

template<class VC >

void agg::path_base< VC >::line_rel ( double  dx, double  dy  )

inline

    {
        rel_to_abs(&dx, &dy);
        m_vertices.add_vertex(dx, dy, path_cmd_line_to);
    }

References agg::path_cmd_line_to.

line_to()

template<class VC >

void agg::path_base< VC >::line_to ( double  x, double  y  )

inline

    {
        m_vertices.add_vertex(x, y, path_cmd_line_to);
    }

References agg::path_cmd_line_to.

Referenced by Slic3r::sla::AGGRaster< PixelRenderer, Renderer, Rasterizer, Scanline >::_to_path(), Slic3r::sla::AGGRaster< PixelRenderer, Renderer, Rasterizer, Scanline >::_to_path_flpxy(), and Slic3r::rasterize_polygons().

Here is the caller graph for this function:

modify_command()

template<class VC >

void agg::path_base< VC >::modify_command	(	unsigned	idx,
		unsigned	cmd
	)

    {
        m_vertices.modify_command(idx, cmd);
    }

References cmd.

modify_vertex() [1/2]

template<class VC >

void agg::path_base< VC >::modify_vertex	(	unsigned	idx,
		double	x,
		double	y
	)

    {
        m_vertices.modify_vertex(idx, x, y);
    }

Referenced by agg::path_base< VertexContainer >::align_path().

Here is the caller graph for this function:

modify_vertex() [2/2]

template<class VC >

void agg::path_base< VC >::modify_vertex	(	unsigned	idx,
		double	x,
		double	y,
		unsigned	cmd
	)

    {
        m_vertices.modify_vertex(idx, x, y, cmd);
    }

References cmd.

move_rel()

template<class VC >

void agg::path_base< VC >::move_rel ( double  dx, double  dy  )

inline

    {
        rel_to_abs(&dx, &dy);
        m_vertices.add_vertex(dx, dy, path_cmd_move_to);
    }

References agg::path_cmd_move_to.

move_to()

template<class VC >

void agg::path_base< VC >::move_to ( double  x, double  y  )

inline

    {
        m_vertices.add_vertex(x, y, path_cmd_move_to);
    }

References agg::path_cmd_move_to.

Referenced by Slic3r::sla::AGGRaster< PixelRenderer, Renderer, Rasterizer, Scanline >::_to_path(), Slic3r::sla::AGGRaster< PixelRenderer, Renderer, Rasterizer, Scanline >::_to_path_flpxy(), and Slic3r::rasterize_polygons().

Here is the caller graph for this function:

perceive_polygon_orientation()

template<class VC >

unsigned agg::path_base< VC >::perceive_polygon_orientation ( unsigned  start, unsigned  end  )

private

    {
        // Calculate signed area (double area to be exact)
        //---------------------
        unsigned np = end - start;
        double area = 0.0;
        unsigned i;
        for(i = 0; i < np; i++)
        {
            double x1, y1, x2, y2;
            m_vertices.vertex(start + i,            &x1, &y1);
            m_vertices.vertex(start + (i + 1) % np, &x2, &y2);
            area += x1 * y2 - y1 * x2;
        }
        return (area < 0.0) ? path_flags_cw : path_flags_ccw;
    }

References agg::path_flags_ccw, and agg::path_flags_cw.

prev_vertex()

template<class VC >

unsigned agg::path_base< VC >::prev_vertex ( double *  x, double *  y  ) const

inline

    {
        return m_vertices.prev_vertex(x, y);
    }

rel_to_abs()

template<class VC >

void agg::path_base< VC >::rel_to_abs ( double *  x, double *  y  ) const

inline

    {
        if(m_vertices.total_vertices())
        {
            double x2;
            double y2;
            if(is_vertex(m_vertices.last_vertex(&x2, &y2)))
            {
                *x += x2;
                *y += y2;
            }
        }
    }

References agg::is_vertex().

Here is the call graph for this function:

remove_all()

template<class VertexContainer >

void agg::path_base< VertexContainer >::remove_all ( )

inline

{ m_vertices.remove_all(); m_iterator = 0; }

References agg::path_base< VertexContainer >::m_iterator, and agg::path_base< VertexContainer >::m_vertices.

rewind()

template<class VC >

void agg::path_base< VC >::rewind ( unsigned  path_id )

inline

    {
        m_iterator = path_id;
    }

start_new_path()

template<class VC >

unsigned agg::path_base< VC >::start_new_path

    {
        if(!is_stop(m_vertices.last_command()))
        {
            m_vertices.add_vertex(0.0, 0.0, path_cmd_stop);
        }
        return m_vertices.total_vertices();
    }

References agg::is_stop(), and agg::path_cmd_stop.

Here is the call graph for this function:

total_vertices()

template<class VC >

unsigned agg::path_base< VC >::total_vertices

inline

    {
        return m_vertices.total_vertices();
    }

Referenced by agg::path_base< VertexContainer >::align_all_paths(), and agg::path_base< VertexContainer >::align_path().

Here is the caller graph for this function:

transform()

template<class VertexContainer >

template<class Trans >

void agg::path_base< VertexContainer >::transform ( const Trans &  trans, unsigned  path_id = 0  )

inline

        {
            unsigned num_ver = m_vertices.total_vertices();
            for(; path_id < num_ver; path_id++)
            {
                double x, y;
                unsigned cmd = m_vertices.vertex(path_id, &x, &y);
                if(is_stop(cmd)) break;
                if(is_vertex(cmd))
                {
                    trans.transform(&x, &y);
                    m_vertices.modify_vertex(path_id, x, y);
                }
            }
        }

References cmd, agg::is_stop(), agg::is_vertex(), and agg::path_base< VertexContainer >::m_vertices.

Here is the call graph for this function:

transform_all_paths()

template<class VertexContainer >

template<class Trans >

void agg::path_base< VertexContainer >::transform_all_paths ( const Trans &  trans )

inline

        {
            unsigned idx;
            unsigned num_ver = m_vertices.total_vertices();
            for(idx = 0; idx < num_ver; idx++)
            {
                double x, y;
                if(is_vertex(m_vertices.vertex(idx, &x, &y)))
                {
                    trans.transform(&x, &y);
                    m_vertices.modify_vertex(idx, x, y);
                }
            }
        }

References agg::is_vertex(), and agg::path_base< VertexContainer >::m_vertices.

Here is the call graph for this function:

translate()

template<class VC >

void agg::path_base< VC >::translate	(	double	dx,
		double	dy,
		unsigned	path_id = 0
	)

    {
        unsigned num_ver = m_vertices.total_vertices();
        for(; path_id < num_ver; path_id++)
        {
            double x, y;
            unsigned cmd = m_vertices.vertex(path_id, &x, &y);
            if(is_stop(cmd)) break;
            if(is_vertex(cmd))
            {
                x += dx;
                y += dy;
                m_vertices.modify_vertex(path_id, x, y);
            }
        }
    }

References cmd, agg::is_stop(), and agg::is_vertex().

Here is the call graph for this function:

translate_all_paths()

template<class VC >

void agg::path_base< VC >::translate_all_paths	(	double	dx,
		double	dy
	)

    {
        unsigned idx;
        unsigned num_ver = m_vertices.total_vertices();
        for(idx = 0; idx < num_ver; idx++)
        {
            double x, y;
            if(is_vertex(m_vertices.vertex(idx, &x, &y)))
            {
                x += dx;
                y += dy;
                m_vertices.modify_vertex(idx, x, y);
            }
        }
    }

References agg::is_vertex().

Here is the call graph for this function:

vertex() [1/2]

template<class VC >

unsigned agg::path_base< VC >::vertex ( double *  x, double *  y  )

inline

    {
        if(m_iterator >= m_vertices.total_vertices()) return path_cmd_stop;
        return m_vertices.vertex(m_iterator++, x, y);
    }

References agg::path_cmd_stop.

vertex() [2/2]

template<class VC >

unsigned agg::path_base< VC >::vertex ( unsigned  idx, double *  x, double *  y  ) const

inline

    {
        return m_vertices.vertex(idx, x, y);
    }

Referenced by agg::path_base< VertexContainer >::align_path().

Here is the caller graph for this function:

vertices() [1/2]

template<class VertexContainer >

container_type & agg::path_base< VertexContainer >::vertices ( )

inline

{ return m_vertices; } 

References agg::path_base< VertexContainer >::m_vertices.

vertices() [2/2]

template<class VertexContainer >

const container_type & agg::path_base< VertexContainer >::vertices ( ) const

inline

{ return m_vertices; } 

References agg::path_base< VertexContainer >::m_vertices.

vline_rel()

template<class VC >

void agg::path_base< VC >::vline_rel ( double  dy )

inline

    {
        double dx = 0;
        rel_to_abs(&dx, &dy);
        m_vertices.add_vertex(dx, dy, path_cmd_line_to);
    }

References agg::path_cmd_line_to.

vline_to()

template<class VC >

void agg::path_base< VC >::vline_to ( double  y )

inline

    {
        m_vertices.add_vertex(last_x(), y, path_cmd_line_to);
    }

References agg::path_cmd_line_to.

Member Data Documentation

m_iterator

template<class VertexContainer >

unsigned agg::path_base< VertexContainer >::m_iterator

private

Referenced by agg::path_base< VertexContainer >::free_all(), and agg::path_base< VertexContainer >::remove_all().

m_vertices

template<class VertexContainer >

VertexContainer agg::path_base< VertexContainer >::m_vertices

private

Referenced by agg::path_base< VertexContainer >::concat_path(), agg::path_base< VertexContainer >::free_all(), agg::path_base< VertexContainer >::join_path(), agg::path_base< VertexContainer >::remove_all(), agg::path_base< VertexContainer >::transform(), agg::path_base< VertexContainer >::transform_all_paths(), agg::path_base< VertexContainer >::vertices(), and agg::path_base< VertexContainer >::vertices().

---

The documentation for this class was generated from the following file:

• src/agg/agg_path_storage.h