[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[freetype2] gsoc-craig-2023 23daa6904: Add tilde correction as an entry
|
From: |
Werner Lemberg |
|
Subject: |
[freetype2] gsoc-craig-2023 23daa6904: Add tilde correction as an entry to the adjustment database. Add comment block about glyph variants algorithm |
|
Date: |
Sun, 15 Oct 2023 01:15:57 -0400 (EDT) |
branch: gsoc-craig-2023
commit 23daa690485e672b200ac4893445163485e87026
Author: Craig White <gerzytet@gmail.com>
Commit: Craig White <gerzytet@gmail.com>
Add tilde correction as an entry to the adjustment database. Add comment
block about glyph variants algorithm
---
src/autofit/afadjust.c | 294 +++++++++++++++++++++++++++----------------------
src/autofit/afadjust.h | 3 +-
src/autofit/aflatin.c | 271 +++++++++++++++++++++------------------------
3 files changed, 287 insertions(+), 281 deletions(-)
diff --git a/src/autofit/afadjust.c b/src/autofit/afadjust.c
index d6a801e57..61d974a3d 100644
--- a/src/autofit/afadjust.c
+++ b/src/autofit/afadjust.c
@@ -21,121 +21,123 @@
FT_LOCAL_ARRAY_DEF( AF_AdjustmentDatabaseEntry )
adjustment_database[] =
{
- {0x21, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /* ! */
- {0x69, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /* i */
- {0x6A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /* j */
- {0xA1, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*Inverted Exclamation
Mark*/
- {0xBF, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*Inverted Question Mark*/
- {0xC0, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*A with grave*/
- {0xC1, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*A with acute*/
- {0xC2, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*A with circumflex*/
- {0xC3, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*A with tilde*/
- {0xC8, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*E with grave*/
- {0xCC, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}, /*I with grave*/
- {0xCD, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xCE, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xD1, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xD2, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xD3, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xD4, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xD5, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xD9, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xD1, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xDB, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xDD, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xE0, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xE1, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xE2, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xE3, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xE8, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xE9, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xEA, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xEC, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xED, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xEE, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xF1, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xF2, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xF3, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xF4, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xF5, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xF9, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xFA, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xFB, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0xFD, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x100, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x101, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x102, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x103, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x106, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x108, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x109, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x10A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x10B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x10C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x10D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x10E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x112, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x113, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x114, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x115, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x116, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x117, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x11B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x11C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x11D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x11E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x11F, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x120, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x121, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x123, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x124, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x125, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x128, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x129, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x12A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x12B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x12C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x12D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x12F, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x130, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x134, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x135, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x139, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x13A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x143, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x144, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x147, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x14C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x14D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x14E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x14F, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x154, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x155, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x158, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x159, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x15A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x15B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x15C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x15D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x160, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x161, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x164, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x168, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x169, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x16A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x16B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x16C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x16D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x174, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x175, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x176, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x177, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x179, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x17A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x17B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x17C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x17D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP},
- {0x17E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP}
+ {0x21, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /* ! */
+ {0x69, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /* i */
+ {0x6A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /* j */
+ {0xA1, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*Inverted Exclamation
Mark*/
+ {0xBF, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /* j */
+ {0xA1, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*Inverted Exclamation
Mark*/
+ {0xBF, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*Inverted Question
Mark*/
+ {0xC0, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*A with grave*/
+ {0xC1, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*A with acute*/
+ {0xC2, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*A with circumflex*/
+ {0xC3, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*A with tilde*/
+ {0xC8, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*E with grave*/
+ {0xCC, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}, /*I with grave*/
+ {0xCD, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xCE, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xD1, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xD2, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xD3, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xD4, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xD5, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xD9, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xD1, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xDB, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xDD, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xE0, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xE1, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xE2, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xE3, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 1}, /*a with tilde*/
+ {0xE8, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xE9, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xEA, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xEC, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xED, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xEE, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xF1, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 1}, /*n with tilde*/
+ {0xF2, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xF3, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xF4, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xF5, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 1}, /*o with tilde*/
+ {0xF9, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xFA, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xFB, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0xFD, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x100, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x101, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x102, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x103, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x106, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x108, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x109, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x10A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x10B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x10C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x10D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x10E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x112, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x113, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x114, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x115, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x116, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x117, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x11B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x11C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x11D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x11E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x11F, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x120, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x121, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x123, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x124, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x125, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x128, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x129, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 1}, /*i with tilde*/
+ {0x12A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x12B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x12C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x12D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x12F, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x130, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x134, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x135, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x139, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x13A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x143, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x144, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x147, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x14C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x14D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x14E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x14F, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x154, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x155, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x158, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x159, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x15A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x15B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x15C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x15D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x160, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x161, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x164, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x168, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x169, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 1}, /*u with tilde*/
+ {0x16A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x16B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x16C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x16D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x174, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x175, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x176, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x177, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x179, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x17A, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x17B, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x17C, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x17D, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0},
+ {0x17E, AF_VERTICAL_ADJUSTMENT_TOP_CONTOUR_UP, 0}
};
/*FT_LOCAL_DEF( FT_Bool )
@@ -182,24 +184,17 @@ af_lookup_vertical_seperation_type(
AF_ReverseCharacterMap map, FT_Int glyph_ind
return entry->vertical_separation_adjustment_type;
}
-/*TODO: this is a testing placeholder
- it only returns 1 for n with tilde*/
-FT_LOCAL_DEF( FT_Int )
+/*1 if tilde correction should be applied to the topmost contour
+else 0*/
+FT_LOCAL_DEF( FT_Bool )
af_lookup_tilde_correction_type( AF_ReverseCharacterMap map, FT_Int
glyph_index ) {
FT_UInt32 codepoint = af_reverse_character_map_lookup( map, glyph_index );
- /* bits are: apply stretch, apply segment removal */
- if ( codepoint == 0xF1 ) { /*n tilde*/
- return 0b01;
- }
- else if ( codepoint == 0xE3 ) /*a tilde*/
- {
- return 0b11;
- }
- else if ( codepoint == 0xF5 ) /*o tilde*/
+ const AF_AdjustmentDatabaseEntry *entry = af_adjustment_database_lookup(
codepoint );
+ if ( entry == NULL )
{
- return 0b10;
+ return 0;
}
- return 0;
+ return entry->apply_tilde;
}
typedef struct AF_ReverseMapEntry_
@@ -283,12 +278,47 @@ af_reverse_character_map_entry_compare( const void *a,
const void *b ) {
}
#ifdef FT_CONFIG_OPTION_USE_HARFBUZZ
-/*Recursive algorithm to find all glyphs that a codepoint could turn into from
the GSUB table.
+/*
+Recursive algorithm to find all glyphs that a codepoint could turn into from
the GSUB table.
+
buffer: a buffer containing only the input codepoint
feature_tag_pool: the current list of features under consideration
current_features: the current list of features being applied
num_features: length of current_features
-result: the set of glyphs in the answer
+result: the set of glyphs that the input codepoint can map to.
+
+The algorithm works by running the hb_ot_shape_glyphs_closure function on
different lists of features
+to see which features will map to glyph onto something different. This
functions returns
+the result of transforming a glyph using a list of features as well as all
intermediate
+forms if the glyph was transformed multiple times.
+With no features enabled, hb_ot_shape_glyphs_closure will only return the
glyph given by cmap.
+This character will be the first to be placed into the results set.
+Next, the algorithm will test the same lookup enabline one feature at a time
+and see if any of those features change the result.
+If any new glyph variants are found this way, they are added to the results set
+and the algorithm will recurce, trying that feature in combination will every
other feature
+to look for further glyph variants.
+
+example:
+suppose we have the following features in the GSUB table:
+f1:
+a -> b
+
+f2:
+b -> c
+
+f3:
+d -> e
+
+The algorithm will take the following steps to find all variants of "a":
+- a is added to the results
+- lookup with feature list {f1}, yielding {a, b}. b is added to the results
list and the algorithm recurses
+- - lookup with feature list {f1, f2}, yielding {a, b, c}. c is added to the
results list and the algorithm recurses
+- - - lookup with feature list {f1, f2, f3} yielding {a, b, c}. No new glyphs
+- - lookup with feature list {f1, f3}, yielding {a, b}. No new glyphs
+- lookup with feature list {f2}, yielding {a}. No new glyphs
+- lookup with feature list {f3}, yielding {a}. No new glyphs
+
*/
FT_LOCAL_DEF( FT_Error )
af_all_glyph_variants_helper( hb_font_t *font,
@@ -300,7 +330,7 @@ af_all_glyph_variants_helper( hb_font_t *font,
{
FT_Error error;
/*get the list of glyphs that are created by only transforming based on the
- features in current features*/
+ features in current_features*/
hb_set_t *baseline_glyphs = NULL, *new_glyphs = NULL;
baseline_glyphs = hb_set_create();
if ( !hb_set_allocation_successful( baseline_glyphs ) )
diff --git a/src/autofit/afadjust.h b/src/autofit/afadjust.h
index 3ac24ae83..318bbaaec 100644
--- a/src/autofit/afadjust.h
+++ b/src/autofit/afadjust.h
@@ -27,12 +27,13 @@ typedef struct AF_AdjustmentDatabaseEntry_
{
FT_UInt32 codepoint;
AF_VerticalSeparationAdjustmentType vertical_separation_adjustment_type;
+ FT_Bool apply_tilde;
} AF_AdjustmentDatabaseEntry;
FT_LOCAL(AF_VerticalSeparationAdjustmentType)
af_lookup_vertical_seperation_type( AF_ReverseCharacterMap map, FT_Int
glyph_index );
-FT_LOCAL( FT_Int )
+FT_LOCAL( FT_Bool )
af_lookup_tilde_correction_type( AF_ReverseCharacterMap map, FT_Int
glyph_index );
FT_LOCAL( FT_UInt32 )
diff --git a/src/autofit/aflatin.c b/src/autofit/aflatin.c
index 2d49094e7..703106577 100644
--- a/src/autofit/aflatin.c
+++ b/src/autofit/aflatin.c
@@ -2855,158 +2855,154 @@ af_remove_segments_containing_point(AF_GlyphHints
hints, AF_Point point)
}
}
+/*remove all segments containing points on the tilde contour*/
static void
-af_latin_stretch_tildes_step_2( AF_GlyphHints hints,
- FT_Int glyph_index,
- AF_ReverseCharacterMap reverse_charmap )
+af_latin_remove_tilde_points_from_edges( AF_GlyphHints hints,
+ FT_Int glyph_index )
{
- if (af_lookup_tilde_correction_type(reverse_charmap, glyph_index) & 1) {
- FT_Int highest_contour = af_find_highest_contour(hints);
- AF_Point first_point = hints->contours[highest_contour];
+ FT_Int highest_contour = af_find_highest_contour(hints);
+ AF_Point first_point = hints->contours[highest_contour];
- /* search for any curve tips that are on a y extrema, and delete any
- segments that contain this point.*/
- AF_Point p = first_point;
+ /* search for any curve tips that are on a y extrema, and delete any
+ segments that contain this point.*/
+ AF_Point p = first_point;
- do
+ do
+ {
+ p = p->next;
+ if ( /*!(p->flags & AF_FLAG_CONTROL)
+ && p->prev->y == p->y && p->next->y == p->y
+ && p->prev->flags & AF_FLAG_CONTROL
+ && p->next->flags & AF_FLAG_CONTROL*/ 1 )
{
- p = p->next;
- if ( /*!(p->flags & AF_FLAG_CONTROL)
- && p->prev->y == p->y && p->next->y == p->y
- && p->prev->flags & AF_FLAG_CONTROL
- && p->next->flags & AF_FLAG_CONTROL*/ 1 )
- {
- FT_TRACE4(("%p", p));
- af_remove_segments_containing_point( hints, p );
- }
- } while ( p != first_point );
- }
+ FT_TRACE4(("%p", p));
+ af_remove_segments_containing_point( hints, p );
+ }
+ } while ( p != first_point );
}
void
af_latin_stretch_tildes( AF_GlyphHints hints,
- FT_Int glyph_index,
- AF_ReverseCharacterMap reverse_charmap ) {
- if ( af_lookup_tilde_correction_type( reverse_charmap, glyph_index ) & 2 ) {
- FT_Int highest_contour = af_find_highest_contour( hints );
- AF_Point p = hints->contours[highest_contour];
- AF_Point first_point = p;
+ FT_Int glyph_index )
+{
+ FT_Int highest_contour = af_find_highest_contour( hints );
+ AF_Point p = hints->contours[highest_contour];
+ AF_Point first_point = p;
+
+ FT_Pos min_y, max_y;
+ min_y = max_y = p->y;
- FT_Pos min_y, max_y;
- min_y = max_y = p->y;
+ FT_Short min_fy, max_fy;
+ min_fy = max_fy = p->fy;
- FT_Short min_fy, max_fy;
- min_fy = max_fy = p->fy;
+ do
+ {
+ p = p->next;
+ if ( p->y < min_y )
+ {
+ min_y = p->y;
+ }
+ if ( p->y > max_y )
+ {
+ max_y = p->y;
+ }
- do
+ if ( p->fy < min_fy )
{
- p = p->next;
- if ( p->y < min_y )
+ min_fy = p->fy;
+ }
+
+ if ( p->fy > max_fy )
+ {
+ max_fy = p->fy;
+ }
+
+ }
+ while ( p != first_point );
+
+ FT_Pos min_measurement = 32000;
+ FT_UInt measurements_taken = 0;
+
+ do
+ {
+ p = p->next;
+ if ( !(p->flags & AF_FLAG_CONTROL)
+ && p->prev->y == p->y && p->next->y == p->y
+ && p->y != min_y && p->y != max_y
+ && p->prev->flags & AF_FLAG_CONTROL
+ && p->next->flags & AF_FLAG_CONTROL )
+ {
+ /* This point could be a candidate. Find the next and previous on-curve
*/
+ /* points, and make sure they are both either above or below the point,
*/
+ /* Then make the measurement */
+ AF_Point prevOn = p->prev;
+ AF_Point nextOn = p->next;
+ while ( prevOn->flags & AF_FLAG_CONTROL )
{
- min_y = p->y;
+ prevOn = prevOn->prev;
}
- if ( p->y > max_y )
+ while ( nextOn->flags & AF_FLAG_CONTROL )
{
- max_y = p->y;
+ nextOn = nextOn->next;
}
-
- if ( p->fy < min_fy )
+ FT_Pos measurement;
+ if ( nextOn->y > p->y && prevOn->y > p->y )
{
- min_fy = p->fy;
+ measurement = p->y - min_y;
}
-
- if ( p->fy > max_fy )
+ else if ( nextOn->y < p->y && prevOn->y < p->y )
{
- max_fy = p->fy;
+ measurement = max_y - p->y;
+ }
+ else
+ {
+ continue;
}
+ if (measurement < min_measurement)
+ {
+ min_measurement = measurement;
+ }
+ measurements_taken++;
}
- while ( p != first_point );
- FT_Pos min_measurement = 32000;
- FT_UInt measurements_taken = 0;
-
- do
- {
- p = p->next;
- if ( !(p->flags & AF_FLAG_CONTROL)
- && p->prev->y == p->y && p->next->y == p->y
- && p->y != min_y && p->y != max_y
- && p->prev->flags & AF_FLAG_CONTROL
- && p->next->flags & AF_FLAG_CONTROL )
- {
- /* This point could be a candidate. Find the next and previous
on-curve */
- /* points, and make sure they are both either above or below the
point, */
- /* Then make the measurement */
- AF_Point prevOn = p->prev;
- AF_Point nextOn = p->next;
- while ( prevOn->flags & AF_FLAG_CONTROL )
- {
- prevOn = prevOn->prev;
- }
- while ( nextOn->flags & AF_FLAG_CONTROL )
- {
- nextOn = nextOn->next;
- }
- FT_Pos measurement;
- if ( nextOn->y > p->y && prevOn->y > p->y )
- {
- measurement = p->y - min_y;
- }
- else if ( nextOn->y < p->y && prevOn->y < p->y )
- {
- measurement = max_y - p->y;
- }
- else
- {
- continue;
- }
+ }
+ while ( p != first_point );
- if (measurement < min_measurement)
- {
- min_measurement = measurement;
- }
- measurements_taken++;
- }
+ FT_Pos height = max_y - min_y;
- }
- while ( p != first_point );
+ FT_Pos target_height = min_measurement + 64;
+ if ( height >= target_height )
+ {
+ return;
+ }
- FT_Pos height = max_y - min_y;
+ p = first_point;
+ do
+ {
+ p = p->next;
+ p->y = ((p->y - min_y) * target_height / height) + min_y;
+ p->fy = ((p->fy - min_fy) * target_height / height) + min_fy;
+ p->oy = p->y;
+ if ( !(p->flags & AF_FLAG_CONTROL) )
+ p->flags |= AF_FLAG_TOUCH_Y;
+ }
+ while ( p != first_point );
- FT_Pos target_height = min_measurement + 64;
- if ( height >= target_height )
+ FT_Pos new_min_y, new_max_y;
+ new_min_y = new_max_y = first_point->y;
+ p = first_point;
+ do {
+ p = p->next;
+ if ( p->y < new_min_y )
{
- return;
+ new_min_y = p->y;
}
-
- p = first_point;
- do
+ if ( p->y > new_max_y )
{
- p = p->next;
- p->y = ((p->y - min_y) * target_height / height) + min_y;
- p->fy = ((p->fy - min_fy) * target_height / height) + min_fy;
- p->oy = p->y;
- if ( !(p->flags & AF_FLAG_CONTROL) )
- p->flags |= AF_FLAG_TOUCH_Y;
+ new_max_y = p->y;
}
- while ( p != first_point );
-
- FT_Pos new_min_y, new_max_y;
- new_min_y = new_max_y = first_point->y;
- p = first_point;
- do {
- p = p->next;
- if ( p->y < new_min_y )
- {
- new_min_y = p->y;
- }
- if ( p->y > new_max_y )
- {
- new_max_y = p->y;
- }
- }
- while ( p != first_point );
}
+ while ( p != first_point );
}
/*True if the given contour overlaps horizontally with the bounding box
@@ -4060,33 +4056,7 @@ af_glyph_hints_apply_vertical_separation_adjustments(
AF_GlyphHints hints,
#endif
}
-/*Print the height of the topmost contour for debugging purposes.
- TODO: remove this once the tilde unflattening works.*/
-static void traceheight(FT_UInt num, AF_GlyphHints hints) {
- AF_Point p = hints->contours[af_find_highest_contour(hints)];
- AF_Point first_point = p;
-
- FT_Pos min_y, max_y;
- min_y = max_y = p->y;
-
- do {
- p = p->next;
- if ( !(p->flags & AF_FLAG_CONTROL) ) {
- if ( p->y < min_y ) {
- min_y = p->y;
- }
- if ( p->y > max_y ) {
- max_y = p->y;
- }
- }
- } while ( p != first_point );
-
- FT_Pos height = max_y - min_y;
- FT_TRACE4(( "height %d: %d\n", num, height ));
-}
-
/* Apply the complete hinting algorithm to a latin glyph. */
-
static FT_Error
af_latin_hints_apply( FT_UInt glyph_index,
AF_GlyphHints hints,
@@ -4119,13 +4089,18 @@ static void traceheight(FT_UInt num, AF_GlyphHints
hints) {
if ( AF_HINTS_DO_VERTICAL( hints ) )
{
- af_latin_stretch_tildes( hints, glyph_index,
metrics->root.reverse_charmap );
+ FT_Bool is_tilde = af_lookup_tilde_correction_type(
metrics->root.reverse_charmap, glyph_index );
+ if ( is_tilde ) {
+ af_latin_stretch_tildes( hints, glyph_index );
+ }
axis = &metrics->axis[AF_DIMENSION_VERT];
error = af_latin_hints_detect_features( hints,
axis->width_count,
axis->widths,
AF_DIMENSION_VERT );
- af_latin_stretch_tildes_step_2( hints, glyph_index,
metrics->root.reverse_charmap );
+ if ( is_tilde ) {
+ af_latin_remove_tilde_points_from_edges( hints, glyph_index );
+ }
if ( error )
goto Exit;
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [freetype2] gsoc-craig-2023 23daa6904: Add tilde correction as an entry to the adjustment database. Add comment block about glyph variants algorithm,
Werner Lemberg <=