| /***************************************************************************/ |
| /* */ |
| /* afhints.h */ |
| /* */ |
| /* Auto-fitter hinting routines (specification). */ |
| /* */ |
| /* Copyright 2003-2015 by */ |
| /* David Turner, Robert Wilhelm, and Werner Lemberg. */ |
| /* */ |
| /* This file is part of the FreeType project, and may only be used, */ |
| /* modified, and distributed under the terms of the FreeType project */ |
| /* license, LICENSE.TXT. By continuing to use, modify, or distribute */ |
| /* this file you indicate that you have read the license and */ |
| /* understand and accept it fully. */ |
| /* */ |
| /***************************************************************************/ |
| |
| |
| #ifndef __AFHINTS_H__ |
| #define __AFHINTS_H__ |
| |
| #include "aftypes.h" |
| |
| #define xxAF_SORT_SEGMENTS |
| |
| FT_BEGIN_HEADER |
| |
| /* |
| * The definition of outline glyph hints. These are shared by all |
| * writing system analysis routines (until now). |
| */ |
| |
| typedef enum AF_Dimension_ |
| { |
| AF_DIMENSION_HORZ = 0, /* x coordinates, */ |
| /* i.e., vertical segments & edges */ |
| AF_DIMENSION_VERT = 1, /* y coordinates, */ |
| /* i.e., horizontal segments & edges */ |
| |
| AF_DIMENSION_MAX /* do not remove */ |
| |
| } AF_Dimension; |
| |
| |
| /* hint directions -- the values are computed so that two vectors are */ |
| /* in opposite directions iff `dir1 + dir2 == 0' */ |
| typedef enum AF_Direction_ |
| { |
| AF_DIR_NONE = 4, |
| AF_DIR_RIGHT = 1, |
| AF_DIR_LEFT = -1, |
| AF_DIR_UP = 2, |
| AF_DIR_DOWN = -2 |
| |
| } AF_Direction; |
| |
| |
| /* |
| * The following explanations are mostly taken from the article |
| * |
| * Real-Time Grid Fitting of Typographic Outlines |
| * |
| * by David Turner and Werner Lemberg |
| * |
| * http://www.tug.org/TUGboat/Articles/tb24-3/lemberg.pdf |
| * |
| * with appropriate updates. |
| * |
| * |
| * Segments |
| * |
| * `af_{cjk,latin,...}_hints_compute_segments' are the functions to |
| * find segments in an outline. |
| * |
| * A segment is a series of at least two consecutive points that are |
| * approximately aligned along a coordinate axis. The analysis to do |
| * so is specific to a writing system. |
| * |
| * |
| * Edges |
| * |
| * `af_{cjk,latin,...}_hints_compute_edges' are the functions to find |
| * edges. |
| * |
| * As soon as segments are defined, the auto-hinter groups them into |
| * edges. An edge corresponds to a single position on the main |
| * dimension that collects one or more segments (allowing for a small |
| * threshold). |
| * |
| * As an example, the `latin' writing system first tries to grid-fit |
| * edges, then to align segments on the edges unless it detects that |
| * they form a serif. |
| * |
| * |
| * A H |
| * | | |
| * | | |
| * | | |
| * | | |
| * C | | F |
| * +------<-----+ +-----<------+ |
| * | B G | |
| * | | |
| * | | |
| * +--------------->------------------+ |
| * D E |
| * |
| * |
| * Stems |
| * |
| * Stems are detected by `af_{cjk,latin,...}_hint_edges'. |
| * |
| * Segments need to be `linked' to other ones in order to detect stems. |
| * A stem is made of two segments that face each other in opposite |
| * directions and that are sufficiently close to each other. Using |
| * vocabulary from the TrueType specification, stem segments form a |
| * `black distance'. |
| * |
| * In the above ASCII drawing, the horizontal segments are BC, DE, and |
| * FG; the vertical segments are AB, CD, EF, and GH. |
| * |
| * Each segment has at most one `best' candidate to form a black |
| * distance, or no candidate at all. Notice that two distinct segments |
| * can have the same candidate, which frequently means a serif. |
| * |
| * A stem is recognized by the following condition: |
| * |
| * best segment_1 = segment_2 && best segment_2 = segment_1 |
| * |
| * The best candidate is stored in field `link' in structure |
| * `AF_Segment'. |
| * |
| * In the above ASCII drawing, the best candidate for both AB and CD is |
| * GH, while the best candidate for GH is AB. Similarly, the best |
| * candidate for EF and GH is AB, while the best candidate for AB is |
| * GH. |
| * |
| * The detection and handling of stems is dependent on the writing |
| * system. |
| * |
| * |
| * Serifs |
| * |
| * Serifs are detected by `af_{cjk,latin,...}_hint_edges'. |
| * |
| * In comparison to a stem, a serif (as handled by the auto-hinter |
| * module that takes care of the `latin' writing system) has |
| * |
| * best segment_1 = segment_2 && best segment_2 != segment_1 |
| * |
| * where segment_1 corresponds to the serif segment (CD and EF in the |
| * above ASCII drawing). |
| * |
| * The best candidate is stored in field `serif' in structure |
| * `AF_Segment' (and `link' is set to NULL). |
| * |
| * |
| * Touched points |
| * |
| * A point is called `touched' if it has been processed somehow by the |
| * auto-hinter. It basically means that it shouldn't be moved again |
| * (or moved only under certain constraints to preserve the already |
| * applied processing). |
| * |
| * |
| * Flat and round segments |
| * |
| * Segments are `round' or `flat', depending on the series of points |
| * that define them. A segment is round if the next and previous point |
| * of an extremum (which can be either a single point or sequence of |
| * points) are both conic or cubic control points. Otherwise, a |
| * segment with an extremum is flat. |
| * |
| * |
| * Strong Points |
| * |
| * Experience has shown that points not part of an edge need to be |
| * interpolated linearly between their two closest edges, even if these |
| * are not part of the contour of those particular points. Typical |
| * candidates for this are |
| * |
| * - angle points (i.e., points where the `in' and `out' direction |
| * differ greatly) |
| * |
| * - inflection points (i.e., where the `in' and `out' angles are the |
| * same, but the curvature changes sign) [currently, such points |
| * aren't handled specially in the auto-hinter] |
| * |
| * `af_glyph_hints_align_strong_points' is the function that takes |
| * care of such situations; it is equivalent to the TrueType `IP' |
| * hinting instruction. |
| * |
| * |
| * Weak Points |
| * |
| * Other points in the outline must be interpolated using the |
| * coordinates of their previous and next unfitted contour neighbours. |
| * These are called `weak points' and are touched by the function |
| * `af_glyph_hints_align_weak_points', equivalent to the TrueType `IUP' |
| * hinting instruction. Typical candidates are control points and |
| * points on the contour without a major direction. |
| * |
| * The major effect is to reduce possible distortion caused by |
| * alignment of edges and strong points, thus weak points are processed |
| * after strong points. |
| */ |
| |
| |
| /* point hint flags */ |
| #define AF_FLAG_NONE 0 |
| |
| /* point type flags */ |
| #define AF_FLAG_CONIC ( 1U << 0 ) |
| #define AF_FLAG_CUBIC ( 1U << 1 ) |
| #define AF_FLAG_CONTROL ( AF_FLAG_CONIC | AF_FLAG_CUBIC ) |
| |
| /* point touch flags */ |
| #define AF_FLAG_TOUCH_X ( 1U << 2 ) |
| #define AF_FLAG_TOUCH_Y ( 1U << 3 ) |
| |
| /* candidates for weak interpolation have this flag set */ |
| #define AF_FLAG_WEAK_INTERPOLATION ( 1U << 4 ) |
| |
| |
| /* edge hint flags */ |
| #define AF_EDGE_NORMAL 0 |
| #define AF_EDGE_ROUND ( 1U << 0 ) |
| #define AF_EDGE_SERIF ( 1U << 1 ) |
| #define AF_EDGE_DONE ( 1U << 2 ) |
| #define AF_EDGE_NEUTRAL ( 1U << 3 ) /* edge aligns to a neutral blue zone */ |
| |
| |
| typedef struct AF_PointRec_* AF_Point; |
| typedef struct AF_SegmentRec_* AF_Segment; |
| typedef struct AF_EdgeRec_* AF_Edge; |
| |
| |
| typedef struct AF_PointRec_ |
| { |
| FT_UShort flags; /* point flags used by hinter */ |
| FT_Char in_dir; /* direction of inwards vector */ |
| FT_Char out_dir; /* direction of outwards vector */ |
| |
| FT_Pos ox, oy; /* original, scaled position */ |
| FT_Short fx, fy; /* original, unscaled position (in font units) */ |
| FT_Pos x, y; /* current position */ |
| FT_Pos u, v; /* current (x,y) or (y,x) depending on context */ |
| |
| AF_Point next; /* next point in contour */ |
| AF_Point prev; /* previous point in contour */ |
| |
| } AF_PointRec; |
| |
| |
| typedef struct AF_SegmentRec_ |
| { |
| FT_Byte flags; /* edge/segment flags for this segment */ |
| FT_Char dir; /* segment direction */ |
| FT_Short pos; /* position of segment */ |
| FT_Short min_coord; /* minimum coordinate of segment */ |
| FT_Short max_coord; /* maximum coordinate of segment */ |
| FT_Short height; /* the hinted segment height */ |
| |
| AF_Edge edge; /* the segment's parent edge */ |
| AF_Segment edge_next; /* link to next segment in parent edge */ |
| |
| AF_Segment link; /* (stem) link segment */ |
| AF_Segment serif; /* primary segment for serifs */ |
| FT_Pos num_linked; /* number of linked segments */ |
| FT_Pos score; /* used during stem matching */ |
| FT_Pos len; /* used during stem matching */ |
| |
| AF_Point first; /* first point in edge segment */ |
| AF_Point last; /* last point in edge segment */ |
| |
| } AF_SegmentRec; |
| |
| |
| typedef struct AF_EdgeRec_ |
| { |
| FT_Short fpos; /* original, unscaled position (in font units) */ |
| FT_Pos opos; /* original, scaled position */ |
| FT_Pos pos; /* current position */ |
| |
| FT_Byte flags; /* edge flags */ |
| FT_Char dir; /* edge direction */ |
| FT_Fixed scale; /* used to speed up interpolation between edges */ |
| |
| AF_Width blue_edge; /* non-NULL if this is a blue edge */ |
| AF_Edge link; /* link edge */ |
| AF_Edge serif; /* primary edge for serifs */ |
| FT_Short num_linked; /* number of linked edges */ |
| FT_Int score; /* used during stem matching */ |
| |
| AF_Segment first; /* first segment in edge */ |
| AF_Segment last; /* last segment in edge */ |
| |
| } AF_EdgeRec; |
| |
| #define AF_SEGMENTS_EMBEDDED 18 /* number of embedded segments */ |
| #define AF_EDGES_EMBEDDED 12 /* number of embedded edges */ |
| |
| typedef struct AF_AxisHintsRec_ |
| { |
| FT_Int num_segments; /* number of used segments */ |
| FT_Int max_segments; /* number of allocated segments */ |
| AF_Segment segments; /* segments array */ |
| #ifdef AF_SORT_SEGMENTS |
| FT_Int mid_segments; |
| #endif |
| |
| FT_Int num_edges; /* number of used edges */ |
| FT_Int max_edges; /* number of allocated edges */ |
| AF_Edge edges; /* edges array */ |
| |
| AF_Direction major_dir; /* either vertical or horizontal */ |
| |
| /* two arrays to avoid allocation penalty */ |
| struct |
| { |
| AF_SegmentRec segments[AF_SEGMENTS_EMBEDDED]; |
| AF_EdgeRec edges[AF_EDGES_EMBEDDED]; |
| } embedded; |
| |
| |
| } AF_AxisHintsRec, *AF_AxisHints; |
| |
| |
| #define AF_POINTS_EMBEDDED 96 /* number of embedded points */ |
| #define AF_CONTOURS_EMBEDDED 8 /* number of embedded contours */ |
| |
| typedef struct AF_GlyphHintsRec_ |
| { |
| FT_Memory memory; |
| |
| FT_Fixed x_scale; |
| FT_Pos x_delta; |
| |
| FT_Fixed y_scale; |
| FT_Pos y_delta; |
| |
| FT_Int max_points; /* number of allocated points */ |
| FT_Int num_points; /* number of used points */ |
| AF_Point points; /* points array */ |
| |
| FT_Int max_contours; /* number of allocated contours */ |
| FT_Int num_contours; /* number of used contours */ |
| AF_Point* contours; /* contours array */ |
| |
| AF_AxisHintsRec axis[AF_DIMENSION_MAX]; |
| |
| FT_UInt32 scaler_flags; /* copy of scaler flags */ |
| FT_UInt32 other_flags; /* free for style-specific */ |
| /* implementations */ |
| AF_StyleMetrics metrics; |
| |
| FT_Pos xmin_delta; /* used for warping */ |
| FT_Pos xmax_delta; |
| |
| /* Two arrays to avoid allocation penalty. */ |
| /* The `embedded' structure must be the last element! */ |
| struct |
| { |
| AF_Point contours[AF_CONTOURS_EMBEDDED]; |
| AF_PointRec points[AF_POINTS_EMBEDDED]; |
| } embedded; |
| |
| } AF_GlyphHintsRec; |
| |
| |
| #define AF_HINTS_TEST_SCALER( h, f ) ( (h)->scaler_flags & (f) ) |
| #define AF_HINTS_TEST_OTHER( h, f ) ( (h)->other_flags & (f) ) |
| |
| |
| #ifdef FT_DEBUG_AUTOFIT |
| |
| #define AF_HINTS_DO_HORIZONTAL( h ) \ |
| ( !_af_debug_disable_horz_hints && \ |
| !AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_HORIZONTAL ) ) |
| |
| #define AF_HINTS_DO_VERTICAL( h ) \ |
| ( !_af_debug_disable_vert_hints && \ |
| !AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_VERTICAL ) ) |
| |
| #define AF_HINTS_DO_BLUES( h ) ( !_af_debug_disable_blue_hints ) |
| |
| #else /* !FT_DEBUG_AUTOFIT */ |
| |
| #define AF_HINTS_DO_HORIZONTAL( h ) \ |
| !AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_HORIZONTAL ) |
| |
| #define AF_HINTS_DO_VERTICAL( h ) \ |
| !AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_VERTICAL ) |
| |
| #define AF_HINTS_DO_BLUES( h ) 1 |
| |
| #endif /* !FT_DEBUG_AUTOFIT */ |
| |
| |
| #define AF_HINTS_DO_ADVANCE( h ) \ |
| !AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_ADVANCE ) |
| |
| #define AF_HINTS_DO_WARP( h ) \ |
| !AF_HINTS_TEST_SCALER( h, AF_SCALER_FLAG_NO_WARPER ) |
| |
| |
| |
| FT_LOCAL( AF_Direction ) |
| af_direction_compute( FT_Pos dx, |
| FT_Pos dy ); |
| |
| |
| FT_LOCAL( FT_Error ) |
| af_axis_hints_new_segment( AF_AxisHints axis, |
| FT_Memory memory, |
| AF_Segment *asegment ); |
| |
| FT_LOCAL( FT_Error) |
| af_axis_hints_new_edge( AF_AxisHints axis, |
| FT_Int fpos, |
| AF_Direction dir, |
| FT_Memory memory, |
| AF_Edge *edge ); |
| |
| FT_LOCAL( void ) |
| af_glyph_hints_init( AF_GlyphHints hints, |
| FT_Memory memory ); |
| |
| FT_LOCAL( void ) |
| af_glyph_hints_rescale( AF_GlyphHints hints, |
| AF_StyleMetrics metrics ); |
| |
| FT_LOCAL( FT_Error ) |
| af_glyph_hints_reload( AF_GlyphHints hints, |
| FT_Outline* outline ); |
| |
| FT_LOCAL( void ) |
| af_glyph_hints_save( AF_GlyphHints hints, |
| FT_Outline* outline ); |
| |
| FT_LOCAL( void ) |
| af_glyph_hints_align_edge_points( AF_GlyphHints hints, |
| AF_Dimension dim ); |
| |
| FT_LOCAL( void ) |
| af_glyph_hints_align_strong_points( AF_GlyphHints hints, |
| AF_Dimension dim ); |
| |
| FT_LOCAL( void ) |
| af_glyph_hints_align_weak_points( AF_GlyphHints hints, |
| AF_Dimension dim ); |
| |
| #ifdef AF_CONFIG_OPTION_USE_WARPER |
| FT_LOCAL( void ) |
| af_glyph_hints_scale_dim( AF_GlyphHints hints, |
| AF_Dimension dim, |
| FT_Fixed scale, |
| FT_Pos delta ); |
| #endif |
| |
| FT_LOCAL( void ) |
| af_glyph_hints_done( AF_GlyphHints hints ); |
| |
| /* */ |
| |
| #define AF_SEGMENT_LEN( seg ) ( (seg)->max_coord - (seg)->min_coord ) |
| |
| #define AF_SEGMENT_DIST( seg1, seg2 ) ( ( (seg1)->pos > (seg2)->pos ) \ |
| ? (seg1)->pos - (seg2)->pos \ |
| : (seg2)->pos - (seg1)->pos ) |
| |
| |
| FT_END_HEADER |
| |
| #endif /* __AFHINTS_H__ */ |
| |
| |
| /* END */ |
