123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653 |
- /***************************************************************************/
- /* */
- /* ftbbox.c */
- /* */
- /* FreeType bbox computation (body). */
- /* */
- /* Copyright 1996-2001, 2002 by */
- /* David Turner, Robert Wilhelm, and Werner Lemberg. */
- /* */
- /* This file is part of the FreeType project, and may only be used */
- /* modified and distributed under the terms of the FreeType project */
- /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
- /* this file you indicate that you have read the license and */
- /* understand and accept it fully. */
- /* */
- /***************************************************************************/
- /*************************************************************************/
- /* */
- /* This component has a _single_ role: to compute exact outline bounding */
- /* boxes. */
- /* */
- /*************************************************************************/
- #include <ft2build.h>
- #include FT_BBOX_H
- #include FT_IMAGE_H
- #include FT_OUTLINE_H
- #include FT_INTERNAL_CALC_H
- typedef struct TBBox_Rec_
- {
- FT_Vector last;
- FT_BBox bbox;
- } TBBox_Rec;
- /*************************************************************************/
- /* */
- /* <Function> */
- /* BBox_Move_To */
- /* */
- /* <Description> */
- /* This function is used as a `move_to' and `line_to' emitter during */
- /* FT_Outline_Decompose(). It simply records the destination point */
- /* in `user->last'; no further computations are necessary since we */
- /* the cbox as the starting bbox which must be refined. */
- /* */
- /* <Input> */
- /* to :: A pointer to the destination vector. */
- /* */
- /* <InOut> */
- /* user :: A pointer to the current walk context. */
- /* */
- /* <Return> */
- /* Always 0. Needed for the interface only. */
- /* */
- static int
- BBox_Move_To( FT_Vector* to,
- TBBox_Rec* user )
- {
- user->last = *to;
- return 0;
- }
- #define CHECK_X( p, bbox ) \
- ( p->x < bbox.xMin || p->x > bbox.xMax )
- #define CHECK_Y( p, bbox ) \
- ( p->y < bbox.yMin || p->y > bbox.yMax )
- /*************************************************************************/
- /* */
- /* <Function> */
- /* BBox_Conic_Check */
- /* */
- /* <Description> */
- /* Finds the extrema of a 1-dimensional conic Bezier curve and update */
- /* a bounding range. This version uses direct computation, as it */
- /* doesn't need square roots. */
- /* */
- /* <Input> */
- /* y1 :: The start coordinate. */
- /* y2 :: The coordinate of the control point. */
- /* y3 :: The end coordinate. */
- /* */
- /* <InOut> */
- /* min :: The address of the current minimum. */
- /* max :: The address of the current maximum. */
- /* */
- static void
- BBox_Conic_Check( FT_Pos y1,
- FT_Pos y2,
- FT_Pos y3,
- FT_Pos* min,
- FT_Pos* max )
- {
- if ( y1 <= y3 )
- {
- if ( y2 == y1 ) /* Flat arc */
- goto Suite;
- }
- else if ( y1 < y3 )
- {
- if ( y2 >= y1 && y2 <= y3 ) /* Ascending arc */
- goto Suite;
- }
- else
- {
- if ( y2 >= y3 && y2 <= y1 ) /* Descending arc */
- {
- y2 = y1;
- y1 = y3;
- y3 = y2;
- goto Suite;
- }
- }
- y1 = y3 = y1 - FT_MulDiv( y2 - y1, y2 - y1, y1 - 2*y2 + y3 );
- Suite:
- if ( y1 < *min ) *min = y1;
- if ( y3 > *max ) *max = y3;
- }
- /*************************************************************************/
- /* */
- /* <Function> */
- /* BBox_Conic_To */
- /* */
- /* <Description> */
- /* This function is used as a `conic_to' emitter during */
- /* FT_Raster_Decompose(). It checks a conic Bezier curve with the */
- /* current bounding box, and computes its extrema if necessary to */
- /* update it. */
- /* */
- /* <Input> */
- /* control :: A pointer to a control point. */
- /* to :: A pointer to the destination vector. */
- /* */
- /* <InOut> */
- /* user :: The address of the current walk context. */
- /* */
- /* <Return> */
- /* Always 0. Needed for the interface only. */
- /* */
- /* <Note> */
- /* In the case of a non-monotonous arc, we compute directly the */
- /* extremum coordinates, as it is sufficiently fast. */
- /* */
- static int
- BBox_Conic_To( FT_Vector* control,
- FT_Vector* to,
- TBBox_Rec* user )
- {
- /* we don't need to check `to' since it is always an `on' point, thus */
- /* within the bbox */
- if ( CHECK_X( control, user->bbox ) )
- BBox_Conic_Check( user->last.x,
- control->x,
- to->x,
- &user->bbox.xMin,
- &user->bbox.xMax );
- if ( CHECK_Y( control, user->bbox ) )
- BBox_Conic_Check( user->last.y,
- control->y,
- to->y,
- &user->bbox.yMin,
- &user->bbox.yMax );
- user->last = *to;
- return 0;
- }
- /*************************************************************************/
- /* */
- /* <Function> */
- /* BBox_Cubic_Check */
- /* */
- /* <Description> */
- /* Finds the extrema of a 1-dimensional cubic Bezier curve and */
- /* updates a bounding range. This version uses splitting because we */
- /* don't want to use square roots and extra accuracies. */
- /* */
- /* <Input> */
- /* p1 :: The start coordinate. */
- /* p2 :: The coordinate of the first control point. */
- /* p3 :: The coordinate of the second control point. */
- /* p4 :: The end coordinate. */
- /* */
- /* <InOut> */
- /* min :: The address of the current minimum. */
- /* max :: The address of the current maximum. */
- /* */
- #if 0
- static void
- BBox_Cubic_Check( FT_Pos p1,
- FT_Pos p2,
- FT_Pos p3,
- FT_Pos p4,
- FT_Pos* min,
- FT_Pos* max )
- {
- FT_Pos stack[32*3 + 1], *arc;
- arc = stack;
- arc[0] = p1;
- arc[1] = p2;
- arc[2] = p3;
- arc[3] = p4;
- do
- {
- FT_Pos y1 = arc[0];
- FT_Pos y2 = arc[1];
- FT_Pos y3 = arc[2];
- FT_Pos y4 = arc[3];
- if ( y1 == y4 )
- {
- if ( y1 == y2 && y1 == y3 ) /* Flat */
- goto Test;
- }
- else if ( y1 < y4 )
- {
- if ( y2 >= y1 && y2 <= y4 && y3 >= y1 && y3 <= y4 ) /* Ascending */
- goto Test;
- }
- else
- {
- if ( y2 >= y4 && y2 <= y1 && y3 >= y4 && y3 <= y1 ) /* Descending */
- {
- y2 = y1;
- y1 = y4;
- y4 = y2;
- goto Test;
- }
- }
- /* Unknown direction -- split the arc in two */
- arc[6] = y4;
- arc[1] = y1 = ( y1 + y2 ) / 2;
- arc[5] = y4 = ( y4 + y3 ) / 2;
- y2 = ( y2 + y3 ) / 2;
- arc[2] = y1 = ( y1 + y2 ) / 2;
- arc[4] = y4 = ( y4 + y2 ) / 2;
- arc[3] = ( y1 + y4 ) / 2;
- arc += 3;
- goto Suite;
- Test:
- if ( y1 < *min ) *min = y1;
- if ( y4 > *max ) *max = y4;
- arc -= 3;
- Suite:
- ;
- } while ( arc >= stack );
- }
- #else
- static void
- test_cubic_extrema( FT_Pos y1,
- FT_Pos y2,
- FT_Pos y3,
- FT_Pos y4,
- FT_Fixed u,
- FT_Pos* min,
- FT_Pos* max )
- {
- /* FT_Pos a = y4 - 3*y3 + 3*y2 - y1; */
- FT_Pos b = y3 - 2*y2 + y1;
- FT_Pos c = y2 - y1;
- FT_Pos d = y1;
- FT_Pos y;
- FT_Fixed uu;
- FT_UNUSED ( y4 );
- /* The polynom is */
- /* */
- /* a*x^3 + 3b*x^2 + 3c*x + d . */
- /* */
- /* However, we also have */
- /* */
- /* dP/dx(u) = 0 , */
- /* */
- /* which implies that */
- /* */
- /* P(u) = b*u^2 + 2c*u + d */
- if ( u > 0 && u < 0x10000L )
- {
- uu = FT_MulFix( u, u );
- y = d + FT_MulFix( c, 2*u ) + FT_MulFix( b, uu );
- if ( y < *min ) *min = y;
- if ( y > *max ) *max = y;
- }
- }
- static void
- BBox_Cubic_Check( FT_Pos y1,
- FT_Pos y2,
- FT_Pos y3,
- FT_Pos y4,
- FT_Pos* min,
- FT_Pos* max )
- {
- /* always compare first and last points */
- if ( y1 < *min ) *min = y1;
- else if ( y1 > *max ) *max = y1;
- if ( y4 < *min ) *min = y4;
- else if ( y4 > *max ) *max = y4;
- /* now, try to see if there are split points here */
- if ( y1 <= y4 )
- {
- /* flat or ascending arc test */
- if ( y1 <= y2 && y2 <= y4 && y1 <= y3 && y3 <= y4 )
- return;
- }
- else /* y1 > y4 */
- {
- /* descending arc test */
- if ( y1 >= y2 && y2 >= y4 && y1 >= y3 && y3 >= y4 )
- return;
- }
- /* There are some split points. Find them. */
- {
- FT_Pos a = y4 - 3*y3 + 3*y2 - y1;
- FT_Pos b = y3 - 2*y2 + y1;
- FT_Pos c = y2 - y1;
- FT_Pos d;
- FT_Fixed t;
- /* We need to solve "ax^2+2bx+c" here, without floating points! */
- /* The trick is to normalize to a different representation in order */
- /* to use our 16.16 fixed point routines. */
- /* */
- /* We compute FT_MulFix(b,b) and FT_MulFix(a,c) after the */
- /* the normalization. These values must fit into a single 16.16 */
- /* value. */
- /* */
- /* We normalize a, b, and c to "8.16" fixed float values to ensure */
- /* that their product is held in a "16.16" value. */
- /* */
- {
- FT_ULong t1, t2;
- int shift = 0;
- /* Technical explanation of what's happening there. */
- /* */
- /* The following computation is based on the fact that for */
- /* any value "y", if "n" is the position of the most */
- /* significant bit of "abs(y)" (starting from 0 for the */
- /* least significant bit), then y is in the range */
- /* */
- /* "-2^n..2^n-1" */
- /* */
- /* We want to shift "a", "b" and "c" concurrently in order */
- /* to ensure that they all fit in 8.16 values, which maps */
- /* to the integer range "-2^23..2^23-1". */
- /* */
- /* Necessarily, we need to shift "a", "b" and "c" so that */
- /* the most significant bit of their absolute values is at */
- /* _most_ at position 23. */
- /* */
- /* We begin by computing "t1" as the bitwise "or" of the */
- /* absolute values of "a", "b", "c". */
- /* */
- t1 = (FT_ULong)((a >= 0) ? a : -a );
- t2 = (FT_ULong)((b >= 0) ? b : -b );
- t1 |= t2;
- t2 = (FT_ULong)((c >= 0) ? c : -c );
- t1 |= t2;
- /* Now, the most significant bit of "t1" is sure to be the */
- /* msb of one of "a", "b", "c", depending on which one is */
- /* expressed in the greatest integer range. */
- /* */
- /* We now compute the "shift", by shifting "t1" as many */
- /* times as necessary to move its msb to position 23. */
- /* */
- /* This corresponds to a value of t1 that is in the range */
- /* 0x40_0000..0x7F_FFFF. */
- /* */
- /* Finally, we shift "a", "b" and "c" by the same amount. */
- /* This ensures that all values are now in the range */
- /* -2^23..2^23, i.e. that they are now expressed as 8.16 */
- /* fixed float numbers. */
- /* */
- /* This also means that we are using 24 bits of precision */
- /* to compute the zeros, independently of the range of */
- /* the original polynom coefficients. */
- /* */
- /* This should ensure reasonably accurate values for the */
- /* zeros. Note that the latter are only expressed with */
- /* 16 bits when computing the extrema (the zeros need to */
- /* be in 0..1 exclusive to be considered part of the arc). */
- /* */
- if ( t1 == 0 ) /* all coefficients are 0! */
- return;
- if ( t1 > 0x7FFFFFUL )
- {
- do
- {
- shift++;
- t1 >>= 1;
- } while ( t1 > 0x7FFFFFUL );
- /* losing some bits of precision, but we use 24 of them */
- /* for the computation anyway. */
- a >>= shift;
- b >>= shift;
- c >>= shift;
- }
- else if ( t1 < 0x400000UL )
- {
- do
- {
- shift++;
- t1 <<= 1;
- } while ( t1 < 0x400000UL );
- a <<= shift;
- b <<= shift;
- c <<= shift;
- }
- }
- /* handle a == 0 */
- if ( a == 0 )
- {
- if ( b != 0 )
- {
- t = - FT_DivFix( c, b ) / 2;
- test_cubic_extrema( y1, y2, y3, y4, t, min, max );
- }
- }
- else
- {
- /* solve the equation now */
- d = FT_MulFix( b, b ) - FT_MulFix( a, c );
- if ( d < 0 )
- return;
- if ( d == 0 )
- {
- /* there is a single split point at -b/a */
- t = - FT_DivFix( b, a );
- test_cubic_extrema( y1, y2, y3, y4, t, min, max );
- }
- else
- {
- /* there are two solutions; we need to filter them though */
- d = FT_SqrtFixed( (FT_Int32)d );
- t = - FT_DivFix( b - d, a );
- test_cubic_extrema( y1, y2, y3, y4, t, min, max );
- t = - FT_DivFix( b + d, a );
- test_cubic_extrema( y1, y2, y3, y4, t, min, max );
- }
- }
- }
- }
- #endif
- /*************************************************************************/
- /* */
- /* <Function> */
- /* BBox_Cubic_To */
- /* */
- /* <Description> */
- /* This function is used as a `cubic_to' emitter during */
- /* FT_Raster_Decompose(). It checks a cubic Bezier curve with the */
- /* current bounding box, and computes its extrema if necessary to */
- /* update it. */
- /* */
- /* <Input> */
- /* control1 :: A pointer to the first control point. */
- /* control2 :: A pointer to the second control point. */
- /* to :: A pointer to the destination vector. */
- /* */
- /* <InOut> */
- /* user :: The address of the current walk context. */
- /* */
- /* <Return> */
- /* Always 0. Needed for the interface only. */
- /* */
- /* <Note> */
- /* In the case of a non-monotonous arc, we don't compute directly */
- /* extremum coordinates, we subdivise instead. */
- /* */
- static int
- BBox_Cubic_To( FT_Vector* control1,
- FT_Vector* control2,
- FT_Vector* to,
- TBBox_Rec* user )
- {
- /* we don't need to check `to' since it is always an `on' point, thus */
- /* within the bbox */
- if ( CHECK_X( control1, user->bbox ) ||
- CHECK_X( control2, user->bbox ) )
- BBox_Cubic_Check( user->last.x,
- control1->x,
- control2->x,
- to->x,
- &user->bbox.xMin,
- &user->bbox.xMax );
- if ( CHECK_Y( control1, user->bbox ) ||
- CHECK_Y( control2, user->bbox ) )
- BBox_Cubic_Check( user->last.y,
- control1->y,
- control2->y,
- to->y,
- &user->bbox.yMin,
- &user->bbox.yMax );
- user->last = *to;
- return 0;
- }
- /* documentation is in ftbbox.h */
- FT_EXPORT_DEF( FT_Error )
- FT_Outline_Get_BBox( FT_Outline* outline,
- FT_BBox *abbox )
- {
- FT_BBox cbox;
- FT_BBox bbox;
- FT_Vector* vec;
- FT_UShort n;
- if ( !abbox )
- return FT_Err_Invalid_Argument;
- if ( !outline )
- return FT_Err_Invalid_Outline;
- /* if outline is empty, return (0,0,0,0) */
- if ( outline->n_points == 0 || outline->n_contours <= 0 )
- {
- abbox->xMin = abbox->xMax = 0;
- abbox->yMin = abbox->yMax = 0;
- return 0;
- }
- /* We compute the control box as well as the bounding box of */
- /* all `on' points in the outline. Then, if the two boxes */
- /* coincide, we exit immediately. */
- vec = outline->points;
- bbox.xMin = bbox.xMax = cbox.xMin = cbox.xMax = vec->x;
- bbox.yMin = bbox.yMax = cbox.yMin = cbox.yMax = vec->y;
- vec++;
- for ( n = 1; n < outline->n_points; n++ )
- {
- FT_Pos x = vec->x;
- FT_Pos y = vec->y;
- /* update control box */
- if ( x < cbox.xMin ) cbox.xMin = x;
- if ( x > cbox.xMax ) cbox.xMax = x;
- if ( y < cbox.yMin ) cbox.yMin = y;
- if ( y > cbox.yMax ) cbox.yMax = y;
- if ( FT_CURVE_TAG( outline->tags[n] ) == FT_CURVE_TAG_ON )
- {
- /* update bbox for `on' points only */
- if ( x < bbox.xMin ) bbox.xMin = x;
- if ( x > bbox.xMax ) bbox.xMax = x;
- if ( y < bbox.yMin ) bbox.yMin = y;
- if ( y > bbox.yMax ) bbox.yMax = y;
- }
- vec++;
- }
- /* test two boxes for equality */
- if ( cbox.xMin < bbox.xMin || cbox.xMax > bbox.xMax ||
- cbox.yMin < bbox.yMin || cbox.yMax > bbox.yMax )
- {
- /* the two boxes are different, now walk over the outline to */
- /* get the Bezier arc extrema. */
- static const FT_Outline_Funcs bbox_interface =
- {
- (FT_Outline_MoveTo_Func) BBox_Move_To,
- (FT_Outline_LineTo_Func) BBox_Move_To,
- (FT_Outline_ConicTo_Func)BBox_Conic_To,
- (FT_Outline_CubicTo_Func)BBox_Cubic_To,
- 0, 0
- };
- FT_Error error;
- TBBox_Rec user;
- user.bbox = bbox;
- error = FT_Outline_Decompose( outline, &bbox_interface, &user );
- if ( error )
- return error;
- *abbox = user.bbox;
- }
- else
- *abbox = bbox;
- return FT_Err_Ok;
- }
- /* END */
|