ReactOS  0.4.15-dev-1033-gd7d716a
afhints.h
Go to the documentation of this file.
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 
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  {
52  AF_DIR_UP = 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  {
325  } embedded;
326 
327 
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  {
337 
340 
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 
353 
354  FT_UInt32 scaler_flags; /* copy of scaler flags */
355  FT_UInt32 other_flags; /* free for style-specific */
356  /* implementations */
358 
359  FT_Pos xmin_delta; /* used for warping */
361 
362  /* Two arrays to avoid allocation penalty. */
363  /* The `embedded' structure must be the last element! */
364  struct
365  {
368  } embedded;
369 
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 
412  FT_Pos dy );
413 
414 
415  FT_LOCAL( FT_Error )
418  AF_Segment *asegment );
419 
422  FT_Int fpos,
424  FT_Bool top_to_bottom_hinting,
426  AF_Edge *edge );
427 
428  FT_LOCAL( void )
430  FT_Memory memory );
431 
432  FT_LOCAL( void )
435 
436  FT_LOCAL( FT_Error )
438  FT_Outline* outline );
439 
440  FT_LOCAL( void )
442  FT_Outline* outline );
443 
444  FT_LOCAL( void )
446  AF_Dimension dim );
447 
448  FT_LOCAL( void )
450  AF_Dimension dim );
451 
452  FT_LOCAL( void )
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 )
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 
477 
478 #endif /* AFHINTS_H_ */
479 
480 
481 /* END */
namespace GUID const ADDRINFOEXW * hints
Definition: sock.c:80
int FT_Error
Definition: fttypes.h:300
struct AF_AxisHintsRec_ * AF_AxisHints
FT_Int max_contours
Definition: afhints.h:348
FT_Char dir
Definition: afhints.h:261
FT_BEGIN_HEADER typedef signed long FT_Pos
Definition: ftimage.h:58
af_glyph_hints_align_strong_points(AF_GlyphHints hints, AF_Dimension dim)
Definition: afhints.c:1256
AF_Segment edge_next
Definition: afhints.h:269
af_axis_hints_new_segment(AF_AxisHints axis, FT_Memory memory, AF_Segment *asegment)
Definition: afhints.c:38
#define FT_END_HEADER
Definition: ftheader.h:54
GLsizei GLenum const GLvoid GLuint GLsizei GLfloat * metrics
Definition: glext.h:11745
FT_Fixed scale
Definition: afhints.h:290
AF_Point first
Definition: afhints.h:276
signed int FT_Int
Definition: fttypes.h:220
FT_Int num_contours
Definition: afhints.h:349
FT_Short min_coord
Definition: afhints.h:264
GLint dy
Definition: linetemp.h:97
GLenum GLenum GLenum GLenum GLenum scale
Definition: glext.h:9032
struct AF_SegmentRec_ * AF_Segment
Definition: afhints.h:237
FT_Pos ox
Definition: afhints.h:247
FT_Pos y_delta
Definition: afhints.h:342
af_glyph_hints_align_edge_points(AF_GlyphHints hints, AF_Dimension dim)
Definition: afhints.c:1181
struct AF_AxisHintsRec_::@3952 embedded
signed char FT_Char
Definition: fttypes.h:143
struct AF_EdgeRec_ * AF_Edge
Definition: afhints.h:238
FT_Short max_coord
Definition: afhints.h:265
FT_Pos y
Definition: afhints.h:249
enum AF_Direction_ AF_Direction
AF_Edge link
Definition: afhints.h:293
AF_Segment last
Definition: afhints.h:298
af_axis_hints_new_edge(AF_AxisHints axis, FT_Int fpos, AF_Direction dir, FT_Bool top_to_bottom_hinting, FT_Memory memory, AF_Edge *edge)
Definition: afhints.c:99
static char memory[1024 *256]
Definition: process.c:116
FT_Pos oy
Definition: afhints.h:247
struct AF_GlyphHintsRec_ AF_GlyphHintsRec
FT_Byte flags
Definition: afhints.h:260
#define AF_POINTS_EMBEDDED
Definition: afhints.h:331
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
af_glyph_hints_rescale(AF_GlyphHints hints, AF_StyleMetrics metrics)
Definition: afhints.c:720
FT_Byte flags
Definition: afhints.h:288
AF_Segment link
Definition: afhints.h:271
FT_Char in_dir
Definition: afhints.h:244
FT_Int score
Definition: afhints.h:295
unsigned char FT_Byte
Definition: fttypes.h:154
#define FT_BEGIN_HEADER
Definition: ftheader.h:36
FT_Short fy
Definition: afhints.h:248
af_direction_compute(FT_Pos dx, FT_Pos dy)
Definition: afhints.c:613
#define FT_LOCAL(x)
Definition: ftconfig.h:387
FT_Fixed x_scale
Definition: afhints.h:338
FT_Int max_edges
Definition: afhints.h:315
FT_Char dir
Definition: afhints.h:289
unsigned int dir
Definition: maze.c:112
AF_Point points
Definition: afhints.h:346
FT_Pos x_delta
Definition: afhints.h:339
FT_Pos score
Definition: afhints.h:273
struct AF_PointRec_ * AF_Point
Definition: afhints.h:236
FT_Short delta
Definition: afhints.h:263
AF_Point prev
Definition: afhints.h:253
FT_Int num_edges
Definition: afhints.h:314
struct AF_EdgeRec_ AF_EdgeRec
FT_Pos pos
Definition: afhints.h:286
FT_Int max_segments
Definition: afhints.h:308
AF_Point * contours
Definition: afhints.h:350
AF_Segment segments
Definition: afhints.h:309
FT_Int num_points
Definition: afhints.h:345
af_glyph_hints_init(AF_GlyphHints hints, FT_Memory memory)
Definition: afhints.c:662
FT_Memory memory
Definition: afhints.h:336
AF_Segment serif
Definition: afhints.h:272
#define AF_SEGMENTS_EMBEDDED
Definition: afhints.h:302
FT_Char out_dir
Definition: afhints.h:245
FT_Short fpos
Definition: afhints.h:284
struct AF_PointRec_ AF_PointRec
GLsizei const GLfloat * points
Definition: glext.h:8112
AF_Point next
Definition: afhints.h:252
signed short FT_Short
Definition: fttypes.h:198
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
FT_Int max_points
Definition: afhints.h:344
AF_Direction major_dir
Definition: afhints.h:318
AF_Edge edge
Definition: afhints.h:268
FT_Pos u
Definition: afhints.h:250
FT_Int num_segments
Definition: afhints.h:307
af_glyph_hints_reload(AF_GlyphHints hints, FT_Outline *outline)
Definition: afhints.c:732
FT_Short fx
Definition: afhints.h:248
Definition: mesh.c:5329
struct AF_AxisHintsRec_ AF_AxisHintsRec
FT_Short height
Definition: afhints.h:266
FT_Short pos
Definition: afhints.h:262
FT_BEGIN_HEADER enum AF_Dimension_ AF_Dimension
FT_Pos xmax_delta
Definition: afhints.h:360
signed long FT_Fixed
Definition: fttypes.h:288
FT_BEGIN_HEADER struct AF_WidthRec_ * AF_Width
FT_UInt32 other_flags
Definition: afhints.h:355
struct AF_GlyphHintsRec_::@3953 embedded
FT_Pos x
Definition: afhints.h:249
FT_Pos v
Definition: afhints.h:250
GLint dx
Definition: linetemp.h:97
af_glyph_hints_align_weak_points(AF_GlyphHints hints, AF_Dimension dim)
Definition: afhints.c:1507
AF_Dimension_
Definition: afhints.h:33
#define AF_EDGES_EMBEDDED
Definition: afhints.h:303
af_glyph_hints_done(AF_GlyphHints hints)
Definition: afhints.c:672
FT_Pos xmin_delta
Definition: afhints.h:359
AF_Segment first
Definition: afhints.h:297
FT_Pos len
Definition: afhints.h:274
AF_Edge serif
Definition: afhints.h:294
struct AF_SegmentRec_ AF_SegmentRec
unsigned short FT_UShort
Definition: fttypes.h:209
AF_Width blue_edge
Definition: afhints.h:292
AF_AxisHintsRec axis[AF_DIMENSION_MAX]
Definition: afhints.h:352
#define AF_CONTOURS_EMBEDDED
Definition: afhints.h:332
FT_UInt32 scaler_flags
Definition: afhints.h:354
FT_Pos opos
Definition: afhints.h:285
AF_Direction_
Definition: afhints.h:47
af_glyph_hints_save(AF_GlyphHints hints, FT_Outline *outline)
Definition: afhints.c:1146
FT_Fixed y_scale
Definition: afhints.h:341
AF_Point last
Definition: afhints.h:277
AF_Edge edges
Definition: afhints.h:316
AF_StyleMetrics metrics
Definition: afhints.h:357
FT_UShort flags
Definition: afhints.h:243