1/***************************************************************************/ 2/* */ 3/* ftbbox.c */ 4/* */ 5/* FreeType bbox computation (body). */ 6/* */ 7/* Copyright 1996-2001, 2002, 2004, 2006, 2010 by */ 8/* David Turner, Robert Wilhelm, and Werner Lemberg. */ 9/* */ 10/* This file is part of the FreeType project, and may only be used */ 11/* modified and distributed under the terms of the FreeType project */ 12/* license, LICENSE.TXT. By continuing to use, modify, or distribute */ 13/* this file you indicate that you have read the license and */ 14/* understand and accept it fully. */ 15/* */ 16/***************************************************************************/ 17 18 19 /*************************************************************************/ 20 /* */ 21 /* This component has a _single_ role: to compute exact outline bounding */ 22 /* boxes. */ 23 /* */ 24 /*************************************************************************/ 25 26 27#include <ft2build.h> 28#include FT_BBOX_H 29#include FT_IMAGE_H 30#include FT_OUTLINE_H 31#include FT_INTERNAL_CALC_H 32#include FT_INTERNAL_OBJECTS_H 33 34 35 typedef struct TBBox_Rec_ 36 { 37 FT_Vector last; 38 FT_BBox bbox; 39 40 } TBBox_Rec; 41 42 43 /*************************************************************************/ 44 /* */ 45 /* <Function> */ 46 /* BBox_Move_To */ 47 /* */ 48 /* <Description> */ 49 /* This function is used as a `move_to' and `line_to' emitter during */ 50 /* FT_Outline_Decompose(). It simply records the destination point */ 51 /* in `user->last'; no further computations are necessary since we */ 52 /* use the cbox as the starting bbox which must be refined. */ 53 /* */ 54 /* <Input> */ 55 /* to :: A pointer to the destination vector. */ 56 /* */ 57 /* <InOut> */ 58 /* user :: A pointer to the current walk context. */ 59 /* */ 60 /* <Return> */ 61 /* Always 0. Needed for the interface only. */ 62 /* */ 63 static int 64 BBox_Move_To( FT_Vector* to, 65 TBBox_Rec* user ) 66 { 67 user->last = *to; 68 69 return 0; 70 } 71 72 73#define CHECK_X( p, bbox ) \ 74 ( p->x < bbox.xMin || p->x > bbox.xMax ) 75 76#define CHECK_Y( p, bbox ) \ 77 ( p->y < bbox.yMin || p->y > bbox.yMax ) 78 79 80 /*************************************************************************/ 81 /* */ 82 /* <Function> */ 83 /* BBox_Conic_Check */ 84 /* */ 85 /* <Description> */ 86 /* Finds the extrema of a 1-dimensional conic Bezier curve and update */ 87 /* a bounding range. This version uses direct computation, as it */ 88 /* doesn't need square roots. */ 89 /* */ 90 /* <Input> */ 91 /* y1 :: The start coordinate. */ 92 /* */ 93 /* y2 :: The coordinate of the control point. */ 94 /* */ 95 /* y3 :: The end coordinate. */ 96 /* */ 97 /* <InOut> */ 98 /* min :: The address of the current minimum. */ 99 /* */ 100 /* max :: The address of the current maximum. */ 101 /* */ 102 static void 103 BBox_Conic_Check( FT_Pos y1, 104 FT_Pos y2, 105 FT_Pos y3, 106 FT_Pos* min, 107 FT_Pos* max ) 108 { 109 if ( y1 <= y3 && y2 == y1 ) /* flat arc */ 110 goto Suite; 111 112 if ( y1 < y3 ) 113 { 114 if ( y2 >= y1 && y2 <= y3 ) /* ascending arc */ 115 goto Suite; 116 } 117 else 118 { 119 if ( y2 >= y3 && y2 <= y1 ) /* descending arc */ 120 { 121 y2 = y1; 122 y1 = y3; 123 y3 = y2; 124 goto Suite; 125 } 126 } 127 128 y1 = y3 = y1 - FT_MulDiv( y2 - y1, y2 - y1, y1 - 2*y2 + y3 ); 129 130 Suite: 131 if ( y1 < *min ) *min = y1; 132 if ( y3 > *max ) *max = y3; 133 } 134 135 136 /*************************************************************************/ 137 /* */ 138 /* <Function> */ 139 /* BBox_Conic_To */ 140 /* */ 141 /* <Description> */ 142 /* This function is used as a `conic_to' emitter during */ 143 /* FT_Outline_Decompose(). It checks a conic Bezier curve with the */ 144 /* current bounding box, and computes its extrema if necessary to */ 145 /* update it. */ 146 /* */ 147 /* <Input> */ 148 /* control :: A pointer to a control point. */ 149 /* */ 150 /* to :: A pointer to the destination vector. */ 151 /* */ 152 /* <InOut> */ 153 /* user :: The address of the current walk context. */ 154 /* */ 155 /* <Return> */ 156 /* Always 0. Needed for the interface only. */ 157 /* */ 158 /* <Note> */ 159 /* In the case of a non-monotonous arc, we compute directly the */ 160 /* extremum coordinates, as it is sufficiently fast. */ 161 /* */ 162 static int 163 BBox_Conic_To( FT_Vector* control, 164 FT_Vector* to, 165 TBBox_Rec* user ) 166 { 167 /* we don't need to check `to' since it is always an `on' point, thus */ 168 /* within the bbox */ 169 170 if ( CHECK_X( control, user->bbox ) ) 171 BBox_Conic_Check( user->last.x, 172 control->x, 173 to->x, 174 &user->bbox.xMin, 175 &user->bbox.xMax ); 176 177 if ( CHECK_Y( control, user->bbox ) ) 178 BBox_Conic_Check( user->last.y, 179 control->y, 180 to->y, 181 &user->bbox.yMin, 182 &user->bbox.yMax ); 183 184 user->last = *to; 185 186 return 0; 187 } 188 189 190 /*************************************************************************/ 191 /* */ 192 /* <Function> */ 193 /* BBox_Cubic_Check */ 194 /* */ 195 /* <Description> */ 196 /* Finds the extrema of a 1-dimensional cubic Bezier curve and */ 197 /* updates a bounding range. This version uses splitting because we */ 198 /* don't want to use square roots and extra accuracy. */ 199 /* */ 200 /* <Input> */ 201 /* p1 :: The start coordinate. */ 202 /* */ 203 /* p2 :: The coordinate of the first control point. */ 204 /* */ 205 /* p3 :: The coordinate of the second control point. */ 206 /* */ 207 /* p4 :: The end coordinate. */ 208 /* */ 209 /* <InOut> */ 210 /* min :: The address of the current minimum. */ 211 /* */ 212 /* max :: The address of the current maximum. */ 213 /* */ 214 215#if 0 216 217 static void 218 BBox_Cubic_Check( FT_Pos p1, 219 FT_Pos p2, 220 FT_Pos p3, 221 FT_Pos p4, 222 FT_Pos* min, 223 FT_Pos* max ) 224 { 225 FT_Pos stack[32*3 + 1], *arc; 226 227 228 arc = stack; 229 230 arc[0] = p1; 231 arc[1] = p2; 232 arc[2] = p3; 233 arc[3] = p4; 234 235 do 236 { 237 FT_Pos y1 = arc[0]; 238 FT_Pos y2 = arc[1]; 239 FT_Pos y3 = arc[2]; 240 FT_Pos y4 = arc[3]; 241 242 243 if ( y1 == y4 ) 244 { 245 if ( y1 == y2 && y1 == y3 ) /* flat */ 246 goto Test; 247 } 248 else if ( y1 < y4 ) 249 { 250 if ( y2 >= y1 && y2 <= y4 && y3 >= y1 && y3 <= y4 ) /* ascending */ 251 goto Test; 252 } 253 else 254 { 255 if ( y2 >= y4 && y2 <= y1 && y3 >= y4 && y3 <= y1 ) /* descending */ 256 { 257 y2 = y1; 258 y1 = y4; 259 y4 = y2; 260 goto Test; 261 } 262 } 263 264 /* unknown direction -- split the arc in two */ 265 arc[6] = y4; 266 arc[1] = y1 = ( y1 + y2 ) / 2; 267 arc[5] = y4 = ( y4 + y3 ) / 2; 268 y2 = ( y2 + y3 ) / 2; 269 arc[2] = y1 = ( y1 + y2 ) / 2; 270 arc[4] = y4 = ( y4 + y2 ) / 2; 271 arc[3] = ( y1 + y4 ) / 2; 272 273 arc += 3; 274 goto Suite; 275 276 Test: 277 if ( y1 < *min ) *min = y1; 278 if ( y4 > *max ) *max = y4; 279 arc -= 3; 280 281 Suite: 282 ; 283 } while ( arc >= stack ); 284 } 285 286#else 287 288 static void 289 test_cubic_extrema( FT_Pos y1, 290 FT_Pos y2, 291 FT_Pos y3, 292 FT_Pos y4, 293 FT_Fixed u, 294 FT_Pos* min, 295 FT_Pos* max ) 296 { 297 /* FT_Pos a = y4 - 3*y3 + 3*y2 - y1; */ 298 FT_Pos b = y3 - 2*y2 + y1; 299 FT_Pos c = y2 - y1; 300 FT_Pos d = y1; 301 FT_Pos y; 302 FT_Fixed uu; 303 304 FT_UNUSED ( y4 ); 305 306 307 /* The polynomial is */ 308 /* */ 309 /* P(x) = a*x^3 + 3b*x^2 + 3c*x + d , */ 310 /* */ 311 /* dP/dx = 3a*x^2 + 6b*x + 3c . */ 312 /* */ 313 /* However, we also have */ 314 /* */ 315 /* dP/dx(u) = 0 , */ 316 /* */ 317 /* which implies by subtraction that */ 318 /* */ 319 /* P(u) = b*u^2 + 2c*u + d . */ 320 321 if ( u > 0 && u < 0x10000L ) 322 { 323 uu = FT_MulFix( u, u ); 324 y = d + FT_MulFix( c, 2*u ) + FT_MulFix( b, uu ); 325 326 if ( y < *min ) *min = y; 327 if ( y > *max ) *max = y; 328 } 329 } 330 331 332 static void 333 BBox_Cubic_Check( FT_Pos y1, 334 FT_Pos y2, 335 FT_Pos y3, 336 FT_Pos y4, 337 FT_Pos* min, 338 FT_Pos* max ) 339 { 340 /* always compare first and last points */ 341 if ( y1 < *min ) *min = y1; 342 else if ( y1 > *max ) *max = y1; 343 344 if ( y4 < *min ) *min = y4; 345 else if ( y4 > *max ) *max = y4; 346 347 /* now, try to see if there are split points here */ 348 if ( y1 <= y4 ) 349 { 350 /* flat or ascending arc test */ 351 if ( y1 <= y2 && y2 <= y4 && y1 <= y3 && y3 <= y4 ) 352 return; 353 } 354 else /* y1 > y4 */ 355 { 356 /* descending arc test */ 357 if ( y1 >= y2 && y2 >= y4 && y1 >= y3 && y3 >= y4 ) 358 return; 359 } 360 361 /* There are some split points. Find them. */ 362 { 363 FT_Pos a = y4 - 3*y3 + 3*y2 - y1; 364 FT_Pos b = y3 - 2*y2 + y1; 365 FT_Pos c = y2 - y1; 366 FT_Pos d; 367 FT_Fixed t; 368 369 370 /* We need to solve `ax^2+2bx+c' here, without floating points! */ 371 /* The trick is to normalize to a different representation in order */ 372 /* to use our 16.16 fixed point routines. */ 373 /* */ 374 /* We compute FT_MulFix(b,b) and FT_MulFix(a,c) after normalization. */ 375 /* These values must fit into a single 16.16 value. */ 376 /* */ 377 /* We normalize a, b, and c to `8.16' fixed float values to ensure */ 378 /* that its product is held in a `16.16' value. */ 379 380 { 381 FT_ULong t1, t2; 382 int shift = 0; 383 384 385 /* The following computation is based on the fact that for */ 386 /* any value `y', if `n' is the position of the most */ 387 /* significant bit of `abs(y)' (starting from 0 for the */ 388 /* least significant bit), then `y' is in the range */ 389 /* */ 390 /* -2^n..2^n-1 */ 391 /* */ 392 /* We want to shift `a', `b', and `c' concurrently in order */ 393 /* to ensure that they all fit in 8.16 values, which maps */ 394 /* to the integer range `-2^23..2^23-1'. */ 395 /* */ 396 /* Necessarily, we need to shift `a', `b', and `c' so that */ 397 /* the most significant bit of its absolute values is at */ 398 /* _most_ at position 23. */ 399 /* */ 400 /* We begin by computing `t1' as the bitwise `OR' of the */ 401 /* absolute values of `a', `b', `c'. */ 402 403 t1 = (FT_ULong)( ( a >= 0 ) ? a : -a ); 404 t2 = (FT_ULong)( ( b >= 0 ) ? b : -b ); 405 t1 |= t2; 406 t2 = (FT_ULong)( ( c >= 0 ) ? c : -c ); 407 t1 |= t2; 408 409 /* Now we can be sure that the most significant bit of `t1' */ 410 /* is the most significant bit of either `a', `b', or `c', */ 411 /* depending on the greatest integer range of the particular */ 412 /* variable. */ 413 /* */ 414 /* Next, we compute the `shift', by shifting `t1' as many */ 415 /* times as necessary to move its MSB to position 23. This */ 416 /* corresponds to a value of `t1' that is in the range */ 417 /* 0x40_0000..0x7F_FFFF. */ 418 /* */ 419 /* Finally, we shift `a', `b', and `c' by the same amount. */ 420 /* This ensures that all values are now in the range */ 421 /* -2^23..2^23, i.e., they are now expressed as 8.16 */ 422 /* fixed-float numbers. This also means that we are using */ 423 /* 24 bits of precision to compute the zeros, independently */ 424 /* of the range of the original polynomial coefficients. */ 425 /* */ 426 /* This algorithm should ensure reasonably accurate values */ 427 /* for the zeros. Note that they are only expressed with */ 428 /* 16 bits when computing the extrema (the zeros need to */ 429 /* be in 0..1 exclusive to be considered part of the arc). */ 430 431 if ( t1 == 0 ) /* all coefficients are 0! */ 432 return; 433 434 if ( t1 > 0x7FFFFFUL ) 435 { 436 do 437 { 438 shift++; 439 t1 >>= 1; 440 441 } while ( t1 > 0x7FFFFFUL ); 442 443 /* this loses some bits of precision, but we use 24 of them */ 444 /* for the computation anyway */ 445 a >>= shift; 446 b >>= shift; 447 c >>= shift; 448 } 449 else if ( t1 < 0x400000UL ) 450 { 451 do 452 { 453 shift++; 454 t1 <<= 1; 455 456 } while ( t1 < 0x400000UL ); 457 458 a <<= shift; 459 b <<= shift; 460 c <<= shift; 461 } 462 } 463 464 /* handle a == 0 */ 465 if ( a == 0 ) 466 { 467 if ( b != 0 ) 468 { 469 t = - FT_DivFix( c, b ) / 2; 470 test_cubic_extrema( y1, y2, y3, y4, t, min, max ); 471 } 472 } 473 else 474 { 475 /* solve the equation now */ 476 d = FT_MulFix( b, b ) - FT_MulFix( a, c ); 477 if ( d < 0 ) 478 return; 479 480 if ( d == 0 ) 481 { 482 /* there is a single split point at -b/a */ 483 t = - FT_DivFix( b, a ); 484 test_cubic_extrema( y1, y2, y3, y4, t, min, max ); 485 } 486 else 487 { 488 /* there are two solutions; we need to filter them */ 489 d = FT_SqrtFixed( (FT_Int32)d ); 490 t = - FT_DivFix( b - d, a ); 491 test_cubic_extrema( y1, y2, y3, y4, t, min, max ); 492 493 t = - FT_DivFix( b + d, a ); 494 test_cubic_extrema( y1, y2, y3, y4, t, min, max ); 495 } 496 } 497 } 498 } 499 500#endif 501 502 503 /*************************************************************************/ 504 /* */ 505 /* <Function> */ 506 /* BBox_Cubic_To */ 507 /* */ 508 /* <Description> */ 509 /* This function is used as a `cubic_to' emitter during */ 510 /* FT_Outline_Decompose(). It checks a cubic Bezier curve with the */ 511 /* current bounding box, and computes its extrema if necessary to */ 512 /* update it. */ 513 /* */ 514 /* <Input> */ 515 /* control1 :: A pointer to the first control point. */ 516 /* */ 517 /* control2 :: A pointer to the second control point. */ 518 /* */ 519 /* to :: A pointer to the destination vector. */ 520 /* */ 521 /* <InOut> */ 522 /* user :: The address of the current walk context. */ 523 /* */ 524 /* <Return> */ 525 /* Always 0. Needed for the interface only. */ 526 /* */ 527 /* <Note> */ 528 /* In the case of a non-monotonous arc, we don't compute directly */ 529 /* extremum coordinates, we subdivide instead. */ 530 /* */ 531 static int 532 BBox_Cubic_To( FT_Vector* control1, 533 FT_Vector* control2, 534 FT_Vector* to, 535 TBBox_Rec* user ) 536 { 537 /* we don't need to check `to' since it is always an `on' point, thus */ 538 /* within the bbox */ 539 540 if ( CHECK_X( control1, user->bbox ) || 541 CHECK_X( control2, user->bbox ) ) 542 BBox_Cubic_Check( user->last.x, 543 control1->x, 544 control2->x, 545 to->x, 546 &user->bbox.xMin, 547 &user->bbox.xMax ); 548 549 if ( CHECK_Y( control1, user->bbox ) || 550 CHECK_Y( control2, user->bbox ) ) 551 BBox_Cubic_Check( user->last.y, 552 control1->y, 553 control2->y, 554 to->y, 555 &user->bbox.yMin, 556 &user->bbox.yMax ); 557 558 user->last = *to; 559 560 return 0; 561 } 562 563FT_DEFINE_OUTLINE_FUNCS(bbox_interface, 564 (FT_Outline_MoveTo_Func) BBox_Move_To, 565 (FT_Outline_LineTo_Func) BBox_Move_To, 566 (FT_Outline_ConicTo_Func)BBox_Conic_To, 567 (FT_Outline_CubicTo_Func)BBox_Cubic_To, 568 0, 0 569 ) 570 571 /* documentation is in ftbbox.h */ 572 573 FT_EXPORT_DEF( FT_Error ) 574 FT_Outline_Get_BBox( FT_Outline* outline, 575 FT_BBox *abbox ) 576 { 577 FT_BBox cbox; 578 FT_BBox bbox; 579 FT_Vector* vec; 580 FT_UShort n; 581 582 583 if ( !abbox ) 584 return FT_Err_Invalid_Argument; 585 586 if ( !outline ) 587 return FT_Err_Invalid_Outline; 588 589 /* if outline is empty, return (0,0,0,0) */ 590 if ( outline->n_points == 0 || outline->n_contours <= 0 ) 591 { 592 abbox->xMin = abbox->xMax = 0; 593 abbox->yMin = abbox->yMax = 0; 594 return 0; 595 } 596 597 /* We compute the control box as well as the bounding box of */ 598 /* all `on' points in the outline. Then, if the two boxes */ 599 /* coincide, we exit immediately. */ 600 601 vec = outline->points; 602 bbox.xMin = bbox.xMax = cbox.xMin = cbox.xMax = vec->x; 603 bbox.yMin = bbox.yMax = cbox.yMin = cbox.yMax = vec->y; 604 vec++; 605 606 for ( n = 1; n < outline->n_points; n++ ) 607 { 608 FT_Pos x = vec->x; 609 FT_Pos y = vec->y; 610 611 612 /* update control box */ 613 if ( x < cbox.xMin ) cbox.xMin = x; 614 if ( x > cbox.xMax ) cbox.xMax = x; 615 616 if ( y < cbox.yMin ) cbox.yMin = y; 617 if ( y > cbox.yMax ) cbox.yMax = y; 618 619 if ( FT_CURVE_TAG( outline->tags[n] ) == FT_CURVE_TAG_ON ) 620 { 621 /* update bbox for `on' points only */ 622 if ( x < bbox.xMin ) bbox.xMin = x; 623 if ( x > bbox.xMax ) bbox.xMax = x; 624 625 if ( y < bbox.yMin ) bbox.yMin = y; 626 if ( y > bbox.yMax ) bbox.yMax = y; 627 } 628 629 vec++; 630 } 631 632 /* test two boxes for equality */ 633 if ( cbox.xMin < bbox.xMin || cbox.xMax > bbox.xMax || 634 cbox.yMin < bbox.yMin || cbox.yMax > bbox.yMax ) 635 { 636 /* the two boxes are different, now walk over the outline to */ 637 /* get the Bezier arc extrema. */ 638 639 FT_Error error; 640 TBBox_Rec user; 641 642#ifdef FT_CONFIG_OPTION_PIC 643 FT_Outline_Funcs bbox_interface; 644 Init_Class_bbox_interface(&bbox_interface); 645#endif 646 647 user.bbox = bbox; 648 649 error = FT_Outline_Decompose( outline, &bbox_interface, &user ); 650 if ( error ) 651 return error; 652 653 *abbox = user.bbox; 654 } 655 else 656 *abbox = bbox; 657 658 return FT_Err_Ok; 659 } 660 661 662/* END */ 663