/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. * The idea of the warping code is to slightly scale and shift a glyph
  19. * within a single dimension so that as much of its segments are aligned
  20. * (more or less) on the grid. To find out the optimal scaling and
  21. * shifting value, various parameter combinations are tried and scored.
  22. */
  23. #include "afwarp.h"
  24. #ifdef AF_CONFIG_OPTION_USE_WARPER
  25. /*************************************************************************/
  26. /* */
  27. /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
  28. /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
  29. /* messages during execution. */
  30. /* */
  31. #undef FT_COMPONENT
  32. #define FT_COMPONENT trace_afwarp
  33. /* The weights cover the range 0/64 - 63/64 of a pixel. Obviously, */
  34. /* values around a half pixel (which means exactly between two grid */
  35. /* lines) gets the worst weight. */
  36. #if 1
  37. static const AF_WarpScore
  38. af_warper_weights[64] =
  39. {
  40. 35, 32, 30, 25, 20, 15, 12, 10, 5, 1, 0, 0, 0, 0, 0, 0,
  41. 0, 0, 0, 0, 0, 0, -1, -2, -5, -8,-10,-10,-20,-20,-30,-30,
  42. -30,-30,-20,-20,-10,-10, -8, -5, -2, -1, 0, 0, 0, 0, 0, 0,
  43. 0, 0, 0, 0, 0, 0, 0, 1, 5, 10, 12, 15, 20, 25, 30, 32,
  44. };
  45. #else
  46. static const AF_WarpScore
  47. af_warper_weights[64] =
  48. {
  49. 30, 20, 10, 5, 4, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0,
  50. 0, 0, 0, 0, 0, 0, 0, -1, -2, -2, -5, -5,-10,-10,-15,-20,
  51. -20,-15,-15,-10,-10, -5, -5, -2, -2, -1, 0, 0, 0, 0, 0, 0,
  52. 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 4, 5, 10, 20,
  53. };
  54. #endif
  55. /* Score segments for a given `scale' and `delta' in the range */
  56. /* `xx1' to `xx2', and store the best result in `warper'. If */
  57. /* the new best score is equal to the old one, prefer the */
  58. /* value with a smaller distortion (around `base_distort'). */
  59. static void
  60. af_warper_compute_line_best( AF_Warper warper,
  61. FT_Fixed scale,
  62. FT_Pos delta,
  63. FT_Pos xx1,
  64. FT_Pos xx2,
  65. AF_WarpScore base_distort,
  66. AF_Segment segments,
  67. FT_UInt num_segments )
  68. {
  69. FT_Int idx_min, idx_max, idx0;
  70. FT_UInt nn;
  71. AF_WarpScore scores[65];
  72. for ( nn = 0; nn < 65; nn++ )
  73. scores[nn] = 0;
  74. idx0 = xx1 - warper->t1;
  75. /* compute minimum and maximum indices */
  76. {
  77. FT_Pos xx1min = warper->x1min;
  78. FT_Pos xx1max = warper->x1max;
  79. FT_Pos w = xx2 - xx1;
  80. if ( xx1min + w < warper->x2min )
  81. xx1min = warper->x2min - w;
  82. xx1max = warper->x1max;
  83. if ( xx1max + w > warper->x2max )
  84. xx1max = warper->x2max - w;
  85. idx_min = xx1min - warper->t1;
  86. idx_max = xx1max - warper->t1;
  87. if ( idx_min < 0 || idx_min > idx_max || idx_max > 64 )
  88. {
  89. FT_TRACE5(( "invalid indices:\n"
  90. " min=%d max=%d, xx1=%ld xx2=%ld,\n"
  91. " x1min=%ld x1max=%ld, x2min=%ld x2max=%ld\n",
  92. idx_min, idx_max, xx1, xx2,
  93. warper->x1min, warper->x1max,
  94. warper->x2min, warper->x2max ));
  95. return;
  96. }
  97. }
  98. for ( nn = 0; nn < num_segments; nn++ )
  99. {
  100. FT_Pos len = segments[nn].max_coord - segments[nn].min_coord;
  101. FT_Pos y0 = FT_MulFix( segments[nn].pos, scale ) + delta;
  102. FT_Pos y = y0 + ( idx_min - idx0 );
  103. FT_Int idx;
  104. /* score the length of the segments for the given range */
  105. for ( idx = idx_min; idx <= idx_max; idx++, y++ )
  106. scores[idx] += af_warper_weights[y & 63] * len;
  107. }
  108. /* find best score */
  109. {
  110. FT_Int idx;
  111. for ( idx = idx_min; idx <= idx_max; idx++ )
  112. {
  113. AF_WarpScore score = scores[idx];
  114. AF_WarpScore distort = base_distort + ( idx - idx0 );
  115. if ( score > warper->best_score ||
  116. ( score == warper->best_score &&
  117. distort < warper->best_distort ) )
  118. {
  119. warper->best_score = score;
  120. warper->best_distort = distort;
  121. warper->best_scale = scale;
  122. warper->best_delta = delta + ( idx - idx0 );
  123. }
  124. }
  125. }
  126. }
  127. /* Compute optimal scaling and delta values for a given glyph and */
  128. /* dimension. */
  129. FT_LOCAL_DEF( void )
  130. af_warper_compute( AF_Warper warper,
  131. AF_GlyphHints hints,
  132. AF_Dimension dim,
  133. FT_Fixed *a_scale,
  134. FT_Pos *a_delta )
  135. {
  136. AF_AxisHints axis;
  137. AF_Point points;
  138. FT_Fixed org_scale;
  139. FT_Pos org_delta;
  140. FT_UInt nn, num_points, num_segments;
  141. FT_Int X1, X2;
  142. FT_Int w;
  143. AF_WarpScore base_distort;
  144. AF_Segment segments;
  145. /* get original scaling transformation */
  146. if ( dim == AF_DIMENSION_VERT )
  147. {
  148. org_scale = hints->y_scale;
  149. org_delta = hints->y_delta;
  150. }
  151. else
  152. {
  153. org_scale = hints->x_scale;
  154. org_delta = hints->x_delta;
  155. }
  156. warper->best_scale = org_scale;
  157. warper->best_delta = org_delta;
  158. warper->best_score = INT_MIN;
  159. warper->best_distort = 0;
  160. axis = &hints->axis[dim];
  161. segments = axis->segments;
  162. num_segments = axis->num_segments;
  163. points = hints->points;
  164. num_points = hints->num_points;
  165. *a_scale = org_scale;
  166. *a_delta = org_delta;
  167. /* get X1 and X2, minimum and maximum in original coordinates */
  168. if ( num_segments < 1 )
  169. return;
  170. #if 1
  171. X1 = X2 = points[0].fx;
  172. for ( nn = 1; nn < num_points; nn++ )
  173. {
  174. FT_Int X = points[nn].fx;
  175. if ( X < X1 )
  176. X1 = X;
  177. if ( X > X2 )
  178. X2 = X;
  179. }
  180. #else
  181. X1 = X2 = segments[0].pos;
  182. for ( nn = 1; nn < num_segments; nn++ )
  183. {
  184. FT_Int X = segments[nn].pos;
  185. if ( X < X1 )
  186. X1 = X;
  187. if ( X > X2 )
  188. X2 = X;
  189. }
  190. #endif
  191. if ( X1 >= X2 )
  192. return;
  193. warper->x1 = FT_MulFix( X1, org_scale ) + org_delta;
  194. warper->x2 = FT_MulFix( X2, org_scale ) + org_delta;
  195. warper->t1 = AF_WARPER_FLOOR( warper->x1 );
  196. warper->t2 = AF_WARPER_CEIL( warper->x2 );
  197. /* examine a half pixel wide range around the maximum coordinates */
  198. warper->x1min = warper->x1 & ~31;
  199. warper->x1max = warper->x1min + 32;
  200. warper->x2min = warper->x2 & ~31;
  201. warper->x2max = warper->x2min + 32;
  202. if ( warper->x1max > warper->x2 )
  203. warper->x1max = warper->x2;
  204. if ( warper->x2min < warper->x1 )
  205. warper->x2min = warper->x1;
  206. warper->w0 = warper->x2 - warper->x1;
  207. if ( warper->w0 <= 64 )
  208. {
  209. warper->x1max = warper->x1;
  210. warper->x2min = warper->x2;
  211. }
  212. /* examine (at most) a pixel wide range around the natural width */
  213. warper->wmin = warper->x2min - warper->x1max;
  214. warper->wmax = warper->x2max - warper->x1min;
  215. #if 1
  216. /* some heuristics to reduce the number of widths to be examined */
  217. {
  218. int margin = 16;
  219. if ( warper->w0 <= 128 )
  220. {
  221. margin = 8;
  222. if ( warper->w0 <= 96 )
  223. margin = 4;
  224. }
  225. if ( warper->wmin < warper->w0 - margin )
  226. warper->wmin = warper->w0 - margin;
  227. if ( warper->wmax > warper->w0 + margin )
  228. warper->wmax = warper->w0 + margin;
  229. }
  230. if ( warper->wmin < warper->w0 * 3 / 4 )
  231. warper->wmin = warper->w0 * 3 / 4;
  232. if ( warper->wmax > warper->w0 * 5 / 4 )
  233. warper->wmax = warper->w0 * 5 / 4;
  234. #else
  235. /* no scaling, just translation */
  236. warper->wmin = warper->wmax = warper->w0;
  237. #endif
  238. for ( w = warper->wmin; w <= warper->wmax; w++ )
  239. {
  240. FT_Fixed new_scale;
  241. FT_Pos new_delta;
  242. FT_Pos xx1, xx2;
  243. /* compute min and max positions for given width, */
  244. /* assuring that they stay within the coordinate ranges */
  245. xx1 = warper->x1;
  246. xx2 = warper->x2;
  247. if ( w >= warper->w0 )
  248. {
  249. xx1 -= w - warper->w0;
  250. if ( xx1 < warper->x1min )
  251. {
  252. xx2 += warper->x1min - xx1;
  253. xx1 = warper->x1min;
  254. }
  255. }
  256. else
  257. {
  258. xx1 -= w - warper->w0;
  259. if ( xx1 > warper->x1max )
  260. {
  261. xx2 -= xx1 - warper->x1max;
  262. xx1 = warper->x1max;
  263. }
  264. }
  265. if ( xx1 < warper->x1 )
  266. base_distort = warper->x1 - xx1;
  267. else
  268. base_distort = xx1 - warper->x1;
  269. if ( xx2 < warper->x2 )
  270. base_distort += warper->x2 - xx2;
  271. else
  272. base_distort += xx2 - warper->x2;
  273. /* give base distortion a greater weight while scoring */
  274. base_distort *= 10;
  275. new_scale = org_scale + FT_DivFix( w - warper->w0, X2 - X1 );
  276. new_delta = xx1 - FT_MulFix( X1, new_scale );
  277. af_warper_compute_line_best( warper, new_scale, new_delta, xx1, xx2,
  278. base_distort,
  279. segments, num_segments );
  280. }
  281. {
  282. FT_Fixed best_scale = warper->best_scale;
  283. FT_Pos best_delta = warper->best_delta;
  284. hints->xmin_delta = FT_MulFix( X1, best_scale - org_scale )
  285. + best_delta;
  286. hints->xmax_delta = FT_MulFix( X2, best_scale - org_scale )
  287. + best_delta;
  288. *a_scale = best_scale;
  289. *a_delta = best_delta;
  290. }
  291. }
  292. #else /* !AF_CONFIG_OPTION_USE_WARPER */
  293. /* ANSI C doesn't like empty source files */
  294. typedef int _af_warp_dummy;
  295. #endif /* !AF_CONFIG_OPTION_USE_WARPER */
  296. /* END */