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 #ifndef AGG_SPAN_INTERPOLATOR_PERSP_INCLUDED 16 #define AGG_SPAN_INTERPOLATOR_PERSP_INCLUDED 17 18 #include "agg_trans_perspective.h" 19 #include "agg_dda_line.h" 20 21 namespace agg 22 { 23 24 25 26 //===========================================span_interpolator_persp_exact 27 template<unsigned SubpixelShift = 8> 28 class span_interpolator_persp_exact 29 { 30 public: 31 typedef trans_perspective trans_type; 32 typedef trans_perspective::iterator_x iterator_type; 33 enum subpixel_scale_e 34 { 35 subpixel_shift = SubpixelShift, 36 subpixel_scale = 1 << subpixel_shift 37 }; 38 39 //-------------------------------------------------------------------- 40 span_interpolator_persp_exact() {} 41 42 //-------------------------------------------------------------------- 43 // Arbitrary quadrangle transformations 44 span_interpolator_persp_exact(const double* src, const double* dst) 45 { 46 quad_to_quad(src, dst); 47 } 48 49 //-------------------------------------------------------------------- 50 // Direct transformations 51 span_interpolator_persp_exact(double x1, double y1, 52 double x2, double y2, 53 const double* quad) 54 { 55 rect_to_quad(x1, y1, x2, y2, quad); 56 } 57 58 //-------------------------------------------------------------------- 59 // Reverse transformations 60 span_interpolator_persp_exact(const double* quad, 61 double x1, double y1, 62 double x2, double y2) 63 { 64 quad_to_rect(quad, x1, y1, x2, y2); 65 } 66 67 //-------------------------------------------------------------------- 68 // Set the transformations using two arbitrary quadrangles. 69 void quad_to_quad(const double* src, const double* dst) 70 { 71 m_trans_dir.quad_to_quad(src, dst); 72 m_trans_inv.quad_to_quad(dst, src); 73 } 74 75 //-------------------------------------------------------------------- 76 // Set the direct transformations, i.e., rectangle -> quadrangle 77 void rect_to_quad(double x1, double y1, double x2, double y2, 78 const double* quad) 79 { 80 double src[8]; 81 src[0] = src[6] = x1; 82 src[2] = src[4] = x2; 83 src[1] = src[3] = y1; 84 src[5] = src[7] = y2; 85 quad_to_quad(src, quad); 86 } 87 88 89 //-------------------------------------------------------------------- 90 // Set the reverse transformations, i.e., quadrangle -> rectangle 91 void quad_to_rect(const double* quad, 92 double x1, double y1, double x2, double y2) 93 { 94 double dst[8]; 95 dst[0] = dst[6] = x1; 96 dst[2] = dst[4] = x2; 97 dst[1] = dst[3] = y1; 98 dst[5] = dst[7] = y2; 99 quad_to_quad(quad, dst); 100 } 101 102 //-------------------------------------------------------------------- 103 // Check if the equations were solved successfully 104 bool is_valid() const { return m_trans_dir.is_valid(); } 105 106 //---------------------------------------------------------------- 107 void begin(double x, double y, unsigned len) 108 { 109 m_iterator = m_trans_dir.begin(x, y, 1.0); 110 double xt = m_iterator.x; 111 double yt = m_iterator.y; 112 113 double dx; 114 double dy; 115 const double delta = 1/double(subpixel_scale); 116 dx = xt + delta; 117 dy = yt; 118 m_trans_inv.transform(&dx, &dy); 119 dx -= x; 120 dy -= y; 121 int sx1 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift; 122 dx = xt; 123 dy = yt + delta; 124 m_trans_inv.transform(&dx, &dy); 125 dx -= x; 126 dy -= y; 127 int sy1 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift; 128 129 x += len; 130 xt = x; 131 yt = y; 132 m_trans_dir.transform(&xt, &yt); 133 134 dx = xt + delta; 135 dy = yt; 136 m_trans_inv.transform(&dx, &dy); 137 dx -= x; 138 dy -= y; 139 int sx2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift; 140 dx = xt; 141 dy = yt + delta; 142 m_trans_inv.transform(&dx, &dy); 143 dx -= x; 144 dy -= y; 145 int sy2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift; 146 147 m_scale_x = dda2_line_interpolator(sx1, sx2, len); 148 m_scale_y = dda2_line_interpolator(sy1, sy2, len); 149 } 150 151 152 //---------------------------------------------------------------- 153 void resynchronize(double xe, double ye, unsigned len) 154 { 155 // Assume x1,y1 are equal to the ones at the previous end point 156 int sx1 = m_scale_x.y(); 157 int sy1 = m_scale_y.y(); 158 159 // Calculate transformed coordinates at x2,y2 160 double xt = xe; 161 double yt = ye; 162 m_trans_dir.transform(&xt, &yt); 163 164 const double delta = 1/double(subpixel_scale); 165 double dx; 166 double dy; 167 168 // Calculate scale by X at x2,y2 169 dx = xt + delta; 170 dy = yt; 171 m_trans_inv.transform(&dx, &dy); 172 dx -= xe; 173 dy -= ye; 174 int sx2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift; 175 176 // Calculate scale by Y at x2,y2 177 dx = xt; 178 dy = yt + delta; 179 m_trans_inv.transform(&dx, &dy); 180 dx -= xe; 181 dy -= ye; 182 int sy2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift; 183 184 // Initialize the interpolators 185 m_scale_x = dda2_line_interpolator(sx1, sx2, len); 186 m_scale_y = dda2_line_interpolator(sy1, sy2, len); 187 } 188 189 190 191 //---------------------------------------------------------------- 192 void operator++() 193 { 194 ++m_iterator; 195 ++m_scale_x; 196 ++m_scale_y; 197 } 198 199 //---------------------------------------------------------------- 200 void coordinates(int* x, int* y) const 201 { 202 *x = iround(m_iterator.x * subpixel_scale); 203 *y = iround(m_iterator.y * subpixel_scale); 204 } 205 206 //---------------------------------------------------------------- 207 void local_scale(int* x, int* y) 208 { 209 *x = m_scale_x.y(); 210 *y = m_scale_y.y(); 211 } 212 213 //---------------------------------------------------------------- 214 void transform(double* x, double* y) const 215 { 216 m_trans_dir.transform(x, y); 217 } 218 219 private: 220 trans_type m_trans_dir; 221 trans_type m_trans_inv; 222 iterator_type m_iterator; 223 dda2_line_interpolator m_scale_x; 224 dda2_line_interpolator m_scale_y; 225 }; 226 227 228 229 230 231 232 233 234 235 236 237 //============================================span_interpolator_persp_lerp 238 template<unsigned SubpixelShift = 8> 239 class span_interpolator_persp_lerp 240 { 241 public: 242 typedef trans_perspective trans_type; 243 enum subpixel_scale_e 244 { 245 subpixel_shift = SubpixelShift, 246 subpixel_scale = 1 << subpixel_shift 247 }; 248 249 //-------------------------------------------------------------------- 250 span_interpolator_persp_lerp() {} 251 252 //-------------------------------------------------------------------- 253 // Arbitrary quadrangle transformations 254 span_interpolator_persp_lerp(const double* src, const double* dst) 255 { 256 quad_to_quad(src, dst); 257 } 258 259 //-------------------------------------------------------------------- 260 // Direct transformations 261 span_interpolator_persp_lerp(double x1, double y1, 262 double x2, double y2, 263 const double* quad) 264 { 265 rect_to_quad(x1, y1, x2, y2, quad); 266 } 267 268 //-------------------------------------------------------------------- 269 // Reverse transformations 270 span_interpolator_persp_lerp(const double* quad, 271 double x1, double y1, 272 double x2, double y2) 273 { 274 quad_to_rect(quad, x1, y1, x2, y2); 275 } 276 277 //-------------------------------------------------------------------- 278 // Set the transformations using two arbitrary quadrangles. 279 void quad_to_quad(const double* src, const double* dst) 280 { 281 m_trans_dir.quad_to_quad(src, dst); 282 m_trans_inv.quad_to_quad(dst, src); 283 } 284 285 //-------------------------------------------------------------------- 286 // Set the direct transformations, i.e., rectangle -> quadrangle 287 void rect_to_quad(double x1, double y1, double x2, double y2, 288 const double* quad) 289 { 290 double src[8]; 291 src[0] = src[6] = x1; 292 src[2] = src[4] = x2; 293 src[1] = src[3] = y1; 294 src[5] = src[7] = y2; 295 quad_to_quad(src, quad); 296 } 297 298 299 //-------------------------------------------------------------------- 300 // Set the reverse transformations, i.e., quadrangle -> rectangle 301 void quad_to_rect(const double* quad, 302 double x1, double y1, double x2, double y2) 303 { 304 double dst[8]; 305 dst[0] = dst[6] = x1; 306 dst[2] = dst[4] = x2; 307 dst[1] = dst[3] = y1; 308 dst[5] = dst[7] = y2; 309 quad_to_quad(quad, dst); 310 } 311 312 //-------------------------------------------------------------------- 313 // Check if the equations were solved successfully 314 bool is_valid() const { return m_trans_dir.is_valid(); } 315 316 //---------------------------------------------------------------- 317 void begin(double x, double y, unsigned len) 318 { 319 // Calculate transformed coordinates at x1,y1 320 double xt = x; 321 double yt = y; 322 m_trans_dir.transform(&xt, &yt); 323 int x1 = iround(xt * subpixel_scale); 324 int y1 = iround(yt * subpixel_scale); 325 326 double dx; 327 double dy; 328 const double delta = 1/double(subpixel_scale); 329 330 // Calculate scale by X at x1,y1 331 dx = xt + delta; 332 dy = yt; 333 m_trans_inv.transform(&dx, &dy); 334 dx -= x; 335 dy -= y; 336 int sx1 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift; 337 338 // Calculate scale by Y at x1,y1 339 dx = xt; 340 dy = yt + delta; 341 m_trans_inv.transform(&dx, &dy); 342 dx -= x; 343 dy -= y; 344 int sy1 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift; 345 346 // Calculate transformed coordinates at x2,y2 347 x += len; 348 xt = x; 349 yt = y; 350 m_trans_dir.transform(&xt, &yt); 351 int x2 = iround(xt * subpixel_scale); 352 int y2 = iround(yt * subpixel_scale); 353 354 // Calculate scale by X at x2,y2 355 dx = xt + delta; 356 dy = yt; 357 m_trans_inv.transform(&dx, &dy); 358 dx -= x; 359 dy -= y; 360 int sx2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift; 361 362 // Calculate scale by Y at x2,y2 363 dx = xt; 364 dy = yt + delta; 365 m_trans_inv.transform(&dx, &dy); 366 dx -= x; 367 dy -= y; 368 int sy2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift; 369 370 // Initialize the interpolators 371 m_coord_x = dda2_line_interpolator(x1, x2, len); 372 m_coord_y = dda2_line_interpolator(y1, y2, len); 373 m_scale_x = dda2_line_interpolator(sx1, sx2, len); 374 m_scale_y = dda2_line_interpolator(sy1, sy2, len); 375 } 376 377 378 //---------------------------------------------------------------- 379 void resynchronize(double xe, double ye, unsigned len) 380 { 381 // Assume x1,y1 are equal to the ones at the previous end point 382 int x1 = m_coord_x.y(); 383 int y1 = m_coord_y.y(); 384 int sx1 = m_scale_x.y(); 385 int sy1 = m_scale_y.y(); 386 387 // Calculate transformed coordinates at x2,y2 388 double xt = xe; 389 double yt = ye; 390 m_trans_dir.transform(&xt, &yt); 391 int x2 = iround(xt * subpixel_scale); 392 int y2 = iround(yt * subpixel_scale); 393 394 const double delta = 1/double(subpixel_scale); 395 double dx; 396 double dy; 397 398 // Calculate scale by X at x2,y2 399 dx = xt + delta; 400 dy = yt; 401 m_trans_inv.transform(&dx, &dy); 402 dx -= xe; 403 dy -= ye; 404 int sx2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift; 405 406 // Calculate scale by Y at x2,y2 407 dx = xt; 408 dy = yt + delta; 409 m_trans_inv.transform(&dx, &dy); 410 dx -= xe; 411 dy -= ye; 412 int sy2 = uround(subpixel_scale/sqrt(dx*dx + dy*dy)) >> subpixel_shift; 413 414 // Initialize the interpolators 415 m_coord_x = dda2_line_interpolator(x1, x2, len); 416 m_coord_y = dda2_line_interpolator(y1, y2, len); 417 m_scale_x = dda2_line_interpolator(sx1, sx2, len); 418 m_scale_y = dda2_line_interpolator(sy1, sy2, len); 419 } 420 421 422 //---------------------------------------------------------------- 423 void operator++() 424 { 425 ++m_coord_x; 426 ++m_coord_y; 427 ++m_scale_x; 428 ++m_scale_y; 429 } 430 431 //---------------------------------------------------------------- 432 void coordinates(int* x, int* y) const 433 { 434 *x = m_coord_x.y(); 435 *y = m_coord_y.y(); 436 } 437 438 //---------------------------------------------------------------- 439 void local_scale(int* x, int* y) 440 { 441 *x = m_scale_x.y(); 442 *y = m_scale_y.y(); 443 } 444 445 //---------------------------------------------------------------- 446 void transform(double* x, double* y) const 447 { 448 m_trans_dir.transform(x, y); 449 } 450 451 private: 452 trans_type m_trans_dir; 453 trans_type m_trans_inv; 454 dda2_line_interpolator m_coord_x; 455 dda2_line_interpolator m_coord_y; 456 dda2_line_interpolator m_scale_x; 457 dda2_line_interpolator m_scale_y; 458 }; 459 460 } 461 462 #endif 463