lib/tahints.h

   1 /* tahints.h */
   2
   3 /*
   4  * Copyright (C) 2011-2012 by Werner Lemberg.
   5  *
   6  * This file is part of the ttfautohint library, and may only be used,
   7  * modified, and distributed under the terms given in `COPYING'.  By
   8  * continuing to use, modify, or distribute this file you indicate that you
   9  * have read `COPYING' and understand and accept it fully.
  10  *
  11  * The file `COPYING' mentioned in the previous paragraph is distributed
  12  * with the ttfautohint library.
  13  */
  14
  15
  16 /* originally file `afhints.h' (2011-Mar-28) from FreeType */
  17
  18 /* heavily modified 2011 by Werner Lemberg <wl@gnu.org> */
  19
  20 #ifndef __TAHINTS_H__
  21 #define __TAHINTS_H__
  22
  23 #include "tatypes.h"
  24
  25 #define xxTA_SORT_SEGMENTS
  26
  27
  28 /* the definition of outline glyph hints; these are shared */
  29 /* by all script analysis routines (until now) */
  30
  31 typedef enum TA_Dimension_
  32 {
  33   TA_DIMENSION_HORZ = 0, /* x coordinates, i.e. vert. segments & edges */
  34   TA_DIMENSION_VERT = 1, /* y coordinates, i.e. horz. segments & edges */
  35   TA_DIMENSION_MAX /* do not remove */
  36 } TA_Dimension;
  37
  38
  39 /* hint directions -- the values are computed so that two vectors */
  40 /* are in opposite directions iff `dir1 + dir2 == 0' */
  41
  42 typedef enum TA_Direction_
  43 {
  44   TA_DIR_NONE = 4,
  45   TA_DIR_RIGHT = 1,
  46   TA_DIR_LEFT= -1,
  47   TA_DIR_UP = 2,
  48   TA_DIR_DOWN = -2
  49 } TA_Direction;
  50
  51
  52 /*
  53  *  The following explanations are mostly taken from the article
  54  *
  55  *    Real-Time Grid Fitting of Typographic Outlines
  56  *
  57  *  by David Turner and Werner Lemberg
  58  *
  59  *   http://www.tug.org/TUGboat/Articles/tb24-3/lemberg.pdf
  60  *
  61  *
  62  *  Segments
  63  *
  64  *    `ta_{cjk,latin,...}_hints_compute_segments' are the functions to
  65  *    find segments in an outline.  A segment is a series of consecutive
  66  *    points that are approximately aligned along a coordinate axis.  The
  67  *    analysis to do so is specific to a script.
  68  *
  69  *    A segment must have at least two points, except in the case of
  70  *    `fake' segments that are generated to hint metrics appropriately,
  71  *    and which consist of a single point.
  72  *
  73  *
  74  *  Edges
  75  *
  76  *    As soon as segments are defined, the auto-hinter groups them into
  77  *    edges.  An edge corresponds to a single position on the main
  78  *    dimension that collects one or more segments (allowing for a small
  79  *    threshold).
  80  *
  81  *    The auto-hinter first tries to grid fit edges, then to align
  82  *    segments on the edges unless it detects that they form a serif.
  83  *
  84  *    `ta_{cjk,latin,...}_hints_compute_edges' are the functions to find
  85  *    edges; they are specific to a script.
  86  *
  87  *
  88  *                      A          H
  89  *                       |        |
  90  *                       |        |
  91  *                       |        |
  92  *                       |        |
  93  *         C             |        |             F
  94  *          +------<-----+        +-----<------+
  95  *          |             B      G             |
  96  *          |                                  |
  97  *          |                                  |
  98  *          +--------------->------------------+
  99  *         D                                    E
 100  *
 101  *
 102  *  Stems
 103  *
 104  *    Segments need to be `linked' to other ones in order to detect stems.
 105  *    A stem is made of two segments that face each other in opposite
 106  *    directions and that are sufficiently close to each other.  Using
 107  *    vocabulary from the TrueType specification, stem segments form a
 108  *    `black distance'.
 109  *
 110  *    In the above ASCII drawing, the horizontal segments are BC, DE, and
 111  *    FG; the vertical segments are AB, CD, EF, and GH.
 112  *
 113  *    Each segment has at most one `best' candidate to form a black
 114  *    distance, or no candidate at all.  Notice that two distinct segments
 115  *    can have the same candidate, which frequently means a serif.
 116  *
 117  *    A stem is recognized by the following condition:
 118  *
 119  *      best segment_1 = segment_2 && best segment_2 = segment_1
 120  *
 121  *    The best candidate is stored in field `link' in structure
 122  *    `TA_Segment'.
 123  *
 124  *    Stems are detected by `ta_{cjk,latin,...}_hint_edges'.
 125  *
 126  *    In the above ASCII drawing, the best candidate for both AB and CD is
 127  *    GH, while the best candidate for GH is AB.  Similarly, the best
 128  *    candidate for EF and GH is AB, while the best candidate for AB is
 129  *    GH.
 130  *
 131  *
 132  *  Serifs
 133  *
 134  *    On the opposite, a serif has
 135  *
 136  *      best segment_1 = segment_2 && best segment_2 != segment_1
 137  *
 138  *    where segment_1 corresponds to the serif segment (CD and EF in the
 139  *    above ASCII drawing).
 140  *
 141  *    The best candidate is stored in field `serif' in structure
 142  *    `TA_Segment' (and `link' is set to NULL).
 143  *
 144  *    Serifs are detected by `ta_{cjk,latin,...}_hint_edges'.
 145  *
 146  *
 147  *  Touched points
 148  *
 149  *    A point is called `touched' if it has been processed somehow by the
 150  *    auto-hinter.  It basically means that it shouldn't be moved again
 151  *    (or moved only under certain constraints to preserve the already
 152  *    applied processing).
 153  *
 154  *
 155  *  Flat and round segments
 156  *
 157  *    Segments are `round' or `flat', depending on the series of points
 158  *    that define them.  A segment is round if the next and previous point
 159  *    of an extremum (which can be either a single point or sequence of
 160  *    points) are both conic or cubic control points.  Otherwise, a
 161  *    segment with an extremum is flat.
 162  *
 163  *
 164  *  Strong Points
 165  *
 166  *    Experience has shown that points which are not part of an edge need
 167  *    to be interpolated linearly between their two closest edges, even if
 168  *    these are not part of the contour of those particular points.
 169  *    Typical candidates for this are
 170  *
 171  *    - angle points (i.e., points where the `in' and `out' direction
 172  *      differ greatly)
 173  *
 174  *    - inflection points (i.e., where the `in' and `out' angles are the
 175  *      same, but the curvature changes sign)
 176  *
 177  *    `ta_glyph_hints_align_strong_points' is the function which takes
 178  *    care of such situations; it is equivalent to the TrueType `IP'
 179  *    hinting instruction.
 180  *
 181  *
 182  *  Weak Points
 183  *
 184  *    Other points in the outline must be interpolated using the
 185  *    coordinates of their previous and next unfitted contour neighbours.
 186  *    These are called `weak points' and are touched by the function
 187  *    `ta_glyph_hints_align_weak_points', equivalent to the TrueType `IUP'
 188  *    hinting instruction.  Typical candidates are control points and
 189  *    points on the contour without a major direction.
 190  *
 191  *    The major effect is to reduce possible distortion caused by
 192  *    alignment of edges and strong points, thus weak points are processed
 193  *    after strong points.
 194  */
 195
 196
 197 /* point hint flags */
 198 #define TA_FLAG_NONE 0
 199
 200 /* point type flags */
 201 #define TA_FLAG_CONIC (1 << 0)
 202 #define TA_FLAG_CUBIC (1 << 1)
 203 #define TA_FLAG_CONTROL (TA_FLAG_CONIC | TA_FLAG_CUBIC)
 204
 205 /* point extremum flags */
 206 #define TA_FLAG_EXTREMA_X (1 << 2)
 207 #define TA_FLAG_EXTREMA_Y (1 << 3)
 208
 209 /* point roundness flags */
 210 #define TA_FLAG_ROUND_X (1 << 4)
 211 #define TA_FLAG_ROUND_Y (1 << 5)
 212
 213 /* point touch flags */
 214 #define TA_FLAG_TOUCH_X (1 << 6)
 215 #define TA_FLAG_TOUCH_Y (1 << 7)
 216
 217 /* candidates for weak interpolation have this flag set */
 218 #define TA_FLAG_WEAK_INTERPOLATION (1 << 8)
 219
 220 /* all inflection points in the outline have this flag set */
 221 #define TA_FLAG_INFLECTION (1 << 9)
 222
 223
 224 /* edge hint flags */
 225 #define TA_EDGE_NORMAL 0
 226 #define TA_EDGE_ROUND (1 << 0)
 227 #define TA_EDGE_SERIF (1 << 1)
 228 #define TA_EDGE_DONE (1 << 2)
 229
 230
 231 typedef struct TA_PointRec_* TA_Point;
 232 typedef struct TA_SegmentRec_* TA_Segment;
 233 typedef struct TA_EdgeRec_* TA_Edge;
 234
 235
 236 typedef struct TA_PointRec_
 237 {
 238   FT_UShort flags; /* point flags used by hinter */
 239   FT_Char in_dir; /* direction of inwards vector */
 240   FT_Char out_dir; /* direction of outwards vector */
 241
 242   FT_Pos ox, oy; /* original, scaled position */
 243   FT_Short fx, fy; /* original, unscaled position (in font units) */
 244   FT_Pos x, y; /* current position */
 245   FT_Pos u, v; /* current (x,y) or (y,x) depending on context */
 246
 247   TA_Point next; /* next point in contour */
 248   TA_Point prev; /* previous point in contour */
 249 } TA_PointRec;
 250
 251
 252 typedef struct TA_SegmentRec_
 253 {
 254   FT_Byte flags; /* edge/segment flags for this segment */
 255   FT_Char dir; /* segment direction */
 256   FT_Short pos; /* position of segment */
 257   FT_Short min_coord; /* minimum coordinate of segment */
 258   FT_Short max_coord; /* maximum coordinate of segment */
 259   FT_Short height; /* the hinted segment height */
 260
 261   TA_Edge edge; /* the segment's parent edge */
 262   TA_Segment edge_next; /* link to next segment in parent edge */
 263
 264   TA_Segment link; /* (stem) link segment */
 265   TA_Segment serif; /* primary segment for serifs */
 266   FT_Pos num_linked; /* number of linked segments */
 267   FT_Pos score; /* used during stem matching */
 268   FT_Pos len; /* used during stem matching */
 269
 270   TA_Point first; /* first point in edge segment */
 271   TA_Point last; /* last point in edge segment */
 272 } TA_SegmentRec;
 273
 274
 275 typedef struct TA_EdgeRec_
 276 {
 277   FT_Short fpos; /* original, unscaled position (in font units) */
 278   FT_Pos opos; /* original, scaled position */
 279   FT_Pos pos; /* current position */
 280
 281   FT_Byte flags; /* edge flags */
 282   FT_Char dir; /* edge direction */
 283   FT_Fixed scale; /* used to speed up interpolation between edges */
 284
 285   TA_Width blue_edge; /* non-NULL if this is a blue edge */
 286   FT_UInt best_blue_idx; /* for the hinting recorder callback */
 287   FT_Bool best_blue_is_shoot; /* for the hinting recorder callback */
 288
 289   TA_Edge link; /* link edge */
 290   TA_Edge serif; /* primary edge for serifs */
 291   FT_Short num_linked; /* number of linked edges */
 292   FT_Int score; /* used during stem matching */
 293
 294   TA_Segment first; /* first segment in edge */
 295   TA_Segment last; /* last segment in edge */
 296 } TA_EdgeRec;
 297
 298
 299 typedef struct TA_AxisHintsRec_
 300 {
 301   FT_Int num_segments; /* number of used segments */
 302   FT_Int max_segments; /* number of allocated segments */
 303   TA_Segment segments; /* segments array */
 304 #ifdef TA_SORT_SEGMENTS
 305   FT_Int mid_segments;
 306 #endif
 307
 308   FT_Int num_edges; /* number of used edges */
 309   FT_Int max_edges; /* number of allocated edges */
 310   TA_Edge edges; /* edges array */
 311
 312   TA_Direction major_dir; /* either vertical or horizontal */
 313 } TA_AxisHintsRec, *TA_AxisHints;
 314
 315
 316 typedef enum TA_Action_
 317 {
 318   /* point actions */
 319
 320   ta_ip_before,
 321   ta_ip_after,
 322   ta_ip_on,
 323   ta_ip_between,
 324
 325   /* edge actions */
 326
 327   ta_blue,
 328   ta_blue_anchor,
 329
 330   ta_anchor,
 331   ta_anchor_serif,
 332   ta_anchor_round,
 333   ta_anchor_round_serif,
 334
 335   ta_adjust,
 336   ta_adjust_serif,
 337   ta_adjust_round,
 338   ta_adjust_round_serif,
 339   ta_adjust_bound,
 340   ta_adjust_bound_serif,
 341   ta_adjust_bound_round,
 342   ta_adjust_bound_round_serif,
 343
 344   ta_link,
 345   ta_link_serif,
 346   ta_link_round,
 347   ta_link_round_serif,
 348
 349   ta_stem,
 350   ta_stem_serif,
 351   ta_stem_round,
 352   ta_stem_round_serif,
 353   ta_stem_bound,
 354   ta_stem_bound_serif,
 355   ta_stem_bound_round,
 356   ta_stem_bound_round_serif,
 357
 358   ta_serif,
 359   ta_serif_lower_bound,
 360   ta_serif_upper_bound,
 361   ta_serif_upper_lower_bound,
 362
 363   ta_serif_anchor,
 364   ta_serif_anchor_lower_bound,
 365   ta_serif_anchor_upper_bound,
 366   ta_serif_anchor_upper_lower_bound,
 367
 368   ta_serif_link1,
 369   ta_serif_link1_lower_bound,
 370   ta_serif_link1_upper_bound,
 371   ta_serif_link1_upper_lower_bound,
 372
 373   ta_serif_link2,
 374   ta_serif_link2_lower_bound,
 375   ta_serif_link2_upper_bound,
 376   ta_serif_link2_upper_lower_bound,
 377
 378   ta_bound
 379 } TA_Action;
 380
 381
 382 typedef void
 383 (*TA_Hints_Recorder)(TA_Action action,
 384                      TA_GlyphHints hints,
 385                      TA_Dimension dim,
 386                      void* arg1, /* TA_Point or TA_Edge */
 387                      TA_Edge arg2,
 388                      TA_Edge arg3,
 389                      TA_Edge lower_bound,
 390                      TA_Edge upper_bound);
 391
 392 typedef struct TA_GlyphHintsRec_
 393 {
 394   FT_Fixed x_scale;
 395   FT_Pos x_delta;
 396
 397   FT_Fixed y_scale;
 398   FT_Pos y_delta;
 399
 400   FT_Int max_points; /* number of allocated points */
 401   FT_Int num_points; /* number of used points */
 402   TA_Point points; /* points array */
 403
 404   FT_Int max_contours; /* number of allocated contours */
 405   FT_Int num_contours; /* number of used contours */
 406   TA_Point* contours; /* contours array */
 407
 408   TA_AxisHintsRec axis[TA_DIMENSION_MAX];
 409
 410   FT_UInt32 scaler_flags; /* copy of scaler flags */
 411   FT_UInt32 other_flags; /* free for script-specific implementations */
 412   TA_ScriptMetrics metrics;
 413
 414   FT_Pos xmin_delta; /* used for warping */
 415   FT_Pos xmax_delta;
 416
 417   TA_Hints_Recorder recorder;
 418   void* user;
 419 } TA_GlyphHintsRec;
 420
 421
 422 #define TA_HINTS_TEST_SCALER(h, f) \
 423           ((h)->scaler_flags & (f))
 424 #define TA_HINTS_TEST_OTHER(h, f) \
 425           ((h)->other_flags & (f))
 426
 427
 428 #ifdef TA_DEBUG
 429
 430 #define TA_HINTS_DO_HORIZONTAL(h) \
 431           (!_ta_debug_disable_horz_hints \
 432            && !TA_HINTS_TEST_SCALER(h, TA_SCALER_FLAG_NO_HORIZONTAL))
 433
 434 #define TA_HINTS_DO_VERTICAL(h) \
 435           (!_ta_debug_disable_vert_hints \
 436            && !TA_HINTS_TEST_SCALER(h, TA_SCALER_FLAG_NO_VERTICAL))
 437
 438 #define TA_HINTS_DO_ADVANCE(h) \
 439           !TA_HINTS_TEST_SCALER(h, TA_SCALER_FLAG_NO_ADVANCE)
 440
 441 #define TA_HINTS_DO_BLUES(h) \
 442           (!_ta_debug_disable_blue_hints)
 443
 444 #else /* !TA_DEBUG */
 445
 446 #define TA_HINTS_DO_HORIZONTAL(h) \
 447           !TA_HINTS_TEST_SCALER(h, TA_SCALER_FLAG_NO_HORIZONTAL)
 448
 449 #define TA_HINTS_DO_VERTICAL(h) \
 450           !TA_HINTS_TEST_SCALER(h, TA_SCALER_FLAG_NO_VERTICAL)
 451
 452 #define TA_HINTS_DO_ADVANCE(h) \
 453           !TA_HINTS_TEST_SCALER(h, TA_SCALER_FLAG_NO_ADVANCE)
 454
 455 #define TA_HINTS_DO_BLUES(h) \
 456           1
 457
 458 #endif /* !TA_DEBUG */
 459
 460
 461 TA_Direction
 462 ta_direction_compute(FT_Pos dx,
 463                      FT_Pos dy);
 464
 465
 466 FT_Error
 467 ta_axis_hints_new_segment(TA_AxisHints axis,
 468                           TA_Segment* asegment);
 469
 470 FT_Error
 471 ta_axis_hints_new_edge(TA_AxisHints axis,
 472                        FT_Int fpos,
 473                        TA_Direction dir,
 474                        TA_Edge* edge);
 475
 476 #ifdef TA_DEBUG
 477 void
 478 ta_glyph_hints_dump_points(TA_GlyphHints hints);
 479
 480 void
 481 ta_glyph_hints_dump_segments(TA_GlyphHints hints);
 482
 483 void
 484 ta_glyph_hints_dump_edges(TA_GlyphHints hints);
 485 #endif
 486
 487 void
 488 ta_glyph_hints_init(TA_GlyphHints hints);
 489
 490 void
 491 ta_glyph_hints_rescale(TA_GlyphHints hints,
 492                        TA_ScriptMetrics metrics);
 493
 494 FT_Error
 495 ta_glyph_hints_reload(TA_GlyphHints hints,
 496                       FT_Outline* outline);
 497
 498 void
 499 ta_glyph_hints_save(TA_GlyphHints hints,
 500                     FT_Outline* outline);
 501
 502 void
 503 ta_glyph_hints_align_edge_points(TA_GlyphHints hints,
 504                                  TA_Dimension dim);
 505
 506 void
 507 ta_glyph_hints_align_strong_points(TA_GlyphHints hints,
 508                                    TA_Dimension dim);
 509
 510 void
 511 ta_glyph_hints_align_weak_points(TA_GlyphHints hints,
 512                                  TA_Dimension dim);
 513
 514 #ifdef TA_CONFIG_OPTION_USE_WARPER
 515 void
 516 ta_glyph_hints_scale_dim(TA_GlyphHints hints,
 517                          TA_Dimension dim,
 518                          FT_Fixed scale,
 519                          FT_Pos delta);
 520 #endif
 521
 522 void
 523 ta_glyph_hints_done(TA_GlyphHints hints);
 524
 525
 526 #define TA_SEGMENT_LEN(seg) \
 527           ((seg)->max_coord - (seg)->min_coord)
 528
 529 #define TA_SEGMENT_DIST(seg1, seg2) \
 530           (((seg1)->pos > (seg2)->pos) ? (seg1)->pos - (seg2)->pos \
 531                                        : (seg2)->pos - (seg1)->pos)
 532
 533 #endif /* __TAHINTS_H__ */
 534
 535 /* end of tahints.h */