ref: 294ce11b00f66a981007e43f0e6bc5c108ee2995
dir: /src/base/ftbbox.c/
/***************************************************************************/ /* */ /* ftbbox.c */ /* */ /* FreeType bbox computation (body). */ /* */ /* Copyright 1996-2002, 2004, 2006, 2010, 2013 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_INTERNAL_DEBUG_H #include FT_BBOX_H #include FT_IMAGE_H #include FT_OUTLINE_H #include FT_INTERNAL_CALC_H #include FT_INTERNAL_OBJECTS_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 */ /* use 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 && y2 == y1 ) /* flat arc */ goto Suite; 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_Outline_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 accuracy. */ /* */ /* <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 q1, q2, q3, q4; q1 = p1; q2 = p2; q3 = p3; q4 = p4; /* for a conic segment to possibly reach new maximum */ /* one of its off-points must be above the current value */ while ( q2 > *max || q3 > *max ) { /* determine which half contains the maximum and split */ if ( q1 + q2 > q3 + q4 ) /* first half */ { q4 = q4 + q3; q3 = q3 + q2; q2 = q2 + q1; q4 = q4 + q3; q3 = q3 + q2; q4 = ( q4 + q3 ) / 8; q3 = q3 / 4; q2 = q2 / 2; } else /* second half */ { q1 = q1 + q2; q2 = q2 + q3; q3 = q3 + q4; q1 = q1 + q2; q2 = q2 + q3; q1 = ( q1 + q2 ) / 8; q2 = q2 / 4; q3 = q3 / 2; } /* check if either end reached the maximum */ if ( q1 == q2 && q1 >= q3 ) { *max = q1; break; } if ( q3 == q4 && q2 <= q4 ) { *max = q4; break; } } q1 = p1; q2 = p2; q3 = p3; q4 = p4; /* for a conic segment to possibly reach new minimum */ /* one of its off-points must be below the current value */ while ( q2 < *min || q3 < *min ) { /* determine which half contains the minimum and split */ if ( q1 + q2 < q3 + q4 ) /* first half */ { q4 = q4 + q3; q3 = q3 + q2; q2 = q2 + q1; q4 = q4 + q3; q3 = q3 + q2; q4 = ( q4 + q3 ) / 8; q3 = q3 / 4; q2 = q2 / 2; } else /* second half */ { q1 = q1 + q2; q2 = q2 + q3; q3 = q3 + q4; q1 = q1 + q2; q2 = q2 + q3; q1 = ( q1 + q2 ) / 8; q2 = q2 / 4; q3 = q3 / 2; } /* check if either end reached the minimum */ if ( q1 == q2 && q1 <= q3 ) { *min = q1; break; } if ( q3 == q4 && q2 >= q4 ) { *min = q4; break; } } } #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 polynomial is */ /* */ /* P(x) = a*x^3 + 3b*x^2 + 3c*x + d , */ /* */ /* dP/dx = 3a*x^2 + 6b*x + 3c . */ /* */ /* However, we also have */ /* */ /* dP/dx(u) = 0 , */ /* */ /* which implies by subtraction 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. */ /* We already made sure that a, b, and c below cannot be all zero. */ { 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; FT_Int shift; /* 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 normalization. */ /* These values must fit into a single 16.16 value. */ /* */ /* We normalize a, b, and c to `8.16' fixed-point values to ensure */ /* that their product is held in a `16.16' value including the sign. */ /* Necessarily, we need to shift `a', `b', and `c' so that the most */ /* significant bit of their absolute values is at position 22. */ /* */ /* This also means that we are using 23 bits of precision to compute */ /* the zeros, independently of the range of the original polynomial */ /* coefficients. */ /* */ /* This algorithm should ensure reasonably accurate values for the */ /* zeros. Note that they 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). */ shift = FT_MSB( FT_ABS( a ) | FT_ABS( b ) | FT_ABS( c ) ); if ( shift > 22 ) { shift -= 22; /* this loses some bits of precision, but we use 23 of them */ /* for the computation anyway */ a >>= shift; b >>= shift; c >>= shift; } else { shift = 22 - shift; 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 */ 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_Outline_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 subdivide 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; } FT_DEFINE_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 ) /* 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_THROW( Invalid_Argument ); if ( !outline ) return FT_THROW( 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. */ FT_Error error; TBBox_Rec user; #ifdef FT_CONFIG_OPTION_PIC FT_Outline_Funcs bbox_interface; Init_Class_bbox_interface(&bbox_interface); #endif 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 */