• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 
2 //----------------------------------------------------------------------------
3 // Anti-Grain Geometry - Version 2.3
4 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
5 //
6 // Permission to copy, use, modify, sell and distribute this software
7 // is granted provided this copyright notice appears in all copies.
8 // This software is provided "as is" without express or implied
9 // warranty, and with no claim as to its suitability for any purpose.
10 //
11 //----------------------------------------------------------------------------
12 //
13 // The author gratefully acknowleges the support of David Turner,
14 // Robert Wilhelm, and Werner Lemberg - the authors of the FreeType
15 // libray - in producing this work. See http://www.freetype.org for details.
16 //
17 //----------------------------------------------------------------------------
18 // Contact: mcseem@antigrain.com
19 //          mcseemagg@yahoo.com
20 //          http://www.antigrain.com
21 //----------------------------------------------------------------------------
22 //
23 // Adaptation for 32-bit screen coordinates has been sponsored by
24 // Liberty Technology Systems, Inc., visit http://lib-sys.com
25 //
26 // Liberty Technology Systems, Inc. is the provider of
27 // PostScript and PDF technology for software developers.
28 //
29 //----------------------------------------------------------------------------
30 #ifndef AGG_RASTERIZER_SCANLINE_AA_INCLUDED
31 #define AGG_RASTERIZER_SCANLINE_AA_INCLUDED
32 
33 #include "agg_array.h"
34 #include "agg_basics.h"
35 #include "agg_clip_liang_barsky.h"
36 #include "agg_math.h"
37 #include "agg_render_scanlines.h"
38 #include "core/fxcrt/fx_coordinates.h"
39 #include "core/fxcrt/fx_memory.h"
40 
41 namespace agg
42 {
43 enum poly_base_scale_e {
44     poly_base_shift = 8,
45     poly_base_size  = 1 << poly_base_shift,
46     poly_base_mask  = poly_base_size - 1
47 };
poly_coord(float c)48 inline int poly_coord(float c)
49 {
50     return int(c * poly_base_size);
51 }
52 struct cell_aa  {
53     int x;
54     int y;
55     int cover;
56     int area;
57     void set(int x, int y, int c, int a);
58     void set_coord(int x, int y);
59     void set_cover(int c, int a);
60     void add_cover(int c, int a);
61 };
62 class outline_aa
63 {
64     enum cell_block_scale_e {
65         cell_block_shift = 12,
66         cell_block_size  = 1 << cell_block_shift,
67         cell_block_mask  = cell_block_size - 1,
68         cell_block_pool  = 256,
69         cell_block_limit = 1024
70     };
71     struct sorted_y  {
72         unsigned start;
73         unsigned num;
74     };
75 public:
76     ~outline_aa();
77     outline_aa();
78     void reset();
79     void move_to(int x, int y);
80     void line_to(int x, int y);
min_x()81     int min_x() const
82     {
83         return m_min_x;
84     }
min_y()85     int min_y() const
86     {
87         return m_min_y;
88     }
max_x()89     int max_x() const
90     {
91         return m_max_x;
92     }
max_y()93     int max_y() const
94     {
95         return m_max_y;
96     }
97     void sort_cells();
total_cells()98     unsigned total_cells() const
99     {
100         return m_num_cells;
101     }
scanline_num_cells(unsigned y)102     unsigned scanline_num_cells(unsigned y) const
103     {
104         return m_sorted_y[y - m_min_y].num;
105     }
scanline_cells(unsigned y)106     const cell_aa* const* scanline_cells(unsigned y) const
107     {
108         return m_sorted_cells.data() + m_sorted_y[y - m_min_y].start;
109     }
sorted()110     bool sorted() const
111     {
112         return m_sorted;
113     }
114 private:
115     outline_aa(const outline_aa&);
116     const outline_aa& operator = (const outline_aa&);
117     void set_cur_cell(int x, int y);
118     void add_cur_cell();
119     void render_hline(int ey, int x1, int y1, int x2, int y2);
120     void render_line(int x1, int y1, int x2, int y2);
121     void allocate_block();
122 private:
123     unsigned  m_num_blocks;
124     unsigned  m_max_blocks;
125     unsigned  m_cur_block;
126     unsigned  m_num_cells;
127     cell_aa** m_cells;
128     cell_aa*  m_cur_cell_ptr;
129     pod_array<cell_aa*> m_sorted_cells;
130     pod_array<sorted_y> m_sorted_y;
131     cell_aa   m_cur_cell;
132     int       m_cur_x;
133     int       m_cur_y;
134     int       m_min_x;
135     int       m_min_y;
136     int       m_max_x;
137     int       m_max_y;
138     bool      m_sorted;
139 };
140 class scanline_hit_test
141 {
142 public:
scanline_hit_test(int x)143     scanline_hit_test(int x) : m_x(x), m_hit(false) {}
reset_spans()144     void reset_spans() {}
finalize(int)145     void finalize(int) {}
add_cell(int x,int)146     void add_cell(int x, int)
147     {
148         if(m_x == x) {
149             m_hit = true;
150         }
151     }
add_span(int x,int len,int)152     void add_span(int x, int len, int)
153     {
154         if(m_x >= x && m_x < x + len) {
155             m_hit = true;
156         }
157     }
num_spans()158     unsigned num_spans() const
159     {
160         return 1;
161     }
hit()162     bool hit() const
163     {
164         return m_hit;
165     }
166 private:
167     int  m_x;
168     bool m_hit;
169 };
170 enum filling_rule_e {
171     fill_non_zero,
172     fill_even_odd
173 };
174 class rasterizer_scanline_aa
175 {
176     enum status {
177         status_initial,
178         status_line_to,
179         status_closed
180     };
181 public:
182     enum aa_scale_e {
183         aa_num   = 1 << 8,
184         aa_mask  = aa_num - 1,
185         aa_2num  = aa_num * 2,
186         aa_2mask = aa_2num - 1
187     };
rasterizer_scanline_aa()188     rasterizer_scanline_aa() :
189         m_filling_rule(fill_non_zero),
190         m_clipped_start_x(0),
191         m_clipped_start_y(0),
192         m_status(status_initial),
193         m_clipping(false)
194     {
195     }
~rasterizer_scanline_aa()196     ~rasterizer_scanline_aa() {}
filling_rule(filling_rule_e filling_rule)197     void filling_rule(filling_rule_e filling_rule)
198     {
199         m_filling_rule = filling_rule;
200     }
min_x()201     int min_x() const
202     {
203         return m_outline.min_x();
204     }
min_y()205     int min_y() const
206     {
207         return m_outline.min_y();
208     }
max_x()209     int max_x() const
210     {
211         return m_outline.max_x();
212     }
max_y()213     int max_y() const
214     {
215         return m_outline.max_y();
216     }
reset()217     void reset()
218     {
219         m_outline.reset();
220         m_status = status_initial;
221     }
clip_box(float x1,float y1,float x2,float y2)222     void clip_box(float x1, float y1, float x2, float y2)
223     {
224         m_clip_box = rect(poly_coord(x1), poly_coord(y1),
225                           poly_coord(x2), poly_coord(y2));
226         m_clip_box.normalize();
227         m_clipping = true;
228     }
add_vertex(float x,float y,unsigned cmd)229     void add_vertex(float x, float y, unsigned cmd)
230     {
231         if(is_close(cmd)) {
232             close_polygon();
233         } else {
234             if(is_move_to(cmd)) {
235                 move_to(poly_coord(x), poly_coord(y));
236             } else {
237                 if(is_vertex(cmd)) {
238                     line_to(poly_coord(x), poly_coord(y));
239                 }
240             }
241         }
242     }
move_to(int x,int y)243     void move_to(int x, int y)
244     {
245         if(m_clipping) {
246             if(m_outline.sorted()) {
247                 reset();
248             }
249             if(m_status == status_line_to) {
250                 close_polygon();
251             }
252             m_prev_x = m_start_x = x;
253             m_prev_y = m_start_y = y;
254             m_status = status_initial;
255             m_prev_flags = clipping_flags(x, y, m_clip_box);
256             if(m_prev_flags == 0) {
257                 move_to_no_clip(x, y);
258             }
259         } else {
260             move_to_no_clip(x, y);
261         }
262     }
line_to(int x,int y)263     void line_to(int x, int y)
264     {
265         if(m_clipping) {
266             clip_segment(x, y);
267         } else {
268             line_to_no_clip(x, y);
269         }
270     }
close_polygon()271     void close_polygon()
272     {
273         if (m_status != status_line_to) {
274             return;
275         }
276         if(m_clipping) {
277             clip_segment(m_start_x, m_start_y);
278         }
279         close_polygon_no_clip();
280     }
calculate_alpha(int area,bool no_smooth)281     AGG_INLINE unsigned calculate_alpha(int area, bool no_smooth) const
282     {
283         int cover = area >> (poly_base_shift * 2 + 1 - 8);
284         if(cover < 0) {
285             cover = -cover;
286         }
287         if(m_filling_rule == fill_even_odd) {
288             cover &= aa_2mask;
289             if(cover > aa_num) {
290                 cover = aa_2num - cover;
291             }
292         }
293         if (no_smooth) {
294             cover = cover > aa_mask / 2 ? aa_mask : 0;
295         }
296         if(cover > aa_mask) {
297             cover = aa_mask;
298         }
299         return cover;
300     }
sort()301     AGG_INLINE void sort()
302     {
303         m_outline.sort_cells();
304     }
rewind_scanlines()305     AGG_INLINE bool rewind_scanlines()
306     {
307         close_polygon();
308         m_outline.sort_cells();
309         if(m_outline.total_cells() == 0) {
310             return false;
311         }
312         m_cur_y = m_outline.min_y();
313         return true;
314     }
navigate_scanline(int y)315     AGG_INLINE bool navigate_scanline(int y)
316     {
317         close_polygon();
318         m_outline.sort_cells();
319         if(m_outline.total_cells() == 0 ||
320                 y < m_outline.min_y() ||
321                 y > m_outline.max_y()) {
322             return false;
323         }
324         m_cur_y = y;
325         return true;
326     }
sweep_scanline(Scanline & sl,bool no_smooth)327     template<class Scanline> bool sweep_scanline(Scanline& sl, bool no_smooth)
328     {
329         for(;;) {
330             if(m_cur_y > m_outline.max_y()) {
331                 return false;
332             }
333             sl.reset_spans();
334             unsigned num_cells = m_outline.scanline_num_cells(m_cur_y);
335             const cell_aa* const* cells = m_outline.scanline_cells(m_cur_y);
336             int cover = 0;
337             while(num_cells) {
338                 const cell_aa* cur_cell = *cells;
339                 int x    = cur_cell->x;
340                 int area = cur_cell->area;
341                 unsigned alpha;
342                 cover += cur_cell->cover;
343                 while(--num_cells) {
344                     cur_cell = *++cells;
345                     if(cur_cell->x != x) {
346                         break;
347                     }
348                     area  += cur_cell->area;
349                     cover += cur_cell->cover;
350                 }
351                 if(area) {
352                     alpha = calculate_alpha((cover << (poly_base_shift + 1)) - area, no_smooth);
353                     if(alpha) {
354                         sl.add_cell(x, alpha);
355                     }
356                     x++;
357                 }
358                 if(num_cells && cur_cell->x > x) {
359                     alpha = calculate_alpha(cover << (poly_base_shift + 1), no_smooth);
360                     if(alpha) {
361                         sl.add_span(x, cur_cell->x - x, alpha);
362                     }
363                 }
364             }
365             if(sl.num_spans()) {
366                 break;
367             }
368             ++m_cur_y;
369         }
370         sl.finalize(m_cur_y);
371         ++m_cur_y;
372         return true;
373     }
374     template<class VertexSource>
375     void add_path(VertexSource& vs, unsigned path_id = 0)
376     {
377         float x;
378         float y;
379         unsigned cmd;
380         vs.rewind(path_id);
381         while(!is_stop(cmd = vs.vertex(&x, &y))) {
382             add_vertex(x, y, cmd);
383         }
384     }
385     template<class VertexSource>
386     void add_path_transformed(VertexSource& vs, const CFX_Matrix* pMatrix, unsigned path_id = 0)
387     {
388         float x;
389         float y;
390         unsigned cmd;
391         vs.rewind(path_id);
392         while(!is_stop(cmd = vs.vertex(&x, &y))) {
393           if (pMatrix) {
394             CFX_PointF ret = pMatrix->Transform(CFX_PointF(x, y));
395             x = ret.x;
396             y = ret.y;
397           }
398           add_vertex(x, y, cmd);
399         }
400     }
401 private:
402     rasterizer_scanline_aa(const rasterizer_scanline_aa&);
403     const rasterizer_scanline_aa&
404     operator = (const rasterizer_scanline_aa&);
move_to_no_clip(int x,int y)405     void move_to_no_clip(int x, int y)
406     {
407         if(m_status == status_line_to) {
408             close_polygon_no_clip();
409         }
410         m_outline.move_to(x * 1, y);
411         m_clipped_start_x = x;
412         m_clipped_start_y = y;
413         m_status = status_line_to;
414     }
line_to_no_clip(int x,int y)415     void line_to_no_clip(int x, int y)
416     {
417         if(m_status != status_initial) {
418             m_outline.line_to(x * 1, y);
419             m_status = status_line_to;
420         }
421     }
close_polygon_no_clip()422     void close_polygon_no_clip()
423     {
424         if(m_status == status_line_to) {
425             m_outline.line_to(m_clipped_start_x * 1, m_clipped_start_y);
426             m_status = status_closed;
427         }
428     }
clip_segment(int x,int y)429     void clip_segment(int x, int y)
430     {
431         unsigned flags = clipping_flags(x, y, m_clip_box);
432         if(m_prev_flags == flags) {
433             if(flags == 0) {
434                 if(m_status == status_initial) {
435                     move_to_no_clip(x, y);
436                 } else {
437                     line_to_no_clip(x, y);
438                 }
439             }
440         } else {
441             int cx[4];
442             int cy[4];
443             unsigned n = clip_liang_barsky(m_prev_x, m_prev_y,
444                                            x, y,
445                                            m_clip_box,
446                                            cx, cy);
447             const int* px = cx;
448             const int* py = cy;
449             while(n--) {
450                 if(m_status == status_initial) {
451                     move_to_no_clip(*px++, *py++);
452                 } else {
453                     line_to_no_clip(*px++, *py++);
454                 }
455             }
456         }
457         m_prev_flags = flags;
458         m_prev_x = x;
459         m_prev_y = y;
460     }
461 private:
462     outline_aa     m_outline;
463     filling_rule_e m_filling_rule;
464     int            m_clipped_start_x;
465     int            m_clipped_start_y;
466     int            m_start_x;
467     int            m_start_y;
468     int            m_prev_x;
469     int            m_prev_y;
470     unsigned       m_prev_flags;
471     unsigned       m_status;
472     rect           m_clip_box;
473     bool           m_clipping;
474     int            m_cur_y;
475 };
476 }
477 #endif
478