agg Namespace Reference

Classes
class	apply_gamma_dir_gray
class	apply_gamma_dir_rgb
class	apply_gamma_inv_gray
class	apply_gamma_inv_rgb
class	bezier_arc
class	bezier_arc_svg
struct	blender_base
struct	blender_gray
struct	blender_gray_pre
struct	blender_rgb
class	blender_rgb_gamma
struct	blender_rgb_pre
class	block_allocator
struct	cell_aa
struct	const_row_info
class	conv_transform
class	gamma_linear
class	gamma_lut
class	gamma_multiply
struct	gamma_none
class	gamma_power
class	gamma_threshold
struct	gray16
struct	gray32
struct	gray8T
class	line_adaptor
struct	linear
struct	mul_one
struct	obj_allocator
struct	order_abgr
struct	order_argb
struct	order_bgr
struct	order_bgra
struct	order_rgb
struct	order_rgba
class	path_base
class	pixfmt_alpha_blend_gray
class	pixfmt_alpha_blend_rgb
class	pixfmt_bgr24_gamma
class	pixfmt_bgr48_gamma
struct	pixfmt_gray_tag
class	pixfmt_rgb24_gamma
class	pixfmt_rgb48_gamma
struct	pixfmt_rgb_tag
struct	pixfmt_rgba_tag
class	pixfmt_sbgr24_gamma
class	pixfmt_srgb24_gamma
struct	pod_allocator
class	pod_array
class	pod_array_adaptor
class	pod_auto_array
class	pod_auto_vector
class	pod_bvector
class	pod_vector
struct	point_base
class	poly_container_adaptor
class	poly_container_reverse_adaptor
class	poly_plain_adaptor
class	range_adaptor
struct	ras_conv_dbl
struct	ras_conv_dbl_3x
struct	ras_conv_int
struct	ras_conv_int_3x
struct	ras_conv_int_sat
class	rasterizer_cells_aa
class	rasterizer_scanline_aa
class	rasterizer_scanline_aa_nogamma
class	rasterizer_sl_clip
class	rasterizer_sl_no_clip
struct	rect_base
class	renderer_base
class	renderer_scanline_aa
class	renderer_scanline_aa_solid
class	renderer_scanline_bin
class	renderer_scanline_bin_solid
struct	rgba
struct	rgba16
struct	rgba32
struct	rgba8T
class	row_accessor
struct	row_info
class	row_ptr_cache
struct	saturation
class	scanline32_p8
class	scanline_hit_test
class	scanline_p8
struct	sRGB
class	sRGB_conv
class	sRGB_conv< float >
class	sRGB_conv< int16u >
class	sRGB_conv< int8u >
class	sRGB_conv_base
class	sRGB_lut
class	sRGB_lut< float >
class	sRGB_lut< int16u >
class	sRGB_lut< int8u >
struct	trans_affine
class	trans_affine_line_segment
class	trans_affine_reflection
class	trans_affine_reflection_unit
class	trans_affine_rotation
class	trans_affine_scaling
class	trans_affine_skewing
class	trans_affine_translation
struct	vertex_base
class	vertex_block_storage
class	vertex_stl_storage

Typedefs
typedef AGG_INT8	int8
typedef AGG_INT8U	int8u
typedef AGG_INT16	int16
typedef AGG_INT16U	int16u
typedef AGG_INT32	int32
typedef AGG_INT32U	int32u
typedef AGG_INT64	int64
typedef AGG_INT64U	int64u
typedef unsigned char	cover_type
typedef rect_base< int >	rect_i
typedef rect_base< float >	rect_f
typedef rect_base< double >	rect_d
typedef point_base< int >	point_i
typedef point_base< float >	point_f
typedef point_base< double >	point_d
typedef vertex_base< int >	vertex_i
typedef vertex_base< float >	vertex_f
typedef vertex_base< double >	vertex_d
typedef gray8T< linear >	gray8
typedef gray8T< sRGB >	sgray8
typedef rgba8T< linear >	rgba8
typedef rgba8T< sRGB >	srgba8
typedef path_base< vertex_block_storage< double > >	path_storage
typedef blender_gray< gray8 >	blender_gray8
typedef blender_gray< sgray8 >	blender_sgray8
typedef blender_gray< gray16 >	blender_gray16
typedef blender_gray< gray32 >	blender_gray32
typedef blender_gray_pre< gray8 >	blender_gray8_pre
typedef blender_gray_pre< sgray8 >	blender_sgray8_pre
typedef blender_gray_pre< gray16 >	blender_gray16_pre
typedef blender_gray_pre< gray32 >	blender_gray32_pre
typedef pixfmt_alpha_blend_gray< blender_gray8, rendering_buffer >	pixfmt_gray8
typedef pixfmt_alpha_blend_gray< blender_sgray8, rendering_buffer >	pixfmt_sgray8
typedef pixfmt_alpha_blend_gray< blender_gray16, rendering_buffer >	pixfmt_gray16
typedef pixfmt_alpha_blend_gray< blender_gray32, rendering_buffer >	pixfmt_gray32
typedef pixfmt_alpha_blend_gray< blender_gray8_pre, rendering_buffer >	pixfmt_gray8_pre
typedef pixfmt_alpha_blend_gray< blender_sgray8_pre, rendering_buffer >	pixfmt_sgray8_pre
typedef pixfmt_alpha_blend_gray< blender_gray16_pre, rendering_buffer >	pixfmt_gray16_pre
typedef pixfmt_alpha_blend_gray< blender_gray32_pre, rendering_buffer >	pixfmt_gray32_pre
typedef blender_rgb< rgba8, order_rgb >	blender_rgb24
typedef blender_rgb< rgba8, order_bgr >	blender_bgr24
typedef blender_rgb< srgba8, order_rgb >	blender_srgb24
typedef blender_rgb< srgba8, order_bgr >	blender_sbgr24
typedef blender_rgb< rgba16, order_rgb >	blender_rgb48
typedef blender_rgb< rgba16, order_bgr >	blender_bgr48
typedef blender_rgb< rgba32, order_rgb >	blender_rgb96
typedef blender_rgb< rgba32, order_bgr >	blender_bgr96
typedef blender_rgb_pre< rgba8, order_rgb >	blender_rgb24_pre
typedef blender_rgb_pre< rgba8, order_bgr >	blender_bgr24_pre
typedef blender_rgb_pre< srgba8, order_rgb >	blender_srgb24_pre
typedef blender_rgb_pre< srgba8, order_bgr >	blender_sbgr24_pre
typedef blender_rgb_pre< rgba16, order_rgb >	blender_rgb48_pre
typedef blender_rgb_pre< rgba16, order_bgr >	blender_bgr48_pre
typedef blender_rgb_pre< rgba32, order_rgb >	blender_rgb96_pre
typedef blender_rgb_pre< rgba32, order_bgr >	blender_bgr96_pre
typedef pixfmt_alpha_blend_rgb< blender_rgb24, rendering_buffer, 3 >	pixfmt_rgb24
typedef pixfmt_alpha_blend_rgb< blender_bgr24, rendering_buffer, 3 >	pixfmt_bgr24
typedef pixfmt_alpha_blend_rgb< blender_srgb24, rendering_buffer, 3 >	pixfmt_srgb24
typedef pixfmt_alpha_blend_rgb< blender_sbgr24, rendering_buffer, 3 >	pixfmt_sbgr24
typedef pixfmt_alpha_blend_rgb< blender_rgb48, rendering_buffer, 3 >	pixfmt_rgb48
typedef pixfmt_alpha_blend_rgb< blender_bgr48, rendering_buffer, 3 >	pixfmt_bgr48
typedef pixfmt_alpha_blend_rgb< blender_rgb96, rendering_buffer, 3 >	pixfmt_rgb96
typedef pixfmt_alpha_blend_rgb< blender_bgr96, rendering_buffer, 3 >	pixfmt_bgr96
typedef pixfmt_alpha_blend_rgb< blender_rgb24_pre, rendering_buffer, 3 >	pixfmt_rgb24_pre
typedef pixfmt_alpha_blend_rgb< blender_bgr24_pre, rendering_buffer, 3 >	pixfmt_bgr24_pre
typedef pixfmt_alpha_blend_rgb< blender_srgb24_pre, rendering_buffer, 3 >	pixfmt_srgb24_pre
typedef pixfmt_alpha_blend_rgb< blender_sbgr24_pre, rendering_buffer, 3 >	pixfmt_sbgr24_pre
typedef pixfmt_alpha_blend_rgb< blender_rgb48_pre, rendering_buffer, 3 >	pixfmt_rgb48_pre
typedef pixfmt_alpha_blend_rgb< blender_bgr48_pre, rendering_buffer, 3 >	pixfmt_bgr48_pre
typedef pixfmt_alpha_blend_rgb< blender_rgb96_pre, rendering_buffer, 3 >	pixfmt_rgb96_pre
typedef pixfmt_alpha_blend_rgb< blender_bgr96_pre, rendering_buffer, 3 >	pixfmt_bgr96_pre
typedef pixfmt_alpha_blend_rgb< blender_rgb24, rendering_buffer, 4, 0 >	pixfmt_rgbx32
typedef pixfmt_alpha_blend_rgb< blender_rgb24, rendering_buffer, 4, 1 >	pixfmt_xrgb32
typedef pixfmt_alpha_blend_rgb< blender_bgr24, rendering_buffer, 4, 1 >	pixfmt_xbgr32
typedef pixfmt_alpha_blend_rgb< blender_bgr24, rendering_buffer, 4, 0 >	pixfmt_bgrx32
typedef pixfmt_alpha_blend_rgb< blender_srgb24, rendering_buffer, 4, 0 >	pixfmt_srgbx32
typedef pixfmt_alpha_blend_rgb< blender_srgb24, rendering_buffer, 4, 1 >	pixfmt_sxrgb32
typedef pixfmt_alpha_blend_rgb< blender_sbgr24, rendering_buffer, 4, 1 >	pixfmt_sxbgr32
typedef pixfmt_alpha_blend_rgb< blender_sbgr24, rendering_buffer, 4, 0 >	pixfmt_sbgrx32
typedef pixfmt_alpha_blend_rgb< blender_rgb48, rendering_buffer, 4, 0 >	pixfmt_rgbx64
typedef pixfmt_alpha_blend_rgb< blender_rgb48, rendering_buffer, 4, 1 >	pixfmt_xrgb64
typedef pixfmt_alpha_blend_rgb< blender_bgr48, rendering_buffer, 4, 1 >	pixfmt_xbgr64
typedef pixfmt_alpha_blend_rgb< blender_bgr48, rendering_buffer, 4, 0 >	pixfmt_bgrx64
typedef pixfmt_alpha_blend_rgb< blender_rgb96, rendering_buffer, 4, 0 >	pixfmt_rgbx128
typedef pixfmt_alpha_blend_rgb< blender_rgb96, rendering_buffer, 4, 1 >	pixfmt_xrgb128
typedef pixfmt_alpha_blend_rgb< blender_bgr96, rendering_buffer, 4, 1 >	pixfmt_xbgr128
typedef pixfmt_alpha_blend_rgb< blender_bgr96, rendering_buffer, 4, 0 >	pixfmt_bgrx128
typedef pixfmt_alpha_blend_rgb< blender_rgb24_pre, rendering_buffer, 4, 0 >	pixfmt_rgbx32_pre
typedef pixfmt_alpha_blend_rgb< blender_rgb24_pre, rendering_buffer, 4, 1 >	pixfmt_xrgb32_pre
typedef pixfmt_alpha_blend_rgb< blender_bgr24_pre, rendering_buffer, 4, 1 >	pixfmt_xbgr32_pre
typedef pixfmt_alpha_blend_rgb< blender_bgr24_pre, rendering_buffer, 4, 0 >	pixfmt_bgrx32_pre
typedef pixfmt_alpha_blend_rgb< blender_srgb24_pre, rendering_buffer, 4, 0 >	pixfmt_srgbx32_pre
typedef pixfmt_alpha_blend_rgb< blender_srgb24_pre, rendering_buffer, 4, 1 >	pixfmt_sxrgb32_pre
typedef pixfmt_alpha_blend_rgb< blender_sbgr24_pre, rendering_buffer, 4, 1 >	pixfmt_sxbgr32_pre
typedef pixfmt_alpha_blend_rgb< blender_sbgr24_pre, rendering_buffer, 4, 0 >	pixfmt_sbgrx32_pre
typedef pixfmt_alpha_blend_rgb< blender_rgb48_pre, rendering_buffer, 4, 0 >	pixfmt_rgbx64_pre
typedef pixfmt_alpha_blend_rgb< blender_rgb48_pre, rendering_buffer, 4, 1 >	pixfmt_xrgb64_pre
typedef pixfmt_alpha_blend_rgb< blender_bgr48_pre, rendering_buffer, 4, 1 >	pixfmt_xbgr64_pre
typedef pixfmt_alpha_blend_rgb< blender_bgr48_pre, rendering_buffer, 4, 0 >	pixfmt_bgrx64_pre
typedef pixfmt_alpha_blend_rgb< blender_rgb96_pre, rendering_buffer, 4, 0 >	pixfmt_rgbx128_pre
typedef pixfmt_alpha_blend_rgb< blender_rgb96_pre, rendering_buffer, 4, 1 >	pixfmt_xrgb128_pre
typedef pixfmt_alpha_blend_rgb< blender_bgr96_pre, rendering_buffer, 4, 1 >	pixfmt_xbgr128_pre
typedef pixfmt_alpha_blend_rgb< blender_bgr96_pre, rendering_buffer, 4, 0 >	pixfmt_bgrx128_pre
typedef rasterizer_sl_clip< ras_conv_int >	rasterizer_sl_clip_int
typedef rasterizer_sl_clip< ras_conv_int_sat >	rasterizer_sl_clip_int_sat
typedef rasterizer_sl_clip< ras_conv_int_3x >	rasterizer_sl_clip_int_3x
typedef rasterizer_sl_clip< ras_conv_dbl >	rasterizer_sl_clip_dbl
typedef rasterizer_sl_clip< ras_conv_dbl_3x >	rasterizer_sl_clip_dbl_3x
typedef row_accessor< int8u >	rendering_buffer

Enumerations
enum	quick_sort_threshold_e { quick_sort_threshold = 9 }
enum	cover_scale_e {   cover_shift = 8 , cover_size = 1 << cover_shift , cover_mask = cover_size - 1 , cover_none = 0 ,   cover_full = cover_mask }
enum	poly_subpixel_scale_e { poly_subpixel_shift = 8 , poly_subpixel_scale = 1<<poly_subpixel_shift , poly_subpixel_mask = poly_subpixel_scale-1 }
enum	filling_rule_e { fill_non_zero , fill_even_odd }
enum	path_commands_e {   path_cmd_stop = 0 , path_cmd_move_to = 1 , path_cmd_line_to = 2 , path_cmd_curve3 = 3 ,   path_cmd_curve4 = 4 , path_cmd_curveN = 5 , path_cmd_catrom = 6 , path_cmd_ubspline = 7 ,   path_cmd_end_poly = 0x0F , path_cmd_mask = 0x0F }
enum	path_flags_e {   path_flags_none = 0 , path_flags_ccw = 0x10 , path_flags_cw = 0x20 , path_flags_close = 0x40 ,   path_flags_mask = 0xF0 }
enum	clipping_flags_e {   clipping_flags_x1_clipped = 4 , clipping_flags_x2_clipped = 1 , clipping_flags_y1_clipped = 8 , clipping_flags_y2_clipped = 2 ,   clipping_flags_x_clipped = clipping_flags_x1_clipped | clipping_flags_x2_clipped , clipping_flags_y_clipped = clipping_flags_y1_clipped | clipping_flags_y2_clipped }
enum	{ qsort_threshold = 9 }
enum	poly_max_coord_e { poly_max_coord = (1 << 30) - 1 }

Functions
template<class T >
void	swap_elements (T &a, T &b)
template<class Array , class Less >
void	quick_sort (Array &arr, Less less)
template<class Array , class Equal >
unsigned	remove_duplicates (Array &arr, Equal equal)
template<class Array >
void	invert_container (Array &arr)
template<class Array , class Value , class Less >
unsigned	binary_search_pos (const Array &arr, const Value &val, Less less)
bool	int_less (int a, int b)
bool	int_greater (int a, int b)
bool	unsigned_less (unsigned a, unsigned b)
bool	unsigned_greater (unsigned a, unsigned b)
AGG_INLINE int	iround (double v)
AGG_INLINE int	uround (double v)
AGG_INLINE int	ifloor (double v)
AGG_INLINE unsigned	ufloor (double v)
AGG_INLINE int	iceil (double v)
AGG_INLINE unsigned	uceil (double v)
double	deg2rad (double deg)
double	rad2deg (double rad)
template<class Rect >
Rect	intersect_rectangles (const Rect &r1, const Rect &r2)
template<class Rect >
Rect	unite_rectangles (const Rect &r1, const Rect &r2)
bool	is_vertex (unsigned c)
bool	is_drawing (unsigned c)
bool	is_stop (unsigned c)
bool	is_move_to (unsigned c)
bool	is_line_to (unsigned c)
bool	is_curve (unsigned c)
bool	is_curve3 (unsigned c)
bool	is_curve4 (unsigned c)
bool	is_end_poly (unsigned c)
bool	is_close (unsigned c)
bool	is_next_poly (unsigned c)
bool	is_cw (unsigned c)
bool	is_ccw (unsigned c)
bool	is_oriented (unsigned c)
bool	is_closed (unsigned c)
unsigned	get_close_flag (unsigned c)
unsigned	clear_orientation (unsigned c)
unsigned	get_orientation (unsigned c)
unsigned	set_orientation (unsigned c, unsigned o)
template<class T >
bool	is_equal_eps (T v1, T v2, T epsilon)
void	arc_to_bezier (double cx, double cy, double rx, double ry, double start_angle, double sweep_angle, double *curve)
template<class T >
unsigned	clipping_flags (T x, T y, const rect_base< T > &clip_box)
template<class T >
unsigned	clipping_flags_x (T x, const rect_base< T > &clip_box)
template<class T >
unsigned	clipping_flags_y (T y, const rect_base< T > &clip_box)
template<class T >
unsigned	clip_liang_barsky (T x1, T y1, T x2, T y2, const rect_base< T > &clip_box, T *x, T *y)
template<class T >
bool	clip_move_point (T x1, T y1, T x2, T y2, const rect_base< T > &clip_box, T *x, T *y, unsigned flags)
template<class T >
unsigned	clip_line_segment (T *x1, T *y1, T *x2, T *y2, const rect_base< T > &clip_box)
rgba	operator+ (const rgba &a, const rgba &b)
rgba	operator* (const rgba &a, double b)
rgba	rgba_pre (double r, double g, double b, double a)
rgba8	rgb8_packed (unsigned v)
rgba8	bgr8_packed (unsigned v)
rgba8	argb8_packed (unsigned v)
template<class GammaLUT >
rgba8	rgba8_gamma_dir (rgba8 c, const GammaLUT &gamma)
template<class GammaLUT >
rgba8	rgba8_gamma_inv (rgba8 c, const GammaLUT &gamma)
template<class GammaLUT >
rgba16	rgba16_gamma_dir (rgba16 c, const GammaLUT &gamma)
template<class GammaLUT >
rgba16	rgba16_gamma_inv (rgba16 c, const GammaLUT &gamma)
double	sRGB_to_linear (double x)
double	linear_to_sRGB (double x)
AGG_INLINE double	cross_product (double x1, double y1, double x2, double y2, double x, double y)
AGG_INLINE bool	point_in_triangle (double x1, double y1, double x2, double y2, double x3, double y3, double x, double y)
AGG_INLINE double	calc_distance (double x1, double y1, double x2, double y2)
AGG_INLINE double	calc_sq_distance (double x1, double y1, double x2, double y2)
AGG_INLINE double	calc_line_point_distance (double x1, double y1, double x2, double y2, double x, double y)
AGG_INLINE double	calc_segment_point_u (double x1, double y1, double x2, double y2, double x, double y)
AGG_INLINE double	calc_segment_point_sq_distance (double x1, double y1, double x2, double y2, double x, double y, double u)
AGG_INLINE double	calc_segment_point_sq_distance (double x1, double y1, double x2, double y2, double x, double y)
AGG_INLINE bool	calc_intersection (double ax, double ay, double bx, double by, double cx, double cy, double dx, double dy, double *x, double *y)
AGG_INLINE bool	intersection_exists (double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
AGG_INLINE void	calc_orthogonal (double thickness, double x1, double y1, double x2, double y2, double *x, double *y)
AGG_INLINE void	dilate_triangle (double x1, double y1, double x2, double y2, double x3, double y3, double *x, double *y, double d)
AGG_INLINE double	calc_triangle_area (double x1, double y1, double x2, double y2, double x3, double y3)
template<class Storage >
double	calc_polygon_area (const Storage &st)
AGG_INLINE unsigned	fast_sqrt (unsigned val)
double	besj (double x, int n)
template<class T >
static AGG_INLINE void	swap_cells (T *a, T *b)
template<class Cell >
void	qsort_cells (Cell **start, unsigned num)
template<class Scanline , class BaseRenderer , class ColorT >
void	render_scanline_aa_solid (const Scanline &sl, BaseRenderer &ren, const ColorT &color)
template<class Rasterizer , class Scanline , class BaseRenderer , class ColorT >
void	render_scanlines_aa_solid (Rasterizer &ras, Scanline &sl, BaseRenderer &ren, const ColorT &color)
template<class Scanline , class BaseRenderer , class SpanAllocator , class SpanGenerator >
void	render_scanline_aa (const Scanline &sl, BaseRenderer &ren, SpanAllocator &alloc, SpanGenerator &span_gen)
template<class Rasterizer , class Scanline , class BaseRenderer , class SpanAllocator , class SpanGenerator >
void	render_scanlines_aa (Rasterizer &ras, Scanline &sl, BaseRenderer &ren, SpanAllocator &alloc, SpanGenerator &span_gen)
template<class Scanline , class BaseRenderer , class ColorT >
void	render_scanline_bin_solid (const Scanline &sl, BaseRenderer &ren, const ColorT &color)
template<class Rasterizer , class Scanline , class BaseRenderer , class ColorT >
void	render_scanlines_bin_solid (Rasterizer &ras, Scanline &sl, BaseRenderer &ren, const ColorT &color)
template<class Scanline , class BaseRenderer , class SpanAllocator , class SpanGenerator >
void	render_scanline_bin (const Scanline &sl, BaseRenderer &ren, SpanAllocator &alloc, SpanGenerator &span_gen)
template<class Rasterizer , class Scanline , class BaseRenderer , class SpanAllocator , class SpanGenerator >
void	render_scanlines_bin (Rasterizer &ras, Scanline &sl, BaseRenderer &ren, SpanAllocator &alloc, SpanGenerator &span_gen)
template<class Rasterizer , class Scanline , class Renderer >
void	render_scanlines (Rasterizer &ras, Scanline &sl, Renderer &ren)
template<class Rasterizer , class Scanline , class Renderer , class VertexSource , class ColorStorage , class PathId >
void	render_all_paths (Rasterizer &ras, Scanline &sl, Renderer &r, VertexSource &vs, const ColorStorage &as, const PathId &path_id, unsigned num_paths)
template<class Rasterizer , class ScanlineAA , class ScanlineBin , class BaseRenderer , class SpanAllocator , class StyleHandler >
void	render_scanlines_compound (Rasterizer &ras, ScanlineAA &sl_aa, ScanlineBin &sl_bin, BaseRenderer &ren, SpanAllocator &alloc, StyleHandler &sh)
template<class Rasterizer , class ScanlineAA , class BaseRenderer , class SpanAllocator , class StyleHandler >
void	render_scanlines_compound_layered (Rasterizer &ras, ScanlineAA &sl_aa, BaseRenderer &ren, SpanAllocator &alloc, StyleHandler &sh)

Variables
const double	pi = 3.14159265358979323846
const double	vertex_dist_epsilon = 1e-14
const double	intersection_epsilon = 1.0e-30
int16u	g_sqrt_table [1024]
int8	g_elder_bit_table [256]
const double	affine_epsilon = 1e-14

---

Class Documentation

agg::linear

struct agg::linear

agg::pixfmt_gray_tag

struct agg::pixfmt_gray_tag

agg::pixfmt_rgb_tag

struct agg::pixfmt_rgb_tag

agg::pixfmt_rgba_tag

struct agg::pixfmt_rgba_tag

agg::sRGB

struct agg::sRGB

agg::sRGB_conv

class agg::sRGB_conv

template<class T>
class agg::sRGB_conv< T >

agg::sRGB_lut

class agg::sRGB_lut

template<class LinearType>
class agg::sRGB_lut< LinearType >

Inheritance diagram for agg::sRGB_lut< LinearType >:

Typedef Documentation

blender_bgr24

typedef blender_rgb<rgba8, order_bgr> agg::blender_bgr24

blender_bgr24_pre

typedef blender_rgb_pre<rgba8, order_bgr> agg::blender_bgr24_pre

blender_bgr48

typedef blender_rgb<rgba16, order_bgr> agg::blender_bgr48

blender_bgr48_pre

typedef blender_rgb_pre<rgba16, order_bgr> agg::blender_bgr48_pre

blender_bgr96

typedef blender_rgb<rgba32, order_bgr> agg::blender_bgr96

blender_bgr96_pre

typedef blender_rgb_pre<rgba32, order_bgr> agg::blender_bgr96_pre

blender_gray16

typedef blender_gray<gray16> agg::blender_gray16

blender_gray16_pre

typedef blender_gray_pre<gray16> agg::blender_gray16_pre

blender_gray32

typedef blender_gray<gray32> agg::blender_gray32

blender_gray32_pre

typedef blender_gray_pre<gray32> agg::blender_gray32_pre

blender_gray8

typedef blender_gray<gray8> agg::blender_gray8

blender_gray8_pre

typedef blender_gray_pre<gray8> agg::blender_gray8_pre

blender_rgb24

typedef blender_rgb<rgba8, order_rgb> agg::blender_rgb24

blender_rgb24_pre

typedef blender_rgb_pre<rgba8, order_rgb> agg::blender_rgb24_pre

blender_rgb48

typedef blender_rgb<rgba16, order_rgb> agg::blender_rgb48

blender_rgb48_pre

typedef blender_rgb_pre<rgba16, order_rgb> agg::blender_rgb48_pre

blender_rgb96

typedef blender_rgb<rgba32, order_rgb> agg::blender_rgb96

blender_rgb96_pre

typedef blender_rgb_pre<rgba32, order_rgb> agg::blender_rgb96_pre

blender_sbgr24

typedef blender_rgb<srgba8, order_bgr> agg::blender_sbgr24

blender_sbgr24_pre

typedef blender_rgb_pre<srgba8, order_bgr> agg::blender_sbgr24_pre

blender_sgray8

typedef blender_gray<sgray8> agg::blender_sgray8

blender_sgray8_pre

typedef blender_gray_pre<sgray8> agg::blender_sgray8_pre

blender_srgb24

typedef blender_rgb<srgba8, order_rgb> agg::blender_srgb24

blender_srgb24_pre

typedef blender_rgb_pre<srgba8, order_rgb> agg::blender_srgb24_pre

cover_type

typedef unsigned char agg::cover_type

gray8

typedef gray8T<linear> agg::gray8

int16

typedef AGG_INT16 agg::int16

int16u

typedef AGG_INT16U agg::int16u

int32

typedef AGG_INT32 agg::int32

int32u

typedef AGG_INT32U agg::int32u

int64

typedef AGG_INT64 agg::int64

int64u

typedef AGG_INT64U agg::int64u

int8

typedef AGG_INT8 agg::int8

int8u

typedef AGG_INT8U agg::int8u

path_storage

typedef path_base<vertex_block_storage<double> > agg::path_storage

pixfmt_bgr24

typedef pixfmt_alpha_blend_rgb<blender_bgr24, rendering_buffer, 3> agg::pixfmt_bgr24

pixfmt_bgr24_pre

typedef pixfmt_alpha_blend_rgb<blender_bgr24_pre, rendering_buffer, 3> agg::pixfmt_bgr24_pre

pixfmt_bgr48

typedef pixfmt_alpha_blend_rgb<blender_bgr48, rendering_buffer, 3> agg::pixfmt_bgr48

pixfmt_bgr48_pre

typedef pixfmt_alpha_blend_rgb<blender_bgr48_pre, rendering_buffer, 3> agg::pixfmt_bgr48_pre

pixfmt_bgr96

typedef pixfmt_alpha_blend_rgb<blender_bgr96, rendering_buffer, 3> agg::pixfmt_bgr96

pixfmt_bgr96_pre

typedef pixfmt_alpha_blend_rgb<blender_bgr96_pre, rendering_buffer, 3> agg::pixfmt_bgr96_pre

pixfmt_bgrx128

typedef pixfmt_alpha_blend_rgb<blender_bgr96, rendering_buffer, 4, 0> agg::pixfmt_bgrx128

pixfmt_bgrx128_pre

typedef pixfmt_alpha_blend_rgb<blender_bgr96_pre, rendering_buffer, 4, 0> agg::pixfmt_bgrx128_pre

pixfmt_bgrx32

typedef pixfmt_alpha_blend_rgb<blender_bgr24, rendering_buffer, 4, 0> agg::pixfmt_bgrx32

pixfmt_bgrx32_pre

typedef pixfmt_alpha_blend_rgb<blender_bgr24_pre, rendering_buffer, 4, 0> agg::pixfmt_bgrx32_pre

pixfmt_bgrx64

typedef pixfmt_alpha_blend_rgb<blender_bgr48, rendering_buffer, 4, 0> agg::pixfmt_bgrx64

pixfmt_bgrx64_pre

typedef pixfmt_alpha_blend_rgb<blender_bgr48_pre, rendering_buffer, 4, 0> agg::pixfmt_bgrx64_pre

pixfmt_gray16

typedef pixfmt_alpha_blend_gray<blender_gray16, rendering_buffer> agg::pixfmt_gray16

pixfmt_gray16_pre

typedef pixfmt_alpha_blend_gray<blender_gray16_pre, rendering_buffer> agg::pixfmt_gray16_pre

pixfmt_gray32

typedef pixfmt_alpha_blend_gray<blender_gray32, rendering_buffer> agg::pixfmt_gray32

pixfmt_gray32_pre

typedef pixfmt_alpha_blend_gray<blender_gray32_pre, rendering_buffer> agg::pixfmt_gray32_pre

pixfmt_gray8

typedef pixfmt_alpha_blend_gray<blender_gray8, rendering_buffer> agg::pixfmt_gray8

pixfmt_gray8_pre

typedef pixfmt_alpha_blend_gray<blender_gray8_pre, rendering_buffer> agg::pixfmt_gray8_pre

pixfmt_rgb24

typedef pixfmt_alpha_blend_rgb<blender_rgb24, rendering_buffer, 3> agg::pixfmt_rgb24

pixfmt_rgb24_pre

typedef pixfmt_alpha_blend_rgb<blender_rgb24_pre, rendering_buffer, 3> agg::pixfmt_rgb24_pre

pixfmt_rgb48

typedef pixfmt_alpha_blend_rgb<blender_rgb48, rendering_buffer, 3> agg::pixfmt_rgb48

pixfmt_rgb48_pre

typedef pixfmt_alpha_blend_rgb<blender_rgb48_pre, rendering_buffer, 3> agg::pixfmt_rgb48_pre

pixfmt_rgb96

typedef pixfmt_alpha_blend_rgb<blender_rgb96, rendering_buffer, 3> agg::pixfmt_rgb96

pixfmt_rgb96_pre

typedef pixfmt_alpha_blend_rgb<blender_rgb96_pre, rendering_buffer, 3> agg::pixfmt_rgb96_pre

pixfmt_rgbx128

typedef pixfmt_alpha_blend_rgb<blender_rgb96, rendering_buffer, 4, 0> agg::pixfmt_rgbx128

pixfmt_rgbx128_pre

typedef pixfmt_alpha_blend_rgb<blender_rgb96_pre, rendering_buffer, 4, 0> agg::pixfmt_rgbx128_pre

pixfmt_rgbx32

typedef pixfmt_alpha_blend_rgb<blender_rgb24, rendering_buffer, 4, 0> agg::pixfmt_rgbx32

pixfmt_rgbx32_pre

typedef pixfmt_alpha_blend_rgb<blender_rgb24_pre, rendering_buffer, 4, 0> agg::pixfmt_rgbx32_pre

pixfmt_rgbx64

typedef pixfmt_alpha_blend_rgb<blender_rgb48, rendering_buffer, 4, 0> agg::pixfmt_rgbx64

pixfmt_rgbx64_pre

typedef pixfmt_alpha_blend_rgb<blender_rgb48_pre, rendering_buffer, 4, 0> agg::pixfmt_rgbx64_pre

pixfmt_sbgr24

typedef pixfmt_alpha_blend_rgb<blender_sbgr24, rendering_buffer, 3> agg::pixfmt_sbgr24

pixfmt_sbgr24_pre

typedef pixfmt_alpha_blend_rgb<blender_sbgr24_pre, rendering_buffer, 3> agg::pixfmt_sbgr24_pre

pixfmt_sbgrx32

typedef pixfmt_alpha_blend_rgb<blender_sbgr24, rendering_buffer, 4, 0> agg::pixfmt_sbgrx32

pixfmt_sbgrx32_pre

typedef pixfmt_alpha_blend_rgb<blender_sbgr24_pre, rendering_buffer, 4, 0> agg::pixfmt_sbgrx32_pre

pixfmt_sgray8

typedef pixfmt_alpha_blend_gray<blender_sgray8, rendering_buffer> agg::pixfmt_sgray8

pixfmt_sgray8_pre

typedef pixfmt_alpha_blend_gray<blender_sgray8_pre, rendering_buffer> agg::pixfmt_sgray8_pre

pixfmt_srgb24

typedef pixfmt_alpha_blend_rgb<blender_srgb24, rendering_buffer, 3> agg::pixfmt_srgb24

pixfmt_srgb24_pre

typedef pixfmt_alpha_blend_rgb<blender_srgb24_pre, rendering_buffer, 3> agg::pixfmt_srgb24_pre

pixfmt_srgbx32

typedef pixfmt_alpha_blend_rgb<blender_srgb24, rendering_buffer, 4, 0> agg::pixfmt_srgbx32

pixfmt_srgbx32_pre

typedef pixfmt_alpha_blend_rgb<blender_srgb24_pre, rendering_buffer, 4, 0> agg::pixfmt_srgbx32_pre

pixfmt_sxbgr32

typedef pixfmt_alpha_blend_rgb<blender_sbgr24, rendering_buffer, 4, 1> agg::pixfmt_sxbgr32

pixfmt_sxbgr32_pre

typedef pixfmt_alpha_blend_rgb<blender_sbgr24_pre, rendering_buffer, 4, 1> agg::pixfmt_sxbgr32_pre

pixfmt_sxrgb32

typedef pixfmt_alpha_blend_rgb<blender_srgb24, rendering_buffer, 4, 1> agg::pixfmt_sxrgb32

pixfmt_sxrgb32_pre

typedef pixfmt_alpha_blend_rgb<blender_srgb24_pre, rendering_buffer, 4, 1> agg::pixfmt_sxrgb32_pre

pixfmt_xbgr128

typedef pixfmt_alpha_blend_rgb<blender_bgr96, rendering_buffer, 4, 1> agg::pixfmt_xbgr128

pixfmt_xbgr128_pre

typedef pixfmt_alpha_blend_rgb<blender_bgr96_pre, rendering_buffer, 4, 1> agg::pixfmt_xbgr128_pre

pixfmt_xbgr32

typedef pixfmt_alpha_blend_rgb<blender_bgr24, rendering_buffer, 4, 1> agg::pixfmt_xbgr32

pixfmt_xbgr32_pre

typedef pixfmt_alpha_blend_rgb<blender_bgr24_pre, rendering_buffer, 4, 1> agg::pixfmt_xbgr32_pre

pixfmt_xbgr64

typedef pixfmt_alpha_blend_rgb<blender_bgr48, rendering_buffer, 4, 1> agg::pixfmt_xbgr64

pixfmt_xbgr64_pre

typedef pixfmt_alpha_blend_rgb<blender_bgr48_pre, rendering_buffer, 4, 1> agg::pixfmt_xbgr64_pre

pixfmt_xrgb128

typedef pixfmt_alpha_blend_rgb<blender_rgb96, rendering_buffer, 4, 1> agg::pixfmt_xrgb128

pixfmt_xrgb128_pre

typedef pixfmt_alpha_blend_rgb<blender_rgb96_pre, rendering_buffer, 4, 1> agg::pixfmt_xrgb128_pre

pixfmt_xrgb32

typedef pixfmt_alpha_blend_rgb<blender_rgb24, rendering_buffer, 4, 1> agg::pixfmt_xrgb32

pixfmt_xrgb32_pre

typedef pixfmt_alpha_blend_rgb<blender_rgb24_pre, rendering_buffer, 4, 1> agg::pixfmt_xrgb32_pre

pixfmt_xrgb64

typedef pixfmt_alpha_blend_rgb<blender_rgb48, rendering_buffer, 4, 1> agg::pixfmt_xrgb64

pixfmt_xrgb64_pre

typedef pixfmt_alpha_blend_rgb<blender_rgb48_pre, rendering_buffer, 4, 1> agg::pixfmt_xrgb64_pre

point_d

typedef point_base<double> agg::point_d

point_f

typedef point_base<float> agg::point_f

point_i

typedef point_base<int> agg::point_i

rasterizer_sl_clip_dbl

typedef rasterizer_sl_clip<ras_conv_dbl> agg::rasterizer_sl_clip_dbl

rasterizer_sl_clip_dbl_3x

typedef rasterizer_sl_clip<ras_conv_dbl_3x> agg::rasterizer_sl_clip_dbl_3x

rasterizer_sl_clip_int

typedef rasterizer_sl_clip<ras_conv_int> agg::rasterizer_sl_clip_int

rasterizer_sl_clip_int_3x

typedef rasterizer_sl_clip<ras_conv_int_3x> agg::rasterizer_sl_clip_int_3x

rasterizer_sl_clip_int_sat

typedef rasterizer_sl_clip<ras_conv_int_sat> agg::rasterizer_sl_clip_int_sat

rect_d

typedef rect_base<double> agg::rect_d

rect_f

typedef rect_base<float> agg::rect_f

rect_i

typedef rect_base<int> agg::rect_i

rendering_buffer

typedef row_accessor<int8u> agg::rendering_buffer

rgba8

typedef rgba8T<linear> agg::rgba8

sgray8

typedef gray8T<sRGB> agg::sgray8

srgba8

typedef rgba8T<sRGB> agg::srgba8

vertex_d

typedef vertex_base<double> agg::vertex_d

vertex_f

typedef vertex_base<float> agg::vertex_f

vertex_i

typedef vertex_base<int> agg::vertex_i

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
qsort_threshold

    {
        qsort_threshold = 9
    };

clipping_flags_e

enum agg::clipping_flags_e

Enumerator
clipping_flags_x1_clipped
clipping_flags_x2_clipped
clipping_flags_y1_clipped
clipping_flags_y2_clipped
clipping_flags_x_clipped
clipping_flags_y_clipped

    {
        clipping_flags_x1_clipped = 4,
        clipping_flags_x2_clipped = 1,
        clipping_flags_y1_clipped = 8,
        clipping_flags_y2_clipped = 2,
        clipping_flags_x_clipped = clipping_flags_x1_clipped | clipping_flags_x2_clipped,
        clipping_flags_y_clipped = clipping_flags_y1_clipped | clipping_flags_y2_clipped
    };

cover_scale_e

enum agg::cover_scale_e

Enumerator
cover_shift
cover_size
cover_mask
cover_none
cover_full

    {
        cover_shift = 8,                 //----cover_shift
        cover_size  = 1 << cover_shift,  //----cover_size 
        cover_mask  = cover_size - 1,    //----cover_mask 
        cover_none  = 0,                 //----cover_none 
        cover_full  = cover_mask         //----cover_full 
    };

filling_rule_e

enum agg::filling_rule_e

Enumerator
fill_non_zero
fill_even_odd

    {
        fill_non_zero,
        fill_even_odd
    };

path_commands_e

enum agg::path_commands_e

Enumerator
path_cmd_stop
path_cmd_move_to
path_cmd_line_to
path_cmd_curve3
path_cmd_curve4
path_cmd_curveN
path_cmd_catrom
path_cmd_ubspline
path_cmd_end_poly
path_cmd_mask

    {
        path_cmd_stop     = 0,        //----path_cmd_stop    
        path_cmd_move_to  = 1,        //----path_cmd_move_to 
        path_cmd_line_to  = 2,        //----path_cmd_line_to 
        path_cmd_curve3   = 3,        //----path_cmd_curve3  
        path_cmd_curve4   = 4,        //----path_cmd_curve4  
        path_cmd_curveN   = 5,        //----path_cmd_curveN
        path_cmd_catrom   = 6,        //----path_cmd_catrom
        path_cmd_ubspline = 7,        //----path_cmd_ubspline
        path_cmd_end_poly = 0x0F,     //----path_cmd_end_poly
        path_cmd_mask     = 0x0F      //----path_cmd_mask    
    };

path_flags_e

enum agg::path_flags_e

Enumerator
path_flags_none
path_flags_ccw
path_flags_cw
path_flags_close
path_flags_mask

    {
        path_flags_none  = 0,         //----path_flags_none 
        path_flags_ccw   = 0x10,      //----path_flags_ccw  
        path_flags_cw    = 0x20,      //----path_flags_cw   
        path_flags_close = 0x40,      //----path_flags_close
        path_flags_mask  = 0xF0       //----path_flags_mask 
    };

poly_max_coord_e

enum agg::poly_max_coord_e

Enumerator
poly_max_coord

    {
        poly_max_coord = (1 << 30) - 1 //----poly_max_coord
    };

poly_subpixel_scale_e

enum agg::poly_subpixel_scale_e

Enumerator
poly_subpixel_shift
poly_subpixel_scale
poly_subpixel_mask

    {
        poly_subpixel_shift = 8,                      //----poly_subpixel_shift
        poly_subpixel_scale = 1<<poly_subpixel_shift, //----poly_subpixel_scale 
        poly_subpixel_mask  = poly_subpixel_scale-1   //----poly_subpixel_mask 
    };

quick_sort_threshold_e

enum agg::quick_sort_threshold_e

Enumerator
quick_sort_threshold

    {
        quick_sort_threshold = 9
    };

Function Documentation

arc_to_bezier()

void agg::arc_to_bezier	(	double	cx,
		double	cy,
		double	rx,
		double	ry,
		double	start_angle,
		double	sweep_angle,
		double *	curve
	)

argb8_packed()

rgba8 agg::argb8_packed ( unsigned  v )

inline

    {
        return rgba8((v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF, v >> 24);
    }

besj()

double agg::besj ( double  x, int  n  )

inline

    {
        if(n < 0)
        {
            return 0;
        }
        double d = 1E-6;
        double b = 0;
        if(fabs(x) <= d) 
        {
            if(n != 0) return 0;
            return 1;
        }
        double b1 = 0; // b1 is the value from the previous iteration
        // Set up a starting order for recurrence
        int m1 = (int)fabs(x) + 6;
        if(fabs(x) > 5) 
        {
            m1 = (int)(fabs(1.4 * x + 60 / x));
        }
        int m2 = (int)(n + 2 + fabs(x) / 4);
        if (m1 > m2) 
        {
            m2 = m1;
        }
    
        // Apply recurrence down from curent max order
        for(;;) 
        {
            double c3 = 0;
            double c2 = 1E-30;
            double c4 = 0;
            int m8 = 1;
            if (m2 / 2 * 2 == m2) 
            {
                m8 = -1;
            }
            int imax = m2 - 2;
            for (int i = 1; i <= imax; i++) 
            {
                double c6 = 2 * (m2 - i) * c2 / x - c3;
                c3 = c2;
                c2 = c6;
                if(m2 - i - 1 == n)
                {
                    b = c6;
                }
                m8 = -1 * m8;
                if (m8 > 0)
                {
                    c4 = c4 + 2 * c6;
                }
            }
            double c6 = 2 * c2 / x - c3;
            if(n == 0)
            {
                b = c6;
            }
            c4 += c6;
            b /= c4;
            if(fabs(b - b1) < d)
            {
                return b;
            }
            b1 = b;
            m2 += 3;
        }
    }

bgr8_packed()

rgba8 agg::bgr8_packed ( unsigned  v )

inline

    {
        return rgba8(v & 0xFF, (v >> 8) & 0xFF, (v >> 16) & 0xFF);
    }

binary_search_pos()

template<class Array , class Value , class Less >

unsigned agg::binary_search_pos	(	const Array &	arr,
		const Value &	val,
		Less	less
	)

    {
        if(arr.size() == 0) return 0;
 
        unsigned beg = 0;
        unsigned end = arr.size() - 1;
 
        if(less(val, arr[0])) return 0;
        if(less(arr[end], val)) return end + 1;
 
        while(end - beg > 1)
        {
            unsigned mid = (end + beg) >> 1;
            if(less(val, arr[mid])) end = mid; 
            else                    beg = mid;
        }
 
        //if(beg <= 0 && less(val, arr[0])) return 0;
        //if(end >= arr.size() - 1 && less(arr[end], val)) ++end;
 
        return end;
    }

calc_distance()

AGG_INLINE double agg::calc_distance	(	double	x1,
		double	y1,
		double	x2,
		double	y2
	)

    {
        double dx = x2-x1;
        double dy = y2-y1;
        return sqrt(dx * dx + dy * dy);
    }

References sqrt().

Referenced by agg::path_base< VertexContainer >::arc_to(), calc_line_point_distance(), and agg::path_base< VertexContainer >::join_path().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_intersection()

AGG_INLINE bool agg::calc_intersection	(	double	ax,
		double	ay,
		double	bx,
		double	by,
		double	cx,
		double	cy,
		double	dx,
		double	dy,
		double *	x,
		double *	y
	)

    {
        double num = (ay-cy) * (dx-cx) - (ax-cx) * (dy-cy);
        double den = (bx-ax) * (dy-cy) - (by-ay) * (dx-cx);
        if(fabs(den) < intersection_epsilon) return false;
        double r = num / den;
        *x = ax + r * (bx-ax);
        *y = ay + r * (by-ay);
        return true;
    }

References intersection_epsilon.

calc_line_point_distance()

AGG_INLINE double agg::calc_line_point_distance	(	double	x1,
		double	y1,
		double	x2,
		double	y2,
		double	x,
		double	y
	)

    {
        double dx = x2-x1;
        double dy = y2-y1;
        double d = sqrt(dx * dx + dy * dy);
        if(d < vertex_dist_epsilon)
        {
            return calc_distance(x1, y1, x, y);
        }
        return ((x - x2) * dy - (y - y2) * dx) / d;
    }

References calc_distance(), sqrt(), and vertex_dist_epsilon.

Here is the call graph for this function:

calc_orthogonal()

AGG_INLINE void agg::calc_orthogonal	(	double	thickness,
		double	x1,
		double	y1,
		double	x2,
		double	y2,
		double *	x,
		double *	y
	)

    {
        double dx = x2 - x1;
        double dy = y2 - y1;
        double d = sqrt(dx*dx + dy*dy); 
        *x =  thickness * dy / d;
        *y = -thickness * dx / d;
    }

References sqrt().

Referenced by dilate_triangle().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_polygon_area()

template<class Storage >

double agg::calc_polygon_area

(

const Storage &

st

)

    {
        unsigned i;
        double sum = 0.0;
        double x  = st[0].x;
        double y  = st[0].y;
        double xs = x;
        double ys = y;
 
        for(i = 1; i < st.size(); i++)
        {
            const typename Storage::value_type& v = st[i];
            sum += x * v.y - y * v.x;
            x = v.x;
            y = v.y;
        }
        return (sum + x * ys - y * xs) * 0.5;
    }

calc_segment_point_sq_distance() [1/2]

AGG_INLINE double agg::calc_segment_point_sq_distance	(	double	x1,
		double	y1,
		double	x2,
		double	y2,
		double	x,
		double	y
	)

    {
        return 
            calc_segment_point_sq_distance(
                x1, y1, x2, y2, x, y,
                calc_segment_point_u(x1, y1, x2, y2, x, y));
    }

References calc_segment_point_sq_distance(), and calc_segment_point_u().

Here is the call graph for this function:

calc_segment_point_sq_distance() [2/2]

AGG_INLINE double agg::calc_segment_point_sq_distance	(	double	x1,
		double	y1,
		double	x2,
		double	y2,
		double	x,
		double	y,
		double	u
	)

    {
        if(u <= 0)
        {
          return calc_sq_distance(x, y, x1, y1);
        }
        else 
        if(u >= 1)
        {
          return calc_sq_distance(x, y, x2, y2);
        }
        return calc_sq_distance(x, y, x1 + u * (x2 - x1), y1 + u * (y2 - y1));
    }

References calc_sq_distance().

Referenced by calc_segment_point_sq_distance().

Here is the call graph for this function:

Here is the caller graph for this function:

calc_segment_point_u()

AGG_INLINE double agg::calc_segment_point_u	(	double	x1,
		double	y1,
		double	x2,
		double	y2,
		double	x,
		double	y
	)

    {
        double dx = x2 - x1;
        double dy = y2 - y1;
 
        if(dx == 0 && dy == 0)
        {
          return 0;
        }
 
        double pdx = x - x1;
        double pdy = y - y1;
 
        return (pdx * dx + pdy * dy) / (dx * dx + dy * dy);
    }

Referenced by calc_segment_point_sq_distance().

Here is the caller graph for this function:

calc_sq_distance()

AGG_INLINE double agg::calc_sq_distance	(	double	x1,
		double	y1,
		double	x2,
		double	y2
	)

    {
        double dx = x2-x1;
        double dy = y2-y1;
        return dx * dx + dy * dy;
    }

Referenced by calc_segment_point_sq_distance().

Here is the caller graph for this function:

calc_triangle_area()

AGG_INLINE double agg::calc_triangle_area	(	double	x1,
		double	y1,
		double	x2,
		double	y2,
		double	x3,
		double	y3
	)

    {
        return (x1*y2 - x2*y1 + x2*y3 - x3*y2 + x3*y1 - x1*y3) * 0.5;
    }

clear_orientation()

unsigned agg::clear_orientation ( unsigned  c )

inline

    {
        return c & ~(path_flags_cw | path_flags_ccw);
    }

References path_flags_ccw, and path_flags_cw.

Referenced by set_orientation().

Here is the caller graph for this function:

clip_liang_barsky()

template<class T >

unsigned agg::clip_liang_barsky ( T  x1, T  y1, T  x2, T  y2, const rect_base< T > &  clip_box, T *  x, T *  y  )

inline

    {
        const double nearzero = 1e-30;
 
        double deltax = x2 - x1;
        double deltay = y2 - y1; 
        double xin;
        double xout;
        double yin;
        double yout;
        double tinx;
        double tiny;
        double toutx;
        double touty;  
        double tin1;
        double tin2;
        double tout1;
        unsigned np = 0;
 
        if(deltax == 0.0) 
        {   
            // bump off of the vertical
            deltax = (x1 > clip_box.x1) ? -nearzero : nearzero;
        }
 
        if(deltay == 0.0) 
        { 
            // bump off of the horizontal 
            deltay = (y1 > clip_box.y1) ? -nearzero : nearzero;
        }
        
        if(deltax > 0.0) 
        {                
            // points to right
            xin  = clip_box.x1;
            xout = clip_box.x2;
        }
        else 
        {
            xin  = clip_box.x2;
            xout = clip_box.x1;
        }
 
        if(deltay > 0.0) 
        {
            // points up
            yin  = clip_box.y1;
            yout = clip_box.y2;
        }
        else 
        {
            yin  = clip_box.y2;
            yout = clip_box.y1;
        }
        
        tinx = (xin - x1) / deltax;
        tiny = (yin - y1) / deltay;
        
        if (tinx < tiny) 
        {
            // hits x first
            tin1 = tinx;
            tin2 = tiny;
        }
        else
        {
            // hits y first
            tin1 = tiny;
            tin2 = tinx;
        }
        
        if(tin1 <= 1.0) 
        {
            if(0.0 < tin1) 
            {
                *x++ = (T)xin;
                *y++ = (T)yin;
                ++np;
            }
 
            if(tin2 <= 1.0)
            {
                toutx = (xout - x1) / deltax;
                touty = (yout - y1) / deltay;
                
                tout1 = (toutx < touty) ? toutx : touty;
                
                if(tin2 > 0.0 || tout1 > 0.0) 
                {
                    if(tin2 <= tout1) 
                    {
                        if(tin2 > 0.0) 
                        {
                            if(tinx > tiny) 
                            {
                                *x++ = (T)xin;
                                *y++ = (T)(y1 + tinx * deltay);
                            }
                            else 
                            {
                                *x++ = (T)(x1 + tiny * deltax);
                                *y++ = (T)yin;
                            }
                            ++np;
                        }
 
                        if(tout1 < 1.0) 
                        {
                            if(toutx < touty) 
                            {
                                *x++ = (T)xout;
                                *y++ = (T)(y1 + toutx * deltay);
                            }
                            else 
                            {
                                *x++ = (T)(x1 + touty * deltax);
                                *y++ = (T)yout;
                            }
                        }
                        else 
                        {
                            *x++ = x2;
                            *y++ = y2;
                        }
                        ++np;
                    }
                    else 
                    {
                        if(tinx > tiny) 
                        {
                            *x++ = (T)xin;
                            *y++ = (T)yout;
                        }
                        else 
                        {
                            *x++ = (T)xout;
                            *y++ = (T)yin;
                        }
                        ++np;
                    }
                }
            }
        }
        return np;
    }

References agg::rect_base< T >::x1, agg::rect_base< T >::x2, agg::rect_base< T >::y1, and agg::rect_base< T >::y2.

clip_line_segment()

template<class T >

unsigned agg::clip_line_segment	(	T *	x1,
		T *	y1,
		T *	x2,
		T *	y2,
		const rect_base< T > &	clip_box
	)

    {
        unsigned f1 = clipping_flags(*x1, *y1, clip_box);
        unsigned f2 = clipping_flags(*x2, *y2, clip_box);
        unsigned ret = 0;
 
        if((f2 | f1) == 0)
        {
            // Fully visible
            return 0;
        }
 
        if((f1 & clipping_flags_x_clipped) != 0 && 
           (f1 & clipping_flags_x_clipped) == (f2 & clipping_flags_x_clipped))
        {
            // Fully clipped
            return 4;
        }
 
        if((f1 & clipping_flags_y_clipped) != 0 && 
           (f1 & clipping_flags_y_clipped) == (f2 & clipping_flags_y_clipped))
        {
            // Fully clipped
            return 4;
        }
 
        T tx1 = *x1;
        T ty1 = *y1;
        T tx2 = *x2;
        T ty2 = *y2;
        if(f1) 
        {   
            if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x1, y1, f1)) 
            {
                return 4;
            }
            if(*x1 == *x2 && *y1 == *y2) 
            {
                return 4;
            }
            ret |= 1;
        }
        if(f2) 
        {
            if(!clip_move_point(tx1, ty1, tx2, ty2, clip_box, x2, y2, f2))
            {
                return 4;
            }
            if(*x1 == *x2 && *y1 == *y2) 
            {
                return 4;
            }
            ret |= 2;
        }
        return ret;
    }

References clip_move_point(), clipping_flags(), clipping_flags_x_clipped, and clipping_flags_y_clipped.

Here is the call graph for this function:

clip_move_point()

template<class T >

bool agg::clip_move_point	(	T	x1,
		T	y1,
		T	x2,
		T	y2,
		const rect_base< T > &	clip_box,
		T *	x,
		T *	y,
		unsigned	flags
	)

    {
       T bound;
 
       if(flags & clipping_flags_x_clipped)
       {
           if(x1 == x2)
           {
               return false;
           }
           bound = (flags & clipping_flags_x1_clipped) ? clip_box.x1 : clip_box.x2;
           *y = (T)(double(bound - x1) * (y2 - y1) / (x2 - x1) + y1);
           *x = bound;
       }
 
       flags = clipping_flags_y(*y, clip_box);
       if(flags & clipping_flags_y_clipped)
       {
           if(y1 == y2)
           {
               return false;
           }
           bound = (flags & clipping_flags_y1_clipped) ? clip_box.y1 : clip_box.y2;
           *x = (T)(double(bound - y1) * (x2 - x1) / (y2 - y1) + x1);
           *y = bound;
       }
       return true;
    }

References clipping_flags_x1_clipped, clipping_flags_x_clipped, clipping_flags_y(), clipping_flags_y1_clipped, clipping_flags_y_clipped, agg::rect_base< T >::x1, agg::rect_base< T >::x2, agg::rect_base< T >::y1, and agg::rect_base< T >::y2.

Referenced by clip_line_segment().

Here is the call graph for this function:

Here is the caller graph for this function:

clipping_flags()

template<class T >

unsigned agg::clipping_flags ( T  x, T  y, const rect_base< T > &  clip_box  )

inline

    {
        return  (x > clip_box.x2) |
               ((y > clip_box.y2) << 1) |
               ((x < clip_box.x1) << 2) |
               ((y < clip_box.y1) << 3);
    }

References agg::rect_base< T >::x1, agg::rect_base< T >::x2, agg::rect_base< T >::y1, and agg::rect_base< T >::y2.

Referenced by clip_line_segment(), agg::rasterizer_sl_clip< Conv >::line_to(), and agg::rasterizer_sl_clip< Conv >::move_to().

Here is the caller graph for this function:

clipping_flags_x()

template<class T >

unsigned agg::clipping_flags_x ( T  x, const rect_base< T > &  clip_box  )

inline

    {
        return  (x > clip_box.x2) | ((x < clip_box.x1) << 2);
    }

References agg::rect_base< T >::x1, and agg::rect_base< T >::x2.

clipping_flags_y()

template<class T >

unsigned agg::clipping_flags_y ( T  y, const rect_base< T > &  clip_box  )

inline

    {
        return ((y > clip_box.y2) << 1) | ((y < clip_box.y1) << 3);
    }

References agg::rect_base< T >::y1, and agg::rect_base< T >::y2.

Referenced by clip_move_point(), and agg::rasterizer_sl_clip< Conv >::line_to().

Here is the caller graph for this function:

cross_product()

AGG_INLINE double agg::cross_product	(	double	x1,
		double	y1,
		double	x2,
		double	y2,
		double	x,
		double	y
	)

    {
        return (x - x2) * (y2 - y1) - (y - y2) * (x2 - x1);
    }

Referenced by dilate_triangle(), and point_in_triangle().

Here is the caller graph for this function:

deg2rad()

double agg::deg2rad ( double  deg )

inline

    {
        return deg * pi / 180.0;
    }

References pi.

dilate_triangle()

AGG_INLINE void agg::dilate_triangle	(	double	x1,
		double	y1,
		double	x2,
		double	y2,
		double	x3,
		double	y3,
		double *	x,
		double *	y,
		double	d
	)

    {
        double dx1=0.0;
        double dy1=0.0; 
        double dx2=0.0;
        double dy2=0.0; 
        double dx3=0.0;
        double dy3=0.0; 
        double loc = cross_product(x1, y1, x2, y2, x3, y3);
        if(fabs(loc) > intersection_epsilon)
        {
            if(cross_product(x1, y1, x2, y2, x3, y3) > 0.0) 
            {
                d = -d;
            }
            calc_orthogonal(d, x1, y1, x2, y2, &dx1, &dy1);
            calc_orthogonal(d, x2, y2, x3, y3, &dx2, &dy2);
            calc_orthogonal(d, x3, y3, x1, y1, &dx3, &dy3);
        }
        *x++ = x1 + dx1;  *y++ = y1 + dy1;
        *x++ = x2 + dx1;  *y++ = y2 + dy1;
        *x++ = x2 + dx2;  *y++ = y2 + dy2;
        *x++ = x3 + dx2;  *y++ = y3 + dy2;
        *x++ = x3 + dx3;  *y++ = y3 + dy3;
        *x++ = x1 + dx3;  *y++ = y1 + dy3;
    }

References calc_orthogonal(), cross_product(), and intersection_epsilon.

Here is the call graph for this function:

fast_sqrt()

AGG_INLINE unsigned agg::fast_sqrt

(

unsigned

val

)

    {
    #if defined(_M_IX86) && defined(_MSC_VER) && !defined(AGG_NO_ASM)
        //For Ix86 family processors this assembler code is used. 
        //The key command here is bsr - determination the number of the most 
        //significant bit of the value. For other processors
        //(and maybe compilers) the pure C "#else" section is used.
        __asm
        {
            mov ebx, val
            mov edx, 11
            bsr ecx, ebx
            sub ecx, 9
            jle less_than_9_bits
            shr ecx, 1
            adc ecx, 0
            sub edx, ecx
            shl ecx, 1
            shr ebx, cl
    less_than_9_bits:
            xor eax, eax
            mov  ax, g_sqrt_table[ebx*2]
            mov ecx, edx
            shr eax, cl
        }
    #else
 
        //This code is actually pure C and portable to most 
        //arcitectures including 64bit ones. 
        unsigned t = val;
        int bit=0;
        unsigned shift = 11;
 
        //The following piece of code is just an emulation of the
        //Ix86 assembler command "bsr" (see above). However on old
        //Intels (like Intel MMX 233MHz) this code is about twice 
        //faster (sic!) then just one "bsr". On PIII and PIV the
        //bsr is optimized quite well.
        bit = t >> 24;
        if(bit)
        {
            bit = g_elder_bit_table[bit] + 24;
        }
        else
        {
            bit = (t >> 16) & 0xFF;
            if(bit)
            {
                bit = g_elder_bit_table[bit] + 16;
            }
            else
            {
                bit = (t >> 8) & 0xFF;
                if(bit)
                {
                    bit = g_elder_bit_table[bit] + 8;
                }
                else
                {
                    bit = g_elder_bit_table[t];
                }
            }
        }
 
        //This code calculates the sqrt.
        bit -= 9;
        if(bit > 0)
        {
            bit = (bit >> 1) + (bit & 1);
            shift -= bit;
            val >>= (bit << 1);
        }
        return g_sqrt_table[val] >> shift;
    #endif
    }

References g_elder_bit_table, and g_sqrt_table.

get_close_flag()

unsigned agg::get_close_flag ( unsigned  c )

inline

    {
        return c & path_flags_close; 
    }

References path_flags_close.

get_orientation()

unsigned agg::get_orientation ( unsigned  c )

inline

    {
        return c & (path_flags_cw | path_flags_ccw);
    }

References path_flags_ccw, and path_flags_cw.

iceil()

AGG_INLINE int agg::iceil

(

double

v

)

    {
        return int(ceil(v));
    }

References ceil().

Here is the call graph for this function:

ifloor()

AGG_INLINE int agg::ifloor

(

double

v

)

    {
        int i = int(v);
        return i - (i > v);
    }

int_greater()

bool agg::int_greater ( int  a, int  b  )

inline

{ return a > b; }

int_less()

bool agg::int_less ( int  a, int  b  )

inline

{ return a < b; }

intersect_rectangles()

template<class Rect >

Rect agg::intersect_rectangles ( const Rect &  r1, const Rect &  r2  )

inline

    {
        Rect r = r1;
 
        // First process x2,y2 because the other order 
        // results in Internal Compiler Error under 
        // Microsoft Visual C++ .NET 2003 69462-335-0000007-18038 in 
        // case of "Maximize Speed" optimization option.
        //-----------------
        if(r.x2 > r2.x2) r.x2 = r2.x2; 
        if(r.y2 > r2.y2) r.y2 = r2.y2;
        if(r.x1 < r2.x1) r.x1 = r2.x1;
        if(r.y1 < r2.y1) r.y1 = r2.y1;
        return r;
    }

intersection_exists()

AGG_INLINE bool agg::intersection_exists	(	double	x1,
		double	y1,
		double	x2,
		double	y2,
		double	x3,
		double	y3,
		double	x4,
		double	y4
	)

    {
        // It's less expensive but you can't control the 
        // boundary conditions: Less or LessEqual
        double dx1 = x2 - x1;
        double dy1 = y2 - y1;
        double dx2 = x4 - x3;
        double dy2 = y4 - y3;
        return ((x3 - x2) * dy1 - (y3 - y2) * dx1 < 0.0) != 
               ((x4 - x2) * dy1 - (y4 - y2) * dx1 < 0.0) &&
               ((x1 - x4) * dy2 - (y1 - y4) * dx2 < 0.0) !=
               ((x2 - x4) * dy2 - (y2 - y4) * dx2 < 0.0);
 
        // It's is more expensive but more flexible 
        // in terms of boundary conditions.
        //--------------------
        //double den  = (x2-x1) * (y4-y3) - (y2-y1) * (x4-x3);
        //if(fabs(den) < intersection_epsilon) return false;
        //double nom1 = (x4-x3) * (y1-y3) - (y4-y3) * (x1-x3);
        //double nom2 = (x2-x1) * (y1-y3) - (y2-y1) * (x1-x3);
        //double ua = nom1 / den;
        //double ub = nom2 / den;
        //return ua >= 0.0 && ua <= 1.0 && ub >= 0.0 && ub <= 1.0;
    }

invert_container()

template<class Array >

void agg::invert_container

(

Array &

arr

)

    {
        int i = 0;
        int j = arr.size() - 1;
        while(i < j)
        {
            swap_elements(arr[i++], arr[j--]);
        }
    }

References swap_elements().

Here is the call graph for this function:

iround()

AGG_INLINE int agg::iround

(

double

v

)

    {
        return int((v < 0.0) ? v - 0.5 : v + 0.5);
    }

Referenced by agg::saturation< Limit >::iround(), agg::ras_conv_int::mul_div(), agg::ras_conv_int_3x::mul_div(), agg::ras_conv_int::upscale(), agg::ras_conv_int_3x::upscale(), agg::ras_conv_dbl::xi(), agg::ras_conv_dbl_3x::xi(), agg::ras_conv_dbl::yi(), and agg::ras_conv_dbl_3x::yi().

Here is the caller graph for this function:

is_ccw()

bool agg::is_ccw ( unsigned  c )

inline

    {
        return (c & path_flags_ccw) != 0;
    }

References path_flags_ccw.

is_close()

bool agg::is_close ( unsigned  c )

inline

    {
        return (c & ~(path_flags_cw | path_flags_ccw)) ==
               (path_cmd_end_poly | path_flags_close); 
    }

References path_cmd_end_poly, path_flags_ccw, path_flags_close, and path_flags_cw.

Referenced by agg::rasterizer_scanline_aa< Clip >::add_vertex(), and agg::rasterizer_scanline_aa_nogamma< Clip >::add_vertex().

Here is the caller graph for this function:

is_closed()

bool agg::is_closed ( unsigned  c )

inline

    {
        return (c & path_flags_close) != 0; 
    }

References path_flags_close.

is_curve()

bool agg::is_curve ( unsigned  c )

inline

    {
        return c == path_cmd_curve3 || c == path_cmd_curve4;
    }

References path_cmd_curve3, and path_cmd_curve4.

Referenced by agg::path_base< VertexContainer >::curve3(), and agg::path_base< VertexContainer >::curve4().

Here is the caller graph for this function:

is_curve3()

bool agg::is_curve3 ( unsigned  c )

inline

    {
        return c == path_cmd_curve3;
    }

References path_cmd_curve3.

is_curve4()

bool agg::is_curve4 ( unsigned  c )

inline

    {
        return c == path_cmd_curve4;
    }

References path_cmd_curve4.

is_cw()

bool agg::is_cw ( unsigned  c )

inline

    {
        return (c & path_flags_cw) != 0;
    }

References path_flags_cw.

is_drawing()

bool agg::is_drawing ( unsigned  c )

inline

    {
        return c >= path_cmd_line_to && c < path_cmd_end_poly;
    }

References path_cmd_end_poly, and path_cmd_line_to.

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

Here is the caller graph for this function:

is_end_poly()

bool agg::is_end_poly ( unsigned  c )

inline

    {
        return (c & path_cmd_mask) == path_cmd_end_poly;
    }

References path_cmd_end_poly, and path_cmd_mask.

Referenced by agg::path_base< VertexContainer >::arrange_polygon_orientation(), and is_next_poly().

Here is the caller graph for this function:

is_equal_eps()

template<class T >

bool agg::is_equal_eps ( T  v1, T  v2, T  epsilon  )

inline

    {
  bool neg1 = v1 < 0.0;
  bool neg2 = v2 < 0.0;
 
  if (neg1 != neg2)
      return std::fabs(v1) < epsilon && std::fabs(v2) < epsilon;
 
        int int1, int2;
  std::frexp(v1, &int1);
  std::frexp(v2, &int2);
  int min12 = int1 < int2 ? int1 : int2;
 
  v1 = std::ldexp(v1, -min12);
  v2 = std::ldexp(v2, -min12);
 
  return std::fabs(v1 - v2) < epsilon;
    }

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

Here is the caller graph for this function:

is_line_to()

bool agg::is_line_to ( unsigned  c )

inline

    {
        return c == path_cmd_line_to;
    }

References path_cmd_line_to.

is_move_to()

bool agg::is_move_to ( unsigned  c )

inline

    {
        return c == path_cmd_move_to;
    }

References path_cmd_move_to.

Referenced by agg::rasterizer_scanline_aa< Clip >::add_vertex(), agg::rasterizer_scanline_aa_nogamma< Clip >::add_vertex(), agg::path_base< VertexContainer >::align_path(), agg::path_base< VertexContainer >::arrange_polygon_orientation(), agg::path_base< VertexContainer >::invert_polygon(), is_next_poly(), and agg::path_base< VertexContainer >::join_path().

Here is the caller graph for this function:

is_next_poly()

bool agg::is_next_poly ( unsigned  c )

inline

    {
        return is_stop(c) || is_move_to(c) || is_end_poly(c);
    }

References is_end_poly(), is_move_to(), and is_stop().

Referenced by agg::path_base< VertexContainer >::arrange_polygon_orientation(), and agg::path_base< VertexContainer >::invert_polygon().

Here is the call graph for this function:

Here is the caller graph for this function:

is_oriented()

bool agg::is_oriented ( unsigned  c )

inline

    {
        return (c & (path_flags_cw | path_flags_ccw)) != 0; 
    }

References path_flags_ccw, and path_flags_cw.

is_stop()

bool agg::is_stop ( unsigned  c )

inline

    { 
        return c == path_cmd_stop;
    }

References path_cmd_stop.

Referenced by agg::rasterizer_scanline_aa< Clip >::add_path(), agg::rasterizer_scanline_aa_nogamma< Clip >::add_path(), agg::path_base< VertexContainer >::arrange_orientations(), agg::path_base< VertexContainer >::concat_path(), is_next_poly(), agg::path_base< VertexContainer >::join_path(), agg::path_base< VertexContainer >::start_new_path(), agg::path_base< VertexContainer >::transform(), and agg::path_base< VertexContainer >::translate().

Here is the caller graph for this function:

is_vertex()

bool agg::is_vertex ( unsigned  c )

inline

    {
        return c >= path_cmd_move_to && c < path_cmd_end_poly;
    }

References path_cmd_end_poly, and path_cmd_move_to.

Referenced by agg::rasterizer_scanline_aa< Clip >::add_vertex(), agg::rasterizer_scanline_aa_nogamma< Clip >::add_vertex(), agg::path_base< VertexContainer >::arc_to(), agg::path_base< VertexContainer >::arrange_polygon_orientation(), agg::path_base< VertexContainer >::curve3(), agg::path_base< VertexContainer >::curve4(), agg::path_base< VertexContainer >::end_poly(), agg::path_base< VertexContainer >::flip_x(), agg::path_base< VertexContainer >::flip_y(), agg::path_base< VertexContainer >::invert_polygon(), agg::path_base< VertexContainer >::join_path(), agg::path_base< VertexContainer >::rel_to_abs(), agg::path_base< VertexContainer >::transform(), agg::path_base< VertexContainer >::transform_all_paths(), agg::path_base< VertexContainer >::translate(), agg::path_base< VertexContainer >::translate_all_paths(), and agg::conv_transform< VertexSource, Transformer >::vertex().

Here is the caller graph for this function:

linear_to_sRGB()

double agg::linear_to_sRGB ( double  x )

inline

    {
        return (x <= 0.0031308) ? (x * 12.92) : (1.055 * pow(x, 1 / 2.4) - 0.055);
    }

Referenced by agg::sRGB_lut< float >::sRGB_lut(), agg::sRGB_lut< int16u >::sRGB_lut(), and agg::sRGB_lut< int8u >::sRGB_lut().

Here is the caller graph for this function:

operator*()

rgba agg::operator* ( const rgba &  a, double  b  )

inline

    {
        return rgba(a) *= b;
    }

operator+()

rgba agg::operator+ ( const rgba &  a, const rgba &  b  )

inline

    {
        return rgba(a) += b;
    }

point_in_triangle()

AGG_INLINE bool agg::point_in_triangle	(	double	x1,
		double	y1,
		double	x2,
		double	y2,
		double	x3,
		double	y3,
		double	x,
		double	y
	)

    {
        bool cp1 = cross_product(x1, y1, x2, y2, x, y) < 0.0;
        bool cp2 = cross_product(x2, y2, x3, y3, x, y) < 0.0;
        bool cp3 = cross_product(x3, y3, x1, y1, x, y) < 0.0;
        return cp1 == cp2 && cp2 == cp3 && cp3 == cp1;
    }

References cross_product().

Here is the call graph for this function:

qsort_cells()

template<class Cell >

void agg::qsort_cells	(	Cell **	start,
		unsigned	num
	)

    {
        Cell**  stack[80];
        Cell*** top; 
        Cell**  limit;
        Cell**  base;
 
        limit = start + num;
        base  = start;
        top   = stack;
 
        for (;;)
        {
            int len = int(limit - base);
 
            Cell** i;
            Cell** j;
            Cell** pivot;
 
            if(len > qsort_threshold)
            {
                // we use base + len/2 as the pivot
                pivot = base + len / 2;
                swap_cells(base, pivot);
 
                i = base + 1;
                j = limit - 1;
 
                // now ensure that *i <= *base <= *j 
                if((*j)->x < (*i)->x)
                {
                    swap_cells(i, j);
                }
 
                if((*base)->x < (*i)->x)
                {
                    swap_cells(base, i);
                }
 
                if((*j)->x < (*base)->x)
                {
                    swap_cells(base, j);
                }
 
                for(;;)
                {
                    int x = (*base)->x;
                    do i++; while( (*i)->x < x );
                    do j--; while( x < (*j)->x );
 
                    if(i > j)
                    {
                        break;
                    }
 
                    swap_cells(i, j);
                }
 
                swap_cells(base, j);
 
                // now, push the largest sub-array
                if(j - base > limit - i)
                {
                    top[0] = base;
                    top[1] = j;
                    base   = i;
                }
                else
                {
                    top[0] = i;
                    top[1] = limit;
                    limit  = j;
                }
                top += 2;
            }
            else
            {
                // the sub-array is small, perform insertion sort
                j = base;
                i = j + 1;
 
                for(; i < limit; j = i, i++)
                {
                    for(; j[1]->x < (*j)->x; j--)
                    {
                        swap_cells(j + 1, j);
                        if (j == base)
                        {
                            break;
                        }
                    }
                }
 
                if(top > stack)
                {
                    top  -= 2;
                    base  = top[0];
                    limit = top[1];
                }
                else
                {
                    break;
                }
            }
        }
    }

References qsort_threshold, and swap_cells().

Referenced by agg::rasterizer_cells_aa< Cell >::sort_cells().

Here is the call graph for this function:

Here is the caller graph for this function:

quick_sort()

template<class Array , class Less >

void agg::quick_sort	(	Array &	arr,
		Less	less
	)

    {
        if(arr.size() < 2) return;
 
        typename Array::value_type* e1;
        typename Array::value_type* e2;
 
        int  stack[80];
        int* top = stack; 
        int  limit = arr.size();
        int  base = 0;
 
        for(;;)
        {
            int len = limit - base;
 
            int i;
            int j;
            int pivot;
 
            if(len > quick_sort_threshold)
            {
                // we use base + len/2 as the pivot
                pivot = base + len / 2;
                swap_elements(arr[base], arr[pivot]);
 
                i = base + 1;
                j = limit - 1;
 
                // now ensure that *i <= *base <= *j 
                e1 = &(arr[j]); 
                e2 = &(arr[i]);
                if(less(*e1, *e2)) swap_elements(*e1, *e2);
 
                e1 = &(arr[base]); 
                e2 = &(arr[i]);
                if(less(*e1, *e2)) swap_elements(*e1, *e2);
 
                e1 = &(arr[j]); 
                e2 = &(arr[base]);
                if(less(*e1, *e2)) swap_elements(*e1, *e2);
 
                for(;;)
                {
                    do i++; while( less(arr[i], arr[base]) );
                    do j--; while( less(arr[base], arr[j]) );
 
                    if( i > j )
                    {
                        break;
                    }
 
                    swap_elements(arr[i], arr[j]);
                }
 
                swap_elements(arr[base], arr[j]);
 
                // now, push the largest sub-array
                if(j - base > limit - i)
                {
                    top[0] = base;
                    top[1] = j;
                    base   = i;
                }
                else
                {
                    top[0] = i;
                    top[1] = limit;
                    limit  = j;
                }
                top += 2;
            }
            else
            {
                // the sub-array is small, perform insertion sort
                j = base;
                i = j + 1;
 
                for(; i < limit; j = i, i++)
                {
                    for(; less(*(e1 = &(arr[j + 1])), *(e2 = &(arr[j]))); j--)
                    {
                        swap_elements(*e1, *e2);
                        if(j == base)
                        {
                            break;
                        }
                    }
                }
                if(top > stack)
                {
                    top  -= 2;
                    base  = top[0];
                    limit = top[1];
                }
                else
                {
                    break;
                }
            }
        }
    }

References quick_sort_threshold, and swap_elements().

Here is the call graph for this function:

rad2deg()

double agg::rad2deg ( double  rad )

inline

    {
        return rad * 180.0 / pi;
    }

References pi.

remove_duplicates()

template<class Array , class Equal >

unsigned agg::remove_duplicates	(	Array &	arr,
		Equal	equal
	)

    {
        if(arr.size() < 2) return arr.size();
 
        unsigned i, j;
        for(i = 1, j = 1; i < arr.size(); i++)
        {
            typename Array::value_type& e = arr[i];
            if(!equal(e, arr[i - 1]))
            {
                arr[j++] = e;
            }
        }
        return j;
    }

render_all_paths()

template<class Rasterizer , class Scanline , class Renderer , class VertexSource , class ColorStorage , class PathId >

void agg::render_all_paths	(	Rasterizer &	ras,
		Scanline &	sl,
		Renderer &	r,
		VertexSource &	vs,
		const ColorStorage &	as,
		const PathId &	path_id,
		unsigned	num_paths
	)

    {
        for(unsigned i = 0; i < num_paths; i++)
        {
            ras.reset();
            ras.add_path(vs, path_id[i]);
            r.color(as[i]);
            render_scanlines(ras, sl, r);
        }
    }

References render_scanlines().

Here is the call graph for this function:

render_scanline_aa()

template<class Scanline , class BaseRenderer , class SpanAllocator , class SpanGenerator >

void agg::render_scanline_aa	(	const Scanline &	sl,
		BaseRenderer &	ren,
		SpanAllocator &	alloc,
		SpanGenerator &	span_gen
	)

    {
        int y = sl.y();
 
        unsigned num_spans = sl.num_spans();
        typename Scanline::const_iterator span = sl.begin();
        for(;;)
        {
            int x = span->x;
            int len = span->len;
            const typename Scanline::cover_type* covers = span->covers;
 
            if(len < 0) len = -len;
            typename BaseRenderer::color_type* colors = alloc.allocate(len);
            span_gen.generate(colors, x, y, len);
            ren.blend_color_hspan(x, y, len, colors, 
                                  (span->len < 0) ? 0 : covers, *covers);
 
            if(--num_spans == 0) break;
            ++span;
        }
    }

Referenced by agg::renderer_scanline_aa< BaseRenderer, SpanAllocator, SpanGenerator >::render(), and render_scanlines_aa().

Here is the caller graph for this function:

render_scanline_aa_solid()

template<class Scanline , class BaseRenderer , class ColorT >

void agg::render_scanline_aa_solid	(	const Scanline &	sl,
		BaseRenderer &	ren,
		const ColorT &	color
	)

    {
        int y = sl.y();
        unsigned num_spans = sl.num_spans();
        typename Scanline::const_iterator span = sl.begin();
 
        for(;;)
        {
            int x = span->x;
            if(span->len > 0)
            {
                ren.blend_solid_hspan(x, y, (unsigned)span->len, 
                                      color, 
                                      span->covers);
            }
            else
            {
                ren.blend_hline(x, y, (unsigned)(x - span->len - 1), 
                                color, 
                                *(span->covers));
            }
            if(--num_spans == 0) break;
            ++span;
        }
    }

Referenced by agg::renderer_scanline_aa_solid< BaseRenderer >::render(), render_scanlines_compound(), and render_scanlines_compound_layered().

Here is the caller graph for this function:

render_scanline_bin()

template<class Scanline , class BaseRenderer , class SpanAllocator , class SpanGenerator >

void agg::render_scanline_bin	(	const Scanline &	sl,
		BaseRenderer &	ren,
		SpanAllocator &	alloc,
		SpanGenerator &	span_gen
	)

    {
        int y = sl.y();
 
        unsigned num_spans = sl.num_spans();
        typename Scanline::const_iterator span = sl.begin();
        for(;;)
        {
            int x = span->x;
            int len = span->len;
            if(len < 0) len = -len;
            typename BaseRenderer::color_type* colors = alloc.allocate(len);
            span_gen.generate(colors, x, y, len);
            ren.blend_color_hspan(x, y, len, colors, 0, cover_full); 
            if(--num_spans == 0) break;
            ++span;
        }
    }

References cover_full.

Referenced by agg::renderer_scanline_bin< BaseRenderer, SpanAllocator, SpanGenerator >::render(), and render_scanlines_bin().

Here is the caller graph for this function:

render_scanline_bin_solid()

template<class Scanline , class BaseRenderer , class ColorT >

void agg::render_scanline_bin_solid	(	const Scanline &	sl,
		BaseRenderer &	ren,
		const ColorT &	color
	)

    {
        unsigned num_spans = sl.num_spans();
        typename Scanline::const_iterator span = sl.begin();
        for(;;)
        {
            ren.blend_hline(span->x, 
                            sl.y(), 
                            span->x - 1 + ((span->len < 0) ? 
                                              -span->len : 
                                               span->len), 
                               color, 
                               cover_full);
            if(--num_spans == 0) break;
            ++span;
        }
    }

References cover_full.

Referenced by agg::renderer_scanline_bin_solid< BaseRenderer >::render().

Here is the caller graph for this function:

render_scanlines()

template<class Rasterizer , class Scanline , class Renderer >

void agg::render_scanlines	(	Rasterizer &	ras,
		Scanline &	sl,
		Renderer &	ren
	)

    {
        if(ras.rewind_scanlines())
        {
            sl.reset(ras.min_x(), ras.max_x());
            ren.prepare();
            while(ras.sweep_scanline(sl))
            {
                ren.render(sl);
            }
        }
    }

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

Here is the caller graph for this function:

render_scanlines_aa()

template<class Rasterizer , class Scanline , class BaseRenderer , class SpanAllocator , class SpanGenerator >

void agg::render_scanlines_aa	(	Rasterizer &	ras,
		Scanline &	sl,
		BaseRenderer &	ren,
		SpanAllocator &	alloc,
		SpanGenerator &	span_gen
	)

    {
        if(ras.rewind_scanlines())
        {
            sl.reset(ras.min_x(), ras.max_x());
            span_gen.prepare();
            while(ras.sweep_scanline(sl))
            {
                render_scanline_aa(sl, ren, alloc, span_gen);
            }
        }
    }

References render_scanline_aa().

Here is the call graph for this function:

render_scanlines_aa_solid()

template<class Rasterizer , class Scanline , class BaseRenderer , class ColorT >

void agg::render_scanlines_aa_solid	(	Rasterizer &	ras,
		Scanline &	sl,
		BaseRenderer &	ren,
		const ColorT &	color
	)

    {
        if(ras.rewind_scanlines())
        {
            // Explicitly convert "color" to the BaseRenderer color type.
            // For example, it can be called with color type "rgba", while
            // "rgba8" is needed. Otherwise it will be implicitly 
            // converted in the loop many times.
            //----------------------
            typename BaseRenderer::color_type ren_color = color;
 
            sl.reset(ras.min_x(), ras.max_x());
            while(ras.sweep_scanline(sl))
            {
                //render_scanline_aa_solid(sl, ren, ren_color);
 
                // This code is equivalent to the above call (copy/paste). 
                // It's just a "manual" optimization for old compilers,
                // like Microsoft Visual C++ v6.0
                //-------------------------------
                int y = sl.y();
                unsigned num_spans = sl.num_spans();
                typename Scanline::const_iterator span = sl.begin();
 
                for(;;)
                {
                    int x = span->x;
                    if(span->len > 0)
                    {
                        ren.blend_solid_hspan(x, y, (unsigned)span->len, 
                                              ren_color, 
                                              span->covers);
                    }
                    else
                    {
                        ren.blend_hline(x, y, (unsigned)(x - span->len - 1), 
                                        ren_color, 
                                        *(span->covers));
                    }
                    if(--num_spans == 0) break;
                    ++span;
                }
            }
        }
    }

render_scanlines_bin()

template<class Rasterizer , class Scanline , class BaseRenderer , class SpanAllocator , class SpanGenerator >

void agg::render_scanlines_bin	(	Rasterizer &	ras,
		Scanline &	sl,
		BaseRenderer &	ren,
		SpanAllocator &	alloc,
		SpanGenerator &	span_gen
	)

    {
        if(ras.rewind_scanlines())
        {
            sl.reset(ras.min_x(), ras.max_x());
            span_gen.prepare();
            while(ras.sweep_scanline(sl))
            {
                render_scanline_bin(sl, ren, alloc, span_gen);
            }
        }
    }

References render_scanline_bin().

Here is the call graph for this function:

render_scanlines_bin_solid()

template<class Rasterizer , class Scanline , class BaseRenderer , class ColorT >

void agg::render_scanlines_bin_solid	(	Rasterizer &	ras,
		Scanline &	sl,
		BaseRenderer &	ren,
		const ColorT &	color
	)

    {
        if(ras.rewind_scanlines())
        {
            // Explicitly convert "color" to the BaseRenderer color type.
            // For example, it can be called with color type "rgba", while
            // "rgba8" is needed. Otherwise it will be implicitly 
            // converted in the loop many times.
            //----------------------
            typename BaseRenderer::color_type ren_color(color);
 
            sl.reset(ras.min_x(), ras.max_x());
            while(ras.sweep_scanline(sl))
            {
                //render_scanline_bin_solid(sl, ren, ren_color);
 
                // This code is equivalent to the above call (copy/paste). 
                // It's just a "manual" optimization for old compilers,
                // like Microsoft Visual C++ v6.0
                //-------------------------------
                unsigned num_spans = sl.num_spans();
                typename Scanline::const_iterator span = sl.begin();
                for(;;)
                {
                    ren.blend_hline(span->x, 
                                    sl.y(), 
                                    span->x - 1 + ((span->len < 0) ? 
                                                      -span->len : 
                                                       span->len), 
                                       ren_color, 
                                       cover_full);
                    if(--num_spans == 0) break;
                    ++span;
                }
            }
        }
    }

References cover_full.

render_scanlines_compound()

template<class Rasterizer , class ScanlineAA , class ScanlineBin , class BaseRenderer , class SpanAllocator , class StyleHandler >

void agg::render_scanlines_compound	(	Rasterizer &	ras,
		ScanlineAA &	sl_aa,
		ScanlineBin &	sl_bin,
		BaseRenderer &	ren,
		SpanAllocator &	alloc,
		StyleHandler &	sh
	)

    {
        if(ras.rewind_scanlines())
        {
            int min_x = ras.min_x();
            int len = ras.max_x() - min_x + 2;
            sl_aa.reset(min_x, ras.max_x());
            sl_bin.reset(min_x, ras.max_x());
 
            typedef typename BaseRenderer::color_type color_type;
            color_type* color_span = alloc.allocate(len * 2);
            color_type* mix_buffer = color_span + len;
            unsigned num_spans;
 
            unsigned num_styles;
            unsigned style;
            bool     solid;
            while((num_styles = ras.sweep_styles()) > 0)
            {
                typename ScanlineAA::const_iterator span_aa;
                if(num_styles == 1)
                {
                    // Optimization for a single style. Happens often
                    //-------------------------
                    if(ras.sweep_scanline(sl_aa, 0))
                    {
                        style = ras.style(0);
                        if(sh.is_solid(style))
                        {
                            // Just solid fill
                            //-----------------------
                            render_scanline_aa_solid(sl_aa, ren, sh.color(style));
                        }
                        else
                        {
                            // Arbitrary span generator
                            //-----------------------
                            span_aa   = sl_aa.begin();
                            num_spans = sl_aa.num_spans();
                            for(;;)
                            {
                                len = span_aa->len;
                                sh.generate_span(color_span, 
                                                 span_aa->x, 
                                                 sl_aa.y(), 
                                                 len, 
                                                 style);
 
                                ren.blend_color_hspan(span_aa->x, 
                                                      sl_aa.y(), 
                                                      span_aa->len,
                                                      color_span,
                                                      span_aa->covers);
                                if(--num_spans == 0) break;
                                ++span_aa;
                            }
                        }
                    }
                }
                else
                {
                    if(ras.sweep_scanline(sl_bin, -1))
                    {
                        // Clear the spans of the mix_buffer
                        //--------------------
                        typename ScanlineBin::const_iterator span_bin = sl_bin.begin();
                        num_spans = sl_bin.num_spans();
                        for(;;)
                        {
                            memset(mix_buffer + span_bin->x - min_x, 
                                   0, 
                                   span_bin->len * sizeof(color_type));
 
                            if(--num_spans == 0) break;
                            ++span_bin;
                        }
 
                        unsigned i;
                        for(i = 0; i < num_styles; i++)
                        {
                            style = ras.style(i);
                            solid = sh.is_solid(style);
 
                            if(ras.sweep_scanline(sl_aa, i))
                            {
                                color_type* colors;
                                color_type* cspan;
                                typename ScanlineAA::cover_type* covers;
                                span_aa   = sl_aa.begin();
                                num_spans = sl_aa.num_spans();
                                if(solid)
                                {
                                    // Just solid fill
                                    //-----------------------
                                    for(;;)
                                    {
                                        color_type c = sh.color(style);
                                        len    = span_aa->len;
                                        colors = mix_buffer + span_aa->x - min_x;
                                        covers = span_aa->covers;
                                        do
                                        {
                                            if(*covers == cover_full) 
                                            {
                                                *colors = c;
                                            }
                                            else
                                            {
                                                colors->add(c, *covers);
                                            }
                                            ++colors;
                                            ++covers;
                                        }
                                        while(--len);
                                        if(--num_spans == 0) break;
                                        ++span_aa;
                                    }
                                }
                                else
                                {
                                    // Arbitrary span generator
                                    //-----------------------
                                    for(;;)
                                    {
                                        len = span_aa->len;
                                        colors = mix_buffer + span_aa->x - min_x;
                                        cspan  = color_span;
                                        sh.generate_span(cspan, 
                                                         span_aa->x, 
                                                         sl_aa.y(), 
                                                         len, 
                                                         style);
                                        covers = span_aa->covers;
                                        do
                                        {
                                            if(*covers == cover_full) 
                                            {
                                                *colors = *cspan;
                                            }
                                            else
                                            {
                                                colors->add(*cspan, *covers);
                                            }
                                            ++cspan;
                                            ++colors;
                                            ++covers;
                                        }
                                        while(--len);
                                        if(--num_spans == 0) break;
                                        ++span_aa;
                                    }
                                }
                            }
                        }
 
                        // Emit the blended result as a color hspan
                        //-------------------------
                        span_bin = sl_bin.begin();
                        num_spans = sl_bin.num_spans();
                        for(;;)
                        {
                            ren.blend_color_hspan(span_bin->x, 
                                                  sl_bin.y(), 
                                                  span_bin->len,
                                                  mix_buffer + span_bin->x - min_x,
                                                  0,
                                                  cover_full);
                            if(--num_spans == 0) break;
                            ++span_bin;
                        }
                    } // if(ras.sweep_scanline(sl_bin, -1))
                } // if(num_styles == 1) ... else
            } // while((num_styles = ras.sweep_styles()) > 0)
        } // if(ras.rewind_scanlines())
    }

References cover_full, render_scanline_aa_solid(), and style.

Here is the call graph for this function:

render_scanlines_compound_layered()

template<class Rasterizer , class ScanlineAA , class BaseRenderer , class SpanAllocator , class StyleHandler >

void agg::render_scanlines_compound_layered	(	Rasterizer &	ras,
		ScanlineAA &	sl_aa,
		BaseRenderer &	ren,
		SpanAllocator &	alloc,
		StyleHandler &	sh
	)

    {
        if(ras.rewind_scanlines())
        {
            int min_x = ras.min_x();
            int len = ras.max_x() - min_x + 2;
            sl_aa.reset(min_x, ras.max_x());
 
            typedef typename BaseRenderer::color_type color_type;
            color_type* color_span   = alloc.allocate(len * 2);
            color_type* mix_buffer   = color_span + len;
            cover_type* cover_buffer = ras.allocate_cover_buffer(len);
            unsigned num_spans;
 
            unsigned num_styles;
            unsigned style;
            bool     solid;
            while((num_styles = ras.sweep_styles()) > 0)
            {
                typename ScanlineAA::const_iterator span_aa;
                if(num_styles == 1)
                {
                    // Optimization for a single style. Happens often
                    //-------------------------
                    if(ras.sweep_scanline(sl_aa, 0))
                    {
                        style = ras.style(0);
                        if(sh.is_solid(style))
                        {
                            // Just solid fill
                            //-----------------------
                            render_scanline_aa_solid(sl_aa, ren, sh.color(style));
                        }
                        else
                        {
                            // Arbitrary span generator
                            //-----------------------
                            span_aa   = sl_aa.begin();
                            num_spans = sl_aa.num_spans();
                            for(;;)
                            {
                                len = span_aa->len;
                                sh.generate_span(color_span, 
                                                 span_aa->x, 
                                                 sl_aa.y(), 
                                                 len, 
                                                 style);
 
                                ren.blend_color_hspan(span_aa->x, 
                                                      sl_aa.y(), 
                                                      span_aa->len,
                                                      color_span,
                                                      span_aa->covers);
                                if(--num_spans == 0) break;
                                ++span_aa;
                            }
                        }
                    }
                }
                else
                {
                    int      sl_start = ras.scanline_start();
                    unsigned sl_len   = ras.scanline_length();
 
                    if(sl_len)
                    {
                        memset(mix_buffer + sl_start - min_x, 
                               0, 
                               sl_len * sizeof(color_type));
 
                        memset(cover_buffer + sl_start - min_x, 
                               0, 
                               sl_len * sizeof(cover_type));
 
                        int sl_y = std::numeric_limits<int>::max();
                        unsigned i;
                        for(i = 0; i < num_styles; i++)
                        {
                            style = ras.style(i);
                            solid = sh.is_solid(style);
 
                            if(ras.sweep_scanline(sl_aa, i))
                            {
                                unsigned    cover;
                                color_type* colors;
                                color_type* cspan;
                                cover_type* src_covers;
                                cover_type* dst_covers;
                                span_aa   = sl_aa.begin();
                                num_spans = sl_aa.num_spans();
                                sl_y      = sl_aa.y();
                                if(solid)
                                {
                                    // Just solid fill
                                    //-----------------------
                                    for(;;)
                                    {
                                        color_type c = sh.color(style);
                                        len    = span_aa->len;
                                        colors = mix_buffer + span_aa->x - min_x;
                                        src_covers = span_aa->covers;
                                        dst_covers = cover_buffer + span_aa->x - min_x;
                                        do
                                        {
                                            cover = *src_covers;
                                            if(*dst_covers + cover > cover_full)
                                            {
                                                cover = cover_full - *dst_covers;
                                            }
                                            if(cover)
                                            {
                                                colors->add(c, cover);
                                                *dst_covers += cover;
                                            }
                                            ++colors;
                                            ++src_covers;
                                            ++dst_covers;
                                        }
                                        while(--len);
                                        if(--num_spans == 0) break;
                                        ++span_aa;
                                    }
                                }
                                else
                                {
                                    // Arbitrary span generator
                                    //-----------------------
                                    for(;;)
                                    {
                                        len = span_aa->len;
                                        colors = mix_buffer + span_aa->x - min_x;
                                        cspan  = color_span;
                                        sh.generate_span(cspan, 
                                                         span_aa->x, 
                                                         sl_aa.y(), 
                                                         len, 
                                                         style);
                                        src_covers = span_aa->covers;
                                        dst_covers = cover_buffer + span_aa->x - min_x;
                                        do
                                        {
                                            cover = *src_covers;
                                            if(*dst_covers + cover > cover_full)
                                            {
                                                cover = cover_full - *dst_covers;
                                            }
                                            if(cover)
                                            {
                                                colors->add(*cspan, cover);
                                                *dst_covers += cover;
                                            }
                                            ++cspan;
                                            ++colors;
                                            ++src_covers;
                                            ++dst_covers;
                                        }
                                        while(--len);
                                        if(--num_spans == 0) break;
                                        ++span_aa;
                                    }
                                }
                            }
                        }
                        ren.blend_color_hspan(sl_start, 
                                              sl_y, 
                                              sl_len,
                                              mix_buffer + sl_start - min_x,
                                              0,
                                              cover_full);
                    } //if(sl_len)
                } //if(num_styles == 1) ... else
            } //while((num_styles = ras.sweep_styles()) > 0)
        } //if(ras.rewind_scanlines())
    }

References cover_full, render_scanline_aa_solid(), and style.

Here is the call graph for this function:

rgb8_packed()

rgba8 agg::rgb8_packed ( unsigned  v )

inline

    {
        return rgba8((v >> 16) & 0xFF, (v >> 8) & 0xFF, v & 0xFF);
    }

rgba16_gamma_dir()

template<class GammaLUT >

rgba16 agg::rgba16_gamma_dir	(	rgba16	c,
		const GammaLUT &	gamma
	)

    {
        return rgba16(gamma.dir(c.r), gamma.dir(c.g), gamma.dir(c.b), c.a);
    }

rgba16_gamma_inv()

template<class GammaLUT >

rgba16 agg::rgba16_gamma_inv	(	rgba16	c,
		const GammaLUT &	gamma
	)

    {
        return rgba16(gamma.inv(c.r), gamma.inv(c.g), gamma.inv(c.b), c.a);
    }

rgba8_gamma_dir()

template<class GammaLUT >

rgba8 agg::rgba8_gamma_dir	(	rgba8	c,
		const GammaLUT &	gamma
	)

    {
        return rgba8(gamma.dir(c.r), gamma.dir(c.g), gamma.dir(c.b), c.a);
    }

rgba8_gamma_inv()

template<class GammaLUT >

rgba8 agg::rgba8_gamma_inv	(	rgba8	c,
		const GammaLUT &	gamma
	)

    {
        return rgba8(gamma.inv(c.r), gamma.inv(c.g), gamma.inv(c.b), c.a);
    }

rgba_pre()

rgba agg::rgba_pre ( double  r, double  g, double  b, double  a  )

inline

    {
        return rgba(r, g, b, a).premultiply();
    }

References agg::rgba::premultiply().

Here is the call graph for this function:

set_orientation()

unsigned agg::set_orientation ( unsigned  c, unsigned  o  )

inline

    {
        return clear_orientation(c) | o;
    }

References clear_orientation().

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

Here is the call graph for this function:

Here is the caller graph for this function:

sRGB_to_linear()

double agg::sRGB_to_linear ( double  x )

inline

    {
        return (x <= 0.04045) ? (x / 12.92) : pow((x + 0.055) / (1.055), 2.4);
    }

Referenced by agg::sRGB_lut< float >::sRGB_lut(), agg::sRGB_lut< int16u >::sRGB_lut(), and agg::sRGB_lut< int8u >::sRGB_lut().

Here is the caller graph for this function:

swap_cells()

template<class T >

static AGG_INLINE void agg::swap_cells ( T *  a, T *  b  )

static

    {
        T temp = *a;
        *a = *b;
        *b = temp;
    }

Referenced by qsort_cells().

Here is the caller graph for this function:

swap_elements()

template<class T >

void agg::swap_elements ( T &  a, T &  b  )

inline

    {
        T temp = a;
        a = b;
        b = temp;
    }

Referenced by invert_container(), and quick_sort().

Here is the caller graph for this function:

uceil()

AGG_INLINE unsigned agg::uceil

(

double

v

)

    {
        return unsigned(ceil(v));
    }

References ceil().

Here is the call graph for this function:

ufloor()

AGG_INLINE unsigned agg::ufloor

(

double

v

)

    {
        return unsigned(v);
    }

unite_rectangles()

template<class Rect >

Rect agg::unite_rectangles ( const Rect &  r1, const Rect &  r2  )

inline

    {
        Rect r = r1;
        if(r.x2 < r2.x2) r.x2 = r2.x2;
        if(r.y2 < r2.y2) r.y2 = r2.y2;
        if(r.x1 > r2.x1) r.x1 = r2.x1;
        if(r.y1 > r2.y1) r.y1 = r2.y1;
        return r;
    }

unsigned_greater()

bool agg::unsigned_greater ( unsigned  a, unsigned  b  )

inline

{ return a > b; }

unsigned_less()

bool agg::unsigned_less ( unsigned  a, unsigned  b  )

inline

{ return a < b; }

uround()

AGG_INLINE int agg::uround

(

double

v

)

    {
        return unsigned(v + 0.5);
    }

Referenced by agg::sRGB_lut< float >::sRGB_lut(), agg::sRGB_lut< int16u >::sRGB_lut(), agg::sRGB_lut< int8u >::sRGB_lut(), agg::rgba8T< Colorspace >::convert(), agg::gray8T< Colorspace >::from_double(), agg::gray16::from_double(), agg::rgba8T< Colorspace >::from_double(), agg::rgba16::from_double(), agg::rasterizer_scanline_aa< Clip >::gamma(), agg::gamma_lut< LoResT, HiResT, GammaShift, HiResShift >::gamma(), agg::rgba8T< Colorspace >::gradient(), agg::rgba16::gradient(), agg::gray8T< Colorspace >::gradient(), agg::gray16::gradient(), agg::gray8T< Colorspace >::luminance(), agg::gray16::luminance(), agg::gray8T< Colorspace >::opacity(), agg::gray16::opacity(), agg::rgba8T< Colorspace >::opacity(), agg::rgba16::opacity(), agg::gray32::operator gray16(), agg::gray32::operator gray8(), agg::gray32::operator rgba16(), agg::rgba32::operator rgba16(), agg::gray32::operator rgba8(), agg::rgba32::operator rgba8(), agg::gray32::scale_cover(), and agg::rgba32::scale_cover().

Here is the caller graph for this function:

Variable Documentation

affine_epsilon

const double agg::affine_epsilon = 1e-14

Referenced by agg::trans_affine::operator!=(), and agg::trans_affine::operator==().

g_elder_bit_table

int8 agg::g_elder_bit_table[256]

extern

Referenced by fast_sqrt().

g_sqrt_table

int16u agg::g_sqrt_table[1024]

extern

Referenced by fast_sqrt().

intersection_epsilon

const double agg::intersection_epsilon = 1.0e-30

Referenced by calc_intersection(), and dilate_triangle().

pi

const double agg::pi = 3.14159265358979323846

Referenced by deg2rad(), and rad2deg().

vertex_dist_epsilon

const double agg::vertex_dist_epsilon = 1e-14

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