1 /**************************************************************************** 2 * 3 * afhints.h 4 * 5 * Auto-fitter hinting routines (specification). 6 * 7 * Copyright 2003-2018 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 #ifndef AFHINTS_H_ 20 #define AFHINTS_H_ 21 22 #include "aftypes.h" 23 24 #define xxAF_SORT_SEGMENTS 25 26 FT_BEGIN_HEADER 27 28 /* 29 * The definition of outline glyph hints. These are shared by all 30 * writing system analysis routines (until now). 31 */ 32 33 typedef enum AF_Dimension_ 34 { 35 AF_DIMENSION_HORZ = 0, /* x coordinates, */ 36 /* i.e., vertical segments & edges */ 37 AF_DIMENSION_VERT = 1, /* y coordinates, */ 38 /* i.e., horizontal segments & edges */ 39 40 AF_DIMENSION_MAX /* do not remove */ 41 42 } AF_Dimension; 43 44 45 /* hint directions -- the values are computed so that two vectors are */ 46 /* in opposite directions iff `dir1 + dir2 == 0' */ 47 typedef enum AF_Direction_ 48 { 49 AF_DIR_NONE = 4, 50 AF_DIR_RIGHT = 1, 51 AF_DIR_LEFT = -1, 52 AF_DIR_UP = 2, 53 AF_DIR_DOWN = -2 54 55 } AF_Direction; 56 57 58 /* 59 * The following explanations are mostly taken from the article 60 * 61 * Real-Time Grid Fitting of Typographic Outlines 62 * 63 * by David Turner and Werner Lemberg 64 * 65 * https://www.tug.org/TUGboat/Articles/tb24-3/lemberg.pdf 66 * 67 * with appropriate updates. 68 * 69 * 70 * Segments 71 * 72 * `af_{cjk,latin,...}_hints_compute_segments' are the functions to 73 * find segments in an outline. 74 * 75 * A segment is a series of at least two consecutive points that are 76 * approximately aligned along a coordinate axis. The analysis to do 77 * so is specific to a writing system. 78 * 79 * 80 * Edges 81 * 82 * `af_{cjk,latin,...}_hints_compute_edges' are the functions to find 83 * edges. 84 * 85 * As soon as segments are defined, the auto-hinter groups them into 86 * edges. An edge corresponds to a single position on the main 87 * dimension that collects one or more segments (allowing for a small 88 * threshold). 89 * 90 * As an example, the `latin' writing system first tries to grid-fit 91 * edges, then to align segments on the edges unless it detects that 92 * they form a serif. 93 * 94 * 95 * A H 96 * | | 97 * | | 98 * | | 99 * | | 100 * C | | F 101 * +------<-----+ +-----<------+ 102 * | B G | 103 * | | 104 * | | 105 * +--------------->------------------+ 106 * D E 107 * 108 * 109 * Stems 110 * 111 * Stems are detected by `af_{cjk,latin,...}_hint_edges'. 112 * 113 * Segments need to be `linked' to other ones in order to detect stems. 114 * A stem is made of two segments that face each other in opposite 115 * directions and that are sufficiently close to each other. Using 116 * vocabulary from the TrueType specification, stem segments form a 117 * `black distance'. 118 * 119 * In the above ASCII drawing, the horizontal segments are BC, DE, and 120 * FG; the vertical segments are AB, CD, EF, and GH. 121 * 122 * Each segment has at most one `best' candidate to form a black 123 * distance, or no candidate at all. Notice that two distinct segments 124 * can have the same candidate, which frequently means a serif. 125 * 126 * A stem is recognized by the following condition: 127 * 128 * best segment_1 = segment_2 && best segment_2 = segment_1 129 * 130 * The best candidate is stored in field `link' in structure 131 * `AF_Segment'. 132 * 133 * In the above ASCII drawing, the best candidate for both AB and CD is 134 * GH, while the best candidate for GH is AB. Similarly, the best 135 * candidate for EF and GH is AB, while the best candidate for AB is 136 * GH. 137 * 138 * The detection and handling of stems is dependent on the writing 139 * system. 140 * 141 * 142 * Serifs 143 * 144 * Serifs are detected by `af_{cjk,latin,...}_hint_edges'. 145 * 146 * In comparison to a stem, a serif (as handled by the auto-hinter 147 * module that takes care of the `latin' writing system) has 148 * 149 * best segment_1 = segment_2 && best segment_2 != segment_1 150 * 151 * where segment_1 corresponds to the serif segment (CD and EF in the 152 * above ASCII drawing). 153 * 154 * The best candidate is stored in field `serif' in structure 155 * `AF_Segment' (and `link' is set to NULL). 156 * 157 * 158 * Touched points 159 * 160 * A point is called `touched' if it has been processed somehow by the 161 * auto-hinter. It basically means that it shouldn't be moved again 162 * (or moved only under certain constraints to preserve the already 163 * applied processing). 164 * 165 * 166 * Flat and round segments 167 * 168 * Segments are `round' or `flat', depending on the series of points 169 * that define them. A segment is round if the next and previous point 170 * of an extremum (which can be either a single point or sequence of 171 * points) are both conic or cubic control points. Otherwise, a 172 * segment with an extremum is flat. 173 * 174 * 175 * Strong Points 176 * 177 * Experience has shown that points not part of an edge need to be 178 * interpolated linearly between their two closest edges, even if these 179 * are not part of the contour of those particular points. Typical 180 * candidates for this are 181 * 182 * - angle points (i.e., points where the `in' and `out' direction 183 * differ greatly) 184 * 185 * - inflection points (i.e., where the `in' and `out' angles are the 186 * same, but the curvature changes sign) [currently, such points 187 * aren't handled specially in the auto-hinter] 188 * 189 * `af_glyph_hints_align_strong_points' is the function that takes 190 * care of such situations; it is equivalent to the TrueType `IP' 191 * hinting instruction. 192 * 193 * 194 * Weak Points 195 * 196 * Other points in the outline must be interpolated using the 197 * coordinates of their previous and next unfitted contour neighbours. 198 * These are called `weak points' and are touched by the function 199 * `af_glyph_hints_align_weak_points', equivalent to the TrueType `IUP' 200 * hinting instruction. Typical candidates are control points and 201 * points on the contour without a major direction. 202 * 203 * The major effect is to reduce possible distortion caused by 204 * alignment of edges and strong points, thus weak points are processed 205 * after strong points. 206 */ 207 208 209 /* point hint flags */ 210 #define AF_FLAG_NONE 0 211 212 /* point type flags */ 213 #define AF_FLAG_CONIC ( 1U << 0 ) 214 #define AF_FLAG_CUBIC ( 1U << 1 ) 215 #define AF_FLAG_CONTROL ( AF_FLAG_CONIC | AF_FLAG_CUBIC ) 216 217 /* point touch flags */ 218 #define AF_FLAG_TOUCH_X ( 1U << 2 ) 219 #define AF_FLAG_TOUCH_Y ( 1U << 3 ) 220 221 /* candidates for weak interpolation have this flag set */ 222 #define AF_FLAG_WEAK_INTERPOLATION ( 1U << 4 ) 223 224 /* the distance to the next point is very small */ 225 #define AF_FLAG_NEAR ( 1U << 5 ) 226 227 228 /* edge hint flags */ 229 #define AF_EDGE_NORMAL 0 230 #define AF_EDGE_ROUND ( 1U << 0 ) 231 #define AF_EDGE_SERIF ( 1U << 1 ) 232 #define AF_EDGE_DONE ( 1U << 2 ) 233 #define AF_EDGE_NEUTRAL ( 1U << 3 ) /* edge aligns to a neutral blue zone */ 234 235 236 typedef struct AF_PointRec_* AF_Point; 237 typedef struct AF_SegmentRec_* AF_Segment; 238 typedef struct AF_EdgeRec_* AF_Edge; 239 240 241 typedef struct AF_PointRec_ 242 { 243 FT_UShort flags; /* point flags used by hinter */ 244 FT_Char in_dir; /* direction of inwards vector */ 245 FT_Char out_dir; /* direction of outwards vector */ 246 247 FT_Pos ox, oy; /* original, scaled position */ 248 FT_Short fx, fy; /* original, unscaled position (in font units) */ 249 FT_Pos x, y; /* current position */ 250 FT_Pos u, v; /* current (x,y) or (y,x) depending on context */ 251 252 AF_Point next; /* next point in contour */ 253 AF_Point prev; /* previous point in contour */ 254 255 } AF_PointRec; 256 257 258 typedef struct AF_SegmentRec_ 259 { 260 FT_Byte flags; /* edge/segment flags for this segment */ 261 FT_Char dir; /* segment direction */ 262 FT_Short pos; /* position of segment */ 263 FT_Short delta; /* deviation from segment position */ 264 FT_Short min_coord; /* minimum coordinate of segment */ 265 FT_Short max_coord; /* maximum coordinate of segment */ 266 FT_Short height; /* the hinted segment height */ 267 268 AF_Edge edge; /* the segment's parent edge */ 269 AF_Segment edge_next; /* link to next segment in parent edge */ 270 271 AF_Segment link; /* (stem) link segment */ 272 AF_Segment serif; /* primary segment for serifs */ 273 FT_Pos score; /* used during stem matching */ 274 FT_Pos len; /* used during stem matching */ 275 276 AF_Point first; /* first point in edge segment */ 277 AF_Point last; /* last point in edge segment */ 278 279 } AF_SegmentRec; 280 281 282 typedef struct AF_EdgeRec_ 283 { 284 FT_Short fpos; /* original, unscaled position (in font units) */ 285 FT_Pos opos; /* original, scaled position */ 286 FT_Pos pos; /* current position */ 287 288 FT_Byte flags; /* edge flags */ 289 FT_Char dir; /* edge direction */ 290 FT_Fixed scale; /* used to speed up interpolation between edges */ 291 292 AF_Width blue_edge; /* non-NULL if this is a blue edge */ 293 AF_Edge link; /* link edge */ 294 AF_Edge serif; /* primary edge for serifs */ 295 FT_Int score; /* used during stem matching */ 296 297 AF_Segment first; /* first segment in edge */ 298 AF_Segment last; /* last segment in edge */ 299 300 } AF_EdgeRec; 301 302 #define AF_SEGMENTS_EMBEDDED 18 /* number of embedded segments */ 303 #define AF_EDGES_EMBEDDED 12 /* number of embedded edges */ 304 305 typedef struct AF_AxisHintsRec_ 306 { 307 FT_Int num_segments; /* number of used segments */ 308 FT_Int max_segments; /* number of allocated segments */ 309 AF_Segment segments; /* segments array */ 310 #ifdef AF_SORT_SEGMENTS 311 FT_Int mid_segments; 312 #endif 313 314 FT_Int num_edges; /* number of used edges */ 315 FT_Int max_edges; /* number of allocated edges */ 316 AF_Edge edges; /* edges array */ 317 318 AF_Direction major_dir; /* either vertical or horizontal */ 319 320 /* two arrays to avoid allocation penalty */ 321 struct 322 { 323 AF_SegmentRec segments[AF_SEGMENTS_EMBEDDED]; 324 AF_EdgeRec edges[AF_EDGES_EMBEDDED]; 325 } embedded; 326 327 328 } AF_AxisHintsRec, *AF_AxisHints; 329 330 331 #define AF_POINTS_EMBEDDED 96 /* number of embedded points */ 332 #define AF_CONTOURS_EMBEDDED 8 /* number of embedded contours */ 333 334 typedef struct AF_GlyphHintsRec_ 335 { 336 FT_Memory memory; 337 338 FT_Fixed x_scale; 339 FT_Pos x_delta; 340 341 FT_Fixed y_scale; 342 FT_Pos y_delta; 343 344 FT_Int max_points; /* number of allocated points */ 345 FT_Int num_points; /* number of used points */ 346 AF_Point points; /* points array */ 347 348 FT_Int max_contours; /* number of allocated contours */ 349 FT_Int num_contours; /* number of used contours */ 350 AF_Point* contours; /* contours array */ 351 352 AF_AxisHintsRec axis[AF_DIMENSION_MAX]; 353 354 FT_UInt32 scaler_flags; /* copy of scaler flags */ 355 FT_UInt32 other_flags; /* free for style-specific */ 356 /* implementations */ 357 AF_StyleMetrics metrics; 358 359 FT_Pos xmin_delta; /* used for warping */ 360 FT_Pos xmax_delta; 361 362 /* Two arrays to avoid allocation penalty. */ 363 /* The `embedded' structure must be the last element! */ 364 struct 365 { 366 AF_Point contours[AF_CONTOURS_EMBEDDED]; 367 AF_PointRec points[AF_POINTS_EMBEDDED]; 368 } embedded; 369 370 } AF_GlyphHintsRec; 371 372 373 #define AF_HINTS_TEST_SCALER( h, f ) ( (h)->scaler_flags & (f) ) 374 #define AF_HINTS_TEST_OTHER( h, f ) ( (h)->other_flags & (f) ) 375 376 377 #ifdef FT_DEBUG_AUTOFIT 378 379 #define AF_HINTS_DO_HORIZONTAL( h ) \ 380 ( !_af_debug_disable_horz_hints && \ 381 !AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_HORIZONTAL ) ) 382 383 #define AF_HINTS_DO_VERTICAL( h ) \ 384 ( !_af_debug_disable_vert_hints && \ 385 !AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_VERTICAL ) ) 386 387 #define AF_HINTS_DO_BLUES( h ) ( !_af_debug_disable_blue_hints ) 388 389 #else /* !FT_DEBUG_AUTOFIT */ 390 391 #define AF_HINTS_DO_HORIZONTAL( h ) \ 392 !AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_HORIZONTAL ) 393 394 #define AF_HINTS_DO_VERTICAL( h ) \ 395 !AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_VERTICAL ) 396 397 #define AF_HINTS_DO_BLUES( h ) 1 398 399 #endif /* !FT_DEBUG_AUTOFIT */ 400 401 402 #define AF_HINTS_DO_ADVANCE( h ) \ 403 !AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_ADVANCE ) 404 405 #define AF_HINTS_DO_WARP( h ) \ 406 !AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_WARPER ) 407 408 409 410 FT_LOCAL( AF_Direction ) 411 af_direction_compute( FT_Pos dx, 412 FT_Pos dy ); 413 414 415 FT_LOCAL( FT_Error ) 416 af_axis_hints_new_segment( AF_AxisHints axis, 417 FT_Memory memory, 418 AF_Segment *asegment ); 419 420 FT_LOCAL( FT_Error) 421 af_axis_hints_new_edge( AF_AxisHints axis, 422 FT_Int fpos, 423 AF_Direction dir, 424 FT_Bool top_to_bottom_hinting, 425 FT_Memory memory, 426 AF_Edge *edge ); 427 428 FT_LOCAL( void ) 429 af_glyph_hints_init( AF_GlyphHints hints, 430 FT_Memory memory ); 431 432 FT_LOCAL( void ) 433 af_glyph_hints_rescale( AF_GlyphHints hints, 434 AF_StyleMetrics metrics ); 435 436 FT_LOCAL( FT_Error ) 437 af_glyph_hints_reload( AF_GlyphHints hints, 438 FT_Outline* outline ); 439 440 FT_LOCAL( void ) 441 af_glyph_hints_save( AF_GlyphHints hints, 442 FT_Outline* outline ); 443 444 FT_LOCAL( void ) 445 af_glyph_hints_align_edge_points( AF_GlyphHints hints, 446 AF_Dimension dim ); 447 448 FT_LOCAL( void ) 449 af_glyph_hints_align_strong_points( AF_GlyphHints hints, 450 AF_Dimension dim ); 451 452 FT_LOCAL( void ) 453 af_glyph_hints_align_weak_points( AF_GlyphHints hints, 454 AF_Dimension dim ); 455 456 #ifdef AF_CONFIG_OPTION_USE_WARPER 457 FT_LOCAL( void ) 458 af_glyph_hints_scale_dim( AF_GlyphHints hints, 459 AF_Dimension dim, 460 FT_Fixed scale, 461 FT_Pos delta ); 462 #endif 463 464 FT_LOCAL( void ) 465 af_glyph_hints_done( AF_GlyphHints hints ); 466 467 /* */ 468 469 #define AF_SEGMENT_LEN( seg ) ( (seg)->max_coord - (seg)->min_coord ) 470 471 #define AF_SEGMENT_DIST( seg1, seg2 ) ( ( (seg1)->pos > (seg2)->pos ) \ 472 ? (seg1)->pos - (seg2)->pos \ 473 : (seg2)->pos - (seg1)->pos ) 474 475 476 FT_END_HEADER 477 478 #endif /* AFHINTS_H_ */ 479 480 481 /* END */ 482