1 /***************************************************************************/

     2 /*                                                                         */

     3 /*  ftstroke.c                                                             */

     4 /*                                                                         */

     5 /*    FreeType path stroker (body).                                        */

     6 /*                                                                         */

     7 /*  Copyright 2002-2006, 2008-2011 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 #include <ft2build.h>

    20 #include FT_STROKER_H

    21 #include FT_TRIGONOMETRY_H

    22 #include FT_OUTLINE_H

    23 #include FT_INTERNAL_MEMORY_H

    24 #include FT_INTERNAL_DEBUG_H

    25 #include FT_INTERNAL_OBJECTS_H

    26 

    27 

    28   /* documentation is in ftstroke.h */

    29 

    30   FT_EXPORT_DEF( FT_StrokerBorder )

    31   FT_Outline_GetInsideBorder( FT_Outline*  outline )

    32   {

    33     FT_Orientation  o = FT_Outline_Get_Orientation( outline );

    34 

    35 

    36     return o == FT_ORIENTATION_TRUETYPE ? FT_STROKER_BORDER_RIGHT

    37                                         : FT_STROKER_BORDER_LEFT ;

    38   }

    39 

    40 

    41   /* documentation is in ftstroke.h */

    42 

    43   FT_EXPORT_DEF( FT_StrokerBorder )

    44   FT_Outline_GetOutsideBorder( FT_Outline*  outline )

    45   {

    46     FT_Orientation  o = FT_Outline_Get_Orientation( outline );

    47 

    48 

    49     return o == FT_ORIENTATION_TRUETYPE ? FT_STROKER_BORDER_LEFT

    50                                         : FT_STROKER_BORDER_RIGHT ;

    51   }

    52 

    53 

    54  /***************************************************************************/

    55  /***************************************************************************/

    56  /*****                                                                 *****/

    57  /*****                       BEZIER COMPUTATIONS                       *****/

    58  /*****                                                                 *****/

    59  /***************************************************************************/

    60  /***************************************************************************/

    61 

    62 #define FT_SMALL_CONIC_THRESHOLD  ( FT_ANGLE_PI / 6 )

    63 #define FT_SMALL_CUBIC_THRESHOLD  ( FT_ANGLE_PI / 6 )

    64 #define FT_EPSILON  2

    65 

    66 #define FT_IS_SMALL( x )  ( (x) > -FT_EPSILON && (x) < FT_EPSILON )

    67 

    68 

    69   static FT_Pos

    70   ft_pos_abs( FT_Pos  x )

    71   {

    72     return x >= 0 ? x : -x ;

    73   }

    74 

    75 

    76   static void

    77   ft_conic_split( FT_Vector*  base )

    78   {

    79     FT_Pos  a, b;

    80 

    81 

    82     base[4].x = base[2].x;

    83     b = base[1].x;

    84     a = base[3].x = ( base[2].x + b ) / 2;

    85     b = base[1].x = ( base[0].x + b ) / 2;

    86     base[2].x = ( a + b ) / 2;

    87 

    88     base[4].y = base[2].y;

    89     b = base[1].y;

    90     a = base[3].y = ( base[2].y + b ) / 2;

    91     b = base[1].y = ( base[0].y + b ) / 2;

    92     base[2].y = ( a + b ) / 2;

    93   }

    94 

    95 

    96   static FT_Bool

    97   ft_conic_is_small_enough( FT_Vector*  base,

    98                             FT_Angle   *angle_in,

    99                             FT_Angle   *angle_out )

   100   {

   101     FT_Vector  d1, d2;

   102     FT_Angle   theta;

   103     FT_Int     close1, close2;

   104 

   105 

   106     d1.x = base[1].x - base[2].x;

   107     d1.y = base[1].y - base[2].y;

   108     d2.x = base[0].x - base[1].x;

   109     d2.y = base[0].y - base[1].y;

   110 

   111     close1 = FT_IS_SMALL( d1.x ) && FT_IS_SMALL( d1.y );

   112     close2 = FT_IS_SMALL( d2.x ) && FT_IS_SMALL( d2.y );

   113 

   114     if ( close1 )

   115     {

   116       if ( close2 )

   117         *angle_in = *angle_out = 0;

   118       else

   119         *angle_in = *angle_out = FT_Atan2( d2.x, d2.y );

   120     }

   121     else if ( close2 )

   122     {

   123       *angle_in = *angle_out = FT_Atan2( d1.x, d1.y );

   124     }

   125     else

   126     {

   127       *angle_in  = FT_Atan2( d1.x, d1.y );

   128       *angle_out = FT_Atan2( d2.x, d2.y );

   129     }

   130 

   131     theta = ft_pos_abs( FT_Angle_Diff( *angle_in, *angle_out ) );

   132 

   133     return FT_BOOL( theta < FT_SMALL_CONIC_THRESHOLD );

   134   }

   135 

   136 

   137   static void

   138   ft_cubic_split( FT_Vector*  base )

   139   {

   140     FT_Pos  a, b, c, d;

   141 

   142 

   143     base[6].x = base[3].x;

   144     c = base[1].x;

   145     d = base[2].x;

   146     base[1].x = a = ( base[0].x + c ) / 2;

   147     base[5].x = b = ( base[3].x + d ) / 2;

   148     c = ( c + d ) / 2;

   149     base[2].x = a = ( a + c ) / 2;

   150     base[4].x = b = ( b + c ) / 2;

   151     base[3].x = ( a + b ) / 2;

   152 

   153     base[6].y = base[3].y;

   154     c = base[1].y;

   155     d = base[2].y;

   156     base[1].y = a = ( base[0].y + c ) / 2;

   157     base[5].y = b = ( base[3].y + d ) / 2;

   158     c = ( c + d ) / 2;

   159     base[2].y = a = ( a + c ) / 2;

   160     base[4].y = b = ( b + c ) / 2;

   161     base[3].y = ( a + b ) / 2;

   162   }

   163 

   164 

   165   static FT_Bool

   166   ft_cubic_is_small_enough( FT_Vector*  base,

   167                             FT_Angle   *angle_in,

   168                             FT_Angle   *angle_mid,

   169                             FT_Angle   *angle_out )

   170   {

   171     FT_Vector  d1, d2, d3;

   172     FT_Angle   theta1, theta2;

   173     FT_Int     close1, close2, close3;

   174 

   175 

   176     d1.x = base[2].x - base[3].x;

   177     d1.y = base[2].y - base[3].y;

   178     d2.x = base[1].x - base[2].x;

   179     d2.y = base[1].y - base[2].y;

   180     d3.x = base[0].x - base[1].x;

   181     d3.y = base[0].y - base[1].y;

   182 

   183     close1 = FT_IS_SMALL( d1.x ) && FT_IS_SMALL( d1.y );

   184     close2 = FT_IS_SMALL( d2.x ) && FT_IS_SMALL( d2.y );

   185     close3 = FT_IS_SMALL( d3.x ) && FT_IS_SMALL( d3.y );

   186 

   187     if ( close1 || close3 )

   188     {

   189       if ( close2 )

   190       {

   191         /* basically a point */

   192         *angle_in = *angle_out = *angle_mid = 0;

   193       }

   194       else if ( close1 )

   195       {

   196         *angle_in  = *angle_mid = FT_Atan2( d2.x, d2.y );

   197         *angle_out = FT_Atan2( d3.x, d3.y );

   198       }

   199       else  /* close2 */

   200       {

   201         *angle_in  = FT_Atan2( d1.x, d1.y );

   202         *angle_mid = *angle_out = FT_Atan2( d2.x, d2.y );

   203       }

   204     }

   205     else if ( close2 )

   206     {

   207       *angle_in  = *angle_mid = FT_Atan2( d1.x, d1.y );

   208       *angle_out = FT_Atan2( d3.x, d3.y );

   209     }

   210     else

   211     {

   212       *angle_in  = FT_Atan2( d1.x, d1.y );

   213       *angle_mid = FT_Atan2( d2.x, d2.y );

   214       *angle_out = FT_Atan2( d3.x, d3.y );

   215     }

   216 

   217     theta1 = ft_pos_abs( FT_Angle_Diff( *angle_in,  *angle_mid ) );

   218     theta2 = ft_pos_abs( FT_Angle_Diff( *angle_mid, *angle_out ) );

   219 

   220     return FT_BOOL( theta1 < FT_SMALL_CUBIC_THRESHOLD &&

   221                     theta2 < FT_SMALL_CUBIC_THRESHOLD );

   222   }

   223 

   224 

   225  /***************************************************************************/

   226  /***************************************************************************/

   227  /*****                                                                 *****/

   228  /*****                       STROKE BORDERS                            *****/

   229  /*****                                                                 *****/

   230  /***************************************************************************/

   231  /***************************************************************************/

   232 

   233   typedef enum  FT_StrokeTags_

   234   {

   235     FT_STROKE_TAG_ON    = 1,   /* on-curve point  */

   236     FT_STROKE_TAG_CUBIC = 2,   /* cubic off-point */

   237     FT_STROKE_TAG_BEGIN = 4,   /* sub-path start  */

   238     FT_STROKE_TAG_END   = 8    /* sub-path end    */

   239 

   240   } FT_StrokeTags;

   241 

   242 #define  FT_STROKE_TAG_BEGIN_END  (FT_STROKE_TAG_BEGIN|FT_STROKE_TAG_END)

   243 

   244   typedef struct  FT_StrokeBorderRec_

   245   {

   246     FT_UInt     num_points;

   247     FT_UInt     max_points;

   248     FT_Vector*  points;

   249     FT_Byte*    tags;

   250     FT_Bool     movable;

   251     FT_Int      start;    /* index of current sub-path start point */

   252     FT_Memory   memory;

   253     FT_Bool     valid;

   254 

   255   } FT_StrokeBorderRec, *FT_StrokeBorder;

   256 

   257 

   258   static FT_Error

   259   ft_stroke_border_grow( FT_StrokeBorder  border,

   260                          FT_UInt          new_points )

   261   {

   262     FT_UInt   old_max = border->max_points;

   263     FT_UInt   new_max = border->num_points + new_points;

   264     FT_Error  error   = FT_Err_Ok;

   265 

   266 

   267     if ( new_max > old_max )

   268     {

   269       FT_UInt    cur_max = old_max;

   270       FT_Memory  memory  = border->memory;

   271 

   272 

   273       while ( cur_max < new_max )

   274         cur_max += ( cur_max >> 1 ) + 16;

   275 

   276       if ( FT_RENEW_ARRAY( border->points, old_max, cur_max ) ||

   277            FT_RENEW_ARRAY( border->tags,   old_max, cur_max ) )

   278         goto Exit;

   279 

   280       border->max_points = cur_max;

   281     }

   282 

   283   Exit:

   284     return error;

   285   }

   286 

   287 

   288   static void

   289   ft_stroke_border_close( FT_StrokeBorder  border,

   290                           FT_Bool          reverse )

   291   {

   292     FT_UInt  start = border->start;

   293     FT_UInt  count = border->num_points;

   294 

   295 

   296     FT_ASSERT( border->start >= 0 );

   297 

   298     /* don't record empty paths! */

   299     if ( count <= start + 1U )

   300       border->num_points = start;

   301     else

   302     {

   303       /* copy the last point to the start of this sub-path, since */

   304       /* it contains the `adjusted' starting coordinates          */

   305       border->num_points    = --count;

   306       border->points[start] = border->points[count];

   307 

   308       if ( reverse )

   309       {

   310         /* reverse the points */

   311         {

   312           FT_Vector*  vec1 = border->points + start + 1;

   313           FT_Vector*  vec2 = border->points + count - 1;

   314 

   315 

   316           for ( ; vec1 < vec2; vec1++, vec2-- )

   317           {

   318             FT_Vector  tmp;

   319 

   320 

   321             tmp   = *vec1;

   322             *vec1 = *vec2;

   323             *vec2 = tmp;

   324           }

   325         }

   326 

   327         /* then the tags */

   328         {

   329           FT_Byte*  tag1 = border->tags + start + 1;

   330           FT_Byte*  tag2 = border->tags + count - 1;

   331 

   332 

   333           for ( ; tag1 < tag2; tag1++, tag2-- )

   334           {

   335             FT_Byte  tmp;

   336 

   337 

   338             tmp   = *tag1;

   339             *tag1 = *tag2;

   340             *tag2 = tmp;

   341           }

   342         }

   343       }

   344 

   345       border->tags[start    ] |= FT_STROKE_TAG_BEGIN;

   346       border->tags[count - 1] |= FT_STROKE_TAG_END;

   347     }

   348 

   349     border->start   = -1;

   350     border->movable = FALSE;

   351   }

   352 

   353 

   354   static FT_Error

   355   ft_stroke_border_lineto( FT_StrokeBorder  border,

   356                            FT_Vector*       to,

   357                            FT_Bool          movable )

   358   {

   359     FT_Error  error = FT_Err_Ok;

   360 

   361 

   362     FT_ASSERT( border->start >= 0 );

   363 

   364     if ( border->movable )

   365     {

   366       /* move last point */

   367       border->points[border->num_points - 1] = *to;

   368     }

   369     else

   370     {

   371       /* add one point */

   372       error = ft_stroke_border_grow( border, 1 );

   373       if ( !error )

   374       {

   375         FT_Vector*  vec = border->points + border->num_points;

   376         FT_Byte*    tag = border->tags   + border->num_points;

   377 

   378 

   379         vec[0] = *to;

   380         tag[0] = FT_STROKE_TAG_ON;

   381 

   382         border->num_points += 1;

   383       }

   384     }

   385     border->movable = movable;

   386     return error;

   387   }

   388 

   389 

   390   static FT_Error

   391   ft_stroke_border_conicto( FT_StrokeBorder  border,

   392                             FT_Vector*       control,

   393                             FT_Vector*       to )

   394   {

   395     FT_Error  error;

   396 

   397 

   398     FT_ASSERT( border->start >= 0 );

   399 

   400     error = ft_stroke_border_grow( border, 2 );

   401     if ( !error )

   402     {

   403       FT_Vector*  vec = border->points + border->num_points;

   404       FT_Byte*    tag = border->tags   + border->num_points;

   405 

   406       vec[0] = *control;

   407       vec[1] = *to;

   408 

   409       tag[0] = 0;

   410       tag[1] = FT_STROKE_TAG_ON;

   411 

   412       border->num_points += 2;

   413     }

   414     border->movable = FALSE;

   415     return error;

   416   }

   417 

   418 

   419   static FT_Error

   420   ft_stroke_border_cubicto( FT_StrokeBorder  border,

   421                             FT_Vector*       control1,

   422                             FT_Vector*       control2,

   423                             FT_Vector*       to )

   424   {

   425     FT_Error  error;

   426 

   427 

   428     FT_ASSERT( border->start >= 0 );

   429 

   430     error = ft_stroke_border_grow( border, 3 );

   431     if ( !error )

   432     {

   433       FT_Vector*  vec = border->points + border->num_points;

   434       FT_Byte*    tag = border->tags   + border->num_points;

   435 

   436 

   437       vec[0] = *control1;

   438       vec[1] = *control2;

   439       vec[2] = *to;

   440 

   441       tag[0] = FT_STROKE_TAG_CUBIC;

   442       tag[1] = FT_STROKE_TAG_CUBIC;

   443       tag[2] = FT_STROKE_TAG_ON;

   444 

   445       border->num_points += 3;

   446     }

   447     border->movable = FALSE;

   448     return error;

   449   }

   450 

   451 

   452 #define FT_ARC_CUBIC_ANGLE  ( FT_ANGLE_PI / 2 )

   453 

   454 

   455   static FT_Error

   456   ft_stroke_border_arcto( FT_StrokeBorder  border,

   457                           FT_Vector*       center,

   458                           FT_Fixed         radius,

   459                           FT_Angle         angle_start,

   460                           FT_Angle         angle_diff )

   461   {

   462     FT_Angle   total, angle, step, rotate, next, theta;

   463     FT_Vector  a, b, a2, b2;

   464     FT_Fixed   length;

   465     FT_Error   error = FT_Err_Ok;

   466 

   467 

   468     /* compute start point */

   469     FT_Vector_From_Polar( &a, radius, angle_start );

   470     a.x += center->x;

   471     a.y += center->y;

   472 

   473     total  = angle_diff;

   474     angle  = angle_start;

   475     rotate = ( angle_diff >= 0 ) ? FT_ANGLE_PI2 : -FT_ANGLE_PI2;

   476 

   477     while ( total != 0 )

   478     {

   479       step = total;

   480       if ( step > FT_ARC_CUBIC_ANGLE )

   481         step = FT_ARC_CUBIC_ANGLE;

   482 

   483       else if ( step < -FT_ARC_CUBIC_ANGLE )

   484         step = -FT_ARC_CUBIC_ANGLE;

   485 

   486       next  = angle + step;

   487       theta = step;

   488       if ( theta < 0 )

   489         theta = -theta;

   490 

   491       theta >>= 1;

   492 

   493       /* compute end point */

   494       FT_Vector_From_Polar( &b, radius, next );

   495       b.x += center->x;

   496       b.y += center->y;

   497 

   498       /* compute first and second control points */

   499       length = FT_MulDiv( radius, FT_Sin( theta ) * 4,

   500                           ( 0x10000L + FT_Cos( theta ) ) * 3 );

   501 

   502       FT_Vector_From_Polar( &a2, length, angle + rotate );

   503       a2.x += a.x;

   504       a2.y += a.y;

   505 

   506       FT_Vector_From_Polar( &b2, length, next - rotate );

   507       b2.x += b.x;

   508       b2.y += b.y;

   509 

   510       /* add cubic arc */

   511       error = ft_stroke_border_cubicto( border, &a2, &b2, &b );

   512       if ( error )

   513         break;

   514 

   515       /* process the rest of the arc ?? */

   516       a      = b;

   517       total -= step;

   518       angle  = next;

   519     }

   520 

   521     return error;

   522   }

   523 

   524 

   525   static FT_Error

   526   ft_stroke_border_moveto( FT_StrokeBorder  border,

   527                            FT_Vector*       to )

   528   {

   529     /* close current open path if any ? */

   530     if ( border->start >= 0 )

   531       ft_stroke_border_close( border, FALSE );

   532 

   533     border->start   = border->num_points;

   534     border->movable = FALSE;

   535 

   536     return ft_stroke_border_lineto( border, to, FALSE );

   537   }

   538 

   539 

   540   static void

   541   ft_stroke_border_init( FT_StrokeBorder  border,

   542                          FT_Memory        memory )

   543   {

   544     border->memory = memory;

   545     border->points = NULL;

   546     border->tags   = NULL;

   547 

   548     border->num_points = 0;

   549     border->max_points = 0;

   550     border->start      = -1;

   551     border->valid      = FALSE;

   552   }

   553 

   554 

   555   static void

   556   ft_stroke_border_reset( FT_StrokeBorder  border )

   557   {

   558     border->num_points = 0;

   559     border->start      = -1;

   560     border->valid      = FALSE;

   561   }

   562 

   563 

   564   static void

   565   ft_stroke_border_done( FT_StrokeBorder  border )

   566   {

   567     FT_Memory  memory = border->memory;

   568 

   569 

   570     FT_FREE( border->points );

   571     FT_FREE( border->tags );

   572 

   573     border->num_points = 0;

   574     border->max_points = 0;

   575     border->start      = -1;

   576     border->valid      = FALSE;

   577   }

   578 

   579 

   580   static FT_Error

   581   ft_stroke_border_get_counts( FT_StrokeBorder  border,

   582                                FT_UInt         *anum_points,

   583                                FT_UInt         *anum_contours )

   584   {

   585     FT_Error  error        = FT_Err_Ok;

   586     FT_UInt   num_points   = 0;

   587     FT_UInt   num_contours = 0;

   588 

   589     FT_UInt     count      = border->num_points;

   590     FT_Vector*  point      = border->points;

   591     FT_Byte*    tags       = border->tags;

   592     FT_Int      in_contour = 0;

   593 

   594 

   595     for ( ; count > 0; count--, num_points++, point++, tags++ )

   596     {

   597       if ( tags[0] & FT_STROKE_TAG_BEGIN )

   598       {

   599         if ( in_contour != 0 )

   600           goto Fail;

   601 

   602         in_contour = 1;

   603       }

   604       else if ( in_contour == 0 )

   605         goto Fail;

   606 

   607       if ( tags[0] & FT_STROKE_TAG_END )

   608       {

   609         in_contour = 0;

   610         num_contours++;

   611       }

   612     }

   613 

   614     if ( in_contour != 0 )

   615       goto Fail;

   616 

   617     border->valid = TRUE;

   618 

   619   Exit:

   620     *anum_points   = num_points;

   621     *anum_contours = num_contours;

   622     return error;

   623 

   624   Fail:

   625     num_points   = 0;

   626     num_contours = 0;

   627     goto Exit;

   628   }

   629 

   630 

   631   static void

   632   ft_stroke_border_export( FT_StrokeBorder  border,

   633                            FT_Outline*      outline )

   634   {

   635     /* copy point locations */

   636     FT_ARRAY_COPY( outline->points + outline->n_points,

   637                    border->points,

   638                    border->num_points );

   639 

   640     /* copy tags */

   641     {

   642       FT_UInt   count = border->num_points;

   643       FT_Byte*  read  = border->tags;

   644       FT_Byte*  write = (FT_Byte*)outline->tags + outline->n_points;

   645 

   646 

   647       for ( ; count > 0; count--, read++, write++ )

   648       {

   649         if ( *read & FT_STROKE_TAG_ON )

   650           *write = FT_CURVE_TAG_ON;

   651         else if ( *read & FT_STROKE_TAG_CUBIC )

   652           *write = FT_CURVE_TAG_CUBIC;

   653         else

   654           *write = FT_CURVE_TAG_CONIC;

   655       }

   656     }

   657 

   658     /* copy contours */

   659     {

   660       FT_UInt    count = border->num_points;

   661       FT_Byte*   tags  = border->tags;

   662       FT_Short*  write = outline->contours + outline->n_contours;

   663       FT_Short   idx   = (FT_Short)outline->n_points;

   664 

   665 

   666       for ( ; count > 0; count--, tags++, idx++ )

   667       {

   668         if ( *tags & FT_STROKE_TAG_END )

   669         {

   670           *write++ = idx;

   671           outline->n_contours++;

   672         }

   673       }

   674     }

   675 

   676     outline->n_points  = (short)( outline->n_points + border->num_points );

   677 

   678     FT_ASSERT( FT_Outline_Check( outline ) == 0 );

   679   }

   680 

   681 

   682  /***************************************************************************/

   683  /***************************************************************************/

   684  /*****                                                                 *****/

   685  /*****                           STROKER                               *****/

   686  /*****                                                                 *****/

   687  /***************************************************************************/

   688  /***************************************************************************/

   689 

   690 #define FT_SIDE_TO_ROTATE( s )   ( FT_ANGLE_PI2 - (s) * FT_ANGLE_PI )

   691 

   692   typedef struct  FT_StrokerRec_

   693   {

   694     FT_Angle             angle_in;

   695     FT_Angle             angle_out;

   696     FT_Vector            center;

   697     FT_Bool              first_point;

   698     FT_Bool              subpath_open;

   699     FT_Angle             subpath_angle;

   700     FT_Vector            subpath_start;

   701 

   702     FT_Stroker_LineCap   line_cap;

   703     FT_Stroker_LineJoin  line_join;

   704     FT_Fixed             miter_limit;

   705     FT_Fixed             radius;

   706 

   707     FT_StrokeBorderRec   borders[2];

   708     FT_Library           library;

   709 

   710   } FT_StrokerRec;

   711 

   712 

   713   /* documentation is in ftstroke.h */

   714 

   715   FT_EXPORT_DEF( FT_Error )

   716   FT_Stroker_New( FT_Library   library,

   717                   FT_Stroker  *astroker )

   718   {

   719     FT_Error    error;

   720     FT_Memory   memory;

   721     FT_Stroker  stroker;

   722 

   723 

   724     if ( !library )

   725       return FT_Err_Invalid_Argument;

   726 

   727     memory = library->memory;

   728 

   729     if ( !FT_NEW( stroker ) )

   730     {

   731       stroker->library = library;

   732 

   733       ft_stroke_border_init( &stroker->borders[0], memory );

   734       ft_stroke_border_init( &stroker->borders[1], memory );

   735     }

   736     *astroker = stroker;

   737     return error;

   738   }

   739 

   740 

   741   /* documentation is in ftstroke.h */

   742 

   743   FT_EXPORT_DEF( void )

   744   FT_Stroker_Set( FT_Stroker           stroker,

   745                   FT_Fixed             radius,

   746                   FT_Stroker_LineCap   line_cap,

   747                   FT_Stroker_LineJoin  line_join,

   748                   FT_Fixed             miter_limit )

   749   {

   750     stroker->radius      = radius;

   751     stroker->line_cap    = line_cap;

   752     stroker->line_join   = line_join;

   753     stroker->miter_limit = miter_limit;

   754 

   755     FT_Stroker_Rewind( stroker );

   756   }

   757 

   758 

   759   /* documentation is in ftstroke.h */

   760 

   761   FT_EXPORT_DEF( void )

   762   FT_Stroker_Rewind( FT_Stroker  stroker )

   763   {

   764     if ( stroker )

   765     {

   766       ft_stroke_border_reset( &stroker->borders[0] );

   767       ft_stroke_border_reset( &stroker->borders[1] );

   768     }

   769   }

   770 

   771 

   772   /* documentation is in ftstroke.h */

   773 

   774   FT_EXPORT_DEF( void )

   775   FT_Stroker_Done( FT_Stroker  stroker )

   776   {

   777     if ( stroker )

   778     {

   779       FT_Memory  memory = stroker->library->memory;

   780 

   781 

   782       ft_stroke_border_done( &stroker->borders[0] );

   783       ft_stroke_border_done( &stroker->borders[1] );

   784 

   785       stroker->library = NULL;

   786       FT_FREE( stroker );

   787     }

   788   }

   789 

   790 

   791   /* creates a circular arc at a corner or cap */

   792   static FT_Error

   793   ft_stroker_arcto( FT_Stroker  stroker,

   794                     FT_Int      side )

   795   {

   796     FT_Angle         total, rotate;

   797     FT_Fixed         radius = stroker->radius;

   798     FT_Error         error  = FT_Err_Ok;

   799     FT_StrokeBorder  border = stroker->borders + side;

   800 

   801 

   802     rotate = FT_SIDE_TO_ROTATE( side );

   803 

   804     total = FT_Angle_Diff( stroker->angle_in, stroker->angle_out );

   805     if ( total == FT_ANGLE_PI )

   806       total = -rotate * 2;

   807 

   808     error = ft_stroke_border_arcto( border,

   809                                     &stroker->center,

   810                                     radius,

   811                                     stroker->angle_in + rotate,

   812                                     total );

   813     border->movable = FALSE;

   814     return error;

   815   }

   816 

   817 

   818   /* adds a cap at the end of an opened path */

   819   static FT_Error

   820   ft_stroker_cap( FT_Stroker  stroker,

   821                   FT_Angle    angle,

   822                   FT_Int      side )

   823   {

   824     FT_Error  error = FT_Err_Ok;

   825 

   826 

   827     if ( stroker->line_cap == FT_STROKER_LINECAP_ROUND )

   828     {

   829       /* add a round cap */

   830       stroker->angle_in  = angle;

   831       stroker->angle_out = angle + FT_ANGLE_PI;

   832       error = ft_stroker_arcto( stroker, side );

   833     }

   834     else if ( stroker->line_cap == FT_STROKER_LINECAP_SQUARE )

   835     {

   836       /* add a square cap */

   837       FT_Vector        delta, delta2;

   838       FT_Angle         rotate = FT_SIDE_TO_ROTATE( side );

   839       FT_Fixed         radius = stroker->radius;

   840       FT_StrokeBorder  border = stroker->borders + side;

   841 

   842 

   843       FT_Vector_From_Polar( &delta2, radius, angle + rotate );

   844       FT_Vector_From_Polar( &delta,  radius, angle );

   845 

   846       delta.x += stroker->center.x + delta2.x;

   847       delta.y += stroker->center.y + delta2.y;

   848 

   849       error = ft_stroke_border_lineto( border, &delta, FALSE );

   850       if ( error )

   851         goto Exit;

   852 

   853       FT_Vector_From_Polar( &delta2, radius, angle - rotate );

   854       FT_Vector_From_Polar( &delta,  radius, angle );

   855 

   856       delta.x += delta2.x + stroker->center.x;

   857       delta.y += delta2.y + stroker->center.y;

   858 

   859       error = ft_stroke_border_lineto( border, &delta, FALSE );

   860     }

   861     else if ( stroker->line_cap == FT_STROKER_LINECAP_BUTT )

   862     {

   863       /* add a butt ending */

   864       FT_Vector        delta;

   865       FT_Angle         rotate = FT_SIDE_TO_ROTATE( side );

   866       FT_Fixed         radius = stroker->radius;

   867       FT_StrokeBorder  border = stroker->borders + side;

   868 

   869 

   870       FT_Vector_From_Polar( &delta, radius, angle + rotate );

   871 

   872       delta.x += stroker->center.x;

   873       delta.y += stroker->center.y;

   874 

   875       error = ft_stroke_border_lineto( border, &delta, FALSE );

   876       if ( error )

   877         goto Exit;

   878 

   879       FT_Vector_From_Polar( &delta, radius, angle - rotate );

   880 

   881       delta.x += stroker->center.x;

   882       delta.y += stroker->center.y;

   883 

   884       error = ft_stroke_border_lineto( border, &delta, FALSE );   

   885     }

   886 

   887   Exit:

   888     return error;

   889   }

   890 

   891 

   892   /* process an inside corner, i.e. compute intersection */

   893   static FT_Error

   894   ft_stroker_inside( FT_Stroker  stroker,

   895                      FT_Int      side)

   896   {

   897     FT_StrokeBorder  border = stroker->borders + side;

   898     FT_Angle         phi, theta, rotate;

   899     FT_Fixed         length, thcos, sigma;

   900     FT_Vector        delta;

   901     FT_Error         error = FT_Err_Ok;

   902 

   903 

   904     rotate = FT_SIDE_TO_ROTATE( side );

   905 

   906     /* compute median angle */

   907     theta = FT_Angle_Diff( stroker->angle_in, stroker->angle_out );

   908     if ( theta == FT_ANGLE_PI )

   909       theta = rotate;

   910     else

   911       theta = theta / 2;

   912 

   913     phi = stroker->angle_in + theta;

   914 

   915     thcos = FT_Cos( theta );

   916     sigma = FT_MulFix( stroker->miter_limit, thcos );

   917 

   918     /* TODO: find better criterion to switch off the optimization */

   919     if ( sigma < 0x10000L )

   920     {

   921       FT_Vector_From_Polar( &delta, stroker->radius,

   922                             stroker->angle_out + rotate );

   923       delta.x += stroker->center.x;

   924       delta.y += stroker->center.y;

   925       border->movable = FALSE;

   926     }

   927     else

   928     {

   929       length = FT_DivFix( stroker->radius, thcos );

   930 

   931       FT_Vector_From_Polar( &delta, length, phi + rotate );

   932       delta.x += stroker->center.x;

   933       delta.y += stroker->center.y;

   934     }

   935 

   936     error = ft_stroke_border_lineto( border, &delta, FALSE );

   937 

   938     return error;

   939   }

   940 

   941 

   942   /* process an outside corner, i.e. compute bevel/miter/round */

   943   static FT_Error

   944   ft_stroker_outside( FT_Stroker  stroker,

   945                       FT_Int      side )

   946   {

   947     FT_StrokeBorder  border = stroker->borders + side;

   948     FT_Error         error;

   949     FT_Angle         rotate;

   950 

   951 

   952     if ( stroker->line_join == FT_STROKER_LINEJOIN_ROUND )

   953       error = ft_stroker_arcto( stroker, side );

   954     else

   955     {

   956       /* this is a mitered or beveled corner */

   957       FT_Fixed  sigma, radius = stroker->radius;

   958       FT_Angle  theta, phi;

   959       FT_Fixed  thcos;

   960       FT_Bool   miter;

   961 

   962 

   963       rotate = FT_SIDE_TO_ROTATE( side );

   964       miter  = FT_BOOL( stroker->line_join == FT_STROKER_LINEJOIN_MITER );

   965 

   966       theta = FT_Angle_Diff( stroker->angle_in, stroker->angle_out );

   967       if ( theta == FT_ANGLE_PI )

   968       {

   969         theta = rotate;

   970         phi   = stroker->angle_in;

   971       }

   972       else

   973       {

   974         theta = theta / 2;

   975         phi   = stroker->angle_in + theta + rotate;

   976       }

   977 

   978       thcos = FT_Cos( theta );

   979       sigma = FT_MulFix( stroker->miter_limit, thcos );

   980 

   981       /* FT_Sin(x) = 0 for x <= 57 */

   982       if ( sigma >= 0x10000L || ft_pos_abs( theta ) <= 57 )

   983         miter = FALSE;

   984 

   985       if ( miter )  /* this is a miter (broken angle) */

   986       {

   987         FT_Vector  middle, delta;

   988         FT_Fixed   length;

   989 

   990 

   991         /* compute middle point */

   992         FT_Vector_From_Polar( &middle,

   993                               FT_MulFix( radius, stroker->miter_limit ),

   994                               phi );

   995         middle.x += stroker->center.x;

   996         middle.y += stroker->center.y;

   997 

   998         /* compute first angle point */

   999         length = FT_MulFix( radius,

  1000                             FT_DivFix( 0x10000L - sigma,

  1001                                        ft_pos_abs( FT_Sin( theta ) ) ) );

  1002 

  1003         FT_Vector_From_Polar( &delta, length, phi + rotate );

  1004         delta.x += middle.x;

  1005         delta.y += middle.y;

  1006 

  1007         error = ft_stroke_border_lineto( border, &delta, FALSE );

  1008         if ( error )

  1009           goto Exit;

  1010 

  1011         /* compute second angle point */

  1012         FT_Vector_From_Polar( &delta, length, phi - rotate );

  1013         delta.x += middle.x;

  1014         delta.y += middle.y;

  1015 

  1016         error = ft_stroke_border_lineto( border, &delta, FALSE );

  1017         if ( error )

  1018           goto Exit;

  1019 

  1020         /* finally, add a movable end point */

  1021         FT_Vector_From_Polar( &delta, radius, stroker->angle_out + rotate );

  1022         delta.x += stroker->center.x;

  1023         delta.y += stroker->center.y;

  1024 

  1025         error = ft_stroke_border_lineto( border, &delta, TRUE );

  1026       }

  1027 

  1028       else /* this is a bevel (intersection) */

  1029       {

  1030         FT_Fixed   length;

  1031         FT_Vector  delta;

  1032 

  1033 

  1034         length = FT_DivFix( stroker->radius, thcos );

  1035 

  1036         FT_Vector_From_Polar( &delta, length, phi );

  1037         delta.x += stroker->center.x;

  1038         delta.y += stroker->center.y;

  1039 

  1040         error = ft_stroke_border_lineto( border, &delta, FALSE );

  1041         if ( error )

  1042           goto Exit;

  1043 

  1044         /* now add end point */

  1045         FT_Vector_From_Polar( &delta, stroker->radius,

  1046                               stroker->angle_out + rotate );

  1047         delta.x += stroker->center.x;

  1048         delta.y += stroker->center.y;

  1049 

  1050         error = ft_stroke_border_lineto( border, &delta, TRUE );

  1051       }

  1052     }

  1053 

  1054   Exit:

  1055     return error;

  1056   }

  1057 

  1058 

  1059   static FT_Error

  1060   ft_stroker_process_corner( FT_Stroker  stroker )

  1061   {

  1062     FT_Error  error = FT_Err_Ok;

  1063     FT_Angle  turn;

  1064     FT_Int    inside_side;

  1065 

  1066 

  1067     turn = FT_Angle_Diff( stroker->angle_in, stroker->angle_out );

  1068 

  1069     /* no specific corner processing is required if the turn is 0 */

  1070     if ( turn == 0 )

  1071       goto Exit;

  1072 

  1073     /* when we turn to the right, the inside side is 0 */

  1074     inside_side = 0;

  1075 

  1076     /* otherwise, the inside side is 1 */

  1077     if ( turn < 0 )

  1078       inside_side = 1;

  1079 

  1080     /* process the inside side */

  1081     error = ft_stroker_inside( stroker, inside_side );

  1082     if ( error )

  1083       goto Exit;

  1084 

  1085     /* process the outside side */

  1086     error = ft_stroker_outside( stroker, 1 - inside_side );

  1087 

  1088   Exit:

  1089     return error;

  1090   }

  1091 

  1092 

  1093   /* add two points to the left and right borders corresponding to the */

  1094   /* start of the subpath                                              */

  1095   static FT_Error

  1096   ft_stroker_subpath_start( FT_Stroker  stroker,

  1097                             FT_Angle    start_angle )

  1098   {

  1099     FT_Vector        delta;

  1100     FT_Vector        point;

  1101     FT_Error         error;

  1102     FT_StrokeBorder  border;

  1103 

  1104 

  1105     FT_Vector_From_Polar( &delta, stroker->radius,

  1106                           start_angle + FT_ANGLE_PI2 );

  1107 

  1108     point.x = stroker->center.x + delta.x;

  1109     point.y = stroker->center.y + delta.y;

  1110 

  1111     border = stroker->borders;

  1112     error = ft_stroke_border_moveto( border, &point );

  1113     if ( error )

  1114       goto Exit;

  1115 

  1116     point.x = stroker->center.x - delta.x;

  1117     point.y = stroker->center.y - delta.y;

  1118 

  1119     border++;

  1120     error = ft_stroke_border_moveto( border, &point );

  1121 

  1122     /* save angle for last cap */

  1123     stroker->subpath_angle = start_angle;

  1124     stroker->first_point   = FALSE;

  1125 

  1126   Exit:

  1127     return error;

  1128   }

  1129 

  1130 

  1131   /* documentation is in ftstroke.h */

  1132 

  1133   FT_EXPORT_DEF( FT_Error )

  1134   FT_Stroker_LineTo( FT_Stroker  stroker,

  1135                      FT_Vector*  to )