/src/freetype/src/autofit/afwarp.c
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 */