agg::rasterizer_scanline_aa_nogamma< Clip > Class Template Reference

#include <src/agg/agg_rasterizer_scanline_aa_nogamma.h>

Collaboration diagram for agg::rasterizer_scanline_aa_nogamma< Clip >:

Public Types
enum	aa_scale_e {   aa_shift = 8 , aa_scale = 1 << aa_shift , aa_mask = aa_scale - 1 , aa_scale2 = aa_scale * 2 ,   aa_mask2 = aa_scale2 - 1 }
typedef Clip	clip_type
typedef Clip::conv_type	conv_type
typedef Clip::coord_type	coord_type

Public Member Functions
	rasterizer_scanline_aa_nogamma ()
void	reset ()
void	reset_clipping ()
void	clip_box (double x1, double y1, double x2, double y2)
void	filling_rule (filling_rule_e filling_rule)
void	auto_close (bool flag)
unsigned	apply_gamma (unsigned cover) const
void	move_to (int x, int y)
void	line_to (int x, int y)
void	move_to_d (double x, double y)
void	line_to_d (double x, double y)
void	close_polygon ()
void	add_vertex (double x, double y, unsigned cmd)
void	edge (int x1, int y1, int x2, int y2)
void	edge_d (double x1, double y1, double x2, double y2)
template<class VertexSource >
void	add_path (VertexSource &vs, unsigned path_id=0)
int	min_x () const
int	min_y () const
int	max_x () const
int	max_y () const
void	sort ()
bool	rewind_scanlines ()
bool	navigate_scanline (int y)
AGG_INLINE unsigned	calculate_alpha (int area) const
template<class Scanline >
bool	sweep_scanline (Scanline &sl)
bool	hit_test (int tx, int ty)

Private Types
enum	status { status_initial , status_move_to , status_line_to , status_closed }

Private Member Functions
	rasterizer_scanline_aa_nogamma (const rasterizer_scanline_aa_nogamma< Clip > &)
const rasterizer_scanline_aa_nogamma< Clip > &	operator= (const rasterizer_scanline_aa_nogamma< Clip > &)

Private Attributes
rasterizer_cells_aa< cell_aa >	m_outline
clip_type	m_clipper
filling_rule_e	m_filling_rule
bool	m_auto_close
coord_type	m_start_x
coord_type	m_start_y
unsigned	m_status
int	m_scan_y

Detailed Description

template<class Clip = rasterizer_sl_clip_int>
class agg::rasterizer_scanline_aa_nogamma< Clip >

Member Typedef Documentation

clip_type

template<class Clip = rasterizer_sl_clip_int>

typedef Clip agg::rasterizer_scanline_aa_nogamma< Clip >::clip_type

conv_type

template<class Clip = rasterizer_sl_clip_int>

typedef Clip::conv_type agg::rasterizer_scanline_aa_nogamma< Clip >::conv_type

coord_type

template<class Clip = rasterizer_sl_clip_int>

typedef Clip::coord_type agg::rasterizer_scanline_aa_nogamma< Clip >::coord_type

Member Enumeration Documentation

aa_scale_e

template<class Clip = rasterizer_sl_clip_int>

enum agg::rasterizer_scanline_aa_nogamma::aa_scale_e

Enumerator
aa_shift
aa_scale
aa_mask
aa_scale2
aa_mask2

        {
            aa_shift  = 8,
            aa_scale  = 1 << aa_shift,
            aa_mask   = aa_scale - 1,
            aa_scale2 = aa_scale * 2,
            aa_mask2  = aa_scale2 - 1
        };

status

template<class Clip = rasterizer_sl_clip_int>

enum agg::rasterizer_scanline_aa_nogamma::status

private

Enumerator
status_initial
status_move_to
status_line_to
status_closed

        {
            status_initial,
            status_move_to,
            status_line_to,
            status_closed
        };

Constructor & Destructor Documentation

rasterizer_scanline_aa_nogamma() [1/2]

template<class Clip = rasterizer_sl_clip_int>

agg::rasterizer_scanline_aa_nogamma< Clip >::rasterizer_scanline_aa_nogamma ( )

inline

                                         : 
            m_outline(),
            m_clipper(),
            m_filling_rule(fill_non_zero),
            m_auto_close(true),
            m_start_x(0),
            m_start_y(0),
            m_status(status_initial)
        {
        }

rasterizer_scanline_aa_nogamma() [2/2]

template<class Clip = rasterizer_sl_clip_int>

agg::rasterizer_scanline_aa_nogamma< Clip >::rasterizer_scanline_aa_nogamma ( const rasterizer_scanline_aa_nogamma< Clip > &  )

private

Member Function Documentation

add_path()

template<class Clip = rasterizer_sl_clip_int>

template<class VertexSource >

void agg::rasterizer_scanline_aa_nogamma< Clip >::add_path ( VertexSource &  vs, unsigned  path_id = 0  )

inline

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

References agg::rasterizer_scanline_aa_nogamma< Clip >::add_vertex(), cmd, agg::is_stop(), agg::rasterizer_scanline_aa_nogamma< Clip >::m_outline, and agg::rasterizer_scanline_aa_nogamma< Clip >::reset().

Here is the call graph for this function:

add_vertex()

template<class Clip >

void agg::rasterizer_scanline_aa_nogamma< Clip >::add_vertex	(	double	x,
		double	y,
		unsigned	cmd
	)

    {
        if(is_move_to(cmd)) 
        {
            move_to_d(x, y);
        }
        else 
        if(is_vertex(cmd))
        {
            line_to_d(x, y);
        }
        else
        if(is_close(cmd))
        {
            close_polygon();
        }
    }

References cmd, agg::is_close(), agg::is_move_to(), and agg::is_vertex().

Referenced by agg::rasterizer_scanline_aa_nogamma< Clip >::add_path().

Here is the call graph for this function:

Here is the caller graph for this function:

apply_gamma()

template<class Clip = rasterizer_sl_clip_int>

unsigned agg::rasterizer_scanline_aa_nogamma< Clip >::apply_gamma ( unsigned  cover ) const

inline

        { 
            return cover;
        }

auto_close()

template<class Clip = rasterizer_sl_clip_int>

void agg::rasterizer_scanline_aa_nogamma< Clip >::auto_close ( bool  flag )

inline

{ m_auto_close = flag; }

References agg::rasterizer_scanline_aa_nogamma< Clip >::m_auto_close.

calculate_alpha()

template<class Clip = rasterizer_sl_clip_int>

AGG_INLINE unsigned agg::rasterizer_scanline_aa_nogamma< Clip >::calculate_alpha ( int  area ) const

inline

        {
            int cover = area >> (poly_subpixel_shift*2 + 1 - aa_shift);
 
            if(cover < 0) cover = -cover;
            if(m_filling_rule == fill_even_odd)
            {
                cover &= aa_mask2;
                if(cover > aa_scale)
                {
                    cover = aa_scale2 - cover;
                }
            }
            if(cover > aa_mask) cover = aa_mask;
            return cover;
        }

References agg::rasterizer_scanline_aa_nogamma< Clip >::aa_mask, agg::rasterizer_scanline_aa_nogamma< Clip >::aa_mask2, agg::rasterizer_scanline_aa_nogamma< Clip >::aa_scale, agg::rasterizer_scanline_aa_nogamma< Clip >::aa_scale2, agg::rasterizer_scanline_aa_nogamma< Clip >::aa_shift, agg::fill_even_odd, agg::rasterizer_scanline_aa_nogamma< Clip >::m_filling_rule, and agg::poly_subpixel_shift.

Referenced by agg::rasterizer_scanline_aa_nogamma< Clip >::sweep_scanline().

Here is the caller graph for this function:

clip_box()

template<class Clip >

void agg::rasterizer_scanline_aa_nogamma< Clip >::clip_box	(	double	x1,
		double	y1,
		double	x2,
		double	y2
	)

    {
        reset();
        m_clipper.clip_box(conv_type::upscale(x1), conv_type::upscale(y1), 
                           conv_type::upscale(x2), conv_type::upscale(y2));
    }

close_polygon()

template<class Clip >

void agg::rasterizer_scanline_aa_nogamma< Clip >::close_polygon

    {
        if(m_status == status_line_to)
        {
            m_clipper.line_to(m_outline, m_start_x, m_start_y);
            m_status = status_closed;
        }
    }

edge()

template<class Clip >

void agg::rasterizer_scanline_aa_nogamma< Clip >::edge	(	int	x1,
		int	y1,
		int	x2,
		int	y2
	)

    {
        if(m_outline.sorted()) reset();
        m_clipper.move_to(conv_type::downscale(x1), conv_type::downscale(y1));
        m_clipper.line_to(m_outline, 
                          conv_type::downscale(x2), 
                          conv_type::downscale(y2));
        m_status = status_move_to;
    }

edge_d()

template<class Clip >

void agg::rasterizer_scanline_aa_nogamma< Clip >::edge_d	(	double	x1,
		double	y1,
		double	x2,
		double	y2
	)

    {
        if(m_outline.sorted()) reset();
        m_clipper.move_to(conv_type::upscale(x1), conv_type::upscale(y1)); 
        m_clipper.line_to(m_outline, 
                          conv_type::upscale(x2), 
                          conv_type::upscale(y2)); 
        m_status = status_move_to;
    }

filling_rule()

template<class Clip >

void agg::rasterizer_scanline_aa_nogamma< Clip >::filling_rule

(

filling_rule_e

filling_rule

)

    { 
        m_filling_rule = filling_rule; 
    }

hit_test()

template<class Clip >

bool agg::rasterizer_scanline_aa_nogamma< Clip >::hit_test	(	int	tx,
		int	ty
	)

    {
        if(!navigate_scanline(ty)) return false;
        scanline_hit_test sl(tx);
        sweep_scanline(sl);
        return sl.hit();
    }

References agg::scanline_hit_test::hit().

Here is the call graph for this function:

line_to()

template<class Clip >

void agg::rasterizer_scanline_aa_nogamma< Clip >::line_to	(	int	x,
		int	y
	)

    {
        m_clipper.line_to(m_outline, 
                          conv_type::downscale(x), 
                          conv_type::downscale(y));
        m_status = status_line_to;
    }

line_to_d()

template<class Clip >

void agg::rasterizer_scanline_aa_nogamma< Clip >::line_to_d	(	double	x,
		double	y
	)

    { 
        m_clipper.line_to(m_outline, 
                          conv_type::upscale(x), 
                          conv_type::upscale(y)); 
        m_status = status_line_to;
    }

max_x()

template<class Clip = rasterizer_sl_clip_int>

int agg::rasterizer_scanline_aa_nogamma< Clip >::max_x ( ) const

inline

{ return m_outline.max_x(); }

References agg::rasterizer_scanline_aa_nogamma< Clip >::m_outline.

max_y()

template<class Clip = rasterizer_sl_clip_int>

int agg::rasterizer_scanline_aa_nogamma< Clip >::max_y ( ) const

inline

{ return m_outline.max_y(); }

References agg::rasterizer_scanline_aa_nogamma< Clip >::m_outline.

min_x()

template<class Clip = rasterizer_sl_clip_int>

int agg::rasterizer_scanline_aa_nogamma< Clip >::min_x ( ) const

inline

{ return m_outline.min_x(); }

References agg::rasterizer_scanline_aa_nogamma< Clip >::m_outline.

min_y()

template<class Clip = rasterizer_sl_clip_int>

int agg::rasterizer_scanline_aa_nogamma< Clip >::min_y ( ) const

inline

{ return m_outline.min_y(); }

References agg::rasterizer_scanline_aa_nogamma< Clip >::m_outline.

move_to()

template<class Clip >

void agg::rasterizer_scanline_aa_nogamma< Clip >::move_to	(	int	x,
		int	y
	)

    {
        if(m_outline.sorted()) reset();
        if(m_auto_close) close_polygon();
        m_clipper.move_to(m_start_x = conv_type::downscale(x), 
                          m_start_y = conv_type::downscale(y));
        m_status = status_move_to;
    }

move_to_d()

template<class Clip >

void agg::rasterizer_scanline_aa_nogamma< Clip >::move_to_d	(	double	x,
		double	y
	)

    { 
        if(m_outline.sorted()) reset();
        if(m_auto_close) close_polygon();
        m_clipper.move_to(m_start_x = conv_type::upscale(x), 
                          m_start_y = conv_type::upscale(y)); 
        m_status = status_move_to;
    }

navigate_scanline()

template<class Clip >

AGG_INLINE bool agg::rasterizer_scanline_aa_nogamma< Clip >::navigate_scanline

(

int

y

)

    {
        if(m_auto_close) close_polygon();
        m_outline.sort_cells();
        if(m_outline.total_cells() == 0 || 
           y < m_outline.min_y() || 
           y > m_outline.max_y()) 
        {
            return false;
        }
        m_scan_y = y;
        return true;
    }

operator=()

template<class Clip = rasterizer_sl_clip_int>

const rasterizer_scanline_aa_nogamma< Clip > & agg::rasterizer_scanline_aa_nogamma< Clip >::operator= ( const rasterizer_scanline_aa_nogamma< Clip > &  )

private

reset()

template<class Clip >

void agg::rasterizer_scanline_aa_nogamma< Clip >::reset

    { 
        m_outline.reset(); 
        m_status = status_initial;
    }

Referenced by agg::rasterizer_scanline_aa_nogamma< Clip >::add_path().

Here is the caller graph for this function:

reset_clipping()

template<class Clip >

void agg::rasterizer_scanline_aa_nogamma< Clip >::reset_clipping

    {
        reset();
        m_clipper.reset_clipping();
    }

rewind_scanlines()

template<class Clip >

AGG_INLINE bool agg::rasterizer_scanline_aa_nogamma< Clip >::rewind_scanlines

    {
        if(m_auto_close) close_polygon();
        m_outline.sort_cells();
        if(m_outline.total_cells() == 0) 
        {
            return false;
        }
        m_scan_y = m_outline.min_y();
        return true;
    }

sort()

template<class Clip >

void agg::rasterizer_scanline_aa_nogamma< Clip >::sort

    {
        if(m_auto_close) close_polygon();
        m_outline.sort_cells();
    }

sweep_scanline()

template<class Clip = rasterizer_sl_clip_int>

template<class Scanline >

bool agg::rasterizer_scanline_aa_nogamma< Clip >::sweep_scanline ( Scanline &  sl )

inline

        {
            for(;;)
            {
                if(m_scan_y > m_outline.max_y()) return false;
                sl.reset_spans();
                unsigned num_cells = m_outline.scanline_num_cells(m_scan_y);
                const cell_aa* const* cells = m_outline.scanline_cells(m_scan_y);
                int cover = 0;
 
                while(num_cells)
                {
                    const cell_aa* cur_cell = *cells;
                    int x    = cur_cell->x;
                    int area = cur_cell->area;
                    unsigned alpha;
 
                    cover += cur_cell->cover;
 
                    //accumulate all cells with the same X
                    while(--num_cells)
                    {
                        cur_cell = *++cells;
                        if(cur_cell->x != x) break;
                        area  += cur_cell->area;
                        cover += cur_cell->cover;
                    }
 
                    if(area)
                    {
                        alpha = calculate_alpha((cover << (poly_subpixel_shift + 1)) - area);
                        if(alpha)
                        {
                            sl.add_cell(x, alpha);
                        }
                        x++;
                    }
 
                    if(num_cells && cur_cell->x > x)
                    {
                        alpha = calculate_alpha(cover << (poly_subpixel_shift + 1));
                        if(alpha)
                        {
                            sl.add_span(x, cur_cell->x - x, alpha);
                        }
                    }
                }
        
                if(sl.num_spans()) break;
                ++m_scan_y;
            }
 
            sl.finalize(m_scan_y);
            ++m_scan_y;
            return true;
        }

References agg::cell_aa::area, agg::rasterizer_scanline_aa_nogamma< Clip >::calculate_alpha(), agg::cell_aa::cover, agg::rasterizer_scanline_aa_nogamma< Clip >::m_outline, agg::rasterizer_scanline_aa_nogamma< Clip >::m_scan_y, agg::poly_subpixel_shift, and agg::cell_aa::x.

Here is the call graph for this function:

Member Data Documentation

m_auto_close

template<class Clip = rasterizer_sl_clip_int>

bool agg::rasterizer_scanline_aa_nogamma< Clip >::m_auto_close

private

Referenced by agg::rasterizer_scanline_aa_nogamma< Clip >::auto_close().

m_clipper

template<class Clip = rasterizer_sl_clip_int>

clip_type agg::rasterizer_scanline_aa_nogamma< Clip >::m_clipper

private

m_filling_rule

template<class Clip = rasterizer_sl_clip_int>

filling_rule_e agg::rasterizer_scanline_aa_nogamma< Clip >::m_filling_rule

private

Referenced by agg::rasterizer_scanline_aa_nogamma< Clip >::calculate_alpha().

m_outline

template<class Clip = rasterizer_sl_clip_int>

rasterizer_cells_aa<cell_aa> agg::rasterizer_scanline_aa_nogamma< Clip >::m_outline

private

Referenced by agg::rasterizer_scanline_aa_nogamma< Clip >::add_path(), agg::rasterizer_scanline_aa_nogamma< Clip >::max_x(), agg::rasterizer_scanline_aa_nogamma< Clip >::max_y(), agg::rasterizer_scanline_aa_nogamma< Clip >::min_x(), agg::rasterizer_scanline_aa_nogamma< Clip >::min_y(), and agg::rasterizer_scanline_aa_nogamma< Clip >::sweep_scanline().

m_scan_y

template<class Clip = rasterizer_sl_clip_int>

int agg::rasterizer_scanline_aa_nogamma< Clip >::m_scan_y

private

Referenced by agg::rasterizer_scanline_aa_nogamma< Clip >::sweep_scanline().

m_start_x

template<class Clip = rasterizer_sl_clip_int>

coord_type agg::rasterizer_scanline_aa_nogamma< Clip >::m_start_x

private

m_start_y

template<class Clip = rasterizer_sl_clip_int>

coord_type agg::rasterizer_scanline_aa_nogamma< Clip >::m_start_y

private

m_status

template<class Clip = rasterizer_sl_clip_int>

unsigned agg::rasterizer_scanline_aa_nogamma< Clip >::m_status

private

---

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

• src/agg/agg_rasterizer_scanline_aa_nogamma.h