1 //---------------------------------------------------------------------------- 2 // Anti-Grain Geometry - Version 2.4 3 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com) 4 // 5 // Permission to copy, use, modify, sell and distribute this software 6 // is granted provided this copyright notice appears in all copies. 7 // This software is provided "as is" without express or implied 8 // warranty, and with no claim as to its suitability for any purpose. 9 // 10 //---------------------------------------------------------------------------- 11 // Contact: mcseem@antigrain.com 12 // mcseemagg@yahoo.com 13 // http://www.antigrain.com 14 //---------------------------------------------------------------------------- 15 // 16 // Class scanline_bin - binary scanline. 17 // 18 //---------------------------------------------------------------------------- 19 // 20 // Adaptation for 32-bit screen coordinates (scanline32_bin) has been sponsored by 21 // Liberty Technology Systems, Inc., visit http://lib-sys.com 22 // 23 // Liberty Technology Systems, Inc. is the provider of 24 // PostScript and PDF technology for software developers. 25 // 26 //---------------------------------------------------------------------------- 27 28 #ifndef AGG_SCANLINE_BIN_INCLUDED 29 #define AGG_SCANLINE_BIN_INCLUDED 30 31 #include "agg_array.h" 32 33 namespace agg 34 { 35 36 //=============================================================scanline_bin 37 // 38 // This is binary scaline container which supports the interface 39 // used in the rasterizer::render(). See description of agg_scanline_u8 40 // for details. 41 // 42 //------------------------------------------------------------------------ 43 class scanline_bin 44 { 45 public: 46 typedef int32 coord_type; 47 48 struct span 49 { 50 int16 x; 51 int16 len; 52 }; 53 54 typedef const span* const_iterator; 55 56 //-------------------------------------------------------------------- scanline_bin()57 scanline_bin() : 58 m_last_x(0x7FFFFFF0), 59 m_spans(), 60 m_cur_span(0) 61 { 62 } 63 64 //-------------------------------------------------------------------- reset(int min_x,int max_x)65 void reset(int min_x, int max_x) 66 { 67 unsigned max_len = max_x - min_x + 3; 68 if(max_len > m_spans.size()) 69 { 70 m_spans.resize(max_len); 71 } 72 m_last_x = 0x7FFFFFF0; 73 m_cur_span = &m_spans[0]; 74 } 75 76 //-------------------------------------------------------------------- add_cell(int x,unsigned)77 void add_cell(int x, unsigned) 78 { 79 if(x == m_last_x+1) 80 { 81 m_cur_span->len++; 82 } 83 else 84 { 85 ++m_cur_span; 86 m_cur_span->x = (int16)x; 87 m_cur_span->len = 1; 88 } 89 m_last_x = x; 90 } 91 92 //-------------------------------------------------------------------- add_span(int x,unsigned len,unsigned)93 void add_span(int x, unsigned len, unsigned) 94 { 95 if(x == m_last_x+1) 96 { 97 m_cur_span->len = (int16)(m_cur_span->len + len); 98 } 99 else 100 { 101 ++m_cur_span; 102 m_cur_span->x = (int16)x; 103 m_cur_span->len = (int16)len; 104 } 105 m_last_x = x + len - 1; 106 } 107 108 //-------------------------------------------------------------------- add_cells(int x,unsigned len,const void *)109 void add_cells(int x, unsigned len, const void*) 110 { 111 add_span(x, len, 0); 112 } 113 114 //-------------------------------------------------------------------- finalize(int y)115 void finalize(int y) 116 { 117 m_y = y; 118 } 119 120 //-------------------------------------------------------------------- reset_spans()121 void reset_spans() 122 { 123 m_last_x = 0x7FFFFFF0; 124 m_cur_span = &m_spans[0]; 125 } 126 127 //-------------------------------------------------------------------- y()128 int y() const { return m_y; } num_spans()129 unsigned num_spans() const { return unsigned(m_cur_span - &m_spans[0]); } begin()130 const_iterator begin() const { return &m_spans[1]; } 131 132 private: 133 scanline_bin(const scanline_bin&); 134 const scanline_bin operator = (const scanline_bin&); 135 136 int m_last_x; 137 int m_y; 138 pod_array<span> m_spans; 139 span* m_cur_span; 140 }; 141 142 143 144 145 146 147 //===========================================================scanline32_bin 148 class scanline32_bin 149 { 150 public: 151 typedef int32 coord_type; 152 153 //-------------------------------------------------------------------- 154 struct span 155 { spanspan156 span() {} spanspan157 span(coord_type x_, coord_type len_) : x(x_), len(len_) {} 158 159 coord_type x; 160 coord_type len; 161 }; 162 typedef pod_bvector<span, 4> span_array_type; 163 164 165 //-------------------------------------------------------------------- 166 class const_iterator 167 { 168 public: const_iterator(const span_array_type & spans)169 const_iterator(const span_array_type& spans) : 170 m_spans(spans), 171 m_span_idx(0) 172 {} 173 174 const span& operator*() const { return m_spans[m_span_idx]; } 175 const span* operator->() const { return &m_spans[m_span_idx]; } 176 177 void operator ++ () { ++m_span_idx; } 178 179 private: 180 const span_array_type& m_spans; 181 unsigned m_span_idx; 182 }; 183 184 185 //-------------------------------------------------------------------- scanline32_bin()186 scanline32_bin() : m_max_len(0), m_last_x(0x7FFFFFF0) {} 187 188 //-------------------------------------------------------------------- reset(int,int)189 void reset(int, int) 190 { 191 m_last_x = 0x7FFFFFF0; 192 m_spans.remove_all(); 193 } 194 195 //-------------------------------------------------------------------- add_cell(int x,unsigned)196 void add_cell(int x, unsigned) 197 { 198 if(x == m_last_x+1) 199 { 200 m_spans.last().len++; 201 } 202 else 203 { 204 m_spans.add(span(coord_type(x), 1)); 205 } 206 m_last_x = x; 207 } 208 209 //-------------------------------------------------------------------- add_span(int x,unsigned len,unsigned)210 void add_span(int x, unsigned len, unsigned) 211 { 212 if(x == m_last_x+1) 213 { 214 m_spans.last().len += coord_type(len); 215 } 216 else 217 { 218 m_spans.add(span(coord_type(x), coord_type(len))); 219 } 220 m_last_x = x + len - 1; 221 } 222 223 //-------------------------------------------------------------------- add_cells(int x,unsigned len,const void *)224 void add_cells(int x, unsigned len, const void*) 225 { 226 add_span(x, len, 0); 227 } 228 229 //-------------------------------------------------------------------- finalize(int y)230 void finalize(int y) 231 { 232 m_y = y; 233 } 234 235 //-------------------------------------------------------------------- reset_spans()236 void reset_spans() 237 { 238 m_last_x = 0x7FFFFFF0; 239 m_spans.remove_all(); 240 } 241 242 //-------------------------------------------------------------------- y()243 int y() const { return m_y; } num_spans()244 unsigned num_spans() const { return m_spans.size(); } begin()245 const_iterator begin() const { return const_iterator(m_spans); } 246 247 private: 248 scanline32_bin(const scanline32_bin&); 249 const scanline32_bin operator = (const scanline32_bin&); 250 251 unsigned m_max_len; 252 int m_last_x; 253 int m_y; 254 span_array_type m_spans; 255 }; 256 257 258 259 260 261 } 262 263 264 #endif 265