source: trunk/poppler/freetype2/src/autofit/afhints.c @ 209

Last change on this file since 209 was 209, checked in by Eugene Romanenko, 14 years ago

PDF plugin: freetype library updated to version 2.3.5

File size: 30.5 KB
Line 
1/***************************************************************************/
2/*                                                                         */
3/*  afhints.c                                                              */
4/*                                                                         */
5/*    Auto-fitter hinting routines (body).                                 */
6/*                                                                         */
7/*  Copyright 2003, 2004, 2005, 2006, 2007 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 "afhints.h"
20#include "aferrors.h"
21#include FT_INTERNAL_CALC_H
22
23
24  FT_LOCAL_DEF( FT_Error )
25  af_axis_hints_new_segment( AF_AxisHints  axis,
26                             FT_Memory     memory,
27                             AF_Segment   *asegment )
28  {
29    FT_Error    error   = AF_Err_Ok;
30    AF_Segment  segment = NULL;
31
32
33    if ( axis->num_segments >= axis->max_segments )
34    {
35      FT_Int  old_max = axis->max_segments;
36      FT_Int  new_max = old_max;
37      FT_Int  big_max = FT_INT_MAX / sizeof ( *segment );
38
39
40      if ( old_max >= big_max )
41      {
42        error = AF_Err_Out_Of_Memory;
43        goto Exit;
44      }
45
46      new_max += ( new_max >> 2 ) + 4;
47      if ( new_max < old_max || new_max > big_max )
48        new_max = big_max;
49
50      if ( FT_RENEW_ARRAY( axis->segments, old_max, new_max ) )
51        goto Exit;
52
53      axis->max_segments = new_max;
54    }
55
56    segment = axis->segments + axis->num_segments++;
57
58  Exit:
59    *asegment = segment;
60    return error;
61  }
62
63
64  FT_LOCAL( FT_Error )
65  af_axis_hints_new_edge( AF_AxisHints  axis,
66                          FT_Int        fpos,
67                          AF_Direction  dir,
68                          FT_Memory     memory,
69                          AF_Edge      *aedge )
70  {
71    FT_Error  error = AF_Err_Ok;
72    AF_Edge   edge  = NULL;
73    AF_Edge   edges;
74
75
76    if ( axis->num_edges >= axis->max_edges )
77    {
78      FT_Int  old_max = axis->max_edges;
79      FT_Int  new_max = old_max;
80      FT_Int  big_max = FT_INT_MAX / sizeof ( *edge );
81
82
83      if ( old_max >= big_max )
84      {
85        error = AF_Err_Out_Of_Memory;
86        goto Exit;
87      }
88
89      new_max += ( new_max >> 2 ) + 4;
90      if ( new_max < old_max || new_max > big_max )
91        new_max = big_max;
92
93      if ( FT_RENEW_ARRAY( axis->edges, old_max, new_max ) )
94        goto Exit;
95
96      axis->max_edges = new_max;
97    }
98
99    edges = axis->edges;
100    edge  = edges + axis->num_edges;
101
102    while ( edge > edges )
103    {
104      if ( edge[-1].fpos < fpos )
105        break;
106
107      /* we want the edge with same position and minor direction */
108      /* to appear before those in the major one in the list     */
109      if ( edge[-1].fpos == fpos && dir == axis->major_dir )
110        break;
111
112      edge[0] = edge[-1];
113      edge--;
114    }
115
116    axis->num_edges++;
117
118    FT_ZERO( edge );
119    edge->fpos = (FT_Short)fpos;
120    edge->dir  = (FT_Char)dir;
121
122  Exit:
123    *aedge = edge;
124    return error;
125  }
126
127
128#ifdef AF_DEBUG
129
130#include <stdio.h>
131
132  static const char*
133  af_dir_str( AF_Direction  dir )
134  {
135    const char*  result;
136
137
138    switch ( dir )
139    {
140    case AF_DIR_UP:
141      result = "up";
142      break;
143    case AF_DIR_DOWN:
144      result = "down";
145      break;
146    case AF_DIR_LEFT:
147      result = "left";
148      break;
149    case AF_DIR_RIGHT:
150      result = "right";
151      break;
152    default:
153      result = "none";
154    }
155
156    return result;
157  }
158
159
160#define AF_INDEX_NUM( ptr, base )  ( (ptr) ? ( (ptr) - (base) ) : -1 )
161
162
163  void
164  af_glyph_hints_dump_points( AF_GlyphHints  hints )
165  {
166    AF_Point  points = hints->points;
167    AF_Point  limit  = points + hints->num_points;
168    AF_Point  point;
169
170
171    printf( "Table of points:\n" );
172    printf(   "  [ index |  xorg |  yorg |  xscale |  yscale "
173              "|  xfit  |  yfit  |  flags ]\n" );
174
175    for ( point = points; point < limit; point++ )
176    {
177      printf( "  [ %5d | %5d | %5d | %-5.2f | %-5.2f "
178              "| %-5.2f | %-5.2f | %c%c%c%c%c%c ]\n",
179              point - points,
180              point->fx,
181              point->fy,
182              point->ox/64.0,
183              point->oy/64.0,
184              point->x/64.0,
185              point->y/64.0,
186              ( point->flags & AF_FLAG_WEAK_INTERPOLATION ) ? 'w' : ' ',
187              ( point->flags & AF_FLAG_INFLECTION )         ? 'i' : ' ',
188              ( point->flags & AF_FLAG_EXTREMA_X )          ? '<' : ' ',
189              ( point->flags & AF_FLAG_EXTREMA_Y )          ? 'v' : ' ',
190              ( point->flags & AF_FLAG_ROUND_X )            ? '(' : ' ',
191              ( point->flags & AF_FLAG_ROUND_Y )            ? 'u' : ' ');
192    }
193    printf( "\n" );
194  }
195
196
197  static const char*
198  af_edge_flags_to_string( AF_Edge_Flags  flags )
199  {
200    static char  temp[32];
201    int          pos = 0;
202
203
204    if ( flags & AF_EDGE_ROUND )
205    {
206      memcpy( temp + pos, "round", 5 );
207      pos += 5;
208    }
209    if ( flags & AF_EDGE_SERIF )
210    {
211      if ( pos > 0 )
212        temp[pos++] = ' ';
213      memcpy( temp + pos, "serif", 5 );
214      pos += 5;
215    }
216    if ( pos == 0 )
217      return "normal";
218
219    temp[pos] = 0;
220
221    return temp;
222  }
223
224
225  /* A function to dump the array of linked segments. */
226  void
227  af_glyph_hints_dump_segments( AF_GlyphHints  hints )
228  {
229    FT_Int  dimension;
230
231
232    for ( dimension = 1; dimension >= 0; dimension-- )
233    {
234      AF_AxisHints  axis     = &hints->axis[dimension];
235      AF_Segment    segments = axis->segments;
236      AF_Segment    limit    = segments + axis->num_segments;
237      AF_Segment    seg;
238
239
240      printf ( "Table of %s segments:\n",
241               dimension == AF_DIMENSION_HORZ ? "vertical" : "horizontal" );
242      printf ( "  [ index |  pos  |  dir  | link | serif |"
243               " height  | extra | flags    ]\n" );
244
245      for ( seg = segments; seg < limit; seg++ )
246      {
247        printf ( "  [ %5d | %5.2g | %5s | %4d | %5d | %5d | %5d | %s ]\n",
248                 seg - segments,
249                 dimension == AF_DIMENSION_HORZ ? (int)seg->first->ox / 64.0
250                                                : (int)seg->first->oy / 64.0,
251                 af_dir_str( (AF_Direction)seg->dir ),
252                 AF_INDEX_NUM( seg->link, segments ),
253                 AF_INDEX_NUM( seg->serif, segments ),
254                 seg->height,
255                 seg->height - ( seg->max_coord - seg->min_coord ),
256                 af_edge_flags_to_string( seg->flags ) );
257      }
258      printf( "\n" );
259    }
260  }
261
262
263  void
264  af_glyph_hints_dump_edges( AF_GlyphHints  hints )
265  {
266    FT_Int  dimension;
267
268
269    for ( dimension = 1; dimension >= 0; dimension-- )
270    {
271      AF_AxisHints  axis  = &hints->axis[dimension];
272      AF_Edge       edges = axis->edges;
273      AF_Edge       limit = edges + axis->num_edges;
274      AF_Edge       edge;
275
276
277      /*
278       *  note: AF_DIMENSION_HORZ corresponds to _vertical_ edges
279       *        since they have constant a X coordinate.
280       */
281      printf ( "Table of %s edges:\n",
282               dimension == AF_DIMENSION_HORZ ? "vertical" : "horizontal" );
283      printf ( "  [ index |  pos  |  dir  | link |"
284               " serif | blue | opos  |  pos  | flags   ]\n" );
285
286      for ( edge = edges; edge < limit; edge++ )
287      {
288        printf ( "  [ %5d | %5.2g | %5s | %4d |"
289                 " %5d |   %c  | %5.2f | %5.2f | %s ]\n",
290                 edge - edges,
291                 (int)edge->opos / 64.0,
292                 af_dir_str( (AF_Direction)edge->dir ),
293                 AF_INDEX_NUM( edge->link, edges ),
294                 AF_INDEX_NUM( edge->serif, edges ),
295                 edge->blue_edge ? 'y' : 'n',
296                 edge->opos / 64.0,
297                 edge->pos / 64.0,
298                 af_edge_flags_to_string( edge->flags ) );
299      }
300      printf( "\n" );
301    }
302  }
303
304#else /* !AF_DEBUG */
305
306  /* these empty stubs are only used to link the `ftgrid' test program */
307  /* when debugging is disabled                                        */
308
309  void
310  af_glyph_hints_dump_points( AF_GlyphHints  hints )
311  {
312    FT_UNUSED( hints );
313  }
314
315
316  void
317  af_glyph_hints_dump_segments( AF_GlyphHints  hints )
318  {
319    FT_UNUSED( hints );
320  }
321
322
323  void
324  af_glyph_hints_dump_edges( AF_GlyphHints  hints )
325  {
326    FT_UNUSED( hints );
327  }
328
329#endif /* !AF_DEBUG */
330
331
332  /* compute the direction value of a given vector */
333  FT_LOCAL_DEF( AF_Direction )
334  af_direction_compute( FT_Pos  dx,
335                        FT_Pos  dy )
336  {
337    FT_Pos        ll, ss;  /* long and short arm lengths */
338    AF_Direction  dir;     /* candidate direction        */
339
340
341    if ( dy >= dx )
342    {
343      if ( dy >= -dx )
344      {
345        dir = AF_DIR_UP;
346        ll  = dy;
347        ss  = dx;
348      }
349      else
350      {
351        dir = AF_DIR_LEFT;
352        ll  = -dx;
353        ss  = dy;
354      }
355    }
356    else /* dy < dx */
357    {
358      if ( dy >= -dx )
359      {
360        dir = AF_DIR_RIGHT;
361        ll  = dx;
362        ss  = dy;
363      }
364      else
365      {
366        dir = AF_DIR_DOWN;
367        ll  = dy;
368        ss  = dx;
369      }
370    }
371
372    ss *= 14;
373    if ( FT_ABS( ll ) <= FT_ABS( ss ) )
374      dir = AF_DIR_NONE;
375
376    return dir;
377  }
378
379
380  /* compute all inflex points in a given glyph */
381
382  static void
383  af_glyph_hints_compute_inflections( AF_GlyphHints  hints )
384  {
385    AF_Point*  contour       = hints->contours;
386    AF_Point*  contour_limit = contour + hints->num_contours;
387
388
389    /* do each contour separately */
390    for ( ; contour < contour_limit; contour++ )
391    {
392      AF_Point  point = contour[0];
393      AF_Point  first = point;
394      AF_Point  start = point;
395      AF_Point  end   = point;
396      AF_Point  before;
397      AF_Point  after;
398      FT_Pos    in_x, in_y, out_x, out_y;
399      AF_Angle  orient_prev, orient_cur;
400      FT_Int    finished = 0;
401
402
403      /* compute first segment in contour */
404      first = point;
405
406      start = end = first;
407      do
408      {
409        end = end->next;
410        if ( end == first )
411          goto Skip;
412
413        in_x = end->fx - start->fx;
414        in_y = end->fy - start->fy;
415
416      } while ( in_x == 0 && in_y == 0 );
417
418      /* extend the segment start whenever possible */
419      before = start;
420      do
421      {
422        do
423        {
424          start  = before;
425          before = before->prev;
426          if ( before == first )
427            goto Skip;
428
429          out_x = start->fx - before->fx;
430          out_y = start->fy - before->fy;
431
432        } while ( out_x == 0 && out_y == 0 );
433
434        orient_prev = ft_corner_orientation( in_x, in_y, out_x, out_y );
435
436      } while ( orient_prev == 0 );
437
438      first = start;
439
440      in_x = out_x;
441      in_y = out_y;
442
443      /* now process all segments in the contour */
444      do
445      {
446        /* first, extend current segment's end whenever possible */
447        after = end;
448        do
449        {
450          do
451          {
452            end   = after;
453            after = after->next;
454            if ( after == first )
455              finished = 1;
456
457            out_x = after->fx - end->fx;
458            out_y = after->fy - end->fy;
459
460          } while ( out_x == 0 && out_y == 0 );
461
462          orient_cur = ft_corner_orientation( in_x, in_y, out_x, out_y );
463
464        } while ( orient_cur == 0 );
465
466        if ( ( orient_prev + orient_cur ) == 0 )
467        {
468          /* we have an inflection point here */
469          do
470          {
471            start->flags |= AF_FLAG_INFLECTION;
472            start = start->next;
473
474          } while ( start != end );
475
476          start->flags |= AF_FLAG_INFLECTION;
477        }
478
479        start = end;
480        end   = after;
481
482        orient_prev = orient_cur;
483        in_x        = out_x;
484        in_y        = out_y;
485
486      } while ( !finished );
487
488    Skip:
489      ;
490    }
491  }
492
493
494  FT_LOCAL_DEF( void )
495  af_glyph_hints_init( AF_GlyphHints  hints,
496                       FT_Memory      memory )
497  {
498    FT_ZERO( hints );
499    hints->memory = memory;
500  }
501
502
503  FT_LOCAL_DEF( void )
504  af_glyph_hints_done( AF_GlyphHints  hints )
505  {
506    if ( hints && hints->memory )
507    {
508      FT_Memory  memory = hints->memory;
509      int        dim;
510
511
512      /*
513       *  note that we don't need to free the segment and edge
514       *  buffers, since they are really within the hints->points array
515       */
516      for ( dim = 0; dim < AF_DIMENSION_MAX; dim++ )
517      {
518        AF_AxisHints  axis = &hints->axis[dim];
519
520
521        axis->num_segments = 0;
522        axis->max_segments = 0;
523        FT_FREE( axis->segments );
524
525        axis->num_edges    = 0;
526        axis->max_edges    = 0;
527        FT_FREE( axis->edges );
528      }
529
530      FT_FREE( hints->contours );
531      hints->max_contours = 0;
532      hints->num_contours = 0;
533
534      FT_FREE( hints->points );
535      hints->num_points = 0;
536      hints->max_points = 0;
537
538      hints->memory = NULL;
539    }
540  }
541
542
543  FT_LOCAL_DEF( void )
544  af_glyph_hints_rescale( AF_GlyphHints     hints,
545                          AF_ScriptMetrics  metrics )
546  {
547    hints->metrics      = metrics;
548    hints->scaler_flags = metrics->scaler.flags;
549  }
550
551
552  FT_LOCAL_DEF( FT_Error )
553  af_glyph_hints_reload( AF_GlyphHints  hints,
554                         FT_Outline*    outline,
555                         FT_Bool        get_inflections )
556  {
557    FT_Error   error   = AF_Err_Ok;
558    AF_Point   points;
559    FT_UInt    old_max, new_max;
560    FT_Fixed   x_scale = hints->x_scale;
561    FT_Fixed   y_scale = hints->y_scale;
562    FT_Pos     x_delta = hints->x_delta;
563    FT_Pos     y_delta = hints->y_delta;
564    FT_Memory  memory  = hints->memory;
565
566
567    hints->num_points   = 0;
568    hints->num_contours = 0;
569
570    hints->axis[0].num_segments = 0;
571    hints->axis[0].num_edges    = 0;
572    hints->axis[1].num_segments = 0;
573    hints->axis[1].num_edges    = 0;
574
575    /* first of all, reallocate the contours array when necessary */
576    new_max = (FT_UInt)outline->n_contours;
577    old_max = hints->max_contours;
578    if ( new_max > old_max )
579    {
580      new_max = ( new_max + 3 ) & ~3;
581
582      if ( FT_RENEW_ARRAY( hints->contours, old_max, new_max ) )
583        goto Exit;
584
585      hints->max_contours = new_max;
586    }
587
588    /*
589     *  then reallocate the points arrays if necessary --
590     *  note that we reserve two additional point positions, used to
591     *  hint metrics appropriately
592     */
593    new_max = (FT_UInt)( outline->n_points + 2 );
594    old_max = hints->max_points;
595    if ( new_max > old_max )
596    {
597      new_max = ( new_max + 2 + 7 ) & ~7;
598
599      if ( FT_RENEW_ARRAY( hints->points, old_max, new_max ) )
600        goto Exit;
601
602      hints->max_points = new_max;
603    }
604
605    hints->num_points   = outline->n_points;
606    hints->num_contours = outline->n_contours;
607
608    /* We can't rely on the value of `FT_Outline.flags' to know the fill   */
609    /* direction used for a glyph, given that some fonts are broken (e.g., */
610    /* the Arphic ones).  We thus recompute it each time we need to.       */
611    /*                                                                     */
612    hints->axis[AF_DIMENSION_HORZ].major_dir = AF_DIR_UP;
613    hints->axis[AF_DIMENSION_VERT].major_dir = AF_DIR_LEFT;
614
615    if ( FT_Outline_Get_Orientation( outline ) == FT_ORIENTATION_POSTSCRIPT )
616    {
617      hints->axis[AF_DIMENSION_HORZ].major_dir = AF_DIR_DOWN;
618      hints->axis[AF_DIMENSION_VERT].major_dir = AF_DIR_RIGHT;
619    }
620
621    hints->x_scale = x_scale;
622    hints->y_scale = y_scale;
623    hints->x_delta = x_delta;
624    hints->y_delta = y_delta;
625
626    hints->xmin_delta = 0;
627    hints->xmax_delta = 0;
628
629    points = hints->points;
630    if ( hints->num_points == 0 )
631      goto Exit;
632
633    {
634      AF_Point  point;
635      AF_Point  point_limit = points + hints->num_points;
636
637
638      /* compute coordinates & Bezier flags, next and prev */
639      {
640        FT_Vector*  vec           = outline->points;
641        char*       tag           = outline->tags;
642        AF_Point    first         = points;
643        AF_Point    end           = points + outline->contours[0];
644        AF_Point    prev          = end;
645        FT_Int      contour_index = 0;
646
647
648        for ( point = points; point < point_limit; point++, vec++, tag++ )
649        {
650          point->fx = (FT_Short)vec->x;
651          point->fy = (FT_Short)vec->y;
652          point->ox = point->x = FT_MulFix( vec->x, x_scale ) + x_delta;
653          point->oy = point->y = FT_MulFix( vec->y, y_scale ) + y_delta;
654
655          switch ( FT_CURVE_TAG( *tag ) )
656          {
657          case FT_CURVE_TAG_CONIC:
658            point->flags = AF_FLAG_CONIC;
659            break;
660          case FT_CURVE_TAG_CUBIC:
661            point->flags = AF_FLAG_CUBIC;
662            break;
663          default:
664            point->flags = 0;
665          }
666
667          point->prev = prev;
668          prev->next  = point;
669          prev        = point;
670
671          if ( point == end )
672          {
673            if ( ++contour_index < outline->n_contours )
674            {
675              first = point + 1;
676              end   = points + outline->contours[contour_index];
677              prev  = end;
678            }
679          }
680        }
681      }
682
683      /* set-up the contours array */
684      {
685        AF_Point*  contour       = hints->contours;
686        AF_Point*  contour_limit = contour + hints->num_contours;
687        short*     end           = outline->contours;
688        short      idx           = 0;
689
690
691        for ( ; contour < contour_limit; contour++, end++ )
692        {
693          contour[0] = points + idx;
694          idx        = (short)( end[0] + 1 );
695        }
696      }
697
698      /* compute directions of in & out vectors */
699      {
700        AF_Point      first  = points;
701        AF_Point      prev   = NULL;
702        FT_Pos        in_x   = 0;
703        FT_Pos        in_y   = 0;
704        AF_Direction  in_dir = AF_DIR_NONE;
705
706
707        for ( point = points; point < point_limit; point++ )
708        {
709          AF_Point  next;
710          FT_Pos    out_x, out_y;
711
712
713          if ( point == first )
714          {
715            prev   = first->prev;
716            in_x   = first->fx - prev->fx;
717            in_y   = first->fy - prev->fy;
718            in_dir = af_direction_compute( in_x, in_y );
719            first  = prev + 1;
720          }
721
722          point->in_dir = (FT_Char)in_dir;
723
724          next  = point->next;
725          out_x = next->fx - point->fx;
726          out_y = next->fy - point->fy;
727
728          in_dir         = af_direction_compute( out_x, out_y );
729          point->out_dir = (FT_Char)in_dir;
730
731          if ( point->flags & ( AF_FLAG_CONIC | AF_FLAG_CUBIC ) )
732          {
733          Is_Weak_Point:
734            point->flags |= AF_FLAG_WEAK_INTERPOLATION;
735          }
736          else if ( point->out_dir == point->in_dir )
737          {
738            if ( point->out_dir != AF_DIR_NONE )
739              goto Is_Weak_Point;
740
741            if ( ft_corner_is_flat( in_x, in_y, out_x, out_y ) )
742              goto Is_Weak_Point;
743          }
744          else if ( point->in_dir == -point->out_dir )
745            goto Is_Weak_Point;
746
747          in_x = out_x;
748          in_y = out_y;
749          prev = point;
750        }
751      }
752    }
753
754    /* compute inflection points --                 */
755    /* disabled due to no longer perceived benefits */
756    if ( 0 && get_inflections )
757      af_glyph_hints_compute_inflections( hints );
758
759  Exit:
760    return error;
761  }
762
763
764  FT_LOCAL_DEF( void )
765  af_glyph_hints_save( AF_GlyphHints  hints,
766                       FT_Outline*    outline )
767  {
768    AF_Point    point = hints->points;
769    AF_Point    limit = point + hints->num_points;
770    FT_Vector*  vec   = outline->points;
771    char*       tag   = outline->tags;
772
773
774    for ( ; point < limit; point++, vec++, tag++ )
775    {
776      vec->x = point->x;
777      vec->y = point->y;
778
779      if ( point->flags & AF_FLAG_CONIC )
780        tag[0] = FT_CURVE_TAG_CONIC;
781      else if ( point->flags & AF_FLAG_CUBIC )
782        tag[0] = FT_CURVE_TAG_CUBIC;
783      else
784        tag[0] = FT_CURVE_TAG_ON;
785    }
786  }
787
788
789  /****************************************************************
790   *
791   *                     EDGE POINT GRID-FITTING
792   *
793   ****************************************************************/
794
795
796  FT_LOCAL_DEF( void )
797  af_glyph_hints_align_edge_points( AF_GlyphHints  hints,
798                                    AF_Dimension   dim )
799  {
800    AF_AxisHints  axis          = & hints->axis[dim];
801    AF_Segment    segments      = axis->segments;
802    AF_Segment    segment_limit = segments + axis->num_segments;
803    AF_Segment    seg;
804
805
806    if ( dim == AF_DIMENSION_HORZ )
807    {
808      for ( seg = segments; seg < segment_limit; seg++ )
809      {
810        AF_Edge   edge = seg->edge;
811        AF_Point  point, first, last;
812
813
814        if ( edge == NULL )
815          continue;
816
817        first = seg->first;
818        last  = seg->last;
819        point = first;
820        for (;;)
821        {
822          point->x      = edge->pos;
823          point->flags |= AF_FLAG_TOUCH_X;
824
825          if ( point == last )
826            break;
827
828          point = point->next;
829
830        }
831      }
832    }
833    else
834    {
835      for ( seg = segments; seg < segment_limit; seg++ )
836      {
837        AF_Edge   edge = seg->edge;
838        AF_Point  point, first, last;
839
840
841        if ( edge == NULL )
842          continue;
843
844        first = seg->first;
845        last  = seg->last;
846        point = first;
847        for (;;)
848        {
849          point->y      = edge->pos;
850          point->flags |= AF_FLAG_TOUCH_Y;
851
852          if ( point == last )
853            break;
854
855          point = point->next;
856        }
857      }
858    }
859  }
860
861
862  /****************************************************************
863   *
864   *                    STRONG POINT INTERPOLATION
865   *
866   ****************************************************************/
867
868
869  /* hint the strong points -- this is equivalent to the TrueType `IP' */
870  /* hinting instruction                                               */
871
872  FT_LOCAL_DEF( void )
873  af_glyph_hints_align_strong_points( AF_GlyphHints  hints,
874                                      AF_Dimension   dim )
875  {
876    AF_Point      points      = hints->points;
877    AF_Point      point_limit = points + hints->num_points;
878    AF_AxisHints  axis        = &hints->axis[dim];
879    AF_Edge       edges       = axis->edges;
880    AF_Edge       edge_limit  = edges + axis->num_edges;
881    AF_Flags      touch_flag;
882
883
884    if ( dim == AF_DIMENSION_HORZ )
885      touch_flag = AF_FLAG_TOUCH_X;
886    else
887      touch_flag  = AF_FLAG_TOUCH_Y;
888
889    if ( edges < edge_limit )
890    {
891      AF_Point  point;
892      AF_Edge   edge;
893
894
895      for ( point = points; point < point_limit; point++ )
896      {
897        FT_Pos  u, ou, fu;  /* point position */
898        FT_Pos  delta;
899
900
901        if ( point->flags & touch_flag )
902          continue;
903
904        /* if this point is candidate to weak interpolation, we       */
905        /* interpolate it after all strong points have been processed */
906
907        if (  ( point->flags & AF_FLAG_WEAK_INTERPOLATION ) &&
908             !( point->flags & AF_FLAG_INFLECTION )         )
909          continue;
910
911        if ( dim == AF_DIMENSION_VERT )
912        {
913          u  = point->fy;
914          ou = point->oy;
915        }
916        else
917        {
918          u  = point->fx;
919          ou = point->ox;
920        }
921
922        fu = u;
923
924        /* is the point before the first edge? */
925        edge  = edges;
926        delta = edge->fpos - u;
927        if ( delta >= 0 )
928        {
929          u = edge->pos - ( edge->opos - ou );
930          goto Store_Point;
931        }
932
933        /* is the point after the last edge? */
934        edge  = edge_limit - 1;
935        delta = u - edge->fpos;
936        if ( delta >= 0 )
937        {
938          u = edge->pos + ( ou - edge->opos );
939          goto Store_Point;
940        }
941
942        {
943          FT_UInt  min, max, mid;
944          FT_Pos   fpos;
945
946
947          /* find enclosing edges */
948          min = 0;
949          max = edge_limit - edges;
950
951#if 1
952          /* for small edge counts, a linear search is better */
953          if ( max <= 8 )
954          {
955            FT_UInt  nn;
956
957            for ( nn = 0; nn < max; nn++ )
958              if ( edges[nn].fpos >= u )
959                break;
960
961            if ( edges[nn].fpos == u )
962            {
963              u = edges[nn].pos;
964              goto Store_Point;
965            }
966            min = nn;
967          }
968          else
969#endif
970          while ( min < max )
971          {
972            mid  = ( max + min ) >> 1;
973            edge = edges + mid;
974            fpos = edge->fpos;
975
976            if ( u < fpos )
977              max = mid;
978            else if ( u > fpos )
979              min = mid + 1;
980            else
981            {
982              /* we are on the edge */
983              u = edge->pos;
984              goto Store_Point;
985            }
986          }
987
988          {
989            AF_Edge  before = edges + min - 1;
990            AF_Edge  after  = edges + min + 0;
991
992
993            /* assert( before && after && before != after ) */
994            if ( before->scale == 0 )
995              before->scale = FT_DivFix( after->pos - before->pos,
996                                         after->fpos - before->fpos );
997
998            u = before->pos + FT_MulFix( fu - before->fpos,
999                                         before->scale );
1000          }
1001        }
1002
1003      Store_Point:
1004        /* save the point position */
1005        if ( dim == AF_DIMENSION_HORZ )
1006          point->x = u;
1007        else
1008          point->y = u;
1009
1010        point->flags |= touch_flag;
1011      }
1012    }
1013  }
1014
1015
1016  /****************************************************************
1017   *
1018   *                    WEAK POINT INTERPOLATION
1019   *
1020   ****************************************************************/
1021
1022
1023  static void
1024  af_iup_shift( AF_Point  p1,
1025                AF_Point  p2,
1026                AF_Point  ref )
1027  {
1028    AF_Point  p;
1029    FT_Pos    delta = ref->u - ref->v;
1030
1031    if ( delta == 0 )
1032      return;
1033
1034    for ( p = p1; p < ref; p++ )
1035      p->u = p->v + delta;
1036
1037    for ( p = ref + 1; p <= p2; p++ )
1038      p->u = p->v + delta;
1039  }
1040
1041
1042  static void
1043  af_iup_interp( AF_Point  p1,
1044                 AF_Point  p2,
1045                 AF_Point  ref1,
1046                 AF_Point  ref2 )
1047  {
1048    AF_Point  p;
1049    FT_Pos    u;
1050    FT_Pos    v1 = ref1->v;
1051    FT_Pos    v2 = ref2->v;
1052    FT_Pos    d1 = ref1->u - v1;
1053    FT_Pos    d2 = ref2->u - v2;
1054
1055
1056    if ( p1 > p2 )
1057      return;
1058
1059    if ( v1 == v2 )
1060    {
1061      for ( p = p1; p <= p2; p++ )
1062      {
1063        u = p->v;
1064
1065        if ( u <= v1 )
1066          u += d1;
1067        else
1068          u += d2;
1069
1070        p->u = u;
1071      }
1072      return;
1073    }
1074
1075    if ( v1 < v2 )
1076    {
1077      for ( p = p1; p <= p2; p++ )
1078      {
1079        u = p->v;
1080
1081        if ( u <= v1 )
1082          u += d1;
1083        else if ( u >= v2 )
1084          u += d2;
1085        else
1086          u = ref1->u + FT_MulDiv( u - v1, ref2->u - ref1->u, v2 - v1 );
1087
1088        p->u = u;
1089      }
1090    }
1091    else
1092    {
1093      for ( p = p1; p <= p2; p++ )
1094      {
1095        u = p->v;
1096
1097        if ( u <= v2 )
1098          u += d2;
1099        else if ( u >= v1 )
1100          u += d1;
1101        else
1102          u = ref1->u + FT_MulDiv( u - v1, ref2->u - ref1->u, v2 - v1 );
1103
1104        p->u = u;
1105      }
1106    }
1107  }
1108
1109
1110  FT_LOCAL_DEF( void )
1111  af_glyph_hints_align_weak_points( AF_GlyphHints  hints,
1112                                    AF_Dimension   dim )
1113  {
1114    AF_Point   points        = hints->points;
1115    AF_Point   point_limit   = points + hints->num_points;
1116    AF_Point*  contour       = hints->contours;
1117    AF_Point*  contour_limit = contour + hints->num_contours;
1118    AF_Flags   touch_flag;
1119    AF_Point   point;
1120    AF_Point   end_point;
1121    AF_Point   first_point;
1122
1123
1124    /* PASS 1: Move segment points to edge positions */
1125
1126    if ( dim == AF_DIMENSION_HORZ )
1127    {
1128      touch_flag = AF_FLAG_TOUCH_X;
1129
1130      for ( point = points; point < point_limit; point++ )
1131      {
1132        point->u = point->x;
1133        point->v = point->ox;
1134      }
1135    }
1136    else
1137    {
1138      touch_flag = AF_FLAG_TOUCH_Y;
1139
1140      for ( point = points; point < point_limit; point++ )
1141      {
1142        point->u = point->y;
1143        point->v = point->oy;
1144      }
1145    }
1146
1147    point = points;
1148
1149    for ( ; contour < contour_limit; contour++ )
1150    {
1151      AF_Point  first_touched, last_touched;
1152
1153
1154      point       = *contour;
1155      end_point   = point->prev;
1156      first_point = point;
1157
1158      /* find first touched point */
1159      for (;;)
1160      {
1161        if ( point > end_point )  /* no touched point in contour */
1162          goto NextContour;
1163
1164        if ( point->flags & touch_flag )
1165          break;
1166
1167        point++;
1168      }
1169
1170      first_touched = point;
1171      last_touched  = point;
1172
1173      for (;;)
1174      {
1175        FT_ASSERT( point <= end_point &&
1176                   ( point->flags & touch_flag ) != 0 );
1177
1178        /* skip any touched neighbhours */
1179        while ( point < end_point && ( point[1].flags & touch_flag ) != 0 )
1180          point++;
1181
1182        last_touched = point;
1183
1184        /* find the next touched point, if any */
1185        point ++;
1186        for (;;)
1187        {
1188          if ( point > end_point )
1189            goto EndContour;
1190
1191          if ( ( point->flags & touch_flag ) != 0 )
1192            break;
1193
1194          point++;
1195        }
1196
1197        /* interpolate between last_touched and point */
1198        af_iup_interp( last_touched + 1, point - 1,
1199                       last_touched, point );
1200      }
1201
1202    EndContour:
1203      /* special case: only one point was touched */
1204      if ( last_touched == first_touched )
1205      {
1206        af_iup_shift( first_point, end_point, first_touched );
1207      }
1208      else /* interpolate the last part */
1209      {
1210        if ( last_touched < end_point )
1211          af_iup_interp( last_touched + 1, end_point,
1212                         last_touched, first_touched );
1213
1214        if ( first_touched > points )
1215          af_iup_interp( first_point, first_touched - 1,
1216                         last_touched, first_touched );
1217      }
1218
1219    NextContour:
1220      ;
1221    }
1222
1223    /* now save the interpolated values back to x/y */
1224    if ( dim == AF_DIMENSION_HORZ )
1225    {
1226      for ( point = points; point < point_limit; point++ )
1227        point->x = point->u;
1228    }
1229    else
1230    {
1231      for ( point = points; point < point_limit; point++ )
1232        point->y = point->u;
1233    }
1234  }
1235
1236
1237#ifdef AF_USE_WARPER
1238
1239  FT_LOCAL_DEF( void )
1240  af_glyph_hints_scale_dim( AF_GlyphHints  hints,
1241                            AF_Dimension   dim,
1242                            FT_Fixed       scale,
1243                            FT_Pos         delta )
1244  {
1245    AF_Point  points       = hints->points;
1246    AF_Point  points_limit = points + hints->num_points;
1247    AF_Point  point;
1248
1249
1250    if ( dim == AF_DIMENSION_HORZ )
1251    {
1252      for ( point = points; point < points_limit; point++ )
1253        point->x = FT_MulFix( point->fx, scale ) + delta;
1254    }
1255    else
1256    {
1257      for ( point = points; point < points_limit; point++ )
1258        point->y = FT_MulFix( point->fy, scale ) + delta;
1259    }
1260  }
1261
1262#endif /* AF_USE_WARPER */
1263
1264/* END */
Note: See TracBrowser for help on using the repository browser.