/src/compiler/android-ndk/jni/freetype/src/autofit/afwarp.c

http://ftk.googlecode.com/ · C · 338 lines · 243 code · 73 blank · 22 comment · 36 complexity · 07d53b9fd7a29198d86bdb2570e63e6c MD5 · raw file

  1. /***************************************************************************/
  2. /* */
  3. /* afwarp.c */
  4. /* */
  5. /* Auto-fitter warping algorithm (body). */
  6. /* */
  7. /* Copyright 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. #include "afwarp.h"
  18. #ifdef AF_USE_WARPER
  19. #if 1
  20. static const AF_WarpScore
  21. af_warper_weights[64] =
  22. {
  23. 35, 32, 30, 25, 20, 15, 12, 10, 5, 1, 0, 0, 0, 0, 0, 0,
  24. 0, 0, 0, 0, 0, 0, -1, -2, -5, -8,-10,-10,-20,-20,-30,-30,
  25. -30,-30,-20,-20,-10,-10, -8, -5, -2, -1, 0, 0, 0, 0, 0, 0,
  26. 0, 0, 0, 0, 0, 0, 0, 1, 5, 10, 12, 15, 20, 25, 30, 32,
  27. };
  28. #else
  29. static const AF_WarpScore
  30. af_warper_weights[64] =
  31. {
  32. 30, 20, 10, 5, 4, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0,
  33. 0, 0, 0, 0, 0, 0, 0, -1, -2, -2, -5, -5,-10,-10,-15,-20,
  34. -20,-15,-15,-10,-10, -5, -5, -2, -2, -1, 0, 0, 0, 0, 0, 0,
  35. 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 4, 5, 10, 20,
  36. };
  37. #endif
  38. static void
  39. af_warper_compute_line_best( AF_Warper warper,
  40. FT_Fixed scale,
  41. FT_Pos delta,
  42. FT_Pos xx1,
  43. FT_Pos xx2,
  44. AF_WarpScore base_distort,
  45. AF_Segment segments,
  46. FT_UInt num_segments )
  47. {
  48. FT_Int idx_min, idx_max, idx0;
  49. FT_UInt nn;
  50. AF_WarpScore scores[65];
  51. for ( nn = 0; nn < 65; nn++ )
  52. scores[nn] = 0;
  53. idx0 = xx1 - warper->t1;
  54. /* compute minimum and maximum indices */
  55. {
  56. FT_Pos xx1min = warper->x1min;
  57. FT_Pos xx1max = warper->x1max;
  58. FT_Pos w = xx2 - xx1;
  59. if ( xx1min + w < warper->x2min )
  60. xx1min = warper->x2min - w;
  61. xx1max = warper->x1max;
  62. if ( xx1max + w > warper->x2max )
  63. xx1max = warper->x2max - w;
  64. idx_min = xx1min - warper->t1;
  65. idx_max = xx1max - warper->t1;
  66. if ( idx_min < 0 || idx_min > idx_max || idx_max > 64 )
  67. {
  68. AF_LOG(( "invalid indices:\n"
  69. " min=%d max=%d, xx1=%ld xx2=%ld,\n"
  70. " x1min=%ld x1max=%ld, x2min=%ld x2max=%ld\n",
  71. idx_min, idx_max, xx1, xx2,
  72. warper->x1min, warper->x1max,
  73. warper->x2min, warper->x2max ));
  74. return;
  75. }
  76. }
  77. for ( nn = 0; nn < num_segments; nn++ )
  78. {
  79. FT_Pos len = segments[nn].max_coord - segments[nn].min_coord;
  80. FT_Pos y0 = FT_MulFix( segments[nn].pos, scale ) + delta;
  81. FT_Pos y = y0 + ( idx_min - idx0 );
  82. FT_Int idx;
  83. for ( idx = idx_min; idx <= idx_max; idx++, y++ )
  84. scores[idx] += af_warper_weights[y & 63] * len;
  85. }
  86. /* find best score */
  87. {
  88. FT_Int idx;
  89. for ( idx = idx_min; idx <= idx_max; idx++ )
  90. {
  91. AF_WarpScore score = scores[idx];
  92. AF_WarpScore distort = base_distort + ( idx - idx0 );
  93. if ( score > warper->best_score ||
  94. ( score == warper->best_score &&
  95. distort < warper->best_distort ) )
  96. {
  97. warper->best_score = score;
  98. warper->best_distort = distort;
  99. warper->best_scale = scale;
  100. warper->best_delta = delta + ( idx - idx0 );
  101. }
  102. }
  103. }
  104. }
  105. FT_LOCAL_DEF( void )
  106. af_warper_compute( AF_Warper warper,
  107. AF_GlyphHints hints,
  108. AF_Dimension dim,
  109. FT_Fixed *a_scale,
  110. FT_Pos *a_delta )
  111. {
  112. AF_AxisHints axis;
  113. AF_Point points;
  114. FT_Fixed org_scale;
  115. FT_Pos org_delta;
  116. FT_UInt nn, num_points, num_segments;
  117. FT_Int X1, X2;
  118. FT_Int w;
  119. AF_WarpScore base_distort;
  120. AF_Segment segments;
  121. /* get original scaling transformation */
  122. if ( dim == AF_DIMENSION_VERT )
  123. {
  124. org_scale = hints->y_scale;
  125. org_delta = hints->y_delta;
  126. }
  127. else
  128. {
  129. org_scale = hints->x_scale;
  130. org_delta = hints->x_delta;
  131. }
  132. warper->best_scale = org_scale;
  133. warper->best_delta = org_delta;
  134. warper->best_score = INT_MIN;
  135. warper->best_distort = 0;
  136. axis = &hints->axis[dim];
  137. segments = axis->segments;
  138. num_segments = axis->num_segments;
  139. points = hints->points;
  140. num_points = hints->num_points;
  141. *a_scale = org_scale;
  142. *a_delta = org_delta;
  143. /* get X1 and X2, minimum and maximum in original coordinates */
  144. if ( num_segments < 1 )
  145. return;
  146. #if 1
  147. X1 = X2 = points[0].fx;
  148. for ( nn = 1; nn < num_points; nn++ )
  149. {
  150. FT_Int X = points[nn].fx;
  151. if ( X < X1 )
  152. X1 = X;
  153. if ( X > X2 )
  154. X2 = X;
  155. }
  156. #else
  157. X1 = X2 = segments[0].pos;
  158. for ( nn = 1; nn < num_segments; nn++ )
  159. {
  160. FT_Int X = segments[nn].pos;
  161. if ( X < X1 )
  162. X1 = X;
  163. if ( X > X2 )
  164. X2 = X;
  165. }
  166. #endif
  167. if ( X1 >= X2 )
  168. return;
  169. warper->x1 = FT_MulFix( X1, org_scale ) + org_delta;
  170. warper->x2 = FT_MulFix( X2, org_scale ) + org_delta;
  171. warper->t1 = AF_WARPER_FLOOR( warper->x1 );
  172. warper->t2 = AF_WARPER_CEIL( warper->x2 );
  173. warper->x1min = warper->x1 & ~31;
  174. warper->x1max = warper->x1min + 32;
  175. warper->x2min = warper->x2 & ~31;
  176. warper->x2max = warper->x2min + 32;
  177. if ( warper->x1max > warper->x2 )
  178. warper->x1max = warper->x2;
  179. if ( warper->x2min < warper->x1 )
  180. warper->x2min = warper->x1;
  181. warper->w0 = warper->x2 - warper->x1;
  182. if ( warper->w0 <= 64 )
  183. {
  184. warper->x1max = warper->x1;
  185. warper->x2min = warper->x2;
  186. }
  187. warper->wmin = warper->x2min - warper->x1max;
  188. warper->wmax = warper->x2max - warper->x1min;
  189. #if 1
  190. {
  191. int margin = 16;
  192. if ( warper->w0 <= 128 )
  193. {
  194. margin = 8;
  195. if ( warper->w0 <= 96 )
  196. margin = 4;
  197. }
  198. if ( warper->wmin < warper->w0 - margin )
  199. warper->wmin = warper->w0 - margin;
  200. if ( warper->wmax > warper->w0 + margin )
  201. warper->wmax = warper->w0 + margin;
  202. }
  203. if ( warper->wmin < warper->w0 * 3 / 4 )
  204. warper->wmin = warper->w0 * 3 / 4;
  205. if ( warper->wmax > warper->w0 * 5 / 4 )
  206. warper->wmax = warper->w0 * 5 / 4;
  207. #else
  208. /* no scaling, just translation */
  209. warper->wmin = warper->wmax = warper->w0;
  210. #endif
  211. for ( w = warper->wmin; w <= warper->wmax; w++ )
  212. {
  213. FT_Fixed new_scale;
  214. FT_Pos new_delta;
  215. FT_Pos xx1, xx2;
  216. xx1 = warper->x1;
  217. xx2 = warper->x2;
  218. if ( w >= warper->w0 )
  219. {
  220. xx1 -= w - warper->w0;
  221. if ( xx1 < warper->x1min )
  222. {
  223. xx2 += warper->x1min - xx1;
  224. xx1 = warper->x1min;
  225. }
  226. }
  227. else
  228. {
  229. xx1 -= w - warper->w0;
  230. if ( xx1 > warper->x1max )
  231. {
  232. xx2 -= xx1 - warper->x1max;
  233. xx1 = warper->x1max;
  234. }
  235. }
  236. if ( xx1 < warper->x1 )
  237. base_distort = warper->x1 - xx1;
  238. else
  239. base_distort = xx1 - warper->x1;
  240. if ( xx2 < warper->x2 )
  241. base_distort += warper->x2 - xx2;
  242. else
  243. base_distort += xx2 - warper->x2;
  244. base_distort *= 10;
  245. new_scale = org_scale + FT_DivFix( w - warper->w0, X2 - X1 );
  246. new_delta = xx1 - FT_MulFix( X1, new_scale );
  247. af_warper_compute_line_best( warper, new_scale, new_delta, xx1, xx2,
  248. base_distort,
  249. segments, num_segments );
  250. }
  251. {
  252. FT_Fixed best_scale = warper->best_scale;
  253. FT_Pos best_delta = warper->best_delta;
  254. hints->xmin_delta = FT_MulFix( X1, best_scale - org_scale )
  255. + best_delta;
  256. hints->xmax_delta = FT_MulFix( X2, best_scale - org_scale )
  257. + best_delta;
  258. *a_scale = best_scale;
  259. *a_delta = best_delta;
  260. }
  261. }
  262. #else /* !AF_USE_WARPER */
  263. char af_warper_dummy = 0; /* make compiler happy */
  264. #endif /* !AF_USE_WARPER */
  265. /* END */