misc/libfreetype/src/base/ftbbox.c
changeset 9372 915436ff64ab
parent 9371 f3840de881bd
child 9373 b769a8e38cbd
equal deleted inserted replaced
9371:f3840de881bd 9372:915436ff64ab
     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 
       
   563 FT_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 */