1/***************************************************************************/ 2/* */ 3/* ftoutln.c */ 4/* */ 5/* FreeType outline management (body). */ 6/* */ 7/* Copyright 1996-2008, 2010, 2012 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 /* All functions are declared in freetype.h. */ 22 /* */ 23 /*************************************************************************/ 24 25 26#include <ft2build.h> 27#include FT_OUTLINE_H 28#include FT_INTERNAL_OBJECTS_H 29#include FT_INTERNAL_DEBUG_H 30#include FT_TRIGONOMETRY_H 31 32 33 /*************************************************************************/ 34 /* */ 35 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 36 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 37 /* messages during execution. */ 38 /* */ 39#undef FT_COMPONENT 40#define FT_COMPONENT trace_outline 41 42 43 static 44 const FT_Outline null_outline = { 0, 0, 0, 0, 0, 0 }; 45 46 47 /* documentation is in ftoutln.h */ 48 49 FT_EXPORT_DEF( FT_Error ) 50 FT_Outline_Decompose( FT_Outline* outline, 51 const FT_Outline_Funcs* func_interface, 52 void* user ) 53 { 54#undef SCALED 55#define SCALED( x ) ( ( (x) << shift ) - delta ) 56 57 FT_Vector v_last; 58 FT_Vector v_control; 59 FT_Vector v_start; 60 61 FT_Vector* point; 62 FT_Vector* limit; 63 char* tags; 64 65 FT_Error error; 66 67 FT_Int n; /* index of contour in outline */ 68 FT_UInt first; /* index of first point in contour */ 69 FT_Int tag; /* current point's state */ 70 71 FT_Int shift; 72 FT_Pos delta; 73 74 75 if ( !outline || !func_interface ) 76 return FT_Err_Invalid_Argument; 77 78 shift = func_interface->shift; 79 delta = func_interface->delta; 80 first = 0; 81 82 for ( n = 0; n < outline->n_contours; n++ ) 83 { 84 FT_Int last; /* index of last point in contour */ 85 86 87 FT_TRACE5(( "FT_Outline_Decompose: Outline %d\n", n )); 88 89 last = outline->contours[n]; 90 if ( last < 0 ) 91 goto Invalid_Outline; 92 limit = outline->points + last; 93 94 v_start = outline->points[first]; 95 v_start.x = SCALED( v_start.x ); 96 v_start.y = SCALED( v_start.y ); 97 98 v_last = outline->points[last]; 99 v_last.x = SCALED( v_last.x ); 100 v_last.y = SCALED( v_last.y ); 101 102 v_control = v_start; 103 104 point = outline->points + first; 105 tags = outline->tags + first; 106 tag = FT_CURVE_TAG( tags[0] ); 107 108 /* A contour cannot start with a cubic control point! */ 109 if ( tag == FT_CURVE_TAG_CUBIC ) 110 goto Invalid_Outline; 111 112 /* check first point to determine origin */ 113 if ( tag == FT_CURVE_TAG_CONIC ) 114 { 115 /* first point is conic control. Yes, this happens. */ 116 if ( FT_CURVE_TAG( outline->tags[last] ) == FT_CURVE_TAG_ON ) 117 { 118 /* start at last point if it is on the curve */ 119 v_start = v_last; 120 limit--; 121 } 122 else 123 { 124 /* if both first and last points are conic, */ 125 /* start at their middle and record its position */ 126 /* for closure */ 127 v_start.x = ( v_start.x + v_last.x ) / 2; 128 v_start.y = ( v_start.y + v_last.y ) / 2; 129 130 v_last = v_start; 131 } 132 point--; 133 tags--; 134 } 135 136 FT_TRACE5(( " move to (%.2f, %.2f)\n", 137 v_start.x / 64.0, v_start.y / 64.0 )); 138 error = func_interface->move_to( &v_start, user ); 139 if ( error ) 140 goto Exit; 141 142 while ( point < limit ) 143 { 144 point++; 145 tags++; 146 147 tag = FT_CURVE_TAG( tags[0] ); 148 switch ( tag ) 149 { 150 case FT_CURVE_TAG_ON: /* emit a single line_to */ 151 { 152 FT_Vector vec; 153 154 155 vec.x = SCALED( point->x ); 156 vec.y = SCALED( point->y ); 157 158 FT_TRACE5(( " line to (%.2f, %.2f)\n", 159 vec.x / 64.0, vec.y / 64.0 )); 160 error = func_interface->line_to( &vec, user ); 161 if ( error ) 162 goto Exit; 163 continue; 164 } 165 166 case FT_CURVE_TAG_CONIC: /* consume conic arcs */ 167 v_control.x = SCALED( point->x ); 168 v_control.y = SCALED( point->y ); 169 170 Do_Conic: 171 if ( point < limit ) 172 { 173 FT_Vector vec; 174 FT_Vector v_middle; 175 176 177 point++; 178 tags++; 179 tag = FT_CURVE_TAG( tags[0] ); 180 181 vec.x = SCALED( point->x ); 182 vec.y = SCALED( point->y ); 183 184 if ( tag == FT_CURVE_TAG_ON ) 185 { 186 FT_TRACE5(( " conic to (%.2f, %.2f)" 187 " with control (%.2f, %.2f)\n", 188 vec.x / 64.0, vec.y / 64.0, 189 v_control.x / 64.0, v_control.y / 64.0 )); 190 error = func_interface->conic_to( &v_control, &vec, user ); 191 if ( error ) 192 goto Exit; 193 continue; 194 } 195 196 if ( tag != FT_CURVE_TAG_CONIC ) 197 goto Invalid_Outline; 198 199 v_middle.x = ( v_control.x + vec.x ) / 2; 200 v_middle.y = ( v_control.y + vec.y ) / 2; 201 202 FT_TRACE5(( " conic to (%.2f, %.2f)" 203 " with control (%.2f, %.2f)\n", 204 v_middle.x / 64.0, v_middle.y / 64.0, 205 v_control.x / 64.0, v_control.y / 64.0 )); 206 error = func_interface->conic_to( &v_control, &v_middle, user ); 207 if ( error ) 208 goto Exit; 209 210 v_control = vec; 211 goto Do_Conic; 212 } 213 214 FT_TRACE5(( " conic to (%.2f, %.2f)" 215 " with control (%.2f, %.2f)\n", 216 v_start.x / 64.0, v_start.y / 64.0, 217 v_control.x / 64.0, v_control.y / 64.0 )); 218 error = func_interface->conic_to( &v_control, &v_start, user ); 219 goto Close; 220 221 default: /* FT_CURVE_TAG_CUBIC */ 222 { 223 FT_Vector vec1, vec2; 224 225 226 if ( point + 1 > limit || 227 FT_CURVE_TAG( tags[1] ) != FT_CURVE_TAG_CUBIC ) 228 goto Invalid_Outline; 229 230 point += 2; 231 tags += 2; 232 233 vec1.x = SCALED( point[-2].x ); 234 vec1.y = SCALED( point[-2].y ); 235 236 vec2.x = SCALED( point[-1].x ); 237 vec2.y = SCALED( point[-1].y ); 238 239 if ( point <= limit ) 240 { 241 FT_Vector vec; 242 243 244 vec.x = SCALED( point->x ); 245 vec.y = SCALED( point->y ); 246 247 FT_TRACE5(( " cubic to (%.2f, %.2f)" 248 " with controls (%.2f, %.2f) and (%.2f, %.2f)\n", 249 vec.x / 64.0, vec.y / 64.0, 250 vec1.x / 64.0, vec1.y / 64.0, 251 vec2.x / 64.0, vec2.y / 64.0 )); 252 error = func_interface->cubic_to( &vec1, &vec2, &vec, user ); 253 if ( error ) 254 goto Exit; 255 continue; 256 } 257 258 FT_TRACE5(( " cubic to (%.2f, %.2f)" 259 " with controls (%.2f, %.2f) and (%.2f, %.2f)\n", 260 v_start.x / 64.0, v_start.y / 64.0, 261 vec1.x / 64.0, vec1.y / 64.0, 262 vec2.x / 64.0, vec2.y / 64.0 )); 263 error = func_interface->cubic_to( &vec1, &vec2, &v_start, user ); 264 goto Close; 265 } 266 } 267 } 268 269 /* close the contour with a line segment */ 270 FT_TRACE5(( " line to (%.2f, %.2f)\n", 271 v_start.x / 64.0, v_start.y / 64.0 )); 272 error = func_interface->line_to( &v_start, user ); 273 274 Close: 275 if ( error ) 276 goto Exit; 277 278 first = last + 1; 279 } 280 281 FT_TRACE5(( "FT_Outline_Decompose: Done\n", n )); 282 return FT_Err_Ok; 283 284 Exit: 285 FT_TRACE5(( "FT_Outline_Decompose: Error %d\n", error )); 286 return error; 287 288 Invalid_Outline: 289 return FT_Err_Invalid_Outline; 290 } 291 292 293 FT_EXPORT_DEF( FT_Error ) 294 FT_Outline_New_Internal( FT_Memory memory, 295 FT_UInt numPoints, 296 FT_Int numContours, 297 FT_Outline *anoutline ) 298 { 299 FT_Error error; 300 301 302 if ( !anoutline || !memory ) 303 return FT_Err_Invalid_Argument; 304 305 *anoutline = null_outline; 306 307 if ( FT_NEW_ARRAY( anoutline->points, numPoints ) || 308 FT_NEW_ARRAY( anoutline->tags, numPoints ) || 309 FT_NEW_ARRAY( anoutline->contours, numContours ) ) 310 goto Fail; 311 312 anoutline->n_points = (FT_UShort)numPoints; 313 anoutline->n_contours = (FT_Short)numContours; 314 anoutline->flags |= FT_OUTLINE_OWNER; 315 316 return FT_Err_Ok; 317 318 Fail: 319 anoutline->flags |= FT_OUTLINE_OWNER; 320 FT_Outline_Done_Internal( memory, anoutline ); 321 322 return error; 323 } 324 325 326 /* documentation is in ftoutln.h */ 327 328 FT_EXPORT_DEF( FT_Error ) 329 FT_Outline_New( FT_Library library, 330 FT_UInt numPoints, 331 FT_Int numContours, 332 FT_Outline *anoutline ) 333 { 334 if ( !library ) 335 return FT_Err_Invalid_Library_Handle; 336 337 return FT_Outline_New_Internal( library->memory, numPoints, 338 numContours, anoutline ); 339 } 340 341 342 /* documentation is in ftoutln.h */ 343 344 FT_EXPORT_DEF( FT_Error ) 345 FT_Outline_Check( FT_Outline* outline ) 346 { 347 if ( outline ) 348 { 349 FT_Int n_points = outline->n_points; 350 FT_Int n_contours = outline->n_contours; 351 FT_Int end0, end; 352 FT_Int n; 353 354 355 /* empty glyph? */ 356 if ( n_points == 0 && n_contours == 0 ) 357 return 0; 358 359 /* check point and contour counts */ 360 if ( n_points <= 0 || n_contours <= 0 ) 361 goto Bad; 362 363 end0 = end = -1; 364 for ( n = 0; n < n_contours; n++ ) 365 { 366 end = outline->contours[n]; 367 368 /* note that we don't accept empty contours */ 369 if ( end <= end0 || end >= n_points ) 370 goto Bad; 371 372 end0 = end; 373 } 374 375 if ( end != n_points - 1 ) 376 goto Bad; 377 378 /* XXX: check the tags array */ 379 return 0; 380 } 381 382 Bad: 383 return FT_Err_Invalid_Argument; 384 } 385 386 387 /* documentation is in ftoutln.h */ 388 389 FT_EXPORT_DEF( FT_Error ) 390 FT_Outline_Copy( const FT_Outline* source, 391 FT_Outline *target ) 392 { 393 FT_Int is_owner; 394 395 396 if ( !source || !target || 397 source->n_points != target->n_points || 398 source->n_contours != target->n_contours ) 399 return FT_Err_Invalid_Argument; 400 401 if ( source == target ) 402 return FT_Err_Ok; 403 404 FT_ARRAY_COPY( target->points, source->points, source->n_points ); 405 406 FT_ARRAY_COPY( target->tags, source->tags, source->n_points ); 407 408 FT_ARRAY_COPY( target->contours, source->contours, source->n_contours ); 409 410 /* copy all flags, except the `FT_OUTLINE_OWNER' one */ 411 is_owner = target->flags & FT_OUTLINE_OWNER; 412 target->flags = source->flags; 413 414 target->flags &= ~FT_OUTLINE_OWNER; 415 target->flags |= is_owner; 416 417 return FT_Err_Ok; 418 } 419 420 421 FT_EXPORT_DEF( FT_Error ) 422 FT_Outline_Done_Internal( FT_Memory memory, 423 FT_Outline* outline ) 424 { 425 if ( memory && outline ) 426 { 427 if ( outline->flags & FT_OUTLINE_OWNER ) 428 { 429 FT_FREE( outline->points ); 430 FT_FREE( outline->tags ); 431 FT_FREE( outline->contours ); 432 } 433 *outline = null_outline; 434 435 return FT_Err_Ok; 436 } 437 else 438 return FT_Err_Invalid_Argument; 439 } 440 441 442 /* documentation is in ftoutln.h */ 443 444 FT_EXPORT_DEF( FT_Error ) 445 FT_Outline_Done( FT_Library library, 446 FT_Outline* outline ) 447 { 448 /* check for valid `outline' in FT_Outline_Done_Internal() */ 449 450 if ( !library ) 451 return FT_Err_Invalid_Library_Handle; 452 453 return FT_Outline_Done_Internal( library->memory, outline ); 454 } 455 456 457 /* documentation is in ftoutln.h */ 458 459 FT_EXPORT_DEF( void ) 460 FT_Outline_Get_CBox( const FT_Outline* outline, 461 FT_BBox *acbox ) 462 { 463 FT_Pos xMin, yMin, xMax, yMax; 464 465 466 if ( outline && acbox ) 467 { 468 if ( outline->n_points == 0 ) 469 { 470 xMin = 0; 471 yMin = 0; 472 xMax = 0; 473 yMax = 0; 474 } 475 else 476 { 477 FT_Vector* vec = outline->points; 478 FT_Vector* limit = vec + outline->n_points; 479 480 481 xMin = xMax = vec->x; 482 yMin = yMax = vec->y; 483 vec++; 484 485 for ( ; vec < limit; vec++ ) 486 { 487 FT_Pos x, y; 488 489 490 x = vec->x; 491 if ( x < xMin ) xMin = x; 492 if ( x > xMax ) xMax = x; 493 494 y = vec->y; 495 if ( y < yMin ) yMin = y; 496 if ( y > yMax ) yMax = y; 497 } 498 } 499 acbox->xMin = xMin; 500 acbox->xMax = xMax; 501 acbox->yMin = yMin; 502 acbox->yMax = yMax; 503 } 504 } 505 506 507 /* documentation is in ftoutln.h */ 508 509 FT_EXPORT_DEF( void ) 510 FT_Outline_Translate( const FT_Outline* outline, 511 FT_Pos xOffset, 512 FT_Pos yOffset ) 513 { 514 FT_UShort n; 515 FT_Vector* vec; 516 517 518 if ( !outline ) 519 return; 520 521 vec = outline->points; 522 523 for ( n = 0; n < outline->n_points; n++ ) 524 { 525 vec->x += xOffset; 526 vec->y += yOffset; 527 vec++; 528 } 529 } 530 531 532 /* documentation is in ftoutln.h */ 533 534 FT_EXPORT_DEF( void ) 535 FT_Outline_Reverse( FT_Outline* outline ) 536 { 537 FT_UShort n; 538 FT_Int first, last; 539 540 541 if ( !outline ) 542 return; 543 544 first = 0; 545 546 for ( n = 0; n < outline->n_contours; n++ ) 547 { 548 last = outline->contours[n]; 549 550 /* reverse point table */ 551 { 552 FT_Vector* p = outline->points + first; 553 FT_Vector* q = outline->points + last; 554 FT_Vector swap; 555 556 557 while ( p < q ) 558 { 559 swap = *p; 560 *p = *q; 561 *q = swap; 562 p++; 563 q--; 564 } 565 } 566 567 /* reverse tags table */ 568 { 569 char* p = outline->tags + first; 570 char* q = outline->tags + last; 571 char swap; 572 573 574 while ( p < q ) 575 { 576 swap = *p; 577 *p = *q; 578 *q = swap; 579 p++; 580 q--; 581 } 582 } 583 584 first = last + 1; 585 } 586 587 outline->flags ^= FT_OUTLINE_REVERSE_FILL; 588 } 589 590 591 /* documentation is in ftoutln.h */ 592 593 FT_EXPORT_DEF( FT_Error ) 594 FT_Outline_Render( FT_Library library, 595 FT_Outline* outline, 596 FT_Raster_Params* params ) 597 { 598 FT_Error error; 599 FT_Bool update = FALSE; 600 FT_Renderer renderer; 601 FT_ListNode node; 602 603 604 if ( !library ) 605 return FT_Err_Invalid_Library_Handle; 606 607 if ( !outline || !params ) 608 return FT_Err_Invalid_Argument; 609 610 renderer = library->cur_renderer; 611 node = library->renderers.head; 612 613 params->source = (void*)outline; 614 615 error = FT_Err_Cannot_Render_Glyph; 616 while ( renderer ) 617 { 618 error = renderer->raster_render( renderer->raster, params ); 619 if ( !error || FT_ERROR_BASE( error ) != FT_Err_Cannot_Render_Glyph ) 620 break; 621 622 /* FT_Err_Cannot_Render_Glyph is returned if the render mode */ 623 /* is unsupported by the current renderer for this glyph image */ 624 /* format */ 625 626 /* now, look for another renderer that supports the same */ 627 /* format */ 628 renderer = FT_Lookup_Renderer( library, FT_GLYPH_FORMAT_OUTLINE, 629 &node ); 630 update = TRUE; 631 } 632 633 /* if we changed the current renderer for the glyph image format */ 634 /* we need to select it as the next current one */ 635 if ( !error && update && renderer ) 636 FT_Set_Renderer( library, renderer, 0, 0 ); 637 638 return error; 639 } 640 641 642 /* documentation is in ftoutln.h */ 643 644 FT_EXPORT_DEF( FT_Error ) 645 FT_Outline_Get_Bitmap( FT_Library library, 646 FT_Outline* outline, 647 const FT_Bitmap *abitmap ) 648 { 649 FT_Raster_Params params; 650 651 652 if ( !abitmap ) 653 return FT_Err_Invalid_Argument; 654 655 /* other checks are delayed to FT_Outline_Render() */ 656 657 params.target = abitmap; 658 params.flags = 0; 659 660 if ( abitmap->pixel_mode == FT_PIXEL_MODE_GRAY || 661 abitmap->pixel_mode == FT_PIXEL_MODE_LCD || 662 abitmap->pixel_mode == FT_PIXEL_MODE_LCD_V ) 663 params.flags |= FT_RASTER_FLAG_AA; 664 665 return FT_Outline_Render( library, outline, ¶ms ); 666 } 667 668 669 /* documentation is in freetype.h */ 670 671 FT_EXPORT_DEF( void ) 672 FT_Vector_Transform( FT_Vector* vector, 673 const FT_Matrix* matrix ) 674 { 675 FT_Pos xz, yz; 676 677 678 if ( !vector || !matrix ) 679 return; 680 681 xz = FT_MulFix( vector->x, matrix->xx ) + 682 FT_MulFix( vector->y, matrix->xy ); 683 684 yz = FT_MulFix( vector->x, matrix->yx ) + 685 FT_MulFix( vector->y, matrix->yy ); 686 687 vector->x = xz; 688 vector->y = yz; 689 } 690 691 692 /* documentation is in ftoutln.h */ 693 694 FT_EXPORT_DEF( void ) 695 FT_Outline_Transform( const FT_Outline* outline, 696 const FT_Matrix* matrix ) 697 { 698 FT_Vector* vec; 699 FT_Vector* limit; 700 701 702 if ( !outline || !matrix ) 703 return; 704 705 vec = outline->points; 706 limit = vec + outline->n_points; 707 708 for ( ; vec < limit; vec++ ) 709 FT_Vector_Transform( vec, matrix ); 710 } 711 712 713#if 0 714 715#define FT_OUTLINE_GET_CONTOUR( outline, c, first, last ) \ 716 do { \ 717 (first) = ( c > 0 ) ? (outline)->points + \ 718 (outline)->contours[c - 1] + 1 \ 719 : (outline)->points; \ 720 (last) = (outline)->points + (outline)->contours[c]; \ 721 } while ( 0 ) 722 723 724 /* Is a point in some contour? */ 725 /* */ 726 /* We treat every point of the contour as if it */ 727 /* it were ON. That is, we allow false positives, */ 728 /* but disallow false negatives. (XXX really?) */ 729 static FT_Bool 730 ft_contour_has( FT_Outline* outline, 731 FT_Short c, 732 FT_Vector* point ) 733 { 734 FT_Vector* first; 735 FT_Vector* last; 736 FT_Vector* a; 737 FT_Vector* b; 738 FT_UInt n = 0; 739 740 741 FT_OUTLINE_GET_CONTOUR( outline, c, first, last ); 742 743 for ( a = first; a <= last; a++ ) 744 { 745 FT_Pos x; 746 FT_Int intersect; 747 748 749 b = ( a == last ) ? first : a + 1; 750 751 intersect = ( a->y - point->y ) ^ ( b->y - point->y ); 752 753 /* a and b are on the same side */ 754 if ( intersect >= 0 ) 755 { 756 if ( intersect == 0 && a->y == point->y ) 757 { 758 if ( ( a->x <= point->x && b->x >= point->x ) || 759 ( a->x >= point->x && b->x <= point->x ) ) 760 return 1; 761 } 762 763 continue; 764 } 765 766 x = a->x + ( b->x - a->x ) * (point->y - a->y ) / ( b->y - a->y ); 767 768 if ( x < point->x ) 769 n++; 770 else if ( x == point->x ) 771 return 1; 772 } 773 774 return n & 1; 775 } 776 777 778 static FT_Bool 779 ft_contour_enclosed( FT_Outline* outline, 780 FT_UShort c ) 781 { 782 FT_Vector* first; 783 FT_Vector* last; 784 FT_Short i; 785 786 787 FT_OUTLINE_GET_CONTOUR( outline, c, first, last ); 788 789 for ( i = 0; i < outline->n_contours; i++ ) 790 { 791 if ( i != c && ft_contour_has( outline, i, first ) ) 792 { 793 FT_Vector* pt; 794 795 796 for ( pt = first + 1; pt <= last; pt++ ) 797 if ( !ft_contour_has( outline, i, pt ) ) 798 return 0; 799 800 return 1; 801 } 802 } 803 804 return 0; 805 } 806 807 808 /* This version differs from the public one in that each */ 809 /* part (contour not enclosed in another contour) of the */ 810 /* outline is checked for orientation. This is */ 811 /* necessary for some buggy CJK fonts. */ 812 static FT_Orientation 813 ft_outline_get_orientation( FT_Outline* outline ) 814 { 815 FT_Short i; 816 FT_Vector* first; 817 FT_Vector* last; 818 FT_Orientation orient = FT_ORIENTATION_NONE; 819 820 821 first = outline->points; 822 for ( i = 0; i < outline->n_contours; i++, first = last + 1 ) 823 { 824 FT_Vector* point; 825 FT_Vector* xmin_point; 826 FT_Pos xmin; 827 828 829 last = outline->points + outline->contours[i]; 830 831 /* skip degenerate contours */ 832 if ( last < first + 2 ) 833 continue; 834 835 if ( ft_contour_enclosed( outline, i ) ) 836 continue; 837 838 xmin = first->x; 839 xmin_point = first; 840 841 for ( point = first + 1; point <= last; point++ ) 842 { 843 if ( point->x < xmin ) 844 { 845 xmin = point->x; 846 xmin_point = point; 847 } 848 } 849 850 /* check the orientation of the contour */ 851 { 852 FT_Vector* prev; 853 FT_Vector* next; 854 FT_Orientation o; 855 856 857 prev = ( xmin_point == first ) ? last : xmin_point - 1; 858 next = ( xmin_point == last ) ? first : xmin_point + 1; 859 860 if ( FT_Atan2( prev->x - xmin_point->x, prev->y - xmin_point->y ) > 861 FT_Atan2( next->x - xmin_point->x, next->y - xmin_point->y ) ) 862 o = FT_ORIENTATION_POSTSCRIPT; 863 else 864 o = FT_ORIENTATION_TRUETYPE; 865 866 if ( orient == FT_ORIENTATION_NONE ) 867 orient = o; 868 else if ( orient != o ) 869 return FT_ORIENTATION_NONE; 870 } 871 } 872 873 return orient; 874 } 875 876#endif /* 0 */ 877 878 879 /* documentation is in ftoutln.h */ 880 881 FT_EXPORT_DEF( FT_Error ) 882 FT_Outline_Embolden( FT_Outline* outline, 883 FT_Pos strength ) 884 { 885 FT_Vector* points; 886 FT_Vector v_prev, v_first, v_next, v_cur; 887 FT_Angle rotate, angle_in, angle_out; 888 FT_Int c, n, first; 889 FT_Int orientation; 890 891 892 if ( !outline ) 893 return FT_Err_Invalid_Argument; 894 895 strength /= 2; 896 if ( strength == 0 ) 897 return FT_Err_Ok; 898 899 orientation = FT_Outline_Get_Orientation( outline ); 900 if ( orientation == FT_ORIENTATION_NONE ) 901 { 902 if ( outline->n_contours ) 903 return FT_Err_Invalid_Argument; 904 else 905 return FT_Err_Ok; 906 } 907 908 if ( orientation == FT_ORIENTATION_TRUETYPE ) 909 rotate = -FT_ANGLE_PI2; 910 else 911 rotate = FT_ANGLE_PI2; 912 913 points = outline->points; 914 915 first = 0; 916 for ( c = 0; c < outline->n_contours; c++ ) 917 { 918 int last = outline->contours[c]; 919 920 921 v_first = points[first]; 922 v_prev = points[last]; 923 v_cur = v_first; 924 925 for ( n = first; n <= last; n++ ) 926 { 927 FT_Vector in, out; 928 FT_Angle angle_diff; 929 FT_Pos d; 930 FT_Fixed scale; 931 932 933 if ( n < last ) 934 v_next = points[n + 1]; 935 else 936 v_next = v_first; 937 938 /* compute the in and out vectors */ 939 in.x = v_cur.x - v_prev.x; 940 in.y = v_cur.y - v_prev.y; 941 942 out.x = v_next.x - v_cur.x; 943 out.y = v_next.y - v_cur.y; 944 945 angle_in = FT_Atan2( in.x, in.y ); 946 angle_out = FT_Atan2( out.x, out.y ); 947 angle_diff = FT_Angle_Diff( angle_in, angle_out ); 948 scale = FT_Cos( angle_diff / 2 ); 949 950 if ( scale < 0x4000L && scale > -0x4000L ) 951 in.x = in.y = 0; 952 else 953 { 954 d = FT_DivFix( strength, scale ); 955 956 FT_Vector_From_Polar( &in, d, angle_in + angle_diff / 2 - rotate ); 957 } 958 959 outline->points[n].x = v_cur.x + strength + in.x; 960 outline->points[n].y = v_cur.y + strength + in.y; 961 962 v_prev = v_cur; 963 v_cur = v_next; 964 } 965 966 first = last + 1; 967 } 968 969 return FT_Err_Ok; 970 } 971 972 973 /* documentation is in ftoutln.h */ 974 975 FT_EXPORT_DEF( FT_Orientation ) 976 FT_Outline_Get_Orientation( FT_Outline* outline ) 977 { 978 FT_Pos xmin = 32768L; 979 FT_Pos xmin_ymin = 32768L; 980 FT_Pos xmin_ymax = -32768L; 981 FT_Vector* xmin_first = NULL; 982 FT_Vector* xmin_last = NULL; 983 984 short* contour; 985 986 FT_Vector* first; 987 FT_Vector* last; 988 FT_Vector* prev; 989 FT_Vector* point; 990 991 int i; 992 FT_Pos ray_y[3]; 993 FT_Orientation result[3] = 994 { FT_ORIENTATION_NONE, FT_ORIENTATION_NONE, FT_ORIENTATION_NONE }; 995 996 997 if ( !outline || outline->n_points <= 0 ) 998 return FT_ORIENTATION_TRUETYPE; 999 1000 /* We use the nonzero winding rule to find the orientation. */ 1001 /* Since glyph outlines behave much more `regular' than arbitrary */ 1002 /* cubic or quadratic curves, this test deals with the polygon */ 1003 /* only which is spanned up by the control points. */ 1004 1005 first = outline->points; 1006 for ( contour = outline->contours; 1007 contour < outline->contours + outline->n_contours; 1008 contour++, first = last + 1 ) 1009 { 1010 FT_Pos contour_xmin = 32768L; 1011 FT_Pos contour_xmax = -32768L; 1012 FT_Pos contour_ymin = 32768L; 1013 FT_Pos contour_ymax = -32768L; 1014 1015 1016 last = outline->points + *contour; 1017 1018 /* skip degenerate contours */ 1019 if ( last < first + 2 ) 1020 continue; 1021 1022 for ( point = first; point <= last; ++point ) 1023 { 1024 if ( point->x < contour_xmin ) 1025 contour_xmin = point->x; 1026 1027 if ( point->x > contour_xmax ) 1028 contour_xmax = point->x; 1029 1030 if ( point->y < contour_ymin ) 1031 contour_ymin = point->y; 1032 1033 if ( point->y > contour_ymax ) 1034 contour_ymax = point->y; 1035 } 1036 1037 if ( contour_xmin < xmin && 1038 contour_xmin != contour_xmax && 1039 contour_ymin != contour_ymax ) 1040 { 1041 xmin = contour_xmin; 1042 xmin_ymin = contour_ymin; 1043 xmin_ymax = contour_ymax; 1044 xmin_first = first; 1045 xmin_last = last; 1046 } 1047 } 1048 1049 if ( xmin == 32768L ) 1050 return FT_ORIENTATION_TRUETYPE; 1051 1052 ray_y[0] = ( xmin_ymin * 3 + xmin_ymax ) >> 2; 1053 ray_y[1] = ( xmin_ymin + xmin_ymax ) >> 1; 1054 ray_y[2] = ( xmin_ymin + xmin_ymax * 3 ) >> 2; 1055 1056 for ( i = 0; i < 3; i++ ) 1057 { 1058 FT_Pos left_x; 1059 FT_Pos right_x; 1060 FT_Vector* left1; 1061 FT_Vector* left2; 1062 FT_Vector* right1; 1063 FT_Vector* right2; 1064 1065 1066 RedoRay: 1067 left_x = 32768L; 1068 right_x = -32768L; 1069 1070 left1 = left2 = right1 = right2 = NULL; 1071 1072 prev = xmin_last; 1073 for ( point = xmin_first; point <= xmin_last; prev = point, ++point ) 1074 { 1075 FT_Pos tmp_x; 1076 1077 1078 if ( point->y == ray_y[i] || prev->y == ray_y[i] ) 1079 { 1080 ray_y[i]++; 1081 goto RedoRay; 1082 } 1083 1084 if ( ( point->y < ray_y[i] && prev->y < ray_y[i] ) || 1085 ( point->y > ray_y[i] && prev->y > ray_y[i] ) ) 1086 continue; 1087 1088 tmp_x = FT_MulDiv( point->x - prev->x, 1089 ray_y[i] - prev->y, 1090 point->y - prev->y ) + prev->x; 1091 1092 if ( tmp_x < left_x ) 1093 { 1094 left_x = tmp_x; 1095 left1 = prev; 1096 left2 = point; 1097 } 1098 1099 if ( tmp_x > right_x ) 1100 { 1101 right_x = tmp_x; 1102 right1 = prev; 1103 right2 = point; 1104 } 1105 } 1106 1107 if ( left1 && right1 ) 1108 { 1109 if ( left1->y < left2->y && right1->y > right2->y ) 1110 result[i] = FT_ORIENTATION_TRUETYPE; 1111 else if ( left1->y > left2->y && right1->y < right2->y ) 1112 result[i] = FT_ORIENTATION_POSTSCRIPT; 1113 else 1114 result[i] = FT_ORIENTATION_NONE; 1115 } 1116 } 1117 1118 if ( result[0] != FT_ORIENTATION_NONE && 1119 ( result[0] == result[1] || result[0] == result[2] ) ) 1120 return result[0]; 1121 1122 if ( result[1] != FT_ORIENTATION_NONE && result[1] == result[2] ) 1123 return result[1]; 1124 1125 return FT_ORIENTATION_TRUETYPE; 1126 } 1127 1128 1129/* END */ 1130