source: trunk/poppler/freetype-2.1.10/src/base/ftstroke.c @ 2

Last change on this file since 2 was 2, checked in by Eugene Romanenko, 15 years ago

First import

File size: 50.1 KB
Line 
1/***************************************************************************/
2/*                                                                         */
3/*  ftstroke.c                                                             */
4/*                                                                         */
5/*    FreeType path stroker (body).                                        */
6/*                                                                         */
7/*  Copyright 2002, 2003, 2004, 2005 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
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   = 0;
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  Exit:
283    return error;
284  }
285
286
287  static void
288  ft_stroke_border_close( FT_StrokeBorder  border,
289                          FT_Bool          reverse )
290  {
291    FT_UInt  start = border->start;
292    FT_UInt  count = border->num_points;
293
294
295    FT_ASSERT( border->start >= 0 );
296
297    /* don't record empty paths! */
298    if ( count <= start + 1U )
299      border->num_points = start;
300    else
301    {
302      /* copy the last point to the start of this sub-path, since */
303      /* it contains the `adjusted' starting coordinates          */
304      border->num_points    = --count;
305      border->points[start] = border->points[count];
306
307      if ( reverse )
308      {
309        /* reverse the points */
310        {
311          FT_Vector*  vec1 = border->points + start + 1;
312          FT_Vector*  vec2 = border->points + count - 1;
313
314
315          for ( ; vec1 < vec2; vec1++, vec2-- )
316          {
317            FT_Vector  tmp;
318
319
320            tmp   = *vec1;
321            *vec1 = *vec2;
322            *vec2 = tmp;
323          }
324        }
325
326        /* then the tags */
327        {
328          FT_Byte*  tag1 = border->tags + start + 1;
329          FT_Byte*  tag2 = border->tags + count - 1;
330
331
332          for ( ; tag1 < tag2; tag1++, tag2-- )
333          {
334            FT_Byte  tmp;
335
336
337            tmp   = *tag1;
338            *tag1 = *tag2;
339            *tag2 = tmp;
340          }
341        }
342      }
343
344      border->tags[start    ] |= FT_STROKE_TAG_BEGIN;
345      border->tags[count - 1] |= FT_STROKE_TAG_END;
346    }
347
348    border->start   = -1;
349    border->movable = 0;
350  }
351
352
353  static FT_Error
354  ft_stroke_border_lineto( FT_StrokeBorder  border,
355                           FT_Vector*       to,
356                           FT_Bool          movable )
357  {
358    FT_Error  error = 0;
359
360
361    FT_ASSERT( border->start >= 0 );
362
363    if ( border->movable )
364    {
365      /* move last point */
366      border->points[border->num_points - 1] = *to;
367    }
368    else
369    {
370      /* add one point */
371      error = ft_stroke_border_grow( border, 1 );
372      if ( !error )
373      {
374        FT_Vector*  vec = border->points + border->num_points;
375        FT_Byte*    tag = border->tags   + border->num_points;
376
377
378        vec[0] = *to;
379        tag[0] = FT_STROKE_TAG_ON;
380
381        border->num_points += 1;
382      }
383    }
384    border->movable = movable;
385    return error;
386  }
387
388
389  static FT_Error
390  ft_stroke_border_conicto( FT_StrokeBorder  border,
391                            FT_Vector*       control,
392                            FT_Vector*       to )
393  {
394    FT_Error  error;
395
396
397    FT_ASSERT( border->start >= 0 );
398
399    error = ft_stroke_border_grow( border, 2 );
400    if ( !error )
401    {
402      FT_Vector*  vec = border->points + border->num_points;
403      FT_Byte*    tag = border->tags   + border->num_points;
404
405      vec[0] = *control;
406      vec[1] = *to;
407
408      tag[0] = 0;
409      tag[1] = FT_STROKE_TAG_ON;
410
411      border->num_points += 2;
412    }
413    border->movable = 0;
414    return error;
415  }
416
417
418  static FT_Error
419  ft_stroke_border_cubicto( FT_StrokeBorder  border,
420                            FT_Vector*       control1,
421                            FT_Vector*       control2,
422                            FT_Vector*       to )
423  {
424    FT_Error  error;
425
426
427    FT_ASSERT( border->start >= 0 );
428
429    error = ft_stroke_border_grow( border, 3 );
430    if ( !error )
431    {
432      FT_Vector*  vec = border->points + border->num_points;
433      FT_Byte*    tag = border->tags   + border->num_points;
434
435
436      vec[0] = *control1;
437      vec[1] = *control2;
438      vec[2] = *to;
439
440      tag[0] = FT_STROKE_TAG_CUBIC;
441      tag[1] = FT_STROKE_TAG_CUBIC;
442      tag[2] = FT_STROKE_TAG_ON;
443
444      border->num_points += 3;
445    }
446    border->movable = 0;
447    return error;
448  }
449
450
451#define FT_ARC_CUBIC_ANGLE  ( FT_ANGLE_PI / 2 )
452
453
454  static FT_Error
455  ft_stroke_border_arcto( FT_StrokeBorder  border,
456                          FT_Vector*       center,
457                          FT_Fixed         radius,
458                          FT_Angle         angle_start,
459                          FT_Angle         angle_diff )
460  {
461    FT_Angle   total, angle, step, rotate, next, theta;
462    FT_Vector  a, b, a2, b2;
463    FT_Fixed   length;
464    FT_Error   error = 0;
465
466
467    /* compute start point */
468    FT_Vector_From_Polar( &a, radius, angle_start );
469    a.x += center->x;
470    a.y += center->y;
471
472    total  = angle_diff;
473    angle  = angle_start;
474    rotate = ( angle_diff >= 0 ) ? FT_ANGLE_PI2 : -FT_ANGLE_PI2;
475
476    while ( total != 0 )
477    {
478      step = total;
479      if ( step > FT_ARC_CUBIC_ANGLE )
480        step = FT_ARC_CUBIC_ANGLE;
481
482      else if ( step < -FT_ARC_CUBIC_ANGLE )
483        step = -FT_ARC_CUBIC_ANGLE;
484
485      next  = angle + step;
486      theta = step;
487      if ( theta < 0 )
488        theta = -theta;
489
490      theta >>= 1;
491
492      /* compute end point */
493      FT_Vector_From_Polar( &b, radius, next );
494      b.x += center->x;
495      b.y += center->y;
496
497      /* compute first and second control points */
498      length = FT_MulDiv( radius, FT_Sin( theta ) * 4,
499                          ( 0x10000L + FT_Cos( theta ) ) * 3 );
500
501      FT_Vector_From_Polar( &a2, length, angle + rotate );
502      a2.x += a.x;
503      a2.y += a.y;
504
505      FT_Vector_From_Polar( &b2, length, next - rotate );
506      b2.x += b.x;
507      b2.y += b.y;
508
509      /* add cubic arc */
510      error = ft_stroke_border_cubicto( border, &a2, &b2, &b );
511      if ( error )
512        break;
513
514      /* process the rest of the arc ?? */
515      a      = b;
516      total -= step;
517      angle  = next;
518    }
519
520    return error;
521  }
522
523
524  static FT_Error
525  ft_stroke_border_moveto( FT_StrokeBorder  border,
526                           FT_Vector*       to )
527  {
528    /* close current open path if any ? */
529    if ( border->start >= 0 )
530      ft_stroke_border_close( border, 0 );
531
532    border->start   = border->num_points;
533    border->movable = 0;
534
535    return ft_stroke_border_lineto( border, to, 0 );
536  }
537
538
539  static void
540  ft_stroke_border_init( FT_StrokeBorder  border,
541                         FT_Memory        memory )
542  {
543    border->memory = memory;
544    border->points = NULL;
545    border->tags   = NULL;
546
547    border->num_points = 0;
548    border->max_points = 0;
549    border->start      = -1;
550    border->valid      = 0;
551  }
552
553
554  static void
555  ft_stroke_border_reset( FT_StrokeBorder  border )
556  {
557    border->num_points = 0;
558    border->start      = -1;
559    border->valid      = 0;
560  }
561
562
563  static void
564  ft_stroke_border_done( FT_StrokeBorder  border )
565  {
566    FT_Memory  memory = border->memory;
567
568
569    FT_FREE( border->points );
570    FT_FREE( border->tags );
571
572    border->num_points = 0;
573    border->max_points = 0;
574    border->start      = -1;
575    border->valid      = 0;
576  }
577
578
579  static FT_Error
580  ft_stroke_border_get_counts( FT_StrokeBorder  border,
581                               FT_UInt         *anum_points,
582                               FT_UInt         *anum_contours )
583  {
584    FT_Error  error        = 0;
585    FT_UInt   num_points   = 0;
586    FT_UInt   num_contours = 0;
587
588    FT_UInt     count      = border->num_points;
589    FT_Vector*  point      = border->points;
590    FT_Byte*    tags       = border->tags;
591    FT_Int      in_contour = 0;
592
593
594    for ( ; count > 0; count--, num_points++, point++, tags++ )
595    {
596      if ( tags[0] & FT_STROKE_TAG_BEGIN )
597      {
598        if ( in_contour != 0 )
599          goto Fail;
600
601        in_contour = 1;
602      }
603      else if ( in_contour == 0 )
604        goto Fail;
605
606      if ( tags[0] & FT_STROKE_TAG_END )
607      {
608        if ( in_contour == 0 )
609          goto Fail;
610
611        in_contour = 0;
612        num_contours++;
613      }
614    }
615
616    if ( in_contour != 0 )
617      goto Fail;
618
619    border->valid = 1;
620
621  Exit:
622    *anum_points   = num_points;
623    *anum_contours = num_contours;
624    return error;
625
626  Fail:
627    num_points   = 0;
628    num_contours = 0;
629    goto Exit;
630  }
631
632
633  static void
634  ft_stroke_border_export( FT_StrokeBorder  border,
635                           FT_Outline*      outline )
636  {
637    /* copy point locations */
638    FT_ARRAY_COPY( outline->points + outline->n_points,
639                   border->points,
640                   border->num_points );
641
642    /* copy tags */
643    {
644      FT_UInt   count = border->num_points;
645      FT_Byte*  read  = border->tags;
646      FT_Byte*  write = (FT_Byte*)outline->tags + outline->n_points;
647
648
649      for ( ; count > 0; count--, read++, write++ )
650      {
651        if ( *read & FT_STROKE_TAG_ON )
652          *write = FT_CURVE_TAG_ON;
653        else if ( *read & FT_STROKE_TAG_CUBIC )
654          *write = FT_CURVE_TAG_CUBIC;
655        else
656          *write = FT_CURVE_TAG_CONIC;
657      }
658    }
659
660    /* copy contours */
661    {
662      FT_UInt    count = border->num_points;
663      FT_Byte*   tags  = border->tags;
664      FT_Short*  write = outline->contours + outline->n_contours;
665      FT_Short   idx   = (FT_Short)outline->n_points;
666
667
668      for ( ; count > 0; count--, tags++, idx++ )
669      {
670        if ( *tags & FT_STROKE_TAG_END )
671        {
672          *write++ = idx;
673          outline->n_contours++;
674        }
675      }
676    }
677
678    outline->n_points  = (short)( outline->n_points + border->num_points );
679
680    FT_ASSERT( FT_Outline_Check( outline ) == 0 );
681  }
682
683
684 /***************************************************************************/
685 /***************************************************************************/
686 /*****                                                                 *****/
687 /*****                           STROKER                               *****/
688 /*****                                                                 *****/
689 /***************************************************************************/
690 /***************************************************************************/
691
692#define FT_SIDE_TO_ROTATE( s )   ( FT_ANGLE_PI2 - (s) * FT_ANGLE_PI )
693
694  typedef struct  FT_StrokerRec_
695  {
696    FT_Angle             angle_in;
697    FT_Angle             angle_out;
698    FT_Vector            center;
699    FT_Bool              first_point;
700    FT_Bool              subpath_open;
701    FT_Angle             subpath_angle;
702    FT_Vector            subpath_start;
703
704    FT_Stroker_LineCap   line_cap;
705    FT_Stroker_LineJoin  line_join;
706    FT_Fixed             miter_limit;
707    FT_Fixed             radius;
708
709    FT_Bool              valid;
710    FT_StrokeBorderRec   borders[2];
711    FT_Memory            memory;
712
713  } FT_StrokerRec;
714
715
716  /* documentation is in ftstroke.h */
717
718  FT_EXPORT_DEF( FT_Error )
719  FT_Stroker_New( FT_Memory    memory,
720                  FT_Stroker  *astroker )
721  {
722    FT_Error    error;
723    FT_Stroker  stroker;
724
725
726    if ( !FT_NEW( stroker ) )
727    {
728      stroker->memory = memory;
729
730      ft_stroke_border_init( &stroker->borders[0], memory );
731      ft_stroke_border_init( &stroker->borders[1], memory );
732    }
733    *astroker = stroker;
734    return error;
735  }
736
737
738  /* documentation is in ftstroke.h */
739
740  FT_EXPORT_DEF( void )
741  FT_Stroker_Set( FT_Stroker           stroker,
742                  FT_Fixed             radius,
743                  FT_Stroker_LineCap   line_cap,
744                  FT_Stroker_LineJoin  line_join,
745                  FT_Fixed             miter_limit )
746  {
747    stroker->radius      = radius;
748    stroker->line_cap    = line_cap;
749    stroker->line_join   = line_join;
750    stroker->miter_limit = miter_limit;
751
752    FT_Stroker_Rewind( stroker );
753  }
754
755
756  /* documentation is in ftstroke.h */
757
758  FT_EXPORT_DEF( void )
759  FT_Stroker_Rewind( FT_Stroker  stroker )
760  {
761    if ( stroker )
762    {
763      ft_stroke_border_reset( &stroker->borders[0] );
764      ft_stroke_border_reset( &stroker->borders[1] );
765    }
766  }
767
768
769  /* documentation is in ftstroke.h */
770
771  FT_EXPORT_DEF( void )
772  FT_Stroker_Done( FT_Stroker  stroker )
773  {
774    if ( stroker )
775    {
776      FT_Memory  memory = stroker->memory;
777
778
779      ft_stroke_border_done( &stroker->borders[0] );
780      ft_stroke_border_done( &stroker->borders[1] );
781
782      stroker->memory = NULL;
783      FT_FREE( stroker );
784    }
785  }
786
787
788  /* creates a circular arc at a corner or cap */
789  static FT_Error
790  ft_stroker_arcto( FT_Stroker  stroker,
791                    FT_Int      side )
792  {
793    FT_Angle         total, rotate;
794    FT_Fixed         radius = stroker->radius;
795    FT_Error         error  = 0;
796    FT_StrokeBorder  border = stroker->borders + side;
797
798
799    rotate = FT_SIDE_TO_ROTATE( side );
800
801    total = FT_Angle_Diff( stroker->angle_in, stroker->angle_out );
802    if ( total == FT_ANGLE_PI )
803      total = -rotate * 2;
804
805    error = ft_stroke_border_arcto( border,
806                                    &stroker->center,
807                                    radius,
808                                    stroker->angle_in + rotate,
809                                    total );
810    border->movable = 0;
811    return error;
812  }
813
814
815  /* adds a cap at the end of an opened path */
816  static FT_Error
817  ft_stroker_cap( FT_Stroker  stroker,
818                  FT_Angle    angle,
819                  FT_Int      side )
820  {
821    FT_Error  error  = 0;
822
823
824    if ( stroker->line_cap == FT_STROKER_LINECAP_ROUND )
825    {
826      /* add a round cap */
827      stroker->angle_in  = angle;
828      stroker->angle_out = angle + FT_ANGLE_PI;
829      error = ft_stroker_arcto( stroker, side );
830    }
831    else if ( stroker->line_cap == FT_STROKER_LINECAP_SQUARE )
832    {
833      /* add a square cap */
834      FT_Vector        delta, delta2;
835      FT_Angle         rotate = FT_SIDE_TO_ROTATE( side );
836      FT_Fixed         radius = stroker->radius;
837      FT_StrokeBorder  border = stroker->borders + side;
838
839
840      FT_Vector_From_Polar( &delta2, radius, angle + rotate );
841      FT_Vector_From_Polar( &delta,  radius, angle );
842
843      delta.x += stroker->center.x + delta2.x;
844      delta.y += stroker->center.y + delta2.y;
845
846      error = ft_stroke_border_lineto( border, &delta, 0 );
847      if ( error )
848        goto Exit;
849
850      FT_Vector_From_Polar( &delta2, radius, angle - rotate );
851      FT_Vector_From_Polar( &delta,  radius, angle );
852
853      delta.x += delta2.x + stroker->center.x;
854      delta.y += delta2.y + stroker->center.y;
855
856      error = ft_stroke_border_lineto( border, &delta, 0 );
857    }
858
859  Exit:
860    return error;
861  }
862
863
864  /* process an inside corner, i.e. compute intersection */
865  static FT_Error
866  ft_stroker_inside( FT_Stroker  stroker,
867                     FT_Int      side)
868  {
869    FT_StrokeBorder  border = stroker->borders + side;
870    FT_Angle         phi, theta, rotate;
871    FT_Fixed         length, thcos, sigma;
872    FT_Vector        delta;
873    FT_Error         error = 0;
874
875
876    rotate = FT_SIDE_TO_ROTATE( side );
877
878    /* compute median angle */
879    theta = FT_Angle_Diff( stroker->angle_in, stroker->angle_out );
880    if ( theta == FT_ANGLE_PI )
881      theta = rotate;
882    else
883      theta = theta / 2;
884
885    phi = stroker->angle_in + theta;
886
887    thcos = FT_Cos( theta );
888    sigma = FT_MulFix( stroker->miter_limit, thcos );
889
890    /* TODO: find better criterion to switch off the optimization */
891    if ( sigma < 0x10000L )
892    {
893      FT_Vector_From_Polar( &delta, stroker->radius,
894                            stroker->angle_out + rotate );
895      delta.x += stroker->center.x;
896      delta.y += stroker->center.y;
897      border->movable = 0;
898    }
899    else
900    {
901      length = FT_DivFix( stroker->radius, thcos );
902
903      FT_Vector_From_Polar( &delta, length, phi + rotate );
904      delta.x += stroker->center.x;
905      delta.y += stroker->center.y;
906    }
907
908    error = ft_stroke_border_lineto( border, &delta, 0 );
909
910    return error;
911  }
912
913
914  /* process an outside corner, i.e. compute bevel/miter/round */
915  static FT_Error
916  ft_stroker_outside( FT_Stroker  stroker,
917                      FT_Int      side )
918  {
919    FT_StrokeBorder  border = stroker->borders + side;
920    FT_Error         error;
921    FT_Angle         rotate;
922
923
924    if ( stroker->line_join == FT_STROKER_LINEJOIN_ROUND )
925    {
926      error = ft_stroker_arcto( stroker, side );
927    }
928    else
929    {
930      /* this is a mitered or beveled corner */
931      FT_Fixed  sigma, radius = stroker->radius;
932      FT_Angle  theta, phi;
933      FT_Fixed  thcos;
934      FT_Bool   miter;
935
936
937      rotate = FT_SIDE_TO_ROTATE( side );
938      miter  = FT_BOOL( stroker->line_join == FT_STROKER_LINEJOIN_MITER );
939
940      theta  = FT_Angle_Diff( stroker->angle_in, stroker->angle_out );
941      if ( theta == FT_ANGLE_PI )
942      {
943        theta = rotate;
944        phi   = stroker->angle_in;
945      }
946      else
947      {
948        theta = theta / 2;
949        phi   = stroker->angle_in + theta + rotate;
950      }
951
952      thcos = FT_Cos( theta );
953      sigma = FT_MulFix( stroker->miter_limit, thcos );
954
955      if ( sigma >= 0x10000L )
956        miter = 0;
957
958      if ( miter )  /* this is a miter (broken angle) */
959      {
960        FT_Vector  middle, delta;
961        FT_Fixed   length;
962
963
964        /* compute middle point */
965        FT_Vector_From_Polar( &middle,
966                              FT_MulFix( radius, stroker->miter_limit ),
967                              phi );
968        middle.x += stroker->center.x;
969        middle.y += stroker->center.y;
970
971        /* compute first angle point */
972        length = FT_MulFix( radius,
973                            FT_DivFix( 0x10000L - sigma,
974                                       ft_pos_abs( FT_Sin( theta ) ) ) );
975
976        FT_Vector_From_Polar( &delta, length, phi + rotate );
977        delta.x += middle.x;
978        delta.y += middle.y;
979
980        error = ft_stroke_border_lineto( border, &delta, 0 );
981        if ( error )
982          goto Exit;
983
984        /* compute second angle point */
985        FT_Vector_From_Polar( &delta, length, phi - rotate );
986        delta.x += middle.x;
987        delta.y += middle.y;
988
989        error = ft_stroke_border_lineto( border, &delta, 0 );
990        if ( error )
991          goto Exit;
992
993        /* finally, add a movable end point */
994        FT_Vector_From_Polar( &delta, radius, stroker->angle_out + rotate );
995        delta.x += stroker->center.x;
996        delta.y += stroker->center.y;
997
998        error = ft_stroke_border_lineto( border, &delta, 1 );
999      }
1000
1001      else /* this is a bevel (intersection) */
1002      {
1003        FT_Fixed   length;
1004        FT_Vector  delta;
1005
1006
1007        length = FT_DivFix( stroker->radius, thcos );
1008
1009        FT_Vector_From_Polar( &delta, length, phi );
1010        delta.x += stroker->center.x;
1011        delta.y += stroker->center.y;
1012
1013        error = ft_stroke_border_lineto( border, &delta, 0 );
1014        if (error) goto Exit;
1015
1016        /* now add end point */
1017        FT_Vector_From_Polar( &delta, stroker->radius,
1018                              stroker->angle_out + rotate );
1019        delta.x += stroker->center.x;
1020        delta.y += stroker->center.y;
1021
1022        error = ft_stroke_border_lineto( border, &delta, 1 );
1023      }
1024    }
1025
1026  Exit:
1027    return error;
1028  }
1029
1030
1031  static FT_Error
1032  ft_stroker_process_corner( FT_Stroker  stroker )
1033  {
1034    FT_Error  error = 0;
1035    FT_Angle  turn;
1036    FT_Int    inside_side;
1037
1038
1039    turn = FT_Angle_Diff( stroker->angle_in, stroker->angle_out );
1040
1041    /* no specific corner processing is required if the turn is 0 */
1042    if ( turn == 0 )
1043      goto Exit;
1044
1045    /* when we turn to the right, the inside side is 0 */
1046    inside_side = 0;
1047
1048    /* otherwise, the inside side is 1 */
1049    if ( turn < 0 )
1050      inside_side = 1;
1051
1052    /* process the inside side */
1053    error = ft_stroker_inside( stroker, inside_side );
1054    if ( error )
1055      goto Exit;
1056
1057    /* process the outside side */
1058    error = ft_stroker_outside( stroker, 1 - inside_side );
1059
1060  Exit:
1061    return error;
1062  }
1063
1064
1065  /* add two points to the left and right borders corresponding to the */
1066  /* start of the subpath..                                            */
1067  static FT_Error
1068  ft_stroker_subpath_start( FT_Stroker  stroker,
1069                            FT_Angle    start_angle )
1070  {
1071    FT_Vector        delta;
1072    FT_Vector        point;
1073    FT_Error         error;
1074    FT_StrokeBorder  border;
1075
1076
1077    FT_Vector_From_Polar( &delta, stroker->radius,
1078                          start_angle + FT_ANGLE_PI2 );
1079
1080    point.x = stroker->center.x + delta.x;
1081    point.y = stroker->center.y + delta.y;
1082
1083    border = stroker->borders;
1084    error = ft_stroke_border_moveto( border, &point );
1085    if ( error )
1086      goto Exit;
1087
1088    point.x = stroker->center.x - delta.x;
1089    point.y = stroker->center.y - delta.y;
1090
1091    border++;
1092    error = ft_stroke_border_moveto( border, &point );
1093
1094    /* save angle for last cap */
1095    stroker->subpath_angle = start_angle;
1096    stroker->first_point   = 0;
1097
1098  Exit:
1099    return error;
1100  }
1101
1102
1103  /* documentation is in ftstroke.h */
1104
1105  FT_EXPORT_DEF( FT_Error )
1106  FT_Stroker_LineTo( FT_Stroker  stroker,
1107                     FT_Vector*  to )
1108  {
1109    FT_Error         error = 0;
1110    FT_StrokeBorder  border;
1111    FT_Vector        delta;
1112    FT_Angle         angle;
1113    FT_Int           side;
1114
1115    delta.x = to->x - stroker->center.x;
1116    delta.y = to->y - stroker->center.y;
1117
1118    angle = FT_Atan2( delta.x, delta.y );
1119    FT_Vector_From_Polar( &delta, stroker->radius, angle + FT_ANGLE_PI2 );
1120
1121    /* process corner if necessary */
1122    if ( stroker->first_point )
1123    {
1124      /* This is the first segment of a subpath.  We need to     */
1125      /* add a point to each border at their respective starting */
1126      /* point locations.                                        */
1127      error = ft_stroker_subpath_start( stroker, angle );
1128      if ( error )
1129        goto Exit;
1130    }
1131    else
1132    {
1133      /* process the current corner */
1134      stroker->angle_out = angle;
1135      error = ft_stroker_process_corner( stroker );
1136      if ( error )
1137        goto Exit;
1138    }
1139
1140    /* now add a line segment to both the "inside" and "outside" paths */
1141
1142    for ( border = stroker->borders, side = 1; side >= 0; side--, border++ )
1143    {
1144      FT_Vector  point;
1145
1146
1147      point.x = to->x + delta.x;
1148      point.y = to->y + delta.y;
1149
1150      error = ft_stroke_border_lineto( border, &point, 1 );
1151      if ( error )
1152        goto Exit;
1153
1154      delta.x = -delta.x;
1155      delta.y = -delta.y;
1156    }
1157
1158    stroker->angle_in = angle;
1159    stroker->center   = *to;
1160
1161  Exit:
1162    return error;
1163  }
1164
1165
1166  /* documentation is in ftstroke.h */
1167
1168  FT_EXPORT_DEF( FT_Error )
1169  FT_Stroker_ConicTo( FT_Stroker  stroker,
1170                      FT_Vector*  control,
1171                      FT_Vector*  to )
1172  {
1173    FT_Error    error = 0;
1174    FT_Vector   bez_stack[34];
1175    FT_Vector*  arc;
1176    FT_Vector*  limit = bez_stack + 30;
1177    FT_Angle    start_angle;
1178    FT_Bool     first_arc = 1;
1179
1180
1181    arc    = bez_stack;
1182    arc[0] = *to;
1183    arc[1] = *control;
1184    arc[2] = stroker->center;
1185
1186    while ( arc >= bez_stack )
1187    {
1188      FT_Angle  angle_in, angle_out;
1189
1190
1191      angle_in = angle_out = 0;  /* remove compiler warnings */
1192
1193      if ( arc < limit                                             &&
1194           !ft_conic_is_small_enough( arc, &angle_in, &angle_out ) )
1195      {
1196        ft_conic_split( arc );
1197        arc += 2;
1198        continue;
1199      }
1200
1201      if ( first_arc )
1202      {
1203        first_arc = 0;
1204
1205        start_angle = angle_in;
1206
1207        /* process corner if necessary */
1208        if ( stroker->first_point )
1209          error = ft_stroker_subpath_start( stroker, start_angle );
1210        else
1211        {
1212          stroker->angle_out = start_angle;
1213          error = ft_stroker_process_corner( stroker );
1214        }
1215      }
1216
1217      /* the arc's angle is small enough; we can add it directly to each */
1218      /* border                                                          */
1219      {
1220        FT_Vector  ctrl, end;
1221        FT_Angle   theta, phi, rotate;
1222        FT_Fixed   length;
1223        FT_Int     side;
1224
1225
1226        theta  = FT_Angle_Diff( angle_in, angle_out ) / 2;
1227        phi    = angle_in + theta;
1228        length = FT_DivFix( stroker->radius, FT_Cos( theta ) );
1229
1230        for ( side = 0; side <= 1; side++ )
1231        {
1232          rotate = FT_SIDE_TO_ROTATE( side );
1233
1234          /* compute control point */
1235          FT_Vector_From_Polar( &ctrl, length, phi + rotate );
1236          ctrl.x += arc[1].x;
1237          ctrl.y += arc[1].y;
1238
1239          /* compute end point */
1240          FT_Vector_From_Polar( &end, stroker->radius, angle_out + rotate );
1241          end.x += arc[0].x;
1242          end.y += arc[0].y;
1243
1244          error = ft_stroke_border_conicto( stroker->borders + side,
1245                                            &ctrl, &end );
1246          if ( error )
1247            goto Exit;
1248        }
1249      }
1250
1251      arc -= 2;
1252
1253      if ( arc < bez_stack )
1254        stroker->angle_in = angle_out;
1255    }
1256
1257    stroker->center = *to;
1258
1259  Exit:
1260    return error;
1261  }
1262
1263
1264  /* documentation is in ftstroke.h */
1265
1266  FT_EXPORT_DEF( FT_Error )
1267  FT_Stroker_CubicTo( FT_Stroker  stroker,
1268                      FT_Vector*  control1,
1269                      FT_Vector*  control2,
1270                      FT_Vector*  to )
1271  {
1272    FT_Error    error = 0;
1273    FT_Vector   bez_stack[37];
1274    FT_Vector*  arc;
1275    FT_Vector*  limit = bez_stack + 32;
1276    FT_Angle    start_angle;
1277    FT_Bool     first_arc = 1;
1278
1279
1280    arc    = bez_stack;
1281    arc[0] = *to;
1282    arc[1] = *control2;
1283    arc[2] = *control1;
1284    arc[3] = stroker->center;
1285
1286    while ( arc >= bez_stack )
1287    {
1288      FT_Angle  angle_in, angle_mid, angle_out;
1289
1290
1291      /* remove compiler warnings */
1292      angle_in = angle_out = angle_mid = 0;
1293
1294      if ( arc < limit                                         &&
1295           !ft_cubic_is_small_enough( arc, &angle_in,
1296                                      &angle_mid, &angle_out ) )
1297      {
1298        ft_cubic_split( arc );
1299        arc += 3;
1300        continue;
1301      }
1302
1303      if ( first_arc )
1304      {
1305        first_arc = 0;
1306
1307        /* process corner if necessary */
1308        start_angle = angle_in;
1309
1310        if ( stroker->first_point )
1311          error = ft_stroker_subpath_start( stroker, start_angle );
1312        else
1313        {
1314          stroker->angle_out = start_angle;
1315          error = ft_stroker_process_corner( stroker );
1316        }
1317        if ( error )
1318          goto Exit;
1319      }
1320
1321      /* the arc's angle is small enough; we can add it directly to each */
1322      /* border                                                          */
1323      {
1324        FT_Vector  ctrl1, ctrl2, end;
1325        FT_Angle   theta1, phi1, theta2, phi2, rotate;
1326        FT_Fixed   length1, length2;
1327        FT_Int     side;
1328
1329
1330        theta1  = ft_pos_abs( angle_mid - angle_in ) / 2;
1331        theta2  = ft_pos_abs( angle_out - angle_mid ) / 2;
1332        phi1    = (angle_mid + angle_in ) / 2;
1333        phi2    = (angle_mid + angle_out ) / 2;
1334        length1 = FT_DivFix( stroker->radius, FT_Cos( theta1 ) );
1335        length2 = FT_DivFix( stroker->radius, FT_Cos(theta2) );
1336
1337        for ( side = 0; side <= 1; side++ )
1338        {
1339          rotate = FT_SIDE_TO_ROTATE( side );
1340
1341          /* compute control points */
1342          FT_Vector_From_Polar( &ctrl1, length1, phi1 + rotate );
1343          ctrl1.x += arc[2].x;
1344          ctrl1.y += arc[2].y;
1345
1346          FT_Vector_From_Polar( &ctrl2, length2, phi2 + rotate );
1347          ctrl2.x += arc[1].x;
1348          ctrl2.y += arc[1].y;
1349
1350          /* compute end point */
1351          FT_Vector_From_Polar( &end, stroker->radius, angle_out + rotate );
1352          end.x += arc[0].x;
1353          end.y += arc[0].y;
1354
1355          error = ft_stroke_border_cubicto( stroker->borders + side,
1356                                            &ctrl1, &ctrl2, &end );
1357          if ( error )
1358            goto Exit;
1359        }
1360      }
1361
1362      arc -= 3;
1363      if ( arc < bez_stack )
1364        stroker->angle_in = angle_out;
1365    }
1366
1367    stroker->center = *to;
1368
1369  Exit:
1370    return error;
1371  }
1372
1373
1374  /* documentation is in ftstroke.h */
1375
1376  FT_EXPORT_DEF( FT_Error )
1377  FT_Stroker_BeginSubPath( FT_Stroker  stroker,
1378                           FT_Vector*  to,
1379                           FT_Bool     open )
1380  {
1381    /* We cannot process the first point, because there is not enough      */
1382    /* information regarding its corner/cap.  The latter will be processed */
1383    /* in the "end_subpath" routine.                                       */
1384    /*                                                                     */
1385    stroker->first_point   = 1;
1386    stroker->center        = *to;
1387    stroker->subpath_open  = open;
1388
1389    /* record the subpath start point index for each border */
1390    stroker->subpath_start = *to;
1391    return 0;
1392  }
1393
1394
1395  static FT_Error
1396  ft_stroker_add_reverse_left( FT_Stroker  stroker,
1397                               FT_Bool     open )
1398  {
1399    FT_StrokeBorder  right  = stroker->borders + 0;
1400    FT_StrokeBorder  left   = stroker->borders + 1;
1401    FT_Int           new_points;
1402    FT_Error         error  = 0;
1403
1404
1405    FT_ASSERT( left->start >= 0 );
1406
1407    new_points = left->num_points - left->start;
1408    if ( new_points > 0 )
1409    {
1410      error = ft_stroke_border_grow( right, (FT_UInt)new_points );
1411      if ( error )
1412        goto Exit;
1413
1414      {
1415        FT_Vector*  dst_point = right->points + right->num_points;
1416        FT_Byte*    dst_tag   = right->tags   + right->num_points;
1417        FT_Vector*  src_point = left->points  + left->num_points - 1;
1418        FT_Byte*    src_tag   = left->tags    + left->num_points - 1;
1419
1420        while ( src_point >= left->points + left->start )
1421        {
1422          *dst_point = *src_point;
1423          *dst_tag   = *src_tag;
1424
1425          if ( open )
1426            dst_tag[0] &= ~FT_STROKE_TAG_BEGIN_END;
1427          else
1428          {
1429            FT_Byte  ttag = (FT_Byte)( dst_tag[0] & FT_STROKE_TAG_BEGIN_END );
1430
1431
1432            /* switch begin/end tags if necessary */
1433            if ( ttag == FT_STROKE_TAG_BEGIN ||
1434                 ttag == FT_STROKE_TAG_END   )
1435              dst_tag[0] ^= FT_STROKE_TAG_BEGIN_END;
1436
1437          }
1438
1439          src_point--;
1440          src_tag--;
1441          dst_point++;
1442          dst_tag++;
1443        }
1444      }
1445
1446      left->num_points   = left->start;
1447      right->num_points += new_points;
1448
1449      right->movable = 0;
1450      left->movable  = 0;
1451    }
1452
1453  Exit:
1454    return error;
1455  }
1456
1457
1458  /* documentation is in ftstroke.h */
1459
1460  /* there's a lot of magic in this function! */
1461  FT_EXPORT_DEF( FT_Error )
1462  FT_Stroker_EndSubPath( FT_Stroker  stroker )
1463  {
1464    FT_Error  error  = 0;
1465
1466    if ( stroker->subpath_open )
1467    {
1468      FT_StrokeBorder  right = stroker->borders;
1469
1470      /* All right, this is an opened path, we need to add a cap between */
1471      /* right & left, add the reverse of left, then add a final cap     */
1472      /* between left & right.                                           */
1473      error = ft_stroker_cap( stroker, stroker->angle_in, 0 );
1474      if ( error )
1475        goto Exit;
1476
1477      /* add reversed points from "left" to "right" */
1478      error = ft_stroker_add_reverse_left( stroker, 1 );
1479      if ( error )
1480        goto Exit;
1481
1482      /* now add the final cap */
1483      stroker->center = stroker->subpath_start;
1484      error = ft_stroker_cap( stroker,
1485                              stroker->subpath_angle + FT_ANGLE_PI, 0 );
1486      if ( error )
1487        goto Exit;
1488
1489      /* Now end the right subpath accordingly.  The left one is */
1490      /* rewind and doesn't need further processing.             */
1491      ft_stroke_border_close( right, 0 );
1492    }
1493    else
1494    {
1495      FT_Angle  turn;
1496      FT_Int    inside_side;
1497
1498      /* close the path if needed */
1499      if ( stroker->center.x != stroker->subpath_start.x ||
1500           stroker->center.y != stroker->subpath_start.y )
1501      {
1502        error = FT_Stroker_LineTo( stroker, &stroker->subpath_start );
1503        if ( error )
1504          goto Exit;
1505      }
1506
1507      /* process the corner */
1508      stroker->angle_out = stroker->subpath_angle;
1509      turn               = FT_Angle_Diff( stroker->angle_in,
1510                                          stroker->angle_out );
1511
1512      /* no specific corner processing is required if the turn is 0 */
1513      if ( turn != 0 )
1514      {
1515        /* when we turn to the right, the inside side is 0 */
1516        inside_side = 0;
1517
1518        /* otherwise, the inside side is 1 */
1519        if ( turn < 0 )
1520          inside_side = 1;
1521
1522        error = ft_stroker_inside( stroker, inside_side );
1523        if ( error )
1524          goto Exit;
1525
1526        /* process the outside side */
1527        error = ft_stroker_outside( stroker, 1 - inside_side );
1528        if ( error )
1529          goto Exit;
1530      }
1531
1532      /* then end our two subpaths */
1533      ft_stroke_border_close( stroker->borders + 0, 1 );
1534      ft_stroke_border_close( stroker->borders + 1, 0 );
1535    }
1536
1537  Exit:
1538    return error;
1539  }
1540
1541
1542  /* documentation is in ftstroke.h */
1543
1544  FT_EXPORT_DEF( FT_Error )
1545  FT_Stroker_GetBorderCounts( FT_Stroker        stroker,
1546                              FT_StrokerBorder  border,
1547                              FT_UInt          *anum_points,
1548                              FT_UInt          *anum_contours )
1549  {
1550    FT_UInt   num_points = 0, num_contours = 0;
1551    FT_Error  error;
1552
1553
1554    if ( !stroker || border > 1 )
1555    {
1556      error = FT_Err_Invalid_Argument;
1557      goto Exit;
1558    }
1559
1560    error = ft_stroke_border_get_counts( stroker->borders + border,
1561                                         &num_points, &num_contours );
1562  Exit:
1563    if ( anum_points )
1564      *anum_points = num_points;
1565
1566    if ( anum_contours )
1567      *anum_contours = num_contours;
1568
1569    return error;
1570  }
1571
1572
1573  /* documentation is in ftstroke.h */
1574
1575  FT_EXPORT_DEF( FT_Error )
1576  FT_Stroker_GetCounts( FT_Stroker  stroker,
1577                        FT_UInt    *anum_points,
1578                        FT_UInt    *anum_contours )
1579  {
1580    FT_UInt   count1, count2, num_points   = 0;
1581    FT_UInt   count3, count4, num_contours = 0;
1582    FT_Error  error;
1583
1584
1585    error = ft_stroke_border_get_counts( stroker->borders + 0,
1586                                         &count1, &count2 );
1587    if ( error )
1588      goto Exit;
1589
1590    error = ft_stroke_border_get_counts( stroker->borders + 1,
1591                                         &count3, &count4 );
1592    if ( error )
1593      goto Exit;
1594
1595    num_points   = count1 + count3;
1596    num_contours = count2 + count4;
1597
1598  Exit:
1599    *anum_points   = num_points;
1600    *anum_contours = num_contours;
1601    return error;
1602  }
1603
1604
1605  /* documentation is in ftstroke.h */
1606
1607  FT_EXPORT_DEF( void )
1608  FT_Stroker_ExportBorder( FT_Stroker        stroker,
1609                           FT_StrokerBorder  border,
1610                           FT_Outline*       outline )
1611  {
1612    if ( border == FT_STROKER_BORDER_LEFT  ||
1613         border == FT_STROKER_BORDER_RIGHT )
1614    {
1615      FT_StrokeBorder  sborder = & stroker->borders[border];
1616
1617
1618      if ( sborder->valid )
1619        ft_stroke_border_export( sborder, outline );
1620    }
1621  }
1622
1623
1624  /* documentation is in ftstroke.h */
1625
1626  FT_EXPORT_DEF( void )
1627  FT_Stroker_Export( FT_Stroker   stroker,
1628                     FT_Outline*  outline )
1629  {
1630    FT_Stroker_ExportBorder( stroker, FT_STROKER_BORDER_LEFT, outline );
1631    FT_Stroker_ExportBorder( stroker, FT_STROKER_BORDER_RIGHT, outline );
1632  }
1633
1634
1635  /* documentation is in ftstroke.h */
1636
1637  /*
1638   *  The following is very similar to FT_Outline_Decompose, except
1639   *  that we do support opened paths, and do not scale the outline.
1640   */
1641  FT_EXPORT_DEF( FT_Error )
1642  FT_Stroker_ParseOutline( FT_Stroker   stroker,
1643                           FT_Outline*  outline,
1644                           FT_Bool      opened )
1645  {
1646    FT_Vector   v_last;
1647    FT_Vector   v_control;
1648    FT_Vector   v_start;
1649
1650    FT_Vector*  point;
1651    FT_Vector*  limit;
1652    char*       tags;
1653
1654    FT_Error    error;
1655
1656    FT_Int   n;         /* index of contour in outline     */
1657    FT_UInt  first;     /* index of first point in contour */
1658    FT_Int   tag;       /* current point's state           */
1659
1660
1661    if ( !outline || !stroker )
1662      return FT_Err_Invalid_Argument;
1663
1664    FT_Stroker_Rewind( stroker );
1665
1666    first = 0;
1667
1668    for ( n = 0; n < outline->n_contours; n++ )
1669    {
1670      FT_UInt  last;  /* index of last point in contour */
1671
1672
1673      last  = outline->contours[n];
1674      limit = outline->points + last;
1675
1676      /* skip empty points; we don't stroke these */
1677      if ( last <= first )
1678      {
1679        first = last + 1;
1680        continue;
1681      }
1682
1683      v_start = outline->points[first];
1684      v_last  = outline->points[last];
1685
1686      v_control = v_start;
1687
1688      point = outline->points + first;
1689      tags  = outline->tags  + first;
1690      tag   = FT_CURVE_TAG( tags[0] );
1691
1692      /* A contour cannot start with a cubic control point! */
1693      if ( tag == FT_CURVE_TAG_CUBIC )
1694        goto Invalid_Outline;
1695
1696      /* check first point to determine origin */
1697      if ( tag == FT_CURVE_TAG_CONIC )
1698      {
1699        /* First point is conic control.  Yes, this happens. */
1700        if ( FT_CURVE_TAG( outline->tags[last] ) == FT_CURVE_TAG_ON )
1701        {
1702          /* start at last point if it is on the curve */
1703          v_start = v_last;
1704          limit--;
1705        }
1706        else
1707        {
1708          /* if both first and last points are conic,         */
1709          /* start at their middle and record its position    */
1710          /* for closure                                      */
1711          v_start.x = ( v_start.x + v_last.x ) / 2;
1712          v_start.y = ( v_start.y + v_last.y ) / 2;
1713
1714          v_last = v_start;
1715        }
1716        point--;
1717        tags--;
1718      }
1719
1720      error = FT_Stroker_BeginSubPath( stroker, &v_start, opened );
1721      if ( error )
1722        goto Exit;
1723
1724      while ( point < limit )
1725      {
1726        point++;
1727        tags++;
1728
1729        tag = FT_CURVE_TAG( tags[0] );
1730        switch ( tag )
1731        {
1732        case FT_CURVE_TAG_ON:  /* emit a single line_to */
1733          {
1734            FT_Vector  vec;
1735
1736
1737            vec.x = point->x;
1738            vec.y = point->y;
1739
1740            error = FT_Stroker_LineTo( stroker, &vec );
1741            if ( error )
1742              goto Exit;
1743            continue;
1744          }
1745
1746        case FT_CURVE_TAG_CONIC:  /* consume conic arcs */
1747          v_control.x = point->x;
1748          v_control.y = point->y;
1749
1750        Do_Conic:
1751          if ( point < limit )
1752          {
1753            FT_Vector  vec;
1754            FT_Vector  v_middle;
1755
1756
1757            point++;
1758            tags++;
1759            tag = FT_CURVE_TAG( tags[0] );
1760
1761            vec = point[0];
1762
1763            if ( tag == FT_CURVE_TAG_ON )
1764            {
1765              error = FT_Stroker_ConicTo( stroker, &v_control, &vec );
1766              if ( error )
1767                goto Exit;
1768              continue;
1769            }
1770
1771            if ( tag != FT_CURVE_TAG_CONIC )
1772              goto Invalid_Outline;
1773
1774            v_middle.x = ( v_control.x + vec.x ) / 2;
1775            v_middle.y = ( v_control.y + vec.y ) / 2;
1776
1777            error = FT_Stroker_ConicTo( stroker, &v_control, &v_middle );
1778            if ( error )
1779              goto Exit;
1780
1781            v_control = vec;
1782            goto Do_Conic;
1783          }
1784
1785          error = FT_Stroker_ConicTo( stroker, &v_control, &v_start );
1786          goto Close;
1787
1788        default:  /* FT_CURVE_TAG_CUBIC */
1789          {
1790            FT_Vector  vec1, vec2;
1791
1792
1793            if ( point + 1 > limit                             ||
1794                 FT_CURVE_TAG( tags[1] ) != FT_CURVE_TAG_CUBIC )
1795              goto Invalid_Outline;
1796
1797            point += 2;
1798            tags  += 2;
1799
1800            vec1 = point[-2];
1801            vec2 = point[-1];
1802
1803            if ( point <= limit )
1804            {
1805              FT_Vector  vec;
1806
1807
1808              vec = point[0];
1809
1810              error = FT_Stroker_CubicTo( stroker, &vec1, &vec2, &vec );
1811              if ( error )
1812                goto Exit;
1813              continue;
1814            }
1815
1816            error = FT_Stroker_CubicTo( stroker, &vec1, &vec2, &v_start );
1817            goto Close;
1818          }
1819        }
1820      }
1821
1822    Close:
1823      if ( error )
1824        goto Exit;
1825
1826      error = FT_Stroker_EndSubPath( stroker );
1827      if ( error )
1828        goto Exit;
1829
1830      first = last + 1;
1831    }
1832
1833    return 0;
1834
1835  Exit:
1836    return error;
1837
1838  Invalid_Outline:
1839    return FT_Err_Invalid_Outline;
1840  }
1841
1842
1843  extern const FT_Glyph_Class  ft_outline_glyph_class;
1844
1845
1846  /* documentation is in ftstroke.h */
1847
1848  FT_EXPORT_DEF( FT_Error )
1849  FT_Glyph_Stroke( FT_Glyph    *pglyph,
1850                   FT_Stroker   stroker,
1851                   FT_Bool      destroy )
1852  {
1853    FT_Error  error = FT_Err_Invalid_Argument;
1854    FT_Glyph  glyph = NULL;
1855
1856
1857    if ( pglyph == NULL )
1858      goto Exit;
1859
1860    glyph = *pglyph;
1861    if ( glyph == NULL || glyph->clazz != &ft_outline_glyph_class )
1862      goto Exit;
1863
1864    {
1865      FT_Glyph  copy;
1866
1867
1868      error = FT_Glyph_Copy( glyph, &copy );
1869      if ( error )
1870        goto Exit;
1871
1872      glyph = copy;
1873    }
1874
1875    {
1876      FT_OutlineGlyph  oglyph  = (FT_OutlineGlyph) glyph;
1877      FT_Outline*      outline = &oglyph->outline;
1878      FT_UInt          num_points, num_contours;
1879
1880
1881      error = FT_Stroker_ParseOutline( stroker, outline, 0 );
1882      if ( error )
1883        goto Fail;
1884
1885      (void)FT_Stroker_GetCounts( stroker, &num_points, &num_contours );
1886
1887      FT_Outline_Done( glyph->library, outline );
1888
1889      error = FT_Outline_New( glyph->library,
1890                              num_points, num_contours, outline );
1891      if ( error )
1892        goto Fail;
1893
1894      outline->n_points   = 0;
1895      outline->n_contours = 0;
1896
1897      FT_Stroker_Export( stroker, outline );
1898    }
1899
1900    if ( destroy )
1901      FT_Done_Glyph( *pglyph );
1902
1903    *pglyph = glyph;
1904    goto Exit;
1905
1906  Fail:
1907    FT_Done_Glyph( glyph );
1908    glyph = NULL;
1909
1910    if ( !destroy )
1911      *pglyph = NULL;
1912
1913  Exit:
1914    return error;
1915  }
1916
1917
1918  /* documentation is in ftstroke.h */
1919
1920  FT_EXPORT_DEF( FT_Error )
1921  FT_Glyph_StrokeBorder( FT_Glyph    *pglyph,
1922                         FT_Stroker   stroker,
1923                         FT_Bool      inside,
1924                         FT_Bool      destroy )
1925  {
1926    FT_Error  error = FT_Err_Invalid_Argument;
1927    FT_Glyph  glyph = NULL;
1928
1929
1930    if ( pglyph == NULL )
1931      goto Exit;
1932
1933    glyph = *pglyph;
1934    if ( glyph == NULL || glyph->clazz != &ft_outline_glyph_class )
1935      goto Exit;
1936
1937    {
1938      FT_Glyph  copy;
1939
1940
1941      error = FT_Glyph_Copy( glyph, &copy );
1942      if ( error )
1943        goto Exit;
1944
1945      glyph = copy;
1946    }
1947
1948    {
1949      FT_OutlineGlyph   oglyph  = (FT_OutlineGlyph) glyph;
1950      FT_StrokerBorder  border;
1951      FT_Outline*       outline = &oglyph->outline;
1952      FT_UInt           num_points, num_contours;
1953
1954
1955      border = FT_Outline_GetOutsideBorder( outline );
1956      if ( inside )
1957      {
1958        if ( border == FT_STROKER_BORDER_LEFT )
1959          border = FT_STROKER_BORDER_RIGHT;
1960        else
1961          border = FT_STROKER_BORDER_LEFT;
1962      }
1963
1964      error = FT_Stroker_ParseOutline( stroker, outline, 0 );
1965      if ( error )
1966        goto Fail;
1967
1968      (void)FT_Stroker_GetBorderCounts( stroker, border,
1969                                        &num_points, &num_contours );
1970
1971      FT_Outline_Done( glyph->library, outline );
1972
1973      error = FT_Outline_New( glyph->library,
1974                              num_points,
1975                              num_contours,
1976                              outline );
1977      if ( error )
1978        goto Fail;
1979
1980      outline->n_points   = 0;
1981      outline->n_contours = 0;
1982
1983      FT_Stroker_ExportBorder( stroker, border, outline );
1984    }
1985
1986    if ( destroy )
1987      FT_Done_Glyph( *pglyph );
1988
1989    *pglyph = glyph;
1990    goto Exit;
1991
1992  Fail:
1993    FT_Done_Glyph( glyph );
1994    glyph = NULL;
1995
1996    if ( !destroy )
1997      *pglyph = NULL;
1998
1999  Exit:
2000    return error;
2001  }
2002
2003
2004/* END */
Note: See TracBrowser for help on using the repository browser.