//---------------------------------------------------------------------------- // Anti-Grain Geometry - Version 2.2 // Copyright (C) 2002-2004 Maxim Shemanarev (http://www.antigrain.com) // // Permission to copy, use, modify, sell and distribute this software // is granted provided this copyright notice appears in all copies. // This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // // The author gratefully acknowleges the support of David Turner, // Robert Wilhelm, and Werner Lemberg - the authors of the FreeType // libray - in producing this work. See http://www.freetype.org for details. // //---------------------------------------------------------------------------- // Contact: mcseem@antigrain.com // mcseemagg@yahoo.com // http://www.antigrain.com //---------------------------------------------------------------------------- // // Class rasterizer_scanline_aa // // //---------------------------------------------------------------------------- #ifndef AGG_RASTERIZER_SCANLINE_AA_INCLUDED #define AGG_RASTERIZER_SCANLINE_AA_INCLUDED #include #include #include "agg_basics.h" #include "agg_math.h" #include "agg_gamma_functions.h" #include "agg_clip_liang_barsky.h" #include "agg_render_scanlines.h" namespace agg { //------------------------------------------------------------------------ // These constants determine the subpixel accuracy, to be more precise, // the number of bits of the fractional part of the coordinates. // The possible coordinate capacity in bits can be calculated by formula: // sizeof(int) * 8 - poly_base_shift * 2, i.e, for 32-bit integers and // 8-bits fractional part the capacity is 16 bits or [-32768...32767]. enum { poly_base_shift = 8, //----poly_base_shift poly_base_size = 1 << poly_base_shift, //----poly_base_size poly_base_mask = poly_base_size - 1 //----poly_base_mask }; //--------------------------------------------------------------poly_coord inline int poly_coord(double c) { return int(c * poly_base_size); } //-----------------------------------------------------------------cell_aa // A pixel cell. There're no constructors defined and it was done // intentionally in order to avoid extra overhead when allocating an // array of cells. struct cell_aa { int16 x; int16 y; int packed_coord; int cover; int area; void set(int x, int y, int c, int a); void set_coord(int x, int y); void set_cover(int c, int a); void add_cover(int c, int a); }; //--------------------------------------------------------------outline_aa // An internal class that implements the main rasterization algorithm. // Used in the rasterizer. Should not be used direcly. class outline_aa { enum { cell_block_shift = 12, cell_block_size = 1 << cell_block_shift, cell_block_mask = cell_block_size - 1, cell_block_pool = 256, cell_block_limit = 1024 }; public: ~outline_aa(); outline_aa(); void reset(); void move_to(int x, int y); void line_to(int x, int y); int min_x() const { return m_min_x; } int min_y() const { return m_min_y; } int max_x() const { return m_max_x; } int max_y() const { return m_max_y; } const cell_aa* const* cells(); unsigned num_cells() { cells(); return m_num_cells; } bool sorted() const { return m_sorted; } private: outline_aa(const outline_aa&); const outline_aa& operator = (const outline_aa&); void set_cur_cell(int x, int y); void add_cur_cell(); void sort_cells(); void render_hline(int ey, int x1, int y1, int x2, int y2); void render_line(int x1, int y1, int x2, int y2); void allocate_block(); static void qsort_cells(cell_aa** start, unsigned num); private: unsigned m_num_blocks; unsigned m_max_blocks; unsigned m_cur_block; unsigned m_num_cells; cell_aa** m_cells; cell_aa* m_cur_cell_ptr; cell_aa** m_sorted_cells; unsigned m_sorted_size; cell_aa m_cur_cell; int m_cur_x; int m_cur_y; int m_min_x; int m_min_y; int m_max_x; int m_max_y; bool m_sorted; }; //----------------------------------------------------------filling_rule_e enum filling_rule_e { fill_non_zero, fill_even_odd }; //==================================================rasterizer_scanline_aa // Polygon rasterizer that is used to render filled polygons with // high-quality Anti-Aliasing. Internally, by default, the class uses // integer coordinates in format 24.8, i.e. 24 bits for integer part // and 8 bits for fractional - see poly_base_shift. This class can be // used in the following way: // // 1. filling_rule(filling_rule_e ft) - optional. // // 2. gamma() - optional. // // 3. reset() // // 4. move_to(x, y) / line_to(x, y) - make the polygon. One can create // more than one contour, but each contour must consist of at least 3 // vertices, i.e. move_to(x1, y1); line_to(x2, y2); line_to(x3, y3); // is the absolute minimum of vertices that define a triangle. // The algorithm does not check either the number of vertices nor // coincidence of their coordinates, but in the worst case it just // won't draw anything. // The orger of the vertices (clockwise or counterclockwise) // is important when using the non-zero filling rule (fill_non_zero). // In this case the vertex order of all the contours must be the same // if you want your intersecting polygons to be without "holes". // You actually can use different vertices order. If the contours do not // intersect each other the order is not important anyway. If they do, // contours with the same vertex order will be rendered without "holes" // while the intersecting contours with different orders will have "holes". // // filling_rule() and gamma() can be called anytime before "sweeping". //------------------------------------------------------------------------ template class rasterizer_scanline_aa { enum status { status_initial, status_line_to, status_closed }; struct iterator { const cell_aa* const* cells; int cover; int last_y; }; public: enum { aa_shift = AA_Shift, aa_num = 1 << aa_shift, aa_mask = aa_num - 1, aa_2num = aa_num * 2, aa_2mask = aa_2num - 1 }; //-------------------------------------------------------------------- rasterizer_scanline_aa() : m_filling_rule(fill_non_zero), m_clipped_start_x(0), m_clipped_start_y(0), m_start_x(0), m_start_y(0), m_prev_x(0), m_prev_y(0), m_prev_flags(0), m_status(status_initial), m_clipping(false) { int i; for(i = 0; i < aa_num; i++) m_gamma[i] = i; } //-------------------------------------------------------------------- template rasterizer_scanline_aa(const GammaF& gamma_function) : m_filling_rule(fill_non_zero), m_clipped_start_x(0), m_clipped_start_y(0), m_start_x(0), m_start_y(0), m_prev_x(0), m_prev_y(0), m_prev_flags(0), m_status(status_initial), m_clipping(false) { gamma(gamma_function); } //-------------------------------------------------------------------- void reset(); void filling_rule(filling_rule_e filling_rule); void clip_box(double x1, double y1, double x2, double y2); void reset_clipping(); //-------------------------------------------------------------------- template void gamma(const GammaF& gamma_function) { int i; for(i = 0; i < aa_num; i++) { m_gamma[i] = int(floor(gamma_function(double(i) / aa_mask) * aa_mask + 0.5)); } } //-------------------------------------------------------------------- unsigned apply_gamma(unsigned cover) const { return m_gamma[cover]; } //-------------------------------------------------------------------- void add_vertex(double x, double y, unsigned cmd); void move_to(int x, int y); void line_to(int x, int y); void close_polygon(); void move_to_d(double x, double y); void line_to_d(double x, double y); //-------------------------------------------------------------------- int min_x() const { return m_outline.min_x(); } int min_y() const { return m_outline.min_y(); } int max_x() const { return m_outline.max_x(); } int max_y() const { return m_outline.max_y(); } //-------------------------------------------------------------------- unsigned calculate_alpha(int area) const { int cover = area >> (poly_base_shift*2 + 1 - aa_shift); if(cover < 0) cover = -cover; if(m_filling_rule == fill_even_odd) { cover &= aa_2mask; if(cover > aa_num) { cover = aa_2num - cover; } } if(cover > aa_mask) cover = aa_mask; return m_gamma[cover]; } //-------------------------------------------------------------------- void sort() { m_outline.cells(); } //-------------------------------------------------------------------- bool rewind_scanlines() { close_polygon(); m_iterator.cells = m_outline.cells(); if(m_outline.num_cells() == 0) { return false; } m_iterator.cover = 0; m_iterator.last_y = (*m_iterator.cells)->y; return true; } //-------------------------------------------------------------------- template bool sweep_scanline(Scanline& sl) { sl.reset_spans(); for(;;) { const cell_aa* cur_cell = *m_iterator.cells; if(cur_cell == 0) return false; ++m_iterator.cells; m_iterator.last_y = cur_cell->y; for(;;) { int coord = cur_cell->packed_coord; int area = cur_cell->area; int last_x = cur_cell->x; m_iterator.cover += cur_cell->cover; //accumulate all cells with the same coordinates for(; (cur_cell = *m_iterator.cells) != 0; ++m_iterator.cells) { if(cur_cell->packed_coord != coord) break; area += cur_cell->area; m_iterator.cover += cur_cell->cover; } int alpha; if(cur_cell == 0 || cur_cell->y != m_iterator.last_y) { if(area) { alpha = calculate_alpha((m_iterator.cover << (poly_base_shift + 1)) - area); if(alpha) { sl.add_cell(last_x, alpha); } ++last_x; } break; } ++m_iterator.cells; if(area) { alpha = calculate_alpha((m_iterator.cover << (poly_base_shift + 1)) - area); if(alpha) { sl.add_cell(last_x, alpha); } ++last_x; } if(cur_cell->x > last_x) { alpha = calculate_alpha(m_iterator.cover << (poly_base_shift + 1)); if(alpha) { sl.add_span(last_x, cur_cell->x - last_x, alpha); } } } if(sl.num_spans()) { sl.finalize(m_iterator.last_y); break; } } return true; } //-------------------------------------------------------------------- bool hit_test(int tx, int ty); //-------------------------------------------------------------------- void add_xy(const double* x, const double* y, unsigned n) { if(n > 2) { move_to_d(*x++, *y++); --n; do { line_to_d(*x++, *y++); } while(--n); } } //------------------------------------------------------------------- template void add_path(VertexSource& vs, unsigned id=0) { double x; double y; unsigned cmd; vs.rewind(id); while(!is_stop(cmd = vs.vertex(&x, &y))) { add_vertex(x, y, cmd); } } private: //-------------------------------------------------------------------- // Disable copying rasterizer_scanline_aa(const rasterizer_scanline_aa&); const rasterizer_scanline_aa& operator = (const rasterizer_scanline_aa&); //-------------------------------------------------------------------- void move_to_no_clip(int x, int y); void line_to_no_clip(int x, int y); void close_polygon_no_clip(); void clip_segment(int x, int y); private: outline_aa m_outline; int m_gamma[aa_num]; filling_rule_e m_filling_rule; int m_clipped_start_x; int m_clipped_start_y; int m_start_x; int m_start_y; int m_prev_x; int m_prev_y; unsigned m_prev_flags; unsigned m_status; rect m_clip_box; bool m_clipping; iterator m_iterator; }; //------------------------------------------------------------------------ template void rasterizer_scanline_aa::reset() { m_outline.reset(); m_status = status_initial; } //------------------------------------------------------------------------ template void rasterizer_scanline_aa::filling_rule(filling_rule_e filling_rule) { m_filling_rule = filling_rule; } //------------------------------------------------------------------------ template void rasterizer_scanline_aa::clip_box(double x1, double y1, double x2, double y2) { reset(); m_clip_box = rect(poly_coord(x1), poly_coord(y1), poly_coord(x2), poly_coord(y2)); m_clip_box.normalize(); m_clipping = true; } //------------------------------------------------------------------------ template void rasterizer_scanline_aa::reset_clipping() { reset(); m_clipping = false; } //------------------------------------------------------------------------ template void rasterizer_scanline_aa::move_to_no_clip(int x, int y) { if(m_status == status_line_to) { close_polygon_no_clip(); } m_outline.move_to(x * XScale, y); m_clipped_start_x = x; m_clipped_start_y = y; m_status = status_line_to; } //------------------------------------------------------------------------ template void rasterizer_scanline_aa::line_to_no_clip(int x, int y) { if(m_status != status_initial) { m_outline.line_to(x * XScale, y); m_status = status_line_to; } } //------------------------------------------------------------------------ template void rasterizer_scanline_aa::close_polygon_no_clip() { if(m_status == status_line_to) { m_outline.line_to(m_clipped_start_x * XScale, m_clipped_start_y); m_status = status_closed; } } //------------------------------------------------------------------------ template void rasterizer_scanline_aa::clip_segment(int x, int y) { unsigned flags = clipping_flags(x, y, m_clip_box); if(m_prev_flags == flags) { if(flags == 0) { if(m_status == status_initial) { move_to_no_clip(x, y); } else { line_to_no_clip(x, y); } } } else { int cx[4]; int cy[4]; unsigned n = clip_liang_barsky(m_prev_x, m_prev_y, x, y, m_clip_box, cx, cy); const int* px = cx; const int* py = cy; while(n--) { if(m_status == status_initial) { move_to_no_clip(*px++, *py++); } else { line_to_no_clip(*px++, *py++); } } } m_prev_flags = flags; m_prev_x = x; m_prev_y = y; } //------------------------------------------------------------------------ template void rasterizer_scanline_aa::add_vertex(double x, double y, unsigned cmd) { if(is_close(cmd)) { close_polygon(); } else { if(is_move_to(cmd)) { move_to(poly_coord(x), poly_coord(y)); } else { if(is_vertex(cmd)) { line_to(poly_coord(x), poly_coord(y)); } } } } //------------------------------------------------------------------------ template void rasterizer_scanline_aa::move_to(int x, int y) { if(m_clipping) { if(m_outline.sorted()) { reset(); } if(m_status == status_line_to) { close_polygon(); } m_prev_x = m_start_x = x; m_prev_y = m_start_y = y; m_status = status_initial; m_prev_flags = clipping_flags(x, y, m_clip_box); if(m_prev_flags == 0) { move_to_no_clip(x, y); } } else { move_to_no_clip(x, y); } } //------------------------------------------------------------------------ template void rasterizer_scanline_aa::line_to(int x, int y) { if(m_clipping) { clip_segment(x, y); } else { line_to_no_clip(x, y); } } //------------------------------------------------------------------------ template void rasterizer_scanline_aa::close_polygon() { if(m_clipping) { clip_segment(m_start_x, m_start_y); } close_polygon_no_clip(); } //------------------------------------------------------------------------ template void rasterizer_scanline_aa::move_to_d(double x, double y) { move_to(poly_coord(x), poly_coord(y)); } //------------------------------------------------------------------------ template void rasterizer_scanline_aa::line_to_d(double x, double y) { line_to(poly_coord(x), poly_coord(y)); } //------------------------------------------------------------------------ template bool rasterizer_scanline_aa::hit_test(int tx, int ty) { close_polygon(); const cell_aa* const* cells = m_outline.cells(); if(m_outline.num_cells() == 0) return false; int cover = 0; const cell_aa* cur_cell = *cells++; for(;;) { int alpha; int coord = cur_cell->packed_coord; int x = cur_cell->x; int y = cur_cell->y; if(y > ty) return false; int area = cur_cell->area; cover += cur_cell->cover; while((cur_cell = *cells++) != 0) { if(cur_cell->packed_coord != coord) break; area += cur_cell->area; cover += cur_cell->cover; } if(area) { alpha = calculate_alpha((cover << (poly_base_shift + 1)) - area); if(alpha) { if(tx == x && ty == y) return true; } x++; } if(!cur_cell) break; if(cur_cell->x > x) { alpha = calculate_alpha(cover << (poly_base_shift + 1)); if(alpha) { if(ty == y && tx >= x && tx <= cur_cell->x) return true; } } } return false; } } #endif