|
1 /***************************************************************************/ |
|
2 /* */ |
|
3 /* pshalgo.c */ |
|
4 /* */ |
|
5 /* PostScript hinting algorithm (body). */ |
|
6 /* */ |
|
7 /* Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 */ |
|
8 /* by */ |
|
9 /* David Turner, Robert Wilhelm, and Werner Lemberg. */ |
|
10 /* */ |
|
11 /* This file is part of the FreeType project, and may only be used */ |
|
12 /* modified and distributed under the terms of the FreeType project */ |
|
13 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */ |
|
14 /* this file you indicate that you have read the license and */ |
|
15 /* understand and accept it fully. */ |
|
16 /* */ |
|
17 /***************************************************************************/ |
|
18 |
|
19 |
|
20 #include <ft2build.h> |
|
21 #include FT_INTERNAL_OBJECTS_H |
|
22 #include FT_INTERNAL_DEBUG_H |
|
23 #include FT_INTERNAL_CALC_H |
|
24 #include "pshalgo.h" |
|
25 |
|
26 #include "pshnterr.h" |
|
27 |
|
28 |
|
29 #undef FT_COMPONENT |
|
30 #define FT_COMPONENT trace_pshalgo2 |
|
31 |
|
32 |
|
33 #ifdef DEBUG_HINTER |
|
34 PSH_Hint_Table ps_debug_hint_table = 0; |
|
35 PSH_HintFunc ps_debug_hint_func = 0; |
|
36 PSH_Glyph ps_debug_glyph = 0; |
|
37 #endif |
|
38 |
|
39 |
|
40 #define COMPUTE_INFLEXS /* compute inflection points to optimize `S' */ |
|
41 /* and similar glyphs */ |
|
42 #define STRONGER /* slightly increase the contrast of smooth */ |
|
43 /* hinting */ |
|
44 |
|
45 |
|
46 /*************************************************************************/ |
|
47 /*************************************************************************/ |
|
48 /***** *****/ |
|
49 /***** BASIC HINTS RECORDINGS *****/ |
|
50 /***** *****/ |
|
51 /*************************************************************************/ |
|
52 /*************************************************************************/ |
|
53 |
|
54 /* return true if two stem hints overlap */ |
|
55 static FT_Int |
|
56 psh_hint_overlap( PSH_Hint hint1, |
|
57 PSH_Hint hint2 ) |
|
58 { |
|
59 return hint1->org_pos + hint1->org_len >= hint2->org_pos && |
|
60 hint2->org_pos + hint2->org_len >= hint1->org_pos; |
|
61 } |
|
62 |
|
63 |
|
64 /* destroy hints table */ |
|
65 static void |
|
66 psh_hint_table_done( PSH_Hint_Table table, |
|
67 FT_Memory memory ) |
|
68 { |
|
69 FT_FREE( table->zones ); |
|
70 table->num_zones = 0; |
|
71 table->zone = 0; |
|
72 |
|
73 FT_FREE( table->sort ); |
|
74 FT_FREE( table->hints ); |
|
75 table->num_hints = 0; |
|
76 table->max_hints = 0; |
|
77 table->sort_global = 0; |
|
78 } |
|
79 |
|
80 |
|
81 /* deactivate all hints in a table */ |
|
82 static void |
|
83 psh_hint_table_deactivate( PSH_Hint_Table table ) |
|
84 { |
|
85 FT_UInt count = table->max_hints; |
|
86 PSH_Hint hint = table->hints; |
|
87 |
|
88 |
|
89 for ( ; count > 0; count--, hint++ ) |
|
90 { |
|
91 psh_hint_deactivate( hint ); |
|
92 hint->order = -1; |
|
93 } |
|
94 } |
|
95 |
|
96 |
|
97 /* internal function to record a new hint */ |
|
98 static void |
|
99 psh_hint_table_record( PSH_Hint_Table table, |
|
100 FT_UInt idx ) |
|
101 { |
|
102 PSH_Hint hint = table->hints + idx; |
|
103 |
|
104 |
|
105 if ( idx >= table->max_hints ) |
|
106 { |
|
107 FT_TRACE0(( "psh_hint_table_record: invalid hint index %d\n", idx )); |
|
108 return; |
|
109 } |
|
110 |
|
111 /* ignore active hints */ |
|
112 if ( psh_hint_is_active( hint ) ) |
|
113 return; |
|
114 |
|
115 psh_hint_activate( hint ); |
|
116 |
|
117 /* now scan the current active hint set to check */ |
|
118 /* whether `hint' overlaps with another hint */ |
|
119 { |
|
120 PSH_Hint* sorted = table->sort_global; |
|
121 FT_UInt count = table->num_hints; |
|
122 PSH_Hint hint2; |
|
123 |
|
124 |
|
125 hint->parent = 0; |
|
126 for ( ; count > 0; count--, sorted++ ) |
|
127 { |
|
128 hint2 = sorted[0]; |
|
129 |
|
130 if ( psh_hint_overlap( hint, hint2 ) ) |
|
131 { |
|
132 hint->parent = hint2; |
|
133 break; |
|
134 } |
|
135 } |
|
136 } |
|
137 |
|
138 if ( table->num_hints < table->max_hints ) |
|
139 table->sort_global[table->num_hints++] = hint; |
|
140 else |
|
141 FT_TRACE0(( "psh_hint_table_record: too many sorted hints! BUG!\n" )); |
|
142 } |
|
143 |
|
144 |
|
145 static void |
|
146 psh_hint_table_record_mask( PSH_Hint_Table table, |
|
147 PS_Mask hint_mask ) |
|
148 { |
|
149 FT_Int mask = 0, val = 0; |
|
150 FT_Byte* cursor = hint_mask->bytes; |
|
151 FT_UInt idx, limit; |
|
152 |
|
153 |
|
154 limit = hint_mask->num_bits; |
|
155 |
|
156 for ( idx = 0; idx < limit; idx++ ) |
|
157 { |
|
158 if ( mask == 0 ) |
|
159 { |
|
160 val = *cursor++; |
|
161 mask = 0x80; |
|
162 } |
|
163 |
|
164 if ( val & mask ) |
|
165 psh_hint_table_record( table, idx ); |
|
166 |
|
167 mask >>= 1; |
|
168 } |
|
169 } |
|
170 |
|
171 |
|
172 /* create hints table */ |
|
173 static FT_Error |
|
174 psh_hint_table_init( PSH_Hint_Table table, |
|
175 PS_Hint_Table hints, |
|
176 PS_Mask_Table hint_masks, |
|
177 PS_Mask_Table counter_masks, |
|
178 FT_Memory memory ) |
|
179 { |
|
180 FT_UInt count; |
|
181 FT_Error error; |
|
182 |
|
183 FT_UNUSED( counter_masks ); |
|
184 |
|
185 |
|
186 count = hints->num_hints; |
|
187 |
|
188 /* allocate our tables */ |
|
189 if ( FT_NEW_ARRAY( table->sort, 2 * count ) || |
|
190 FT_NEW_ARRAY( table->hints, count ) || |
|
191 FT_NEW_ARRAY( table->zones, 2 * count + 1 ) ) |
|
192 goto Exit; |
|
193 |
|
194 table->max_hints = count; |
|
195 table->sort_global = table->sort + count; |
|
196 table->num_hints = 0; |
|
197 table->num_zones = 0; |
|
198 table->zone = 0; |
|
199 |
|
200 /* initialize the `table->hints' array */ |
|
201 { |
|
202 PSH_Hint write = table->hints; |
|
203 PS_Hint read = hints->hints; |
|
204 |
|
205 |
|
206 for ( ; count > 0; count--, write++, read++ ) |
|
207 { |
|
208 write->org_pos = read->pos; |
|
209 write->org_len = read->len; |
|
210 write->flags = read->flags; |
|
211 } |
|
212 } |
|
213 |
|
214 /* we now need to determine the initial `parent' stems; first */ |
|
215 /* activate the hints that are given by the initial hint masks */ |
|
216 if ( hint_masks ) |
|
217 { |
|
218 PS_Mask mask = hint_masks->masks; |
|
219 |
|
220 |
|
221 count = hint_masks->num_masks; |
|
222 table->hint_masks = hint_masks; |
|
223 |
|
224 for ( ; count > 0; count--, mask++ ) |
|
225 psh_hint_table_record_mask( table, mask ); |
|
226 } |
|
227 |
|
228 /* finally, do a linear parse in case some hints were left alone */ |
|
229 if ( table->num_hints != table->max_hints ) |
|
230 { |
|
231 FT_UInt idx; |
|
232 |
|
233 |
|
234 FT_TRACE0(( "psh_hint_table_init: missing/incorrect hint masks\n" )); |
|
235 |
|
236 count = table->max_hints; |
|
237 for ( idx = 0; idx < count; idx++ ) |
|
238 psh_hint_table_record( table, idx ); |
|
239 } |
|
240 |
|
241 Exit: |
|
242 return error; |
|
243 } |
|
244 |
|
245 |
|
246 static void |
|
247 psh_hint_table_activate_mask( PSH_Hint_Table table, |
|
248 PS_Mask hint_mask ) |
|
249 { |
|
250 FT_Int mask = 0, val = 0; |
|
251 FT_Byte* cursor = hint_mask->bytes; |
|
252 FT_UInt idx, limit, count; |
|
253 |
|
254 |
|
255 limit = hint_mask->num_bits; |
|
256 count = 0; |
|
257 |
|
258 psh_hint_table_deactivate( table ); |
|
259 |
|
260 for ( idx = 0; idx < limit; idx++ ) |
|
261 { |
|
262 if ( mask == 0 ) |
|
263 { |
|
264 val = *cursor++; |
|
265 mask = 0x80; |
|
266 } |
|
267 |
|
268 if ( val & mask ) |
|
269 { |
|
270 PSH_Hint hint = &table->hints[idx]; |
|
271 |
|
272 |
|
273 if ( !psh_hint_is_active( hint ) ) |
|
274 { |
|
275 FT_UInt count2; |
|
276 |
|
277 #if 0 |
|
278 PSH_Hint* sort = table->sort; |
|
279 PSH_Hint hint2; |
|
280 |
|
281 |
|
282 for ( count2 = count; count2 > 0; count2--, sort++ ) |
|
283 { |
|
284 hint2 = sort[0]; |
|
285 if ( psh_hint_overlap( hint, hint2 ) ) |
|
286 FT_TRACE0(( "psh_hint_table_activate_mask:" |
|
287 " found overlapping hints\n" )) |
|
288 } |
|
289 #else |
|
290 count2 = 0; |
|
291 #endif |
|
292 |
|
293 if ( count2 == 0 ) |
|
294 { |
|
295 psh_hint_activate( hint ); |
|
296 if ( count < table->max_hints ) |
|
297 table->sort[count++] = hint; |
|
298 else |
|
299 FT_TRACE0(( "psh_hint_tableactivate_mask:" |
|
300 " too many active hints\n" )); |
|
301 } |
|
302 } |
|
303 } |
|
304 |
|
305 mask >>= 1; |
|
306 } |
|
307 table->num_hints = count; |
|
308 |
|
309 /* now, sort the hints; they are guaranteed to not overlap */ |
|
310 /* so we can compare their "org_pos" field directly */ |
|
311 { |
|
312 FT_Int i1, i2; |
|
313 PSH_Hint hint1, hint2; |
|
314 PSH_Hint* sort = table->sort; |
|
315 |
|
316 |
|
317 /* a simple bubble sort will do, since in 99% of cases, the hints */ |
|
318 /* will be already sorted -- and the sort will be linear */ |
|
319 for ( i1 = 1; i1 < (FT_Int)count; i1++ ) |
|
320 { |
|
321 hint1 = sort[i1]; |
|
322 for ( i2 = i1 - 1; i2 >= 0; i2-- ) |
|
323 { |
|
324 hint2 = sort[i2]; |
|
325 |
|
326 if ( hint2->org_pos < hint1->org_pos ) |
|
327 break; |
|
328 |
|
329 sort[i2 + 1] = hint2; |
|
330 sort[i2] = hint1; |
|
331 } |
|
332 } |
|
333 } |
|
334 } |
|
335 |
|
336 |
|
337 /*************************************************************************/ |
|
338 /*************************************************************************/ |
|
339 /***** *****/ |
|
340 /***** HINTS GRID-FITTING AND OPTIMIZATION *****/ |
|
341 /***** *****/ |
|
342 /*************************************************************************/ |
|
343 /*************************************************************************/ |
|
344 |
|
345 #if 1 |
|
346 static FT_Pos |
|
347 psh_dimension_quantize_len( PSH_Dimension dim, |
|
348 FT_Pos len, |
|
349 FT_Bool do_snapping ) |
|
350 { |
|
351 if ( len <= 64 ) |
|
352 len = 64; |
|
353 else |
|
354 { |
|
355 FT_Pos delta = len - dim->stdw.widths[0].cur; |
|
356 |
|
357 |
|
358 if ( delta < 0 ) |
|
359 delta = -delta; |
|
360 |
|
361 if ( delta < 40 ) |
|
362 { |
|
363 len = dim->stdw.widths[0].cur; |
|
364 if ( len < 48 ) |
|
365 len = 48; |
|
366 } |
|
367 |
|
368 if ( len < 3 * 64 ) |
|
369 { |
|
370 delta = ( len & 63 ); |
|
371 len &= -64; |
|
372 |
|
373 if ( delta < 10 ) |
|
374 len += delta; |
|
375 |
|
376 else if ( delta < 32 ) |
|
377 len += 10; |
|
378 |
|
379 else if ( delta < 54 ) |
|
380 len += 54; |
|
381 |
|
382 else |
|
383 len += delta; |
|
384 } |
|
385 else |
|
386 len = FT_PIX_ROUND( len ); |
|
387 } |
|
388 |
|
389 if ( do_snapping ) |
|
390 len = FT_PIX_ROUND( len ); |
|
391 |
|
392 return len; |
|
393 } |
|
394 #endif /* 0 */ |
|
395 |
|
396 |
|
397 #ifdef DEBUG_HINTER |
|
398 |
|
399 static void |
|
400 ps_simple_scale( PSH_Hint_Table table, |
|
401 FT_Fixed scale, |
|
402 FT_Fixed delta, |
|
403 FT_Int dimension ) |
|
404 { |
|
405 PSH_Hint hint; |
|
406 FT_UInt count; |
|
407 |
|
408 |
|
409 for ( count = 0; count < table->max_hints; count++ ) |
|
410 { |
|
411 hint = table->hints + count; |
|
412 |
|
413 hint->cur_pos = FT_MulFix( hint->org_pos, scale ) + delta; |
|
414 hint->cur_len = FT_MulFix( hint->org_len, scale ); |
|
415 |
|
416 if ( ps_debug_hint_func ) |
|
417 ps_debug_hint_func( hint, dimension ); |
|
418 } |
|
419 } |
|
420 |
|
421 #endif /* DEBUG_HINTER */ |
|
422 |
|
423 |
|
424 static FT_Fixed |
|
425 psh_hint_snap_stem_side_delta( FT_Fixed pos, |
|
426 FT_Fixed len ) |
|
427 { |
|
428 FT_Fixed delta1 = FT_PIX_ROUND( pos ) - pos; |
|
429 FT_Fixed delta2 = FT_PIX_ROUND( pos + len ) - pos - len; |
|
430 |
|
431 |
|
432 if ( FT_ABS( delta1 ) <= FT_ABS( delta2 ) ) |
|
433 return delta1; |
|
434 else |
|
435 return delta2; |
|
436 } |
|
437 |
|
438 |
|
439 static void |
|
440 psh_hint_align( PSH_Hint hint, |
|
441 PSH_Globals globals, |
|
442 FT_Int dimension, |
|
443 PSH_Glyph glyph ) |
|
444 { |
|
445 PSH_Dimension dim = &globals->dimension[dimension]; |
|
446 FT_Fixed scale = dim->scale_mult; |
|
447 FT_Fixed delta = dim->scale_delta; |
|
448 |
|
449 |
|
450 if ( !psh_hint_is_fitted( hint ) ) |
|
451 { |
|
452 FT_Pos pos = FT_MulFix( hint->org_pos, scale ) + delta; |
|
453 FT_Pos len = FT_MulFix( hint->org_len, scale ); |
|
454 |
|
455 FT_Int do_snapping; |
|
456 FT_Pos fit_len; |
|
457 PSH_AlignmentRec align; |
|
458 |
|
459 |
|
460 /* ignore stem alignments when requested through the hint flags */ |
|
461 if ( ( dimension == 0 && !glyph->do_horz_hints ) || |
|
462 ( dimension == 1 && !glyph->do_vert_hints ) ) |
|
463 { |
|
464 hint->cur_pos = pos; |
|
465 hint->cur_len = len; |
|
466 |
|
467 psh_hint_set_fitted( hint ); |
|
468 return; |
|
469 } |
|
470 |
|
471 /* perform stem snapping when requested - this is necessary |
|
472 * for monochrome and LCD hinting modes only |
|
473 */ |
|
474 do_snapping = ( dimension == 0 && glyph->do_horz_snapping ) || |
|
475 ( dimension == 1 && glyph->do_vert_snapping ); |
|
476 |
|
477 hint->cur_len = fit_len = len; |
|
478 |
|
479 /* check blue zones for horizontal stems */ |
|
480 align.align = PSH_BLUE_ALIGN_NONE; |
|
481 align.align_bot = align.align_top = 0; |
|
482 |
|
483 if ( dimension == 1 ) |
|
484 psh_blues_snap_stem( &globals->blues, |
|
485 hint->org_pos + hint->org_len, |
|
486 hint->org_pos, |
|
487 &align ); |
|
488 |
|
489 switch ( align.align ) |
|
490 { |
|
491 case PSH_BLUE_ALIGN_TOP: |
|
492 /* the top of the stem is aligned against a blue zone */ |
|
493 hint->cur_pos = align.align_top - fit_len; |
|
494 break; |
|
495 |
|
496 case PSH_BLUE_ALIGN_BOT: |
|
497 /* the bottom of the stem is aligned against a blue zone */ |
|
498 hint->cur_pos = align.align_bot; |
|
499 break; |
|
500 |
|
501 case PSH_BLUE_ALIGN_TOP | PSH_BLUE_ALIGN_BOT: |
|
502 /* both edges of the stem are aligned against blue zones */ |
|
503 hint->cur_pos = align.align_bot; |
|
504 hint->cur_len = align.align_top - align.align_bot; |
|
505 break; |
|
506 |
|
507 default: |
|
508 { |
|
509 PSH_Hint parent = hint->parent; |
|
510 |
|
511 |
|
512 if ( parent ) |
|
513 { |
|
514 FT_Pos par_org_center, par_cur_center; |
|
515 FT_Pos cur_org_center, cur_delta; |
|
516 |
|
517 |
|
518 /* ensure that parent is already fitted */ |
|
519 if ( !psh_hint_is_fitted( parent ) ) |
|
520 psh_hint_align( parent, globals, dimension, glyph ); |
|
521 |
|
522 /* keep original relation between hints, this is, use the */ |
|
523 /* scaled distance between the centers of the hints to */ |
|
524 /* compute the new position */ |
|
525 par_org_center = parent->org_pos + ( parent->org_len >> 1 ); |
|
526 par_cur_center = parent->cur_pos + ( parent->cur_len >> 1 ); |
|
527 cur_org_center = hint->org_pos + ( hint->org_len >> 1 ); |
|
528 |
|
529 cur_delta = FT_MulFix( cur_org_center - par_org_center, scale ); |
|
530 pos = par_cur_center + cur_delta - ( len >> 1 ); |
|
531 } |
|
532 |
|
533 hint->cur_pos = pos; |
|
534 hint->cur_len = fit_len; |
|
535 |
|
536 /* Stem adjustment tries to snap stem widths to standard |
|
537 * ones. This is important to prevent unpleasant rounding |
|
538 * artefacts. |
|
539 */ |
|
540 if ( glyph->do_stem_adjust ) |
|
541 { |
|
542 if ( len <= 64 ) |
|
543 { |
|
544 /* the stem is less than one pixel; we will center it |
|
545 * around the nearest pixel center |
|
546 */ |
|
547 if ( len >= 32 ) |
|
548 { |
|
549 /* This is a special case where we also widen the stem |
|
550 * and align it to the pixel grid. |
|
551 * |
|
552 * stem_center = pos + (len/2) |
|
553 * nearest_pixel_center = FT_ROUND(stem_center-32)+32 |
|
554 * new_pos = nearest_pixel_center-32 |
|
555 * = FT_ROUND(stem_center-32) |
|
556 * = FT_FLOOR(stem_center-32+32) |
|
557 * = FT_FLOOR(stem_center) |
|
558 * new_len = 64 |
|
559 */ |
|
560 pos = FT_PIX_FLOOR( pos + ( len >> 1 ) ); |
|
561 len = 64; |
|
562 } |
|
563 else if ( len > 0 ) |
|
564 { |
|
565 /* This is a very small stem; we simply align it to the |
|
566 * pixel grid, trying to find the minimal displacement. |
|
567 * |
|
568 * left = pos |
|
569 * right = pos + len |
|
570 * left_nearest_edge = ROUND(pos) |
|
571 * right_nearest_edge = ROUND(right) |
|
572 * |
|
573 * if ( ABS(left_nearest_edge - left) <= |
|
574 * ABS(right_nearest_edge - right) ) |
|
575 * new_pos = left |
|
576 * else |
|
577 * new_pos = right |
|
578 */ |
|
579 FT_Pos left_nearest = FT_PIX_ROUND( pos ); |
|
580 FT_Pos right_nearest = FT_PIX_ROUND( pos + len ); |
|
581 FT_Pos left_disp = left_nearest - pos; |
|
582 FT_Pos right_disp = right_nearest - ( pos + len ); |
|
583 |
|
584 |
|
585 if ( left_disp < 0 ) |
|
586 left_disp = -left_disp; |
|
587 if ( right_disp < 0 ) |
|
588 right_disp = -right_disp; |
|
589 if ( left_disp <= right_disp ) |
|
590 pos = left_nearest; |
|
591 else |
|
592 pos = right_nearest; |
|
593 } |
|
594 else |
|
595 { |
|
596 /* this is a ghost stem; we simply round it */ |
|
597 pos = FT_PIX_ROUND( pos ); |
|
598 } |
|
599 } |
|
600 else |
|
601 { |
|
602 len = psh_dimension_quantize_len( dim, len, 0 ); |
|
603 } |
|
604 } |
|
605 |
|
606 /* now that we have a good hinted stem width, try to position */ |
|
607 /* the stem along a pixel grid integer coordinate */ |
|
608 hint->cur_pos = pos + psh_hint_snap_stem_side_delta( pos, len ); |
|
609 hint->cur_len = len; |
|
610 } |
|
611 } |
|
612 |
|
613 if ( do_snapping ) |
|
614 { |
|
615 pos = hint->cur_pos; |
|
616 len = hint->cur_len; |
|
617 |
|
618 if ( len < 64 ) |
|
619 len = 64; |
|
620 else |
|
621 len = FT_PIX_ROUND( len ); |
|
622 |
|
623 switch ( align.align ) |
|
624 { |
|
625 case PSH_BLUE_ALIGN_TOP: |
|
626 hint->cur_pos = align.align_top - len; |
|
627 hint->cur_len = len; |
|
628 break; |
|
629 |
|
630 case PSH_BLUE_ALIGN_BOT: |
|
631 hint->cur_len = len; |
|
632 break; |
|
633 |
|
634 case PSH_BLUE_ALIGN_BOT | PSH_BLUE_ALIGN_TOP: |
|
635 /* don't touch */ |
|
636 break; |
|
637 |
|
638 |
|
639 default: |
|
640 hint->cur_len = len; |
|
641 if ( len & 64 ) |
|
642 pos = FT_PIX_FLOOR( pos + ( len >> 1 ) ) + 32; |
|
643 else |
|
644 pos = FT_PIX_ROUND( pos + ( len >> 1 ) ); |
|
645 |
|
646 hint->cur_pos = pos - ( len >> 1 ); |
|
647 hint->cur_len = len; |
|
648 } |
|
649 } |
|
650 |
|
651 psh_hint_set_fitted( hint ); |
|
652 |
|
653 #ifdef DEBUG_HINTER |
|
654 if ( ps_debug_hint_func ) |
|
655 ps_debug_hint_func( hint, dimension ); |
|
656 #endif |
|
657 } |
|
658 } |
|
659 |
|
660 |
|
661 #if 0 /* not used for now, experimental */ |
|
662 |
|
663 /* |
|
664 * A variant to perform "light" hinting (i.e. FT_RENDER_MODE_LIGHT) |
|
665 * of stems |
|
666 */ |
|
667 static void |
|
668 psh_hint_align_light( PSH_Hint hint, |
|
669 PSH_Globals globals, |
|
670 FT_Int dimension, |
|
671 PSH_Glyph glyph ) |
|
672 { |
|
673 PSH_Dimension dim = &globals->dimension[dimension]; |
|
674 FT_Fixed scale = dim->scale_mult; |
|
675 FT_Fixed delta = dim->scale_delta; |
|
676 |
|
677 |
|
678 if ( !psh_hint_is_fitted( hint ) ) |
|
679 { |
|
680 FT_Pos pos = FT_MulFix( hint->org_pos, scale ) + delta; |
|
681 FT_Pos len = FT_MulFix( hint->org_len, scale ); |
|
682 |
|
683 FT_Pos fit_len; |
|
684 |
|
685 PSH_AlignmentRec align; |
|
686 |
|
687 |
|
688 /* ignore stem alignments when requested through the hint flags */ |
|
689 if ( ( dimension == 0 && !glyph->do_horz_hints ) || |
|
690 ( dimension == 1 && !glyph->do_vert_hints ) ) |
|
691 { |
|
692 hint->cur_pos = pos; |
|
693 hint->cur_len = len; |
|
694 |
|
695 psh_hint_set_fitted( hint ); |
|
696 return; |
|
697 } |
|
698 |
|
699 fit_len = len; |
|
700 |
|
701 hint->cur_len = fit_len; |
|
702 |
|
703 /* check blue zones for horizontal stems */ |
|
704 align.align = PSH_BLUE_ALIGN_NONE; |
|
705 align.align_bot = align.align_top = 0; |
|
706 |
|
707 if ( dimension == 1 ) |
|
708 psh_blues_snap_stem( &globals->blues, |
|
709 hint->org_pos + hint->org_len, |
|
710 hint->org_pos, |
|
711 &align ); |
|
712 |
|
713 switch ( align.align ) |
|
714 { |
|
715 case PSH_BLUE_ALIGN_TOP: |
|
716 /* the top of the stem is aligned against a blue zone */ |
|
717 hint->cur_pos = align.align_top - fit_len; |
|
718 break; |
|
719 |
|
720 case PSH_BLUE_ALIGN_BOT: |
|
721 /* the bottom of the stem is aligned against a blue zone */ |
|
722 hint->cur_pos = align.align_bot; |
|
723 break; |
|
724 |
|
725 case PSH_BLUE_ALIGN_TOP | PSH_BLUE_ALIGN_BOT: |
|
726 /* both edges of the stem are aligned against blue zones */ |
|
727 hint->cur_pos = align.align_bot; |
|
728 hint->cur_len = align.align_top - align.align_bot; |
|
729 break; |
|
730 |
|
731 default: |
|
732 { |
|
733 PSH_Hint parent = hint->parent; |
|
734 |
|
735 |
|
736 if ( parent ) |
|
737 { |
|
738 FT_Pos par_org_center, par_cur_center; |
|
739 FT_Pos cur_org_center, cur_delta; |
|
740 |
|
741 |
|
742 /* ensure that parent is already fitted */ |
|
743 if ( !psh_hint_is_fitted( parent ) ) |
|
744 psh_hint_align_light( parent, globals, dimension, glyph ); |
|
745 |
|
746 par_org_center = parent->org_pos + ( parent->org_len / 2 ); |
|
747 par_cur_center = parent->cur_pos + ( parent->cur_len / 2 ); |
|
748 cur_org_center = hint->org_pos + ( hint->org_len / 2 ); |
|
749 |
|
750 cur_delta = FT_MulFix( cur_org_center - par_org_center, scale ); |
|
751 pos = par_cur_center + cur_delta - ( len >> 1 ); |
|
752 } |
|
753 |
|
754 /* Stems less than one pixel wide are easy -- we want to |
|
755 * make them as dark as possible, so they must fall within |
|
756 * one pixel. If the stem is split between two pixels |
|
757 * then snap the edge that is nearer to the pixel boundary |
|
758 * to the pixel boundary. |
|
759 */ |
|
760 if ( len <= 64 ) |
|
761 { |
|
762 if ( ( pos + len + 63 ) / 64 != pos / 64 + 1 ) |
|
763 pos += psh_hint_snap_stem_side_delta ( pos, len ); |
|
764 } |
|
765 |
|
766 /* Position stems other to minimize the amount of mid-grays. |
|
767 * There are, in general, two positions that do this, |
|
768 * illustrated as A) and B) below. |
|
769 * |
|
770 * + + + + |
|
771 * |
|
772 * A) |--------------------------------| |
|
773 * B) |--------------------------------| |
|
774 * C) |--------------------------------| |
|
775 * |
|
776 * Position A) (split the excess stem equally) should be better |
|
777 * for stems of width N + f where f < 0.5. |
|
778 * |
|
779 * Position B) (split the deficiency equally) should be better |
|
780 * for stems of width N + f where f > 0.5. |
|
781 * |
|
782 * It turns out though that minimizing the total number of lit |
|
783 * pixels is also important, so position C), with one edge |
|
784 * aligned with a pixel boundary is actually preferable |
|
785 * to A). There are also more possibile positions for C) than |
|
786 * for A) or B), so it involves less distortion of the overall |
|
787 * character shape. |
|
788 */ |
|
789 else /* len > 64 */ |
|
790 { |
|
791 FT_Fixed frac_len = len & 63; |
|
792 FT_Fixed center = pos + ( len >> 1 ); |
|
793 FT_Fixed delta_a, delta_b; |
|
794 |
|
795 |
|
796 if ( ( len / 64 ) & 1 ) |
|
797 { |
|
798 delta_a = FT_PIX_FLOOR( center ) + 32 - center; |
|
799 delta_b = FT_PIX_ROUND( center ) - center; |
|
800 } |
|
801 else |
|
802 { |
|
803 delta_a = FT_PIX_ROUND( center ) - center; |
|
804 delta_b = FT_PIX_FLOOR( center ) + 32 - center; |
|
805 } |
|
806 |
|
807 /* We choose between B) and C) above based on the amount |
|
808 * of fractinal stem width; for small amounts, choose |
|
809 * C) always, for large amounts, B) always, and inbetween, |
|
810 * pick whichever one involves less stem movement. |
|
811 */ |
|
812 if ( frac_len < 32 ) |
|
813 { |
|
814 pos += psh_hint_snap_stem_side_delta ( pos, len ); |
|
815 } |
|
816 else if ( frac_len < 48 ) |
|
817 { |
|
818 FT_Fixed side_delta = psh_hint_snap_stem_side_delta ( pos, |
|
819 len ); |
|
820 |
|
821 if ( FT_ABS( side_delta ) < FT_ABS( delta_b ) ) |
|
822 pos += side_delta; |
|
823 else |
|
824 pos += delta_b; |
|
825 } |
|
826 else |
|
827 { |
|
828 pos += delta_b; |
|
829 } |
|
830 } |
|
831 |
|
832 hint->cur_pos = pos; |
|
833 } |
|
834 } /* switch */ |
|
835 |
|
836 psh_hint_set_fitted( hint ); |
|
837 |
|
838 #ifdef DEBUG_HINTER |
|
839 if ( ps_debug_hint_func ) |
|
840 ps_debug_hint_func( hint, dimension ); |
|
841 #endif |
|
842 } |
|
843 } |
|
844 |
|
845 #endif /* 0 */ |
|
846 |
|
847 |
|
848 static void |
|
849 psh_hint_table_align_hints( PSH_Hint_Table table, |
|
850 PSH_Globals globals, |
|
851 FT_Int dimension, |
|
852 PSH_Glyph glyph ) |
|
853 { |
|
854 PSH_Hint hint; |
|
855 FT_UInt count; |
|
856 |
|
857 #ifdef DEBUG_HINTER |
|
858 |
|
859 PSH_Dimension dim = &globals->dimension[dimension]; |
|
860 FT_Fixed scale = dim->scale_mult; |
|
861 FT_Fixed delta = dim->scale_delta; |
|
862 |
|
863 |
|
864 if ( ps_debug_no_vert_hints && dimension == 0 ) |
|
865 { |
|
866 ps_simple_scale( table, scale, delta, dimension ); |
|
867 return; |
|
868 } |
|
869 |
|
870 if ( ps_debug_no_horz_hints && dimension == 1 ) |
|
871 { |
|
872 ps_simple_scale( table, scale, delta, dimension ); |
|
873 return; |
|
874 } |
|
875 |
|
876 #endif /* DEBUG_HINTER*/ |
|
877 |
|
878 hint = table->hints; |
|
879 count = table->max_hints; |
|
880 |
|
881 for ( ; count > 0; count--, hint++ ) |
|
882 psh_hint_align( hint, globals, dimension, glyph ); |
|
883 } |
|
884 |
|
885 |
|
886 /*************************************************************************/ |
|
887 /*************************************************************************/ |
|
888 /***** *****/ |
|
889 /***** POINTS INTERPOLATION ROUTINES *****/ |
|
890 /***** *****/ |
|
891 /*************************************************************************/ |
|
892 /*************************************************************************/ |
|
893 |
|
894 #define PSH_ZONE_MIN -3200000L |
|
895 #define PSH_ZONE_MAX +3200000L |
|
896 |
|
897 #define xxDEBUG_ZONES |
|
898 |
|
899 |
|
900 #ifdef DEBUG_ZONES |
|
901 |
|
902 #include FT_CONFIG_STANDARD_LIBRARY_H |
|
903 |
|
904 static void |
|
905 psh_print_zone( PSH_Zone zone ) |
|
906 { |
|
907 printf( "zone [scale,delta,min,max] = [%.3f,%.3f,%d,%d]\n", |
|
908 zone->scale / 65536.0, |
|
909 zone->delta / 64.0, |
|
910 zone->min, |
|
911 zone->max ); |
|
912 } |
|
913 |
|
914 #else |
|
915 |
|
916 #define psh_print_zone( x ) do { } while ( 0 ) |
|
917 |
|
918 #endif /* DEBUG_ZONES */ |
|
919 |
|
920 |
|
921 /*************************************************************************/ |
|
922 /*************************************************************************/ |
|
923 /***** *****/ |
|
924 /***** HINTER GLYPH MANAGEMENT *****/ |
|
925 /***** *****/ |
|
926 /*************************************************************************/ |
|
927 /*************************************************************************/ |
|
928 |
|
929 #if 1 |
|
930 |
|
931 #define psh_corner_is_flat ft_corner_is_flat |
|
932 #define psh_corner_orientation ft_corner_orientation |
|
933 |
|
934 #else |
|
935 |
|
936 FT_LOCAL_DEF( FT_Int ) |
|
937 psh_corner_is_flat( FT_Pos x_in, |
|
938 FT_Pos y_in, |
|
939 FT_Pos x_out, |
|
940 FT_Pos y_out ) |
|
941 { |
|
942 FT_Pos ax = x_in; |
|
943 FT_Pos ay = y_in; |
|
944 |
|
945 FT_Pos d_in, d_out, d_corner; |
|
946 |
|
947 |
|
948 if ( ax < 0 ) |
|
949 ax = -ax; |
|
950 if ( ay < 0 ) |
|
951 ay = -ay; |
|
952 d_in = ax + ay; |
|
953 |
|
954 ax = x_out; |
|
955 if ( ax < 0 ) |
|
956 ax = -ax; |
|
957 ay = y_out; |
|
958 if ( ay < 0 ) |
|
959 ay = -ay; |
|
960 d_out = ax + ay; |
|
961 |
|
962 ax = x_out + x_in; |
|
963 if ( ax < 0 ) |
|
964 ax = -ax; |
|
965 ay = y_out + y_in; |
|
966 if ( ay < 0 ) |
|
967 ay = -ay; |
|
968 d_corner = ax + ay; |
|
969 |
|
970 return ( d_in + d_out - d_corner ) < ( d_corner >> 4 ); |
|
971 } |
|
972 |
|
973 static FT_Int |
|
974 psh_corner_orientation( FT_Pos in_x, |
|
975 FT_Pos in_y, |
|
976 FT_Pos out_x, |
|
977 FT_Pos out_y ) |
|
978 { |
|
979 FT_Int result; |
|
980 |
|
981 |
|
982 /* deal with the trivial cases quickly */ |
|
983 if ( in_y == 0 ) |
|
984 { |
|
985 if ( in_x >= 0 ) |
|
986 result = out_y; |
|
987 else |
|
988 result = -out_y; |
|
989 } |
|
990 else if ( in_x == 0 ) |
|
991 { |
|
992 if ( in_y >= 0 ) |
|
993 result = -out_x; |
|
994 else |
|
995 result = out_x; |
|
996 } |
|
997 else if ( out_y == 0 ) |
|
998 { |
|
999 if ( out_x >= 0 ) |
|
1000 result = in_y; |
|
1001 else |
|
1002 result = -in_y; |
|
1003 } |
|
1004 else if ( out_x == 0 ) |
|
1005 { |
|
1006 if ( out_y >= 0 ) |
|
1007 result = -in_x; |
|
1008 else |
|
1009 result = in_x; |
|
1010 } |
|
1011 else /* general case */ |
|
1012 { |
|
1013 long long delta = (long long)in_x * out_y - (long long)in_y * out_x; |
|
1014 |
|
1015 if ( delta == 0 ) |
|
1016 result = 0; |
|
1017 else |
|
1018 result = 1 - 2 * ( delta < 0 ); |
|
1019 } |
|
1020 |
|
1021 return result; |
|
1022 } |
|
1023 |
|
1024 #endif /* !1 */ |
|
1025 |
|
1026 |
|
1027 #ifdef COMPUTE_INFLEXS |
|
1028 |
|
1029 /* compute all inflex points in a given glyph */ |
|
1030 static void |
|
1031 psh_glyph_compute_inflections( PSH_Glyph glyph ) |
|
1032 { |
|
1033 FT_UInt n; |
|
1034 |
|
1035 |
|
1036 for ( n = 0; n < glyph->num_contours; n++ ) |
|
1037 { |
|
1038 PSH_Point first, start, end, before, after; |
|
1039 FT_Pos in_x, in_y, out_x, out_y; |
|
1040 FT_Int orient_prev, orient_cur; |
|
1041 FT_Int finished = 0; |
|
1042 |
|
1043 |
|
1044 /* we need at least 4 points to create an inflection point */ |
|
1045 if ( glyph->contours[n].count < 4 ) |
|
1046 continue; |
|
1047 |
|
1048 /* compute first segment in contour */ |
|
1049 first = glyph->contours[n].start; |
|
1050 |
|
1051 start = end = first; |
|
1052 do |
|
1053 { |
|
1054 end = end->next; |
|
1055 if ( end == first ) |
|
1056 goto Skip; |
|
1057 |
|
1058 in_x = end->org_u - start->org_u; |
|
1059 in_y = end->org_v - start->org_v; |
|
1060 |
|
1061 } while ( in_x == 0 && in_y == 0 ); |
|
1062 |
|
1063 /* extend the segment start whenever possible */ |
|
1064 before = start; |
|
1065 do |
|
1066 { |
|
1067 do |
|
1068 { |
|
1069 start = before; |
|
1070 before = before->prev; |
|
1071 if ( before == first ) |
|
1072 goto Skip; |
|
1073 |
|
1074 out_x = start->org_u - before->org_u; |
|
1075 out_y = start->org_v - before->org_v; |
|
1076 |
|
1077 } while ( out_x == 0 && out_y == 0 ); |
|
1078 |
|
1079 orient_prev = psh_corner_orientation( in_x, in_y, out_x, out_y ); |
|
1080 |
|
1081 } while ( orient_prev == 0 ); |
|
1082 |
|
1083 first = start; |
|
1084 in_x = out_x; |
|
1085 in_y = out_y; |
|
1086 |
|
1087 /* now, process all segments in the contour */ |
|
1088 do |
|
1089 { |
|
1090 /* first, extend current segment's end whenever possible */ |
|
1091 after = end; |
|
1092 do |
|
1093 { |
|
1094 do |
|
1095 { |
|
1096 end = after; |
|
1097 after = after->next; |
|
1098 if ( after == first ) |
|
1099 finished = 1; |
|
1100 |
|
1101 out_x = after->org_u - end->org_u; |
|
1102 out_y = after->org_v - end->org_v; |
|
1103 |
|
1104 } while ( out_x == 0 && out_y == 0 ); |
|
1105 |
|
1106 orient_cur = psh_corner_orientation( in_x, in_y, out_x, out_y ); |
|
1107 |
|
1108 } while ( orient_cur == 0 ); |
|
1109 |
|
1110 if ( ( orient_cur ^ orient_prev ) < 0 ) |
|
1111 { |
|
1112 do |
|
1113 { |
|
1114 psh_point_set_inflex( start ); |
|
1115 start = start->next; |
|
1116 } |
|
1117 while ( start != end ); |
|
1118 |
|
1119 psh_point_set_inflex( start ); |
|
1120 } |
|
1121 |
|
1122 start = end; |
|
1123 end = after; |
|
1124 orient_prev = orient_cur; |
|
1125 in_x = out_x; |
|
1126 in_y = out_y; |
|
1127 |
|
1128 } while ( !finished ); |
|
1129 |
|
1130 Skip: |
|
1131 ; |
|
1132 } |
|
1133 } |
|
1134 |
|
1135 #endif /* COMPUTE_INFLEXS */ |
|
1136 |
|
1137 |
|
1138 static void |
|
1139 psh_glyph_done( PSH_Glyph glyph ) |
|
1140 { |
|
1141 FT_Memory memory = glyph->memory; |
|
1142 |
|
1143 |
|
1144 psh_hint_table_done( &glyph->hint_tables[1], memory ); |
|
1145 psh_hint_table_done( &glyph->hint_tables[0], memory ); |
|
1146 |
|
1147 FT_FREE( glyph->points ); |
|
1148 FT_FREE( glyph->contours ); |
|
1149 |
|
1150 glyph->num_points = 0; |
|
1151 glyph->num_contours = 0; |
|
1152 |
|
1153 glyph->memory = 0; |
|
1154 } |
|
1155 |
|
1156 |
|
1157 static int |
|
1158 psh_compute_dir( FT_Pos dx, |
|
1159 FT_Pos dy ) |
|
1160 { |
|
1161 FT_Pos ax, ay; |
|
1162 int result = PSH_DIR_NONE; |
|
1163 |
|
1164 |
|
1165 ax = ( dx >= 0 ) ? dx : -dx; |
|
1166 ay = ( dy >= 0 ) ? dy : -dy; |
|
1167 |
|
1168 if ( ay * 12 < ax ) |
|
1169 { |
|
1170 /* |dy| <<< |dx| means a near-horizontal segment */ |
|
1171 result = ( dx >= 0 ) ? PSH_DIR_RIGHT : PSH_DIR_LEFT; |
|
1172 } |
|
1173 else if ( ax * 12 < ay ) |
|
1174 { |
|
1175 /* |dx| <<< |dy| means a near-vertical segment */ |
|
1176 result = ( dy >= 0 ) ? PSH_DIR_UP : PSH_DIR_DOWN; |
|
1177 } |
|
1178 |
|
1179 return result; |
|
1180 } |
|
1181 |
|
1182 |
|
1183 /* load outline point coordinates into hinter glyph */ |
|
1184 static void |
|
1185 psh_glyph_load_points( PSH_Glyph glyph, |
|
1186 FT_Int dimension ) |
|
1187 { |
|
1188 FT_Vector* vec = glyph->outline->points; |
|
1189 PSH_Point point = glyph->points; |
|
1190 FT_UInt count = glyph->num_points; |
|
1191 |
|
1192 |
|
1193 for ( ; count > 0; count--, point++, vec++ ) |
|
1194 { |
|
1195 point->flags2 = 0; |
|
1196 point->hint = NULL; |
|
1197 if ( dimension == 0 ) |
|
1198 { |
|
1199 point->org_u = vec->x; |
|
1200 point->org_v = vec->y; |
|
1201 } |
|
1202 else |
|
1203 { |
|
1204 point->org_u = vec->y; |
|
1205 point->org_v = vec->x; |
|
1206 } |
|
1207 |
|
1208 #ifdef DEBUG_HINTER |
|
1209 point->org_x = vec->x; |
|
1210 point->org_y = vec->y; |
|
1211 #endif |
|
1212 |
|
1213 } |
|
1214 } |
|
1215 |
|
1216 |
|
1217 /* save hinted point coordinates back to outline */ |
|
1218 static void |
|
1219 psh_glyph_save_points( PSH_Glyph glyph, |
|
1220 FT_Int dimension ) |
|
1221 { |
|
1222 FT_UInt n; |
|
1223 PSH_Point point = glyph->points; |
|
1224 FT_Vector* vec = glyph->outline->points; |
|
1225 char* tags = glyph->outline->tags; |
|
1226 |
|
1227 |
|
1228 for ( n = 0; n < glyph->num_points; n++ ) |
|
1229 { |
|
1230 if ( dimension == 0 ) |
|
1231 vec[n].x = point->cur_u; |
|
1232 else |
|
1233 vec[n].y = point->cur_u; |
|
1234 |
|
1235 if ( psh_point_is_strong( point ) ) |
|
1236 tags[n] |= (char)( ( dimension == 0 ) ? 32 : 64 ); |
|
1237 |
|
1238 #ifdef DEBUG_HINTER |
|
1239 |
|
1240 if ( dimension == 0 ) |
|
1241 { |
|
1242 point->cur_x = point->cur_u; |
|
1243 point->flags_x = point->flags2 | point->flags; |
|
1244 } |
|
1245 else |
|
1246 { |
|
1247 point->cur_y = point->cur_u; |
|
1248 point->flags_y = point->flags2 | point->flags; |
|
1249 } |
|
1250 |
|
1251 #endif |
|
1252 |
|
1253 point++; |
|
1254 } |
|
1255 } |
|
1256 |
|
1257 |
|
1258 static FT_Error |
|
1259 psh_glyph_init( PSH_Glyph glyph, |
|
1260 FT_Outline* outline, |
|
1261 PS_Hints ps_hints, |
|
1262 PSH_Globals globals ) |
|
1263 { |
|
1264 FT_Error error; |
|
1265 FT_Memory memory; |
|
1266 |
|
1267 |
|
1268 /* clear all fields */ |
|
1269 FT_MEM_ZERO( glyph, sizeof ( *glyph ) ); |
|
1270 |
|
1271 memory = glyph->memory = globals->memory; |
|
1272 |
|
1273 /* allocate and setup points + contours arrays */ |
|
1274 if ( FT_NEW_ARRAY( glyph->points, outline->n_points ) || |
|
1275 FT_NEW_ARRAY( glyph->contours, outline->n_contours ) ) |
|
1276 goto Exit; |
|
1277 |
|
1278 glyph->num_points = outline->n_points; |
|
1279 glyph->num_contours = outline->n_contours; |
|
1280 |
|
1281 { |
|
1282 FT_UInt first = 0, next, n; |
|
1283 PSH_Point points = glyph->points; |
|
1284 PSH_Contour contour = glyph->contours; |
|
1285 |
|
1286 |
|
1287 for ( n = 0; n < glyph->num_contours; n++ ) |
|
1288 { |
|
1289 FT_Int count; |
|
1290 PSH_Point point; |
|
1291 |
|
1292 |
|
1293 next = outline->contours[n] + 1; |
|
1294 count = next - first; |
|
1295 |
|
1296 contour->start = points + first; |
|
1297 contour->count = (FT_UInt)count; |
|
1298 |
|
1299 if ( count > 0 ) |
|
1300 { |
|
1301 point = points + first; |
|
1302 |
|
1303 point->prev = points + next - 1; |
|
1304 point->contour = contour; |
|
1305 |
|
1306 for ( ; count > 1; count-- ) |
|
1307 { |
|
1308 point[0].next = point + 1; |
|
1309 point[1].prev = point; |
|
1310 point++; |
|
1311 point->contour = contour; |
|
1312 } |
|
1313 point->next = points + first; |
|
1314 } |
|
1315 |
|
1316 contour++; |
|
1317 first = next; |
|
1318 } |
|
1319 } |
|
1320 |
|
1321 { |
|
1322 PSH_Point points = glyph->points; |
|
1323 PSH_Point point = points; |
|
1324 FT_Vector* vec = outline->points; |
|
1325 FT_UInt n; |
|
1326 |
|
1327 |
|
1328 for ( n = 0; n < glyph->num_points; n++, point++ ) |
|
1329 { |
|
1330 FT_Int n_prev = (FT_Int)( point->prev - points ); |
|
1331 FT_Int n_next = (FT_Int)( point->next - points ); |
|
1332 FT_Pos dxi, dyi, dxo, dyo; |
|
1333 |
|
1334 |
|
1335 if ( !( outline->tags[n] & FT_CURVE_TAG_ON ) ) |
|
1336 point->flags = PSH_POINT_OFF; |
|
1337 |
|
1338 dxi = vec[n].x - vec[n_prev].x; |
|
1339 dyi = vec[n].y - vec[n_prev].y; |
|
1340 |
|
1341 point->dir_in = (FT_Char)psh_compute_dir( dxi, dyi ); |
|
1342 |
|
1343 dxo = vec[n_next].x - vec[n].x; |
|
1344 dyo = vec[n_next].y - vec[n].y; |
|
1345 |
|
1346 point->dir_out = (FT_Char)psh_compute_dir( dxo, dyo ); |
|
1347 |
|
1348 /* detect smooth points */ |
|
1349 if ( point->flags & PSH_POINT_OFF ) |
|
1350 point->flags |= PSH_POINT_SMOOTH; |
|
1351 |
|
1352 else if ( point->dir_in == point->dir_out ) |
|
1353 { |
|
1354 if ( point->dir_out != PSH_DIR_NONE || |
|
1355 psh_corner_is_flat( dxi, dyi, dxo, dyo ) ) |
|
1356 point->flags |= PSH_POINT_SMOOTH; |
|
1357 } |
|
1358 } |
|
1359 } |
|
1360 |
|
1361 glyph->outline = outline; |
|
1362 glyph->globals = globals; |
|
1363 |
|
1364 #ifdef COMPUTE_INFLEXS |
|
1365 psh_glyph_load_points( glyph, 0 ); |
|
1366 psh_glyph_compute_inflections( glyph ); |
|
1367 #endif /* COMPUTE_INFLEXS */ |
|
1368 |
|
1369 /* now deal with hints tables */ |
|
1370 error = psh_hint_table_init( &glyph->hint_tables [0], |
|
1371 &ps_hints->dimension[0].hints, |
|
1372 &ps_hints->dimension[0].masks, |
|
1373 &ps_hints->dimension[0].counters, |
|
1374 memory ); |
|
1375 if ( error ) |
|
1376 goto Exit; |
|
1377 |
|
1378 error = psh_hint_table_init( &glyph->hint_tables [1], |
|
1379 &ps_hints->dimension[1].hints, |
|
1380 &ps_hints->dimension[1].masks, |
|
1381 &ps_hints->dimension[1].counters, |
|
1382 memory ); |
|
1383 if ( error ) |
|
1384 goto Exit; |
|
1385 |
|
1386 Exit: |
|
1387 return error; |
|
1388 } |
|
1389 |
|
1390 |
|
1391 /* compute all extrema in a glyph for a given dimension */ |
|
1392 static void |
|
1393 psh_glyph_compute_extrema( PSH_Glyph glyph ) |
|
1394 { |
|
1395 FT_UInt n; |
|
1396 |
|
1397 |
|
1398 /* first of all, compute all local extrema */ |
|
1399 for ( n = 0; n < glyph->num_contours; n++ ) |
|
1400 { |
|
1401 PSH_Point first = glyph->contours[n].start; |
|
1402 PSH_Point point, before, after; |
|
1403 |
|
1404 |
|
1405 if ( glyph->contours[n].count == 0 ) |
|
1406 continue; |
|
1407 |
|
1408 point = first; |
|
1409 before = point; |
|
1410 after = point; |
|
1411 |
|
1412 do |
|
1413 { |
|
1414 before = before->prev; |
|
1415 if ( before == first ) |
|
1416 goto Skip; |
|
1417 |
|
1418 } while ( before->org_u == point->org_u ); |
|
1419 |
|
1420 first = point = before->next; |
|
1421 |
|
1422 for (;;) |
|
1423 { |
|
1424 after = point; |
|
1425 do |
|
1426 { |
|
1427 after = after->next; |
|
1428 if ( after == first ) |
|
1429 goto Next; |
|
1430 |
|
1431 } while ( after->org_u == point->org_u ); |
|
1432 |
|
1433 if ( before->org_u < point->org_u ) |
|
1434 { |
|
1435 if ( after->org_u < point->org_u ) |
|
1436 { |
|
1437 /* local maximum */ |
|
1438 goto Extremum; |
|
1439 } |
|
1440 } |
|
1441 else /* before->org_u > point->org_u */ |
|
1442 { |
|
1443 if ( after->org_u > point->org_u ) |
|
1444 { |
|
1445 /* local minimum */ |
|
1446 Extremum: |
|
1447 do |
|
1448 { |
|
1449 psh_point_set_extremum( point ); |
|
1450 point = point->next; |
|
1451 |
|
1452 } while ( point != after ); |
|
1453 } |
|
1454 } |
|
1455 |
|
1456 before = after->prev; |
|
1457 point = after; |
|
1458 |
|
1459 } /* for */ |
|
1460 |
|
1461 Next: |
|
1462 ; |
|
1463 } |
|
1464 |
|
1465 /* for each extremum, determine its direction along the */ |
|
1466 /* orthogonal axis */ |
|
1467 for ( n = 0; n < glyph->num_points; n++ ) |
|
1468 { |
|
1469 PSH_Point point, before, after; |
|
1470 |
|
1471 |
|
1472 point = &glyph->points[n]; |
|
1473 before = point; |
|
1474 after = point; |
|
1475 |
|
1476 if ( psh_point_is_extremum( point ) ) |
|
1477 { |
|
1478 do |
|
1479 { |
|
1480 before = before->prev; |
|
1481 if ( before == point ) |
|
1482 goto Skip; |
|
1483 |
|
1484 } while ( before->org_v == point->org_v ); |
|
1485 |
|
1486 do |
|
1487 { |
|
1488 after = after->next; |
|
1489 if ( after == point ) |
|
1490 goto Skip; |
|
1491 |
|
1492 } while ( after->org_v == point->org_v ); |
|
1493 } |
|
1494 |
|
1495 if ( before->org_v < point->org_v && |
|
1496 after->org_v > point->org_v ) |
|
1497 { |
|
1498 psh_point_set_positive( point ); |
|
1499 } |
|
1500 else if ( before->org_v > point->org_v && |
|
1501 after->org_v < point->org_v ) |
|
1502 { |
|
1503 psh_point_set_negative( point ); |
|
1504 } |
|
1505 |
|
1506 Skip: |
|
1507 ; |
|
1508 } |
|
1509 } |
|
1510 |
|
1511 |
|
1512 /* major_dir is the direction for points on the bottom/left of the stem; */ |
|
1513 /* Points on the top/right of the stem will have a direction of */ |
|
1514 /* -major_dir. */ |
|
1515 |
|
1516 static void |
|
1517 psh_hint_table_find_strong_points( PSH_Hint_Table table, |
|
1518 PSH_Point point, |
|
1519 FT_UInt count, |
|
1520 FT_Int threshold, |
|
1521 FT_Int major_dir ) |
|
1522 { |
|
1523 PSH_Hint* sort = table->sort; |
|
1524 FT_UInt num_hints = table->num_hints; |
|
1525 |
|
1526 |
|
1527 for ( ; count > 0; count--, point++ ) |
|
1528 { |
|
1529 FT_Int point_dir = 0; |
|
1530 FT_Pos org_u = point->org_u; |
|
1531 |
|
1532 |
|
1533 if ( psh_point_is_strong( point ) ) |
|
1534 continue; |
|
1535 |
|
1536 if ( PSH_DIR_COMPARE( point->dir_in, major_dir ) ) |
|
1537 point_dir = point->dir_in; |
|
1538 |
|
1539 else if ( PSH_DIR_COMPARE( point->dir_out, major_dir ) ) |
|
1540 point_dir = point->dir_out; |
|
1541 |
|
1542 if ( point_dir ) |
|
1543 { |
|
1544 if ( point_dir == major_dir ) |
|
1545 { |
|
1546 FT_UInt nn; |
|
1547 |
|
1548 |
|
1549 for ( nn = 0; nn < num_hints; nn++ ) |
|
1550 { |
|
1551 PSH_Hint hint = sort[nn]; |
|
1552 FT_Pos d = org_u - hint->org_pos; |
|
1553 |
|
1554 |
|
1555 if ( d < threshold && -d < threshold ) |
|
1556 { |
|
1557 psh_point_set_strong( point ); |
|
1558 point->flags2 |= PSH_POINT_EDGE_MIN; |
|
1559 point->hint = hint; |
|
1560 break; |
|
1561 } |
|
1562 } |
|
1563 } |
|
1564 else if ( point_dir == -major_dir ) |
|
1565 { |
|
1566 FT_UInt nn; |
|
1567 |
|
1568 |
|
1569 for ( nn = 0; nn < num_hints; nn++ ) |
|
1570 { |
|
1571 PSH_Hint hint = sort[nn]; |
|
1572 FT_Pos d = org_u - hint->org_pos - hint->org_len; |
|
1573 |
|
1574 |
|
1575 if ( d < threshold && -d < threshold ) |
|
1576 { |
|
1577 psh_point_set_strong( point ); |
|
1578 point->flags2 |= PSH_POINT_EDGE_MAX; |
|
1579 point->hint = hint; |
|
1580 break; |
|
1581 } |
|
1582 } |
|
1583 } |
|
1584 } |
|
1585 |
|
1586 #if 1 |
|
1587 else if ( psh_point_is_extremum( point ) ) |
|
1588 { |
|
1589 /* treat extrema as special cases for stem edge alignment */ |
|
1590 FT_UInt nn, min_flag, max_flag; |
|
1591 |
|
1592 |
|
1593 if ( major_dir == PSH_DIR_HORIZONTAL ) |
|
1594 { |
|
1595 min_flag = PSH_POINT_POSITIVE; |
|
1596 max_flag = PSH_POINT_NEGATIVE; |
|
1597 } |
|
1598 else |
|
1599 { |
|
1600 min_flag = PSH_POINT_NEGATIVE; |
|
1601 max_flag = PSH_POINT_POSITIVE; |
|
1602 } |
|
1603 |
|
1604 if ( point->flags2 & min_flag ) |
|
1605 { |
|
1606 for ( nn = 0; nn < num_hints; nn++ ) |
|
1607 { |
|
1608 PSH_Hint hint = sort[nn]; |
|
1609 FT_Pos d = org_u - hint->org_pos; |
|
1610 |
|
1611 |
|
1612 if ( d < threshold && -d < threshold ) |
|
1613 { |
|
1614 point->flags2 |= PSH_POINT_EDGE_MIN; |
|
1615 point->hint = hint; |
|
1616 psh_point_set_strong( point ); |
|
1617 break; |
|
1618 } |
|
1619 } |
|
1620 } |
|
1621 else if ( point->flags2 & max_flag ) |
|
1622 { |
|
1623 for ( nn = 0; nn < num_hints; nn++ ) |
|
1624 { |
|
1625 PSH_Hint hint = sort[nn]; |
|
1626 FT_Pos d = org_u - hint->org_pos - hint->org_len; |
|
1627 |
|
1628 |
|
1629 if ( d < threshold && -d < threshold ) |
|
1630 { |
|
1631 point->flags2 |= PSH_POINT_EDGE_MAX; |
|
1632 point->hint = hint; |
|
1633 psh_point_set_strong( point ); |
|
1634 break; |
|
1635 } |
|
1636 } |
|
1637 } |
|
1638 |
|
1639 if ( point->hint == NULL ) |
|
1640 { |
|
1641 for ( nn = 0; nn < num_hints; nn++ ) |
|
1642 { |
|
1643 PSH_Hint hint = sort[nn]; |
|
1644 |
|
1645 |
|
1646 if ( org_u >= hint->org_pos && |
|
1647 org_u <= hint->org_pos + hint->org_len ) |
|
1648 { |
|
1649 point->hint = hint; |
|
1650 break; |
|
1651 } |
|
1652 } |
|
1653 } |
|
1654 } |
|
1655 |
|
1656 #endif /* 1 */ |
|
1657 } |
|
1658 } |
|
1659 |
|
1660 |
|
1661 /* the accepted shift for strong points in fractional pixels */ |
|
1662 #define PSH_STRONG_THRESHOLD 32 |
|
1663 |
|
1664 /* the maximum shift value in font units */ |
|
1665 #define PSH_STRONG_THRESHOLD_MAXIMUM 30 |
|
1666 |
|
1667 |
|
1668 /* find strong points in a glyph */ |
|
1669 static void |
|
1670 psh_glyph_find_strong_points( PSH_Glyph glyph, |
|
1671 FT_Int dimension ) |
|
1672 { |
|
1673 /* a point is `strong' if it is located on a stem edge and */ |
|
1674 /* has an `in' or `out' tangent parallel to the hint's direction */ |
|
1675 |
|
1676 PSH_Hint_Table table = &glyph->hint_tables[dimension]; |
|
1677 PS_Mask mask = table->hint_masks->masks; |
|
1678 FT_UInt num_masks = table->hint_masks->num_masks; |
|
1679 FT_UInt first = 0; |
|
1680 FT_Int major_dir = dimension == 0 ? PSH_DIR_VERTICAL |
|
1681 : PSH_DIR_HORIZONTAL; |
|
1682 PSH_Dimension dim = &glyph->globals->dimension[dimension]; |
|
1683 FT_Fixed scale = dim->scale_mult; |
|
1684 FT_Int threshold; |
|
1685 |
|
1686 |
|
1687 threshold = (FT_Int)FT_DivFix( PSH_STRONG_THRESHOLD, scale ); |
|
1688 if ( threshold > PSH_STRONG_THRESHOLD_MAXIMUM ) |
|
1689 threshold = PSH_STRONG_THRESHOLD_MAXIMUM; |
|
1690 |
|
1691 /* process secondary hints to `selected' points */ |
|
1692 if ( num_masks > 1 && glyph->num_points > 0 ) |
|
1693 { |
|
1694 /* the `endchar' op can reduce the number of points */ |
|
1695 first = mask->end_point > glyph->num_points |
|
1696 ? glyph->num_points |
|
1697 : mask->end_point; |
|
1698 mask++; |
|
1699 for ( ; num_masks > 1; num_masks--, mask++ ) |
|
1700 { |
|
1701 FT_UInt next; |
|
1702 FT_Int count; |
|
1703 |
|
1704 |
|
1705 next = mask->end_point > glyph->num_points |
|
1706 ? glyph->num_points |
|
1707 : mask->end_point; |
|
1708 count = next - first; |
|
1709 if ( count > 0 ) |
|
1710 { |
|
1711 PSH_Point point = glyph->points + first; |
|
1712 |
|
1713 |
|
1714 psh_hint_table_activate_mask( table, mask ); |
|
1715 |
|
1716 psh_hint_table_find_strong_points( table, point, count, |
|
1717 threshold, major_dir ); |
|
1718 } |
|
1719 first = next; |
|
1720 } |
|
1721 } |
|
1722 |
|
1723 /* process primary hints for all points */ |
|
1724 if ( num_masks == 1 ) |
|
1725 { |
|
1726 FT_UInt count = glyph->num_points; |
|
1727 PSH_Point point = glyph->points; |
|
1728 |
|
1729 |
|
1730 psh_hint_table_activate_mask( table, table->hint_masks->masks ); |
|
1731 |
|
1732 psh_hint_table_find_strong_points( table, point, count, |
|
1733 threshold, major_dir ); |
|
1734 } |
|
1735 |
|
1736 /* now, certain points may have been attached to a hint and */ |
|
1737 /* not marked as strong; update their flags then */ |
|
1738 { |
|
1739 FT_UInt count = glyph->num_points; |
|
1740 PSH_Point point = glyph->points; |
|
1741 |
|
1742 |
|
1743 for ( ; count > 0; count--, point++ ) |
|
1744 if ( point->hint && !psh_point_is_strong( point ) ) |
|
1745 psh_point_set_strong( point ); |
|
1746 } |
|
1747 } |
|
1748 |
|
1749 |
|
1750 /* find points in a glyph which are in a blue zone and have `in' or */ |
|
1751 /* `out' tangents parallel to the horizontal axis */ |
|
1752 static void |
|
1753 psh_glyph_find_blue_points( PSH_Blues blues, |
|
1754 PSH_Glyph glyph ) |
|
1755 { |
|
1756 PSH_Blue_Table table; |
|
1757 PSH_Blue_Zone zone; |
|
1758 FT_UInt glyph_count = glyph->num_points; |
|
1759 FT_UInt blue_count; |
|
1760 PSH_Point point = glyph->points; |
|
1761 |
|
1762 |
|
1763 for ( ; glyph_count > 0; glyph_count--, point++ ) |
|
1764 { |
|
1765 FT_Pos y; |
|
1766 |
|
1767 |
|
1768 /* check tangents */ |
|
1769 if ( !PSH_DIR_COMPARE( point->dir_in, PSH_DIR_HORIZONTAL ) && |
|
1770 !PSH_DIR_COMPARE( point->dir_out, PSH_DIR_HORIZONTAL ) ) |
|
1771 continue; |
|
1772 |
|
1773 /* skip strong points */ |
|
1774 if ( psh_point_is_strong( point ) ) |
|
1775 continue; |
|
1776 |
|
1777 y = point->org_u; |
|
1778 |
|
1779 /* look up top zones */ |
|
1780 table = &blues->normal_top; |
|
1781 blue_count = table->count; |
|
1782 zone = table->zones; |
|
1783 |
|
1784 for ( ; blue_count > 0; blue_count--, zone++ ) |
|
1785 { |
|
1786 FT_Pos delta = y - zone->org_bottom; |
|
1787 |
|
1788 |
|
1789 if ( delta < -blues->blue_fuzz ) |
|
1790 break; |
|
1791 |
|
1792 if ( y <= zone->org_top + blues->blue_fuzz ) |
|
1793 if ( blues->no_overshoots || delta <= blues->blue_threshold ) |
|
1794 { |
|
1795 point->cur_u = zone->cur_bottom; |
|
1796 psh_point_set_strong( point ); |
|
1797 psh_point_set_fitted( point ); |
|
1798 } |
|
1799 } |
|
1800 |
|
1801 /* look up bottom zones */ |
|
1802 table = &blues->normal_bottom; |
|
1803 blue_count = table->count; |
|
1804 zone = table->zones + blue_count - 1; |
|
1805 |
|
1806 for ( ; blue_count > 0; blue_count--, zone-- ) |
|
1807 { |
|
1808 FT_Pos delta = zone->org_top - y; |
|
1809 |
|
1810 |
|
1811 if ( delta < -blues->blue_fuzz ) |
|
1812 break; |
|
1813 |
|
1814 if ( y >= zone->org_bottom - blues->blue_fuzz ) |
|
1815 if ( blues->no_overshoots || delta < blues->blue_threshold ) |
|
1816 { |
|
1817 point->cur_u = zone->cur_top; |
|
1818 psh_point_set_strong( point ); |
|
1819 psh_point_set_fitted( point ); |
|
1820 } |
|
1821 } |
|
1822 } |
|
1823 } |
|
1824 |
|
1825 |
|
1826 /* interpolate strong points with the help of hinted coordinates */ |
|
1827 static void |
|
1828 psh_glyph_interpolate_strong_points( PSH_Glyph glyph, |
|
1829 FT_Int dimension ) |
|
1830 { |
|
1831 PSH_Dimension dim = &glyph->globals->dimension[dimension]; |
|
1832 FT_Fixed scale = dim->scale_mult; |
|
1833 |
|
1834 FT_UInt count = glyph->num_points; |
|
1835 PSH_Point point = glyph->points; |
|
1836 |
|
1837 |
|
1838 for ( ; count > 0; count--, point++ ) |
|
1839 { |
|
1840 PSH_Hint hint = point->hint; |
|
1841 |
|
1842 |
|
1843 if ( hint ) |
|
1844 { |
|
1845 FT_Pos delta; |
|
1846 |
|
1847 |
|
1848 if ( psh_point_is_edge_min( point ) ) |
|
1849 point->cur_u = hint->cur_pos; |
|
1850 |
|
1851 else if ( psh_point_is_edge_max( point ) ) |
|
1852 point->cur_u = hint->cur_pos + hint->cur_len; |
|
1853 |
|
1854 else |
|
1855 { |
|
1856 delta = point->org_u - hint->org_pos; |
|
1857 |
|
1858 if ( delta <= 0 ) |
|
1859 point->cur_u = hint->cur_pos + FT_MulFix( delta, scale ); |
|
1860 |
|
1861 else if ( delta >= hint->org_len ) |
|
1862 point->cur_u = hint->cur_pos + hint->cur_len + |
|
1863 FT_MulFix( delta - hint->org_len, scale ); |
|
1864 |
|
1865 else /* hint->org_len > 0 */ |
|
1866 point->cur_u = hint->cur_pos + |
|
1867 FT_MulDiv( delta, hint->cur_len, |
|
1868 hint->org_len ); |
|
1869 } |
|
1870 psh_point_set_fitted( point ); |
|
1871 } |
|
1872 } |
|
1873 } |
|
1874 |
|
1875 |
|
1876 #define PSH_MAX_STRONG_INTERNAL 16 |
|
1877 |
|
1878 static void |
|
1879 psh_glyph_interpolate_normal_points( PSH_Glyph glyph, |
|
1880 FT_Int dimension ) |
|
1881 { |
|
1882 |
|
1883 #if 1 |
|
1884 /* first technique: a point is strong if it is a local extremum */ |
|
1885 |
|
1886 PSH_Dimension dim = &glyph->globals->dimension[dimension]; |
|
1887 FT_Fixed scale = dim->scale_mult; |
|
1888 FT_Memory memory = glyph->memory; |
|
1889 |
|
1890 PSH_Point* strongs = NULL; |
|
1891 PSH_Point strongs_0[PSH_MAX_STRONG_INTERNAL]; |
|
1892 FT_UInt num_strongs = 0; |
|
1893 |
|
1894 PSH_Point points = glyph->points; |
|
1895 PSH_Point points_end = points + glyph->num_points; |
|
1896 PSH_Point point; |
|
1897 |
|
1898 |
|
1899 /* first count the number of strong points */ |
|
1900 for ( point = points; point < points_end; point++ ) |
|
1901 { |
|
1902 if ( psh_point_is_strong( point ) ) |
|
1903 num_strongs++; |
|
1904 } |
|
1905 |
|
1906 if ( num_strongs == 0 ) /* nothing to do here */ |
|
1907 return; |
|
1908 |
|
1909 /* allocate an array to store a list of points, */ |
|
1910 /* stored in increasing org_u order */ |
|
1911 if ( num_strongs <= PSH_MAX_STRONG_INTERNAL ) |
|
1912 strongs = strongs_0; |
|
1913 else |
|
1914 { |
|
1915 FT_Error error; |
|
1916 |
|
1917 |
|
1918 if ( FT_NEW_ARRAY( strongs, num_strongs ) ) |
|
1919 return; |
|
1920 } |
|
1921 |
|
1922 num_strongs = 0; |
|
1923 for ( point = points; point < points_end; point++ ) |
|
1924 { |
|
1925 PSH_Point* insert; |
|
1926 |
|
1927 |
|
1928 if ( !psh_point_is_strong( point ) ) |
|
1929 continue; |
|
1930 |
|
1931 for ( insert = strongs + num_strongs; insert > strongs; insert-- ) |
|
1932 { |
|
1933 if ( insert[-1]->org_u <= point->org_u ) |
|
1934 break; |
|
1935 |
|
1936 insert[0] = insert[-1]; |
|
1937 } |
|
1938 insert[0] = point; |
|
1939 num_strongs++; |
|
1940 } |
|
1941 |
|
1942 /* now try to interpolate all normal points */ |
|
1943 for ( point = points; point < points_end; point++ ) |
|
1944 { |
|
1945 if ( psh_point_is_strong( point ) ) |
|
1946 continue; |
|
1947 |
|
1948 /* sometimes, some local extrema are smooth points */ |
|
1949 if ( psh_point_is_smooth( point ) ) |
|
1950 { |
|
1951 if ( point->dir_in == PSH_DIR_NONE || |
|
1952 point->dir_in != point->dir_out ) |
|
1953 continue; |
|
1954 |
|
1955 if ( !psh_point_is_extremum( point ) && |
|
1956 !psh_point_is_inflex( point ) ) |
|
1957 continue; |
|
1958 |
|
1959 point->flags &= ~PSH_POINT_SMOOTH; |
|
1960 } |
|
1961 |
|
1962 /* find best enclosing point coordinates then interpolate */ |
|
1963 { |
|
1964 PSH_Point before, after; |
|
1965 FT_UInt nn; |
|
1966 |
|
1967 |
|
1968 for ( nn = 0; nn < num_strongs; nn++ ) |
|
1969 if ( strongs[nn]->org_u > point->org_u ) |
|
1970 break; |
|
1971 |
|
1972 if ( nn == 0 ) /* point before the first strong point */ |
|
1973 { |
|
1974 after = strongs[0]; |
|
1975 |
|
1976 point->cur_u = after->cur_u + |
|
1977 FT_MulFix( point->org_u - after->org_u, |
|
1978 scale ); |
|
1979 } |
|
1980 else |
|
1981 { |
|
1982 before = strongs[nn - 1]; |
|
1983 |
|
1984 for ( nn = num_strongs; nn > 0; nn-- ) |
|
1985 if ( strongs[nn - 1]->org_u < point->org_u ) |
|
1986 break; |
|
1987 |
|
1988 if ( nn == num_strongs ) /* point is after last strong point */ |
|
1989 { |
|
1990 before = strongs[nn - 1]; |
|
1991 |
|
1992 point->cur_u = before->cur_u + |
|
1993 FT_MulFix( point->org_u - before->org_u, |
|
1994 scale ); |
|
1995 } |
|
1996 else |
|
1997 { |
|
1998 FT_Pos u; |
|
1999 |
|
2000 |
|
2001 after = strongs[nn]; |
|
2002 |
|
2003 /* now interpolate point between before and after */ |
|
2004 u = point->org_u; |
|
2005 |
|
2006 if ( u == before->org_u ) |
|
2007 point->cur_u = before->cur_u; |
|
2008 |
|
2009 else if ( u == after->org_u ) |
|
2010 point->cur_u = after->cur_u; |
|
2011 |
|
2012 else |
|
2013 point->cur_u = before->cur_u + |
|
2014 FT_MulDiv( u - before->org_u, |
|
2015 after->cur_u - before->cur_u, |
|
2016 after->org_u - before->org_u ); |
|
2017 } |
|
2018 } |
|
2019 psh_point_set_fitted( point ); |
|
2020 } |
|
2021 } |
|
2022 |
|
2023 if ( strongs != strongs_0 ) |
|
2024 FT_FREE( strongs ); |
|
2025 |
|
2026 #endif /* 1 */ |
|
2027 |
|
2028 } |
|
2029 |
|
2030 |
|
2031 /* interpolate other points */ |
|
2032 static void |
|
2033 psh_glyph_interpolate_other_points( PSH_Glyph glyph, |
|
2034 FT_Int dimension ) |
|
2035 { |
|
2036 PSH_Dimension dim = &glyph->globals->dimension[dimension]; |
|
2037 FT_Fixed scale = dim->scale_mult; |
|
2038 FT_Fixed delta = dim->scale_delta; |
|
2039 PSH_Contour contour = glyph->contours; |
|
2040 FT_UInt num_contours = glyph->num_contours; |
|
2041 |
|
2042 |
|
2043 for ( ; num_contours > 0; num_contours--, contour++ ) |
|
2044 { |
|
2045 PSH_Point start = contour->start; |
|
2046 PSH_Point first, next, point; |
|
2047 FT_UInt fit_count; |
|
2048 |
|
2049 |
|
2050 /* count the number of strong points in this contour */ |
|
2051 next = start + contour->count; |
|
2052 fit_count = 0; |
|
2053 first = 0; |
|
2054 |
|
2055 for ( point = start; point < next; point++ ) |
|
2056 if ( psh_point_is_fitted( point ) ) |
|
2057 { |
|
2058 if ( !first ) |
|
2059 first = point; |
|
2060 |
|
2061 fit_count++; |
|
2062 } |
|
2063 |
|
2064 /* if there are less than 2 fitted points in the contour, we */ |
|
2065 /* simply scale and eventually translate the contour points */ |
|
2066 if ( fit_count < 2 ) |
|
2067 { |
|
2068 if ( fit_count == 1 ) |
|
2069 delta = first->cur_u - FT_MulFix( first->org_u, scale ); |
|
2070 |
|
2071 for ( point = start; point < next; point++ ) |
|
2072 if ( point != first ) |
|
2073 point->cur_u = FT_MulFix( point->org_u, scale ) + delta; |
|
2074 |
|
2075 goto Next_Contour; |
|
2076 } |
|
2077 |
|
2078 /* there are more than 2 strong points in this contour; we */ |
|
2079 /* need to interpolate weak points between them */ |
|
2080 start = first; |
|
2081 do |
|
2082 { |
|
2083 point = first; |
|
2084 |
|
2085 /* skip consecutive fitted points */ |
|
2086 for (;;) |
|
2087 { |
|
2088 next = first->next; |
|
2089 if ( next == start ) |
|
2090 goto Next_Contour; |
|
2091 |
|
2092 if ( !psh_point_is_fitted( next ) ) |
|
2093 break; |
|
2094 |
|
2095 first = next; |
|
2096 } |
|
2097 |
|
2098 /* find next fitted point after unfitted one */ |
|
2099 for (;;) |
|
2100 { |
|
2101 next = next->next; |
|
2102 if ( psh_point_is_fitted( next ) ) |
|
2103 break; |
|
2104 } |
|
2105 |
|
2106 /* now interpolate between them */ |
|
2107 { |
|
2108 FT_Pos org_a, org_ab, cur_a, cur_ab; |
|
2109 FT_Pos org_c, org_ac, cur_c; |
|
2110 FT_Fixed scale_ab; |
|
2111 |
|
2112 |
|
2113 if ( first->org_u <= next->org_u ) |
|
2114 { |
|
2115 org_a = first->org_u; |
|
2116 cur_a = first->cur_u; |
|
2117 org_ab = next->org_u - org_a; |
|
2118 cur_ab = next->cur_u - cur_a; |
|
2119 } |
|
2120 else |
|
2121 { |
|
2122 org_a = next->org_u; |
|
2123 cur_a = next->cur_u; |
|
2124 org_ab = first->org_u - org_a; |
|
2125 cur_ab = first->cur_u - cur_a; |
|
2126 } |
|
2127 |
|
2128 scale_ab = 0x10000L; |
|
2129 if ( org_ab > 0 ) |
|
2130 scale_ab = FT_DivFix( cur_ab, org_ab ); |
|
2131 |
|
2132 point = first->next; |
|
2133 do |
|
2134 { |
|
2135 org_c = point->org_u; |
|
2136 org_ac = org_c - org_a; |
|
2137 |
|
2138 if ( org_ac <= 0 ) |
|
2139 { |
|
2140 /* on the left of the interpolation zone */ |
|
2141 cur_c = cur_a + FT_MulFix( org_ac, scale ); |
|
2142 } |
|
2143 else if ( org_ac >= org_ab ) |
|
2144 { |
|
2145 /* on the right on the interpolation zone */ |
|
2146 cur_c = cur_a + cur_ab + FT_MulFix( org_ac - org_ab, scale ); |
|
2147 } |
|
2148 else |
|
2149 { |
|
2150 /* within the interpolation zone */ |
|
2151 cur_c = cur_a + FT_MulFix( org_ac, scale_ab ); |
|
2152 } |
|
2153 |
|
2154 point->cur_u = cur_c; |
|
2155 |
|
2156 point = point->next; |
|
2157 |
|
2158 } while ( point != next ); |
|
2159 } |
|
2160 |
|
2161 /* keep going until all points in the contours have been processed */ |
|
2162 first = next; |
|
2163 |
|
2164 } while ( first != start ); |
|
2165 |
|
2166 Next_Contour: |
|
2167 ; |
|
2168 } |
|
2169 } |
|
2170 |
|
2171 |
|
2172 /*************************************************************************/ |
|
2173 /*************************************************************************/ |
|
2174 /***** *****/ |
|
2175 /***** HIGH-LEVEL INTERFACE *****/ |
|
2176 /***** *****/ |
|
2177 /*************************************************************************/ |
|
2178 /*************************************************************************/ |
|
2179 |
|
2180 FT_Error |
|
2181 ps_hints_apply( PS_Hints ps_hints, |
|
2182 FT_Outline* outline, |
|
2183 PSH_Globals globals, |
|
2184 FT_Render_Mode hint_mode ) |
|
2185 { |
|
2186 PSH_GlyphRec glyphrec; |
|
2187 PSH_Glyph glyph = &glyphrec; |
|
2188 FT_Error error; |
|
2189 #ifdef DEBUG_HINTER |
|
2190 FT_Memory memory; |
|
2191 #endif |
|
2192 FT_Int dimension; |
|
2193 |
|
2194 |
|
2195 /* something to do? */ |
|
2196 if ( outline->n_points == 0 || outline->n_contours == 0 ) |
|
2197 return PSH_Err_Ok; |
|
2198 |
|
2199 #ifdef DEBUG_HINTER |
|
2200 |
|
2201 memory = globals->memory; |
|
2202 |
|
2203 if ( ps_debug_glyph ) |
|
2204 { |
|
2205 psh_glyph_done( ps_debug_glyph ); |
|
2206 FT_FREE( ps_debug_glyph ); |
|
2207 } |
|
2208 |
|
2209 if ( FT_NEW( glyph ) ) |
|
2210 return error; |
|
2211 |
|
2212 ps_debug_glyph = glyph; |
|
2213 |
|
2214 #endif /* DEBUG_HINTER */ |
|
2215 |
|
2216 error = psh_glyph_init( glyph, outline, ps_hints, globals ); |
|
2217 if ( error ) |
|
2218 goto Exit; |
|
2219 |
|
2220 /* try to optimize the y_scale so that the top of non-capital letters |
|
2221 * is aligned on a pixel boundary whenever possible |
|
2222 */ |
|
2223 { |
|
2224 PSH_Dimension dim_x = &glyph->globals->dimension[0]; |
|
2225 PSH_Dimension dim_y = &glyph->globals->dimension[1]; |
|
2226 |
|
2227 FT_Fixed x_scale = dim_x->scale_mult; |
|
2228 FT_Fixed y_scale = dim_y->scale_mult; |
|
2229 |
|
2230 FT_Fixed old_x_scale = x_scale; |
|
2231 FT_Fixed old_y_scale = y_scale; |
|
2232 |
|
2233 FT_Fixed scaled; |
|
2234 FT_Fixed fitted; |
|
2235 |
|
2236 FT_Bool rescale = FALSE; |
|
2237 |
|
2238 |
|
2239 scaled = FT_MulFix( globals->blues.normal_top.zones->org_ref, y_scale ); |
|
2240 fitted = FT_PIX_ROUND( scaled ); |
|
2241 |
|
2242 if ( fitted != 0 && scaled != fitted ) |
|
2243 { |
|
2244 rescale = TRUE; |
|
2245 |
|
2246 y_scale = FT_MulDiv( y_scale, fitted, scaled ); |
|
2247 |
|
2248 if ( fitted < scaled ) |
|
2249 x_scale -= x_scale / 50; |
|
2250 |
|
2251 psh_globals_set_scale( glyph->globals, x_scale, y_scale, 0, 0 ); |
|
2252 } |
|
2253 |
|
2254 glyph->do_horz_hints = 1; |
|
2255 glyph->do_vert_hints = 1; |
|
2256 |
|
2257 glyph->do_horz_snapping = FT_BOOL( hint_mode == FT_RENDER_MODE_MONO || |
|
2258 hint_mode == FT_RENDER_MODE_LCD ); |
|
2259 |
|
2260 glyph->do_vert_snapping = FT_BOOL( hint_mode == FT_RENDER_MODE_MONO || |
|
2261 hint_mode == FT_RENDER_MODE_LCD_V ); |
|
2262 |
|
2263 glyph->do_stem_adjust = FT_BOOL( hint_mode != FT_RENDER_MODE_LIGHT ); |
|
2264 |
|
2265 for ( dimension = 0; dimension < 2; dimension++ ) |
|
2266 { |
|
2267 /* load outline coordinates into glyph */ |
|
2268 psh_glyph_load_points( glyph, dimension ); |
|
2269 |
|
2270 /* compute local extrema */ |
|
2271 psh_glyph_compute_extrema( glyph ); |
|
2272 |
|
2273 /* compute aligned stem/hints positions */ |
|
2274 psh_hint_table_align_hints( &glyph->hint_tables[dimension], |
|
2275 glyph->globals, |
|
2276 dimension, |
|
2277 glyph ); |
|
2278 |
|
2279 /* find strong points, align them, then interpolate others */ |
|
2280 psh_glyph_find_strong_points( glyph, dimension ); |
|
2281 if ( dimension == 1 ) |
|
2282 psh_glyph_find_blue_points( &globals->blues, glyph ); |
|
2283 psh_glyph_interpolate_strong_points( glyph, dimension ); |
|
2284 psh_glyph_interpolate_normal_points( glyph, dimension ); |
|
2285 psh_glyph_interpolate_other_points( glyph, dimension ); |
|
2286 |
|
2287 /* save hinted coordinates back to outline */ |
|
2288 psh_glyph_save_points( glyph, dimension ); |
|
2289 |
|
2290 if ( rescale ) |
|
2291 psh_globals_set_scale( glyph->globals, |
|
2292 old_x_scale, old_y_scale, 0, 0 ); |
|
2293 } |
|
2294 } |
|
2295 |
|
2296 Exit: |
|
2297 |
|
2298 #ifndef DEBUG_HINTER |
|
2299 psh_glyph_done( glyph ); |
|
2300 #endif |
|
2301 |
|
2302 return error; |
|
2303 } |
|
2304 |
|
2305 |
|
2306 /* END */ |