DesignCraft: An open-source page and layout design editor written by scratch in pure Rust
Fonts: cap height and x-height from glyph outlines when a font doesn't declare them
aiongg771bbafb82d7
diff --git a/crates/compose/src/tests.rs b/crates/compose/src/tests.rsindex 02ec152fd..f4758aa97 100644--- a/crates/compose/src/tests.rs+++ b/crates/compose/src/tests.rs@@ -1579,18 +1579,18 @@ fn cap_height_and_x_height_first_baselines_use_the_fonts_cap_and_x_heights() {fn cap_height_and_x_height_fall_back_without_usable_os2_values() {use designcraft_doc::FirstBaseline;let db = designcraft_fonts::FontDb::global();- // No OS/2 table, zero / negative and absurd values: the top of the H (0.656 em) and 0.5 of the- // (1 em) ascent.+ // No OS/2 table, zero / negative and absurd values: the top of the H (0.656 em) and of the x+ // (0.486 em).let zero: &[(usize, i16)] = &[(CAP_HEIGHT, 0), (X_HEIGHT, -40)];let big: &[(usize, i16)] = &[(CAP_HEIGHT, i16::MAX), (X_HEIGHT, i16::MAX)];for (family, fields) in [("CapXHeightNoO", None), ("CapXHeightNeg", Some(zero)), ("CapXHeightBig", Some(big))] {db.add_font(test_font(family, fields));let face = db.face(family, "Regular");assert_eq!(face.family, family);- assert_eq!((face.cap_height, face.x_height), (656.0, face.ascent * 0.5), "{family}");+ assert_eq!((face.cap_height, face.x_height), (656.0, 486.0), "{family}");let cap = first_baseline_in(family, |o| o.first_baseline = FirstBaseline::CapHeight);let x = first_baseline_in(family, |o| o.first_baseline = FirstBaseline::XHeight);- assert!((cap - (40.0 + 13.12)).abs() < 0.01 && (x - (40.0 + 10.0)).abs() < 0.01, "{family}: {cap} {x}");+ assert!((cap - (40.0 + 13.12)).abs() < 0.01 && (x - (40.0 + 9.72)).abs() < 0.01, "{family}: {cap} {x}");}}diff --git a/crates/fonts/src/fontdb.rs b/crates/fonts/src/fontdb.rsindex 046a98e8b..188087549 100644--- a/crates/fonts/src/fontdb.rs+++ b/crates/fonts/src/fontdb.rs@@ -703,14 +703,15 @@ fn make_face(bytes: FontBytes, source: FontSource, index: u32, family: String, sascent: m.ascent as f64,typo_ascent: typo_ascent(&f, &location, upem).unwrap_or(m.ascent as f64),descent: -(m.descent as f64),+ // Fonts with an OS/2 table older than version 2 don't declare these: measure them from+ // flat-topped letters before falling back to a share of the ascent, which can be far off+ // (drop caps are sized from the cap height).cap_height: plausible(m.cap_height.map(f64::from), upem)- .or_else(|| {- // No OS/2 cap height: the top of the H.- let gid = f.charmap().map('H')?;- plausible(f.glyph_metrics(Size::unscaled(), &location).bounds(gid).map(|b| b.y_max as f64), upem)- })+ .or_else(|| measured_top(&f, &location, &['H', 'I', 'E', 'T'], upem)).unwrap_or(m.ascent as f64 * 0.72),- x_height: plausible(m.x_height.map(f64::from), upem).unwrap_or(m.ascent as f64 * 0.5),+ x_height: plausible(m.x_height.map(f64::from), upem)+ .or_else(|| measured_top(&f, &location, &['x', 'z', 'v'], upem))+ .unwrap_or(m.ascent as f64 * 0.5),shaper,coords,location,@@ -729,6 +730,36 @@ fn plausible(v: Option<f64>, upem: f64) -> Option<f64> {v.filter(|v| *v > 0.0 && *v <= 4.0 * upem)}+/// The top of the first of `chars` the font has a non-empty outline for, in font units: the+/// highest point of its unhinted outline at `location`, if [`plausible`]. For flat-topped letters+/// that is the cap height (`H`) or x-height (`x`).+fn measured_top(f: &skrifa::FontRef<'_>, location: &Location, chars: &[char], upem: f64) -> Option<f64> {+ struct Top(f32);+ impl OutlinePen for Top {+ fn move_to(&mut self, _x: f32, y: f32) {+ self.0 = self.0.max(y);+ }+ fn line_to(&mut self, _x: f32, y: f32) {+ self.0 = self.0.max(y);+ }+ fn quad_to(&mut self, _cx: f32, _cy: f32, _x: f32, y: f32) {+ self.0 = self.0.max(y);+ }+ fn curve_to(&mut self, _cx0: f32, _cy0: f32, _cx1: f32, _cy1: f32, _x: f32, y: f32) {+ self.0 = self.0.max(y);+ }+ fn close(&mut self) {}+ }+ let cmap = f.charmap();+ let glyphs = f.outline_glyphs();+ chars.iter().find_map(|&c| {+ let g = glyphs.get(cmap.map(c)?)?;+ let mut pen = Top(f32::NEG_INFINITY);+ g.draw(DrawSettings::unhinted(Size::unscaled(), location), &mut pen).ok()?;+ plausible(Some(f64::from(pen.0)), upem)+ })+}+/// The OS/2 typographic ascender in font units at `location`, if the font has an OS/2 table and/// the value is [`plausible`].fn typo_ascent(f: &skrifa::FontRef<'_>, location: &Location, upem: f64) -> Option<f64> {@@ -1483,3 +1514,54 @@ mod tests_docfonts;#[cfg(test)]#[path = "tests_vertical.rs"]mod tests_vertical;++#[cfg(test)]+mod tests_heights {+ use super::*;+ use crate::testing::{font_mapping, with_table_u16};++ fn face_of(bytes: Vec<u8>) -> FontFace {+ make_face(FontBytes::Owned(Arc::new(bytes)), FontSource::Memory, 0, "Test".into(), "Regular".into(), Vec::new()).unwrap()+ }++ /// `font` with OS/2 sxHeight and sCapHeight set to 0 (undeclared).+ fn undeclared(font: Vec<u8>) -> Vec<u8> {+ with_table_u16(with_table_u16(font, b"OS/2", 86, 0).unwrap(), b"OS/2", 88, 0).unwrap()+ }++ /// The top of Source Sans 3's glyph for `c` from its bounding box (font units).+ fn bbox_top(c: char) -> f64 {+ let f = skrifa::FontRef::new(BUNDLED[0]).unwrap();+ f.glyph_metrics(Size::unscaled(), LocationRef::default()).bounds(f.charmap().map(c).unwrap()).unwrap().y_max as f64+ }++ /// A font that doesn't declare its cap height and x-height gets them measured from its+ /// flat-topped letters, also when it lacks the first choices `H` and `x`; a font that+ /// declares them keeps them.+ #[test]+ fn undeclared_heights_are_measured_from_outlines() {+ let glyphs = [('H', 'H'), ('x', 'x'), ('E', 'E'), ('z', 'z')];+ for (glyphs, cap, x) in [(&glyphs[..], 'H', 'x'), (&glyphs[2..], 'E', 'z')] {+ let face = face_of(undeclared(font_mapping("Heights", glyphs).unwrap()));+ let (cap, x) = (bbox_top(cap), bbox_top(x));+ assert!(cap > x && x > 0.0);+ assert!((face.cap_height - cap).abs() <= 1.0, "{glyphs:?}: cap height {} vs {cap}", face.cap_height);+ assert!((face.x_height - x).abs() <= 1.0, "{glyphs:?}: x-height {} vs {x}", face.x_height);+ }+ let declared = face_of(font_mapping("Heights", &glyphs).unwrap());+ assert_eq!((declared.cap_height, declared.x_height), (660.0, 486.0), "Source Sans 3 Regular's OS/2 values");+ // Declared values win over the outlines: `H` drawn as `x` doesn't lower the cap height.+ let face = face_of(font_mapping("Heights", &[('H', 'x'), ('x', 'H')]).unwrap());+ assert_eq!((face.cap_height, face.x_height), (declared.cap_height, declared.x_height));+ }++ /// Without any of the letters, or with only empty outlines, the heights fall back to a share+ /// of the ascent.+ #[test]+ fn heights_without_measurable_letters_fall_back_to_the_ascent() {+ for glyphs in [&[('a', 'a')][..], &[('H', ' '), ('x', ' ')]] {+ let face = face_of(undeclared(font_mapping("Heights", glyphs).unwrap()));+ assert_eq!((face.cap_height, face.x_height), (face.ascent * 0.72, face.ascent * 0.5), "{glyphs:?}");+ }+ }+}