feat(ttf2sig): find ZWJ ligatures

Author: Xiphoseer

crates/ttf2sig/src/bin/ttf-info.rs

@@ -7,9 +7,9 @@ use signum::{
         metrics::{FontMetrics, DEFAULT_FONT_SIZE},
         printer::PrinterKind,
     },
-    image::{GrayImage, ImageFormat},
+    image::{GenericImage, GrayImage, ImageFormat},
 };
-use ttf2sig::{glyph_index_vec, LigatureInfo};
+use ttf2sig::{glyph_index_vec, KerningInfo, LigatureInfo};
 use ttf_parser::{Face, GlyphId};
 
 #[derive(Parser)]
@@ -33,13 +33,31 @@ fn main() -> color_eyre::Result<()> {
 
     let face = Face::parse(&data, opt.index)?;
     let l = LigatureInfo::new(&face);
+    let gpos = KerningInfo::new(&face);
+
+    debug_kern(&face);
 
     let lig = opt.ligature.chars().collect::<Vec<_>>();
 
     let glyphs = glyph_index_vec(&face, &lig).ok_or_eyre("Not all glyphs in font")?;
+    eprintln!("{lig:?} => {glyphs:?}");
     let lig_glyph = l.find(&glyphs);
     println!("{:?} => {:?}", lig, lig_glyph);
 
+    for pair in glyphs.windows(2) {
+        let (first, second) = (pair[0], pair[1]);
+        // kern ttf-parser
+        if let Some((v1, v2)) = gpos.find(first, second) {
+            println!("v1: {v1:?}");
+            println!("v2: {v2:?}");
+        }
+    }
+
+    let font_size = DEFAULT_FONT_SIZE;
+    let pk = PrinterKind::Needle24;
+    let fm = FontMetrics::new(pk, font_size);
+    let px = fm.em_square_pixels() as f32;
+
     let font = fontdue::Font::from_bytes(
         &data[..],
         fontdue::FontSettings {
@@ -49,21 +67,63 @@ fn main() -> color_eyre::Result<()> {
         },
     )
     .expect("already ttf parsed");
+
+    for pair in lig.windows(2) {
+        // kern fontdue
+        let (a, b) = (pair[0], pair[1]);
+        let kern = font.horizontal_kern(a, b, px);
+        println!("kern {pair:?} => {:?}", kern);
+    }
+
     if let Some(gl) = lig_glyph {
-        let img = _raster(&font, gl)?;
+        let img = _raster(&font, gl, px)?;
         _show(&img)?;
+    } else {
+        let mut ymin = i32::MAX;
+        let mut ymax = i32::MIN;
+        let mut x = 0;
+        let mut width = 0;
+        let mut pos = vec![];
+        for g in &glyphs {
+            let m = font.metrics_indexed(g.0, px);
+            println!("{m:?}");
+            ymin = m.ymin.min(ymin);
+            let y = m.ymin + (m.height as i32);
+            ymax = y.max(ymax);
+            width = (x + m.width).max(width);
+            pos.push((x as u32, y));
+            x += m.advance_width as usize;
+        }
+        let height = (ymax - ymin) as usize;
+        let mut canvas = GrayImage::new(width as u32, height as u32);
+        canvas.fill(0xFF);
+
+        let mut pos_iter = pos.into_iter().map(|(x, y)| (x, (ymax - y) as u32));
+        for g in glyphs {
+            let img = _raster(&font, g, px)?;
+            let (x, y) = pos_iter.next().expect("pos vec");
+            canvas.copy_from(&img, x, y).unwrap();
+        }
+        _show(&canvas)?;
     }
 
     Ok(())
 }
 
-fn _raster(font: &fontdue::Font, g: GlyphId) -> color_eyre::Result<GrayImage> {
-    let font_size = DEFAULT_FONT_SIZE;
-    let pk = PrinterKind::Needle24;
-    let fm = FontMetrics::new(pk, font_size);
-    let px_per_em = fm.em_square_pixels();
+fn debug_kern(face: &Face<'_>) {
+    if let Some(_kern) = face.tables().kern {
+    } else {
+        eprintln!("No kerning info (kern)");
+    }
+
+    if let Some(_kerx) = face.tables().kerx {
+    } else {
+        eprintln!("No extended kerning info (kerx)");
+    }
+}
 
-    let (metrics, bitmap) = font.rasterize_indexed(g.0, px_per_em as f32);
+fn _raster(font: &fontdue::Font, g: GlyphId, px: f32) -> color_eyre::Result<GrayImage> {
+    let (metrics, bitmap) = font.rasterize_indexed(g.0, px);
     let inverted = bitmap.iter().copied().map(|c| 255 - c).collect();
     let img = GrayImage::from_vec(metrics.width as u32, metrics.height as u32, inverted)
         .context("image creation")?;

crates/ttf2sig/src/kerning.rs

@@ -0,0 +1,57 @@
+use ttf_parser::{
+    gpos::{PairAdjustment, PositioningSubtable, ValueRecord},
+    Face, GlyphId,
+};
+
+#[derive(Debug)]
+pub struct KerningInfo<'a> {
+    pair_adjustments: Vec<PairAdjustment<'a>>,
+}
+
+impl<'a> KerningInfo<'a> {
+    pub fn new(face: &Face<'a>) -> Self {
+        Self {
+            pair_adjustments: face
+                .tables()
+                .gpos
+                .map(|gpos| {
+                    gpos.lookups
+                        .into_iter()
+                        .flat_map(|lookup| {
+                            lookup
+                                .subtables
+                                .into_iter::<PositioningSubtable>()
+                                .filter_map(|subtable| match subtable {
+                                    PositioningSubtable::Pair(pair) => Some(pair),
+                                    _ => None,
+                                })
+                        })
+                        .collect()
+                })
+                .unwrap_or_default(),
+        }
+    }
+
+    pub fn find(
+        &self,
+        first: GlyphId,
+        second: GlyphId,
+    ) -> Option<(ValueRecord<'a>, ValueRecord<'a>)> {
+        for p in &self.pair_adjustments {
+            if let Some(c) = p.coverage().get(first) {
+                match p {
+                    PairAdjustment::Format1 { coverage: _, sets } => {
+                        let set = sets.get(c).expect("coverage");
+                        return set.get(second);
+                    }
+                    PairAdjustment::Format2 {
+                        coverage: _,
+                        classes: _,
+                        matrix: _,
+                    } => unimplemented!(),
+                }
+            }
+        }
+        None
+    }
+}

crates/ttf2sig/src/lib.rs

@@ -1,53 +1,9 @@
-use ttf_parser::{
-    gsub::{LigatureSubstitution, SubstitutionSubtable},
-    Face, GlyphId,
-};
+mod kerning;
+mod ligature;
 
-pub struct LigatureInfo<'a> {
-    ligature_substitutions: Vec<LigatureSubstitution<'a>>,
-}
-
-impl<'a> LigatureInfo<'a> {
-    pub fn new(face: &Face<'a>) -> Self {
-        Self {
-            ligature_substitutions: face
-                .tables()
-                .gsub
-                .map(|gsub| {
-                    gsub.lookups
-                        .into_iter()
-                        .flat_map(|lookup| {
-                            lookup
-                                .subtables
-                                .into_iter::<SubstitutionSubtable>()
-                                .filter_map(|subtable| match subtable {
-                                    SubstitutionSubtable::Ligature(lig) => Some(lig),
-                                    _ => None,
-                                })
-                        })
-                        .collect()
-                })
-                .unwrap_or_default(),
-        }
-    }
-
-    pub fn find(&self, glyphs: &[GlyphId]) -> Option<GlyphId> {
-        let (&first, rest) = glyphs.split_first()?;
-
-        for lig in &self.ligature_substitutions {
-            if let Some(coverage) = lig.coverage.get(first) {
-                let l = lig.ligature_sets.get(coverage)?;
-                for ligature in l {
-                    if ligature.components.into_iter().eq(rest.iter().copied()) {
-                        return Some(ligature.glyph);
-                    }
-                }
-                return None;
-            }
-        }
-        None
-    }
-}
+pub use kerning::KerningInfo;
+pub use ligature::LigatureInfo;
+use ttf_parser::{Face, GlyphId};
 
 pub fn glyph_index_vec(face: &Face<'_>, lig: &[char]) -> Option<Vec<GlyphId>> {
     let mut v = Vec::new();

crates/ttf2sig/src/ligature.rs

@@ -0,0 +1,62 @@
+use ttf_parser::{
+    gsub::{LigatureSubstitution, SubstitutionSubtable},
+    Face, GlyphId,
+};
+
+pub struct LigatureInfo<'a> {
+    ligature_substitutions: Vec<LigatureSubstitution<'a>>,
+    zwj: Option<GlyphId>,
+}
+
+const ZERO_WIDTH_JOINER: char = '\u{200D}';
+
+impl<'a> LigatureInfo<'a> {
+    pub fn new(face: &Face<'a>) -> Self {
+        Self {
+            zwj: face.glyph_index(ZERO_WIDTH_JOINER),
+            ligature_substitutions: face
+                .tables()
+                .gsub
+                .map(|gsub| {
+                    gsub.lookups
+                        .into_iter()
+                        .flat_map(|lookup| {
+                            lookup
+                                .subtables
+                                .into_iter::<SubstitutionSubtable>()
+                                .filter_map(|subtable| match subtable {
+                                    SubstitutionSubtable::Ligature(lig) => Some(lig),
+                                    _ => None,
+                                })
+                        })
+                        .collect()
+                })
+                .unwrap_or_default(),
+        }
+    }
+
+    pub fn find(&self, glyphs: &[GlyphId]) -> Option<GlyphId> {
+        let (&first, rest) = glyphs.split_first()?;
+
+        for lig in &self.ligature_substitutions {
+            if let Some(coverage) = lig.coverage.get(first) {
+                let l = lig.ligature_sets.get(coverage)?;
+                for ligature in l {
+                    if ligature.components.into_iter().eq(rest.iter().copied()) {
+                        return Some(ligature.glyph);
+                    } else if let Some(zwj) = self.zwj {
+                        if ligature
+                            .components
+                            .into_iter()
+                            .eq(rest.iter().copied().flat_map(|i| [zwj, i].into_iter()))
+                        {
+                            return Some(ligature.glyph);
+                        }
+                    }
+                }
+                return None;
+            }
+        }
+        None
+    }
+}