PageRenderTime 27ms CodeModel.GetById 2ms app.highlight 20ms RepoModel.GetById 1ms app.codeStats 0ms

/src/freetype/src/base/ftbbox.c

https://bitbucket.org/cabalistic/ogredeps/
C | 662 lines | 334 code | 98 blank | 230 comment | 89 complexity | 5c93f2657a78014622bef5c5fc08d21e MD5 | raw file
  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 */