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#ifndef AGG_BASICS_INCLUDED 17#define AGG_BASICS_INCLUDED 18 19#include <math.h> 20#include "agg_config.h" 21 22//---------------------------------------------------------AGG_CUSTOM_ALLOCATOR 23#ifdef AGG_CUSTOM_ALLOCATOR 24#include "agg_allocator.h" 25#else 26namespace agg 27{ 28 // The policy of all AGG containers and memory allocation strategy 29 // in general is that no allocated data requires explicit construction. 30 // It means that the allocator can be really simple; you can even 31 // replace new/delete to malloc/free. The constructors and destructors 32 // won't be called in this case, however everything will remain working. 33 // The second argument of deallocate() is the size of the allocated 34 // block. You can use this information if you wish. 35 //------------------------------------------------------------pod_allocator 36 template<class T> struct pod_allocator 37 { 38 static T* allocate(unsigned num) { return new T [num]; } 39 static void deallocate(T* ptr, unsigned) { delete [] ptr; } 40 }; 41 42 // Single object allocator. It's also can be replaced with your custom 43 // allocator. The difference is that it can only allocate a single 44 // object and the constructor and destructor must be called. 45 // In AGG there is no need to allocate an array of objects with 46 // calling their constructors (only single ones). So that, if you 47 // replace these new/delete to malloc/free make sure that the in-place 48 // new is called and take care of calling the destructor too. 49 //------------------------------------------------------------obj_allocator 50 template<class T> struct obj_allocator 51 { 52 static T* allocate() { return new T; } 53 static void deallocate(T* ptr) { delete ptr; } 54 }; 55} 56#endif 57 58 59//-------------------------------------------------------- Default basic types 60// 61// If the compiler has different capacity of the basic types you can redefine 62// them via the compiler command line or by generating agg_config.h that is 63// empty by default. 64// 65#ifndef AGG_INT8 66#define AGG_INT8 signed char 67#endif 68 69#ifndef AGG_INT8U 70#define AGG_INT8U unsigned char 71#endif 72 73#ifndef AGG_INT16 74#define AGG_INT16 short 75#endif 76 77#ifndef AGG_INT16U 78#define AGG_INT16U unsigned short 79#endif 80 81#ifndef AGG_INT32 82#define AGG_INT32 int 83#endif 84 85#ifndef AGG_INT32U 86#define AGG_INT32U unsigned 87#endif 88 89#ifndef AGG_INT64 90#if defined(_MSC_VER) || defined(__BORLANDC__) 91#define AGG_INT64 signed __int64 92#else 93#define AGG_INT64 signed long long 94#endif 95#endif 96 97#ifndef AGG_INT64U 98#if defined(_MSC_VER) || defined(__BORLANDC__) 99#define AGG_INT64U unsigned __int64 100#else 101#define AGG_INT64U unsigned long long 102#endif 103#endif 104 105//------------------------------------------------ Some fixes for MS Visual C++ 106#if defined(_MSC_VER) 107#pragma warning(disable:4786) // Identifier was truncated... 108#endif 109 110#if defined(_MSC_VER) 111#define AGG_INLINE __forceinline 112#else 113#define AGG_INLINE inline 114#endif 115 116namespace agg 117{ 118 //------------------------------------------------------------------------- 119 typedef AGG_INT8 int8; //----int8 120 typedef AGG_INT8U int8u; //----int8u 121 typedef AGG_INT16 int16; //----int16 122 typedef AGG_INT16U int16u; //----int16u 123 typedef AGG_INT32 int32; //----int32 124 typedef AGG_INT32U int32u; //----int32u 125 typedef AGG_INT64 int64; //----int64 126 typedef AGG_INT64U int64u; //----int64u 127 128#if defined(AGG_FISTP) 129#pragma warning(push) 130#pragma warning(disable : 4035) //Disable warning "no return value" 131 AGG_INLINE int iround(double v) //-------iround 132 { 133 int t; 134 __asm fld qword ptr [v] 135 __asm fistp dword ptr [t] 136 __asm mov eax, dword ptr [t] 137 } 138 AGG_INLINE unsigned uround(double v) //-------uround 139 { 140 unsigned t; 141 __asm fld qword ptr [v] 142 __asm fistp dword ptr [t] 143 __asm mov eax, dword ptr [t] 144 } 145#pragma warning(pop) 146 AGG_INLINE int ifloor(double v) 147 { 148 return int(floor(v)); 149 } 150 AGG_INLINE unsigned ufloor(double v) //-------ufloor 151 { 152 return unsigned(floor(v)); 153 } 154 AGG_INLINE int iceil(double v) 155 { 156 return int(ceil(v)); 157 } 158 AGG_INLINE unsigned uceil(double v) //--------uceil 159 { 160 return unsigned(ceil(v)); 161 } 162#elif defined(AGG_QIFIST) 163 AGG_INLINE int iround(double v) 164 { 165 return int(v); 166 } 167 AGG_INLINE int uround(double v) 168 { 169 return unsigned(v); 170 } 171 AGG_INLINE int ifloor(double v) 172 { 173 return int(floor(v)); 174 } 175 AGG_INLINE unsigned ufloor(double v) 176 { 177 return unsigned(floor(v)); 178 } 179 AGG_INLINE int iceil(double v) 180 { 181 return int(ceil(v)); 182 } 183 AGG_INLINE unsigned uceil(double v) 184 { 185 return unsigned(ceil(v)); 186 } 187#else 188 AGG_INLINE int iround(double v) 189 { 190 return int((v < 0.0) ? v - 0.5 : v + 0.5); 191 } 192 AGG_INLINE int uround(double v) 193 { 194 return unsigned(v + 0.5); 195 } 196 AGG_INLINE int ifloor(double v) 197 { 198 int i = int(v); 199 return i - (i > v); 200 } 201 AGG_INLINE unsigned ufloor(double v) 202 { 203 return unsigned(v); 204 } 205 AGG_INLINE int iceil(double v) 206 { 207 return int(ceil(v)); 208 } 209 AGG_INLINE unsigned uceil(double v) 210 { 211 return unsigned(ceil(v)); 212 } 213#endif 214 215 //---------------------------------------------------------------saturation 216 template<int Limit> struct saturation 217 { 218 AGG_INLINE static int iround(double v) 219 { 220 if(v < double(-Limit)) return -Limit; 221 if(v > double( Limit)) return Limit; 222 return agg::iround(v); 223 } 224 }; 225 226 //------------------------------------------------------------------mul_one 227 template<unsigned Shift> struct mul_one 228 { 229 AGG_INLINE static unsigned mul(unsigned a, unsigned b) 230 { 231 unsigned q = a * b + (1 << (Shift-1)); 232 return (q + (q >> Shift)) >> Shift; 233 } 234 }; 235 236 //------------------------------------------------------------------------- 237 typedef unsigned char cover_type; //----cover_type 238 enum cover_scale_e 239 { 240 cover_shift = 8, //----cover_shift 241 cover_size = 1 << cover_shift, //----cover_size 242 cover_mask = cover_size - 1, //----cover_mask 243 cover_none = 0, //----cover_none 244 cover_full = cover_mask //----cover_full 245 }; 246 247 //----------------------------------------------------poly_subpixel_scale_e 248 // These constants determine the subpixel accuracy, to be more precise, 249 // the number of bits of the fractional part of the coordinates. 250 // The possible coordinate capacity in bits can be calculated by formula: 251 // sizeof(int) * 8 - poly_subpixel_shift, i.e, for 32-bit integers and 252 // 8-bits fractional part the capacity is 24 bits. 253 enum poly_subpixel_scale_e 254 { 255 poly_subpixel_shift = 8, //----poly_subpixel_shift 256 poly_subpixel_scale = 1<<poly_subpixel_shift, //----poly_subpixel_scale 257 poly_subpixel_mask = poly_subpixel_scale-1 //----poly_subpixel_mask 258 }; 259 260 //----------------------------------------------------------filling_rule_e 261 enum filling_rule_e 262 { 263 fill_non_zero, 264 fill_even_odd 265 }; 266 267 //-----------------------------------------------------------------------pi 268 const double pi = 3.14159265358979323846; 269 270 //------------------------------------------------------------------deg2rad 271 inline double deg2rad(double deg) 272 { 273 return deg * pi / 180.0; 274 } 275 276 //------------------------------------------------------------------rad2deg 277 inline double rad2deg(double rad) 278 { 279 return rad * 180.0 / pi; 280 } 281 282 //----------------------------------------------------------------rect_base 283 template<class T> struct rect_base 284 { 285 typedef T value_type; 286 typedef rect_base<T> self_type; 287 T x1, y1, x2, y2; 288 289 rect_base() {} 290 rect_base(T x1_, T y1_, T x2_, T y2_) : 291 x1(x1_), y1(y1_), x2(x2_), y2(y2_) {} 292 293 void init(T x1_, T y1_, T x2_, T y2_) 294 { 295 x1 = x1_; y1 = y1_; x2 = x2_; y2 = y2_; 296 } 297 298 const self_type& normalize() 299 { 300 T t; 301 if(x1 > x2) { t = x1; x1 = x2; x2 = t; } 302 if(y1 > y2) { t = y1; y1 = y2; y2 = t; } 303 return *this; 304 } 305 306 bool clip(const self_type& r) 307 { 308 if(x2 > r.x2) x2 = r.x2; 309 if(y2 > r.y2) y2 = r.y2; 310 if(x1 < r.x1) x1 = r.x1; 311 if(y1 < r.y1) y1 = r.y1; 312 return x1 <= x2 && y1 <= y2; 313 } 314 315 bool is_valid() const 316 { 317 return x1 <= x2 && y1 <= y2; 318 } 319 320 bool hit_test(T x, T y) const 321 { 322 return (x >= x1 && x <= x2 && y >= y1 && y <= y2); 323 } 324 325 bool overlaps(const self_type& r) const 326 { 327 return !(r.x1 > x2 || r.x2 < x1 328 || r.y1 > y2 || r.y2 < y1); 329 } 330 }; 331 332 //-----------------------------------------------------intersect_rectangles 333 template<class Rect> 334 inline Rect intersect_rectangles(const Rect& r1, const Rect& r2) 335 { 336 Rect r = r1; 337 338 // First process x2,y2 because the other order 339 // results in Internal Compiler Error under 340 // Microsoft Visual C++ .NET 2003 69462-335-0000007-18038 in 341 // case of "Maximize Speed" optimization option. 342 //----------------- 343 if(r.x2 > r2.x2) r.x2 = r2.x2; 344 if(r.y2 > r2.y2) r.y2 = r2.y2; 345 if(r.x1 < r2.x1) r.x1 = r2.x1; 346 if(r.y1 < r2.y1) r.y1 = r2.y1; 347 return r; 348 } 349 350 351 //---------------------------------------------------------unite_rectangles 352 template<class Rect> 353 inline Rect unite_rectangles(const Rect& r1, const Rect& r2) 354 { 355 Rect r = r1; 356 if(r.x2 < r2.x2) r.x2 = r2.x2; 357 if(r.y2 < r2.y2) r.y2 = r2.y2; 358 if(r.x1 > r2.x1) r.x1 = r2.x1; 359 if(r.y1 > r2.y1) r.y1 = r2.y1; 360 return r; 361 } 362 363 typedef rect_base<int> rect_i; //----rect_i 364 typedef rect_base<float> rect_f; //----rect_f 365 typedef rect_base<double> rect_d; //----rect_d 366 367 //---------------------------------------------------------path_commands_e 368 enum path_commands_e 369 { 370 path_cmd_stop = 0, //----path_cmd_stop 371 path_cmd_move_to = 1, //----path_cmd_move_to 372 path_cmd_line_to = 2, //----path_cmd_line_to 373 path_cmd_curve3 = 3, //----path_cmd_curve3 374 path_cmd_curve4 = 4, //----path_cmd_curve4 375 path_cmd_curveN = 5, //----path_cmd_curveN 376 path_cmd_catrom = 6, //----path_cmd_catrom 377 path_cmd_ubspline = 7, //----path_cmd_ubspline 378 path_cmd_end_poly = 0x0F, //----path_cmd_end_poly 379 path_cmd_mask = 0x0F //----path_cmd_mask 380 }; 381 382 //------------------------------------------------------------path_flags_e 383 enum path_flags_e 384 { 385 path_flags_none = 0, //----path_flags_none 386 path_flags_ccw = 0x10, //----path_flags_ccw 387 path_flags_cw = 0x20, //----path_flags_cw 388 path_flags_close = 0x40, //----path_flags_close 389 path_flags_mask = 0xF0 //----path_flags_mask 390 }; 391 392 //---------------------------------------------------------------is_vertex 393 inline bool is_vertex(unsigned c) 394 { 395 return c >= path_cmd_move_to && c < path_cmd_end_poly; 396 } 397 398 //--------------------------------------------------------------is_drawing 399 inline bool is_drawing(unsigned c) 400 { 401 return c >= path_cmd_line_to && c < path_cmd_end_poly; 402 } 403 404 //-----------------------------------------------------------------is_stop 405 inline bool is_stop(unsigned c) 406 { 407 return c == path_cmd_stop; 408 } 409 410 //--------------------------------------------------------------is_move_to 411 inline bool is_move_to(unsigned c) 412 { 413 return c == path_cmd_move_to; 414 } 415 416 //--------------------------------------------------------------is_line_to 417 inline bool is_line_to(unsigned c) 418 { 419 return c == path_cmd_line_to; 420 } 421 422 //----------------------------------------------------------------is_curve 423 inline bool is_curve(unsigned c) 424 { 425 return c == path_cmd_curve3 || c == path_cmd_curve4; 426 } 427 428 //---------------------------------------------------------------is_curve3 429 inline bool is_curve3(unsigned c) 430 { 431 return c == path_cmd_curve3; 432 } 433 434 //---------------------------------------------------------------is_curve4 435 inline bool is_curve4(unsigned c) 436 { 437 return c == path_cmd_curve4; 438 } 439 440 //-------------------------------------------------------------is_end_poly 441 inline bool is_end_poly(unsigned c) 442 { 443 return (c & path_cmd_mask) == path_cmd_end_poly; 444 } 445 446 //----------------------------------------------------------------is_close 447 inline bool is_close(unsigned c) 448 { 449 return (c & ~(path_flags_cw | path_flags_ccw)) == 450 (path_cmd_end_poly | path_flags_close); 451 } 452 453 //------------------------------------------------------------is_next_poly 454 inline bool is_next_poly(unsigned c) 455 { 456 return is_stop(c) || is_move_to(c) || is_end_poly(c); 457 } 458 459 //-------------------------------------------------------------------is_cw 460 inline bool is_cw(unsigned c) 461 { 462 return (c & path_flags_cw) != 0; 463 } 464 465 //------------------------------------------------------------------is_ccw 466 inline bool is_ccw(unsigned c) 467 { 468 return (c & path_flags_ccw) != 0; 469 } 470 471 //-------------------------------------------------------------is_oriented 472 inline bool is_oriented(unsigned c) 473 { 474 return (c & (path_flags_cw | path_flags_ccw)) != 0; 475 } 476 477 //---------------------------------------------------------------is_closed 478 inline bool is_closed(unsigned c) 479 { 480 return (c & path_flags_close) != 0; 481 } 482 483 //----------------------------------------------------------get_close_flag 484 inline unsigned get_close_flag(unsigned c) 485 { 486 return c & path_flags_close; 487 } 488 489 //-------------------------------------------------------clear_orientation 490 inline unsigned clear_orientation(unsigned c) 491 { 492 return c & ~(path_flags_cw | path_flags_ccw); 493 } 494 495 //---------------------------------------------------------get_orientation 496 inline unsigned get_orientation(unsigned c) 497 { 498 return c & (path_flags_cw | path_flags_ccw); 499 } 500 501 //---------------------------------------------------------set_orientation 502 inline unsigned set_orientation(unsigned c, unsigned o) 503 { 504 return clear_orientation(c) | o; 505 } 506 507 //--------------------------------------------------------------point_base 508 template<class T> struct point_base 509 { 510 typedef T value_type; 511 T x,y; 512 point_base() {} 513 point_base(T x_, T y_) : x(x_), y(y_) {} 514 }; 515 typedef point_base<int> point_i; //-----point_i 516 typedef point_base<float> point_f; //-----point_f 517 typedef point_base<double> point_d; //-----point_d 518 519 //-------------------------------------------------------------vertex_base 520 template<class T> struct vertex_base 521 { 522 typedef T value_type; 523 T x,y; 524 unsigned cmd; 525 vertex_base() {} 526 vertex_base(T x_, T y_, unsigned cmd_) : x(x_), y(y_), cmd(cmd_) {} 527 }; 528 typedef vertex_base<int> vertex_i; //-----vertex_i 529 typedef vertex_base<float> vertex_f; //-----vertex_f 530 typedef vertex_base<double> vertex_d; //-----vertex_d 531 532 //----------------------------------------------------------------row_info 533 template<class T> struct row_info 534 { 535 int x1, x2; 536 T* ptr; 537 row_info() {} 538 row_info(int x1_, int x2_, T* ptr_) : x1(x1_), x2(x2_), ptr(ptr_) {} 539 }; 540 541 //----------------------------------------------------------const_row_info 542 template<class T> struct const_row_info 543 { 544 int x1, x2; 545 const T* ptr; 546 const_row_info() {} 547 const_row_info(int x1_, int x2_, const T* ptr_) : 548 x1(x1_), x2(x2_), ptr(ptr_) {} 549 }; 550 551 //------------------------------------------------------------is_equal_eps 552 template<class T> inline bool is_equal_eps(T v1, T v2, T epsilon) 553 { 554 return fabs(v1 - v2) <= double(epsilon); 555 } 556} 557 558 559#endif 560 561