PageRenderTime 39ms CodeModel.GetById 2ms app.highlight 33ms RepoModel.GetById 1ms app.codeStats 0ms

/src/freetype/src/autofit/afwarp.c

https://bitbucket.org/cabalistic/ogredeps/
C | 374 lines | 245 code | 78 blank | 51 comment | 36 complexity | b7fdee273f13d4718a8e3978232f43d7 MD5 | raw file
  1/***************************************************************************/
  2/*                                                                         */
  3/*  afwarp.c                                                               */
  4/*                                                                         */
  5/*    Auto-fitter warping algorithm (body).                                */
  6/*                                                                         */
  7/*  Copyright 2006, 2007, 2011 by                                          */
  8/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
  9/*                                                                         */
 10/*  This file is part of the FreeType project, and may only be used,       */
 11/*  modified, and distributed under the terms of the FreeType project      */
 12/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
 13/*  this file you indicate that you have read the license and              */
 14/*  understand and accept it fully.                                        */
 15/*                                                                         */
 16/***************************************************************************/
 17
 18
 19  /*
 20   *  The idea of the warping code is to slightly scale and shift a glyph
 21   *  within a single dimension so that as much of its segments are aligned
 22   *  (more or less) on the grid.  To find out the optimal scaling and
 23   *  shifting value, various parameter combinations are tried and scored.
 24   */
 25
 26#include "afwarp.h"
 27
 28#ifdef AF_CONFIG_OPTION_USE_WARPER
 29
 30  /*************************************************************************/
 31  /*                                                                       */
 32  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
 33  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
 34  /* messages during execution.                                            */
 35  /*                                                                       */
 36#undef  FT_COMPONENT
 37#define FT_COMPONENT  trace_afwarp
 38
 39
 40  /* The weights cover the range 0/64 - 63/64 of a pixel.  Obviously, */
 41  /* values around a half pixel (which means exactly between two grid */
 42  /* lines) gets the worst weight.                                    */
 43#if 1
 44  static const AF_WarpScore
 45  af_warper_weights[64] =
 46  {
 47    35, 32, 30, 25, 20, 15, 12, 10,  5,  1,  0,  0,  0,  0,  0,  0,
 48     0,  0,  0,  0,  0,  0, -1, -2, -5, -8,-10,-10,-20,-20,-30,-30,
 49
 50   -30,-30,-20,-20,-10,-10, -8, -5, -2, -1,  0,  0,  0,  0,  0,  0,
 51     0,  0,  0,  0,  0,  0,  0,  1,  5, 10, 12, 15, 20, 25, 30, 32,
 52  };
 53#else
 54  static const AF_WarpScore
 55  af_warper_weights[64] =
 56  {
 57    30, 20, 10,  5,  4,  4,  3,  2,  1,  0,  0,  0,  0,  0,  0,  0,
 58     0,  0,  0,  0,  0,  0,  0, -1, -2, -2, -5, -5,-10,-10,-15,-20,
 59
 60   -20,-15,-15,-10,-10, -5, -5, -2, -2, -1,  0,  0,  0,  0,  0,  0,
 61     0,  0,  0,  0,  0,  0,  0,  0,  1,  2,  3,  4,  4,  5, 10, 20,
 62  };
 63#endif
 64
 65
 66  /* Score segments for a given `scale' and `delta' in the range */
 67  /* `xx1' to `xx2', and store the best result in `warper'.  If  */
 68  /* the new best score is equal to the old one, prefer the      */
 69  /* value with a smaller distortion (around `base_distort').    */
 70
 71  static void
 72  af_warper_compute_line_best( AF_Warper     warper,
 73                               FT_Fixed      scale,
 74                               FT_Pos        delta,
 75                               FT_Pos        xx1,
 76                               FT_Pos        xx2,
 77                               AF_WarpScore  base_distort,
 78                               AF_Segment    segments,
 79                               FT_UInt       num_segments )
 80  {
 81    FT_Int        idx_min, idx_max, idx0;
 82    FT_UInt       nn;
 83    AF_WarpScore  scores[65];
 84
 85
 86    for ( nn = 0; nn < 65; nn++ )
 87      scores[nn] = 0;
 88
 89    idx0 = xx1 - warper->t1;
 90
 91    /* compute minimum and maximum indices */
 92    {
 93      FT_Pos  xx1min = warper->x1min;
 94      FT_Pos  xx1max = warper->x1max;
 95      FT_Pos  w      = xx2 - xx1;
 96
 97
 98      if ( xx1min + w < warper->x2min )
 99        xx1min = warper->x2min - w;
100
101      xx1max = warper->x1max;
102      if ( xx1max + w > warper->x2max )
103        xx1max = warper->x2max - w;
104
105      idx_min = xx1min - warper->t1;
106      idx_max = xx1max - warper->t1;
107
108      if ( idx_min < 0 || idx_min > idx_max || idx_max > 64 )
109      {
110        FT_TRACE5(( "invalid indices:\n"
111                    "  min=%d max=%d, xx1=%ld xx2=%ld,\n"
112                    "  x1min=%ld x1max=%ld, x2min=%ld x2max=%ld\n",
113                    idx_min, idx_max, xx1, xx2,
114                    warper->x1min, warper->x1max,
115                    warper->x2min, warper->x2max ));
116        return;
117      }
118    }
119
120    for ( nn = 0; nn < num_segments; nn++ )
121    {
122      FT_Pos  len = segments[nn].max_coord - segments[nn].min_coord;
123      FT_Pos  y0  = FT_MulFix( segments[nn].pos, scale ) + delta;
124      FT_Pos  y   = y0 + ( idx_min - idx0 );
125      FT_Int  idx;
126
127
128      /* score the length of the segments for the given range */
129      for ( idx = idx_min; idx <= idx_max; idx++, y++ )
130        scores[idx] += af_warper_weights[y & 63] * len;
131    }
132
133    /* find best score */
134    {
135      FT_Int  idx;
136
137
138      for ( idx = idx_min; idx <= idx_max; idx++ )
139      {
140        AF_WarpScore  score = scores[idx];
141        AF_WarpScore  distort = base_distort + ( idx - idx0 );
142
143
144        if ( score > warper->best_score         ||
145             ( score == warper->best_score    &&
146               distort < warper->best_distort ) )
147        {
148          warper->best_score   = score;
149          warper->best_distort = distort;
150          warper->best_scale   = scale;
151          warper->best_delta   = delta + ( idx - idx0 );
152        }
153      }
154    }
155  }
156
157
158  /* Compute optimal scaling and delta values for a given glyph and */
159  /* dimension.                                                     */
160
161  FT_LOCAL_DEF( void )
162  af_warper_compute( AF_Warper      warper,
163                     AF_GlyphHints  hints,
164                     AF_Dimension   dim,
165                     FT_Fixed      *a_scale,
166                     FT_Pos        *a_delta )
167  {
168    AF_AxisHints  axis;
169    AF_Point      points;
170
171    FT_Fixed      org_scale;
172    FT_Pos        org_delta;
173
174    FT_UInt       nn, num_points, num_segments;
175    FT_Int        X1, X2;
176    FT_Int        w;
177
178    AF_WarpScore  base_distort;
179    AF_Segment    segments;
180
181
182    /* get original scaling transformation */
183    if ( dim == AF_DIMENSION_VERT )
184    {
185      org_scale = hints->y_scale;
186      org_delta = hints->y_delta;
187    }
188    else
189    {
190      org_scale = hints->x_scale;
191      org_delta = hints->x_delta;
192    }
193
194    warper->best_scale   = org_scale;
195    warper->best_delta   = org_delta;
196    warper->best_score   = INT_MIN;
197    warper->best_distort = 0;
198
199    axis         = &hints->axis[dim];
200    segments     = axis->segments;
201    num_segments = axis->num_segments;
202    points       = hints->points;
203    num_points   = hints->num_points;
204
205    *a_scale = org_scale;
206    *a_delta = org_delta;
207
208    /* get X1 and X2, minimum and maximum in original coordinates */
209    if ( num_segments < 1 )
210      return;
211
212#if 1
213    X1 = X2 = points[0].fx;
214    for ( nn = 1; nn < num_points; nn++ )
215    {
216      FT_Int  X = points[nn].fx;
217
218
219      if ( X < X1 )
220        X1 = X;
221      if ( X > X2 )
222        X2 = X;
223    }
224#else
225    X1 = X2 = segments[0].pos;
226    for ( nn = 1; nn < num_segments; nn++ )
227    {
228      FT_Int  X = segments[nn].pos;
229
230
231      if ( X < X1 )
232        X1 = X;
233      if ( X > X2 )
234        X2 = X;
235    }
236#endif
237
238    if ( X1 >= X2 )
239      return;
240
241    warper->x1 = FT_MulFix( X1, org_scale ) + org_delta;
242    warper->x2 = FT_MulFix( X2, org_scale ) + org_delta;
243
244    warper->t1 = AF_WARPER_FLOOR( warper->x1 );
245    warper->t2 = AF_WARPER_CEIL( warper->x2 );
246
247    /* examine a half pixel wide range around the maximum coordinates */
248    warper->x1min = warper->x1 & ~31;
249    warper->x1max = warper->x1min + 32;
250    warper->x2min = warper->x2 & ~31;
251    warper->x2max = warper->x2min + 32;
252
253    if ( warper->x1max > warper->x2 )
254      warper->x1max = warper->x2;
255
256    if ( warper->x2min < warper->x1 )
257      warper->x2min = warper->x1;
258
259    warper->w0 = warper->x2 - warper->x1;
260
261    if ( warper->w0 <= 64 )
262    {
263      warper->x1max = warper->x1;
264      warper->x2min = warper->x2;
265    }
266
267    /* examine (at most) a pixel wide range around the natural width */
268    warper->wmin = warper->x2min - warper->x1max;
269    warper->wmax = warper->x2max - warper->x1min;
270
271#if 1
272    /* some heuristics to reduce the number of widths to be examined */
273    {
274      int  margin = 16;
275
276
277      if ( warper->w0 <= 128 )
278      {
279         margin = 8;
280         if ( warper->w0 <= 96 )
281           margin = 4;
282      }
283
284      if ( warper->wmin < warper->w0 - margin )
285        warper->wmin = warper->w0 - margin;
286
287      if ( warper->wmax > warper->w0 + margin )
288        warper->wmax = warper->w0 + margin;
289    }
290
291    if ( warper->wmin < warper->w0 * 3 / 4 )
292      warper->wmin = warper->w0 * 3 / 4;
293
294    if ( warper->wmax > warper->w0 * 5 / 4 )
295      warper->wmax = warper->w0 * 5 / 4;
296#else
297    /* no scaling, just translation */
298    warper->wmin = warper->wmax = warper->w0;
299#endif
300
301    for ( w = warper->wmin; w <= warper->wmax; w++ )
302    {
303      FT_Fixed  new_scale;
304      FT_Pos    new_delta;
305      FT_Pos    xx1, xx2;
306
307
308      /* compute min and max positions for given width,       */
309      /* assuring that they stay within the coordinate ranges */
310      xx1 = warper->x1;
311      xx2 = warper->x2;
312      if ( w >= warper->w0 )
313      {
314        xx1 -= w - warper->w0;
315        if ( xx1 < warper->x1min )
316        {
317          xx2 += warper->x1min - xx1;
318          xx1  = warper->x1min;
319        }
320      }
321      else
322      {
323        xx1 -= w - warper->w0;
324        if ( xx1 > warper->x1max )
325        {
326          xx2 -= xx1 - warper->x1max;
327          xx1  = warper->x1max;
328        }
329      }
330
331      if ( xx1 < warper->x1 )
332        base_distort = warper->x1 - xx1;
333      else
334        base_distort = xx1 - warper->x1;
335
336      if ( xx2 < warper->x2 )
337        base_distort += warper->x2 - xx2;
338      else
339        base_distort += xx2 - warper->x2;
340
341      /* give base distortion a greater weight while scoring */
342      base_distort *= 10;
343
344      new_scale = org_scale + FT_DivFix( w - warper->w0, X2 - X1 );
345      new_delta = xx1 - FT_MulFix( X1, new_scale );
346
347      af_warper_compute_line_best( warper, new_scale, new_delta, xx1, xx2,
348                                   base_distort,
349                                   segments, num_segments );
350    }
351
352    {
353      FT_Fixed  best_scale = warper->best_scale;
354      FT_Pos    best_delta = warper->best_delta;
355
356
357      hints->xmin_delta = FT_MulFix( X1, best_scale - org_scale )
358                          + best_delta;
359      hints->xmax_delta = FT_MulFix( X2, best_scale - org_scale )
360                          + best_delta;
361
362      *a_scale = best_scale;
363      *a_delta = best_delta;
364    }
365  }
366
367#else /* !AF_CONFIG_OPTION_USE_WARPER */
368
369  /* ANSI C doesn't like empty source files */
370  typedef int  _af_warp_dummy;
371
372#endif /* !AF_CONFIG_OPTION_USE_WARPER */
373
374/* END */