chore: protoype ligatures with ttf-parser

Author: Xiphoseer

Cargo.lock

@@ -26,7 +26,7 @@ serde = "1.0"
 futures-lite = "2.3.0"
 
 [features]
-ttf = ["dep:fontdue", "dep:tempfile"]
+ttf = ["dep:fontdue", "dep:tempfile", "dep:ttf-parser"]
 default = ["ttf"]
 
 [dependencies.image]
@@ -38,6 +38,10 @@ features = ["png"]
 version = "0.9"
 optional = true
 
+[dependencies.ttf-parser]
+version = "0.25"
+optional = true
+
 [dependencies.tempfile]
 version = "3.17.1"
 optional = true

Cargo.toml

@@ -0,0 +1,83 @@
+use std::path::PathBuf;
+
+use clap::Parser;
+use color_eyre::eyre::{Context, ContextCompat, OptionExt};
+use image::{GrayImage, ImageFormat};
+use sdo_tool::ttf::{glyph_index_vec, LigatureInfo};
+use signum::chsets::{
+    metrics::{FontMetrics, DEFAULT_FONT_SIZE},
+    printer::PrinterKind,
+};
+use ttf_parser::{Face, GlyphId};
+
+#[derive(Parser)]
+/// Options for decoding an ATARI String
+pub struct Opts {
+    /// The file to convert
+    font_file: PathBuf,
+
+    /// The ligature to check
+    #[clap(default_value = "ch")]
+    ligature: String,
+
+    #[clap(short, long, default_value = "0")]
+    index: u32,
+}
+
+fn main() -> color_eyre::Result<()> {
+    color_eyre::install()?;
+    let opt: Opts = Opts::parse();
+    let data = std::fs::read(&opt.font_file)?;
+
+    let face = Face::parse(&data, opt.index)?;
+    let l = LigatureInfo::new(&face);
+
+    let lig = opt.ligature.chars().collect::<Vec<_>>();
+
+    let glyphs = glyph_index_vec(&face, &lig).ok_or_eyre("Not all glyphs in font")?;
+    let lig_glyph = l.find(&glyphs);
+    println!("{:?} => {:?}", lig, lig_glyph);
+
+    let font = fontdue::Font::from_bytes(
+        &data[..],
+        fontdue::FontSettings {
+            collection_index: opt.index,
+            scale: 40.0,
+            load_substitutions: true,
+        },
+    )
+    .expect("already ttf parsed");
+    if let Some(gl) = lig_glyph {
+        let img = _raster(&font, gl)?;
+        _show(&img)?;
+    }
+
+    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();
+
+    let (metrics, bitmap) = font.rasterize_indexed(g.0, px_per_em as f32);
+    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")?;
+    Ok(img)
+}
+
+fn _show(img: &GrayImage) -> color_eyre::Result<()> {
+    let mut tmpfile =
+        tempfile::NamedTempFile::with_suffix(".png").context("failed to create tempfile")?;
+    img.write_to(&mut tmpfile, ImageFormat::Png)
+        .expect("image to PDF");
+
+    let mut child = std::process::Command::new("eog")
+        .arg(tmpfile.path())
+        .spawn()?;
+
+    let _o = child.wait()?;
+    Ok(())
+}

src/bin/ttf-info.rs

@@ -1 +1,3 @@
 pub mod cli;
+#[cfg(feature = "ttf")]
+pub mod ttf;

src/lib.rs

@@ -0,0 +1,58 @@
+use ttf_parser::{
+    gsub::{LigatureSubstitution, SubstitutionSubtable},
+    Face, GlyphId,
+};
+
+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 fn glyph_index_vec(face: &Face<'_>, lig: &[char]) -> Option<Vec<GlyphId>> {
+    let mut v = Vec::new();
+    for &code_point in lig {
+        v.push(face.glyph_index(code_point)?);
+    }
+    Some(v)
+}