use alloc::vec::Vec;
use crate::error::ModelError;
use crate::outline::Outline;
use crate::{Glyph, GlyphId};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct Metrics {
pub advance_width: u16,
pub left_side_bearing: i16,
}
impl Metrics {
#[must_use]
pub const fn new(advance_width: u16, left_side_bearing: i16) -> Self {
Metrics {
advance_width,
left_side_bearing,
}
}
#[must_use]
pub const fn advance_width(&self) -> u16 {
self.advance_width
}
#[must_use]
pub const fn left_side_bearing(&self) -> i16 {
self.left_side_bearing
}
#[must_use]
pub fn right_side_bearing(&self, outline: &Outline) -> Option<i16> {
let b = outline.bbox()?;
let ink = crate::num::round(b.width()) as i32;
let advance = i32::from(self.advance_width);
i16::try_from(advance - ink).ok()
}
pub fn advance_for(outline: &Outline, glyph: GlyphId) -> Result<(u16, i16), ModelError> {
let Some(bbox) = outline.bbox() else {
return Ok((0, 0));
};
let advance = crate::num::ceil(f64::from(bbox.width()));
if advance > f64::from(u16::MAX) {
return Err(ModelError::AdvanceOverflow {
glyph,
advance: advance as i32,
});
}
let lsb = crate::num::to_i32(crate::num::round(bbox.min_x()))
.clamp(i32::from(i16::MIN), i32::from(i16::MAX)) as i16;
Ok((advance as u16, lsb))
}
}
#[derive(Debug, Clone, Copy, Default)]
struct Extents {
advance_width_max: u16,
min_left_side_bearing: Option<i16>,
min_right_side_bearing: Option<i16>,
x_max_extent: i16,
}
impl Extents {
fn add(&mut self, g: &Glyph) {
self.advance_width_max = self.advance_width_max.max(g.advance_width());
let lsb = g.left_side_bearing();
self.min_left_side_bearing = Some(match self.min_left_side_bearing {
Some(m) => m.min(lsb),
None => lsb,
});
let Some(bbox) = g.bbox() else {
return;
};
let ink = crate::num::round(bbox.width()) as i32;
let rsb = i32::from(g.advance_width()) - ink;
if let Ok(v) = i16::try_from(rsb) {
self.min_right_side_bearing = Some(match self.min_right_side_bearing {
Some(m) => m.min(v),
None => v,
});
}
let extent = i32::from(lsb) + crate::num::round(bbox.max_x()) as i32;
if let Ok(e) = i16::try_from(extent) {
self.x_max_extent = self.x_max_extent.max(e);
}
}
fn into_header(
self,
ascender: i16,
descender: i16,
vertical: Option<VerticalMetrics>,
) -> FontMetrics {
FontMetrics {
ascender,
descender,
line_gap: 0,
advance_width_max: self.advance_width_max,
min_left_side_bearing: self.min_left_side_bearing.unwrap_or(0),
min_right_side_bearing: self.min_right_side_bearing.unwrap_or(0),
x_max_extent: self.x_max_extent,
vertical,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FontMetrics {
pub ascender: i16,
pub descender: i16,
pub line_gap: i16,
pub advance_width_max: u16,
pub min_left_side_bearing: i16,
pub min_right_side_bearing: i16,
pub x_max_extent: i16,
pub vertical: Option<VerticalMetrics>,
}
impl Default for FontMetrics {
fn default() -> Self {
FontMetrics {
ascender: 800,
descender: -200,
line_gap: 0,
advance_width_max: 0,
min_left_side_bearing: 0,
min_right_side_bearing: 0,
x_max_extent: 0,
vertical: None,
}
}
}
impl FontMetrics {
#[must_use]
pub const fn with_vertical(self, vertical: VerticalMetrics) -> Self {
FontMetrics {
vertical: Some(vertical),
..self
}
}
#[must_use]
pub fn line_height(&self) -> i32 {
i32::from(self.ascender) - i32::from(self.descender) + i32::from(self.line_gap)
}
#[must_use]
pub fn vertical_line_height(&self) -> Option<i32> {
self.vertical
.map(|v| i32::from(v.ascender) - i32::from(v.descender) + i32::from(v.line_gap))
}
#[must_use]
pub fn derive(glyphs: &[Glyph]) -> FontMetrics {
let mut acc = Extents::default();
let mut ascender = Self::default().ascender;
let mut descender = Self::default().descender;
for g in glyphs {
acc.add(g);
if let Some(bbox) = g.bbox() {
if let Ok(y) = i16::try_from(crate::num::round(bbox.max_y()) as i32) {
ascender = ascender.max(y);
}
if let Ok(y) = i16::try_from(crate::num::round(bbox.min_y()) as i32) {
descender = descender.min(y);
}
}
}
acc.into_header(ascender, descender, None)
}
pub fn reset_extents(&mut self) {
let ascender = self.ascender;
let descender = self.descender;
let line_gap = self.line_gap;
let vertical = self.vertical;
*self = Extents::default().into_header(ascender, descender, vertical);
self.line_gap = line_gap;
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct VerticalMetrics {
pub ascender: i16,
pub descender: i16,
pub line_gap: i16,
pub advance_height_max: u16,
pub min_top_side_bearing: i16,
pub min_bottom_side_bearing: i16,
pub y_max_extent: i16,
}
impl VerticalMetrics {
#[must_use]
pub fn line_height(&self) -> i32 {
i32::from(self.ascender) - i32::from(self.descender) + i32::from(self.line_gap)
}
}
#[derive(Debug, Clone)]
pub struct MetricsBuilder {
ascender: i16,
descender: i16,
line_gap: i16,
extents: Extents,
seen: Vec<GlyphId>,
vertical: Option<VerticalMetrics>,
}
impl Default for MetricsBuilder {
fn default() -> Self {
MetricsBuilder::new()
}
}
impl MetricsBuilder {
#[must_use]
pub fn new() -> Self {
MetricsBuilder {
ascender: 800,
descender: -200,
line_gap: 0,
extents: Extents::default(),
seen: Vec::new(),
vertical: None,
}
}
#[must_use]
pub const fn with_ascender(mut self, ascender: i16) -> Self {
self.ascender = ascender;
self
}
#[must_use]
pub const fn with_descender(mut self, descender: i16) -> Self {
self.descender = descender;
self
}
#[must_use]
pub const fn with_line_gap(mut self, line_gap: i16) -> Self {
self.line_gap = line_gap;
self
}
#[must_use]
pub fn with_vertical(mut self, vertical: VerticalMetrics) -> Self {
self.vertical = Some(vertical);
self
}
pub fn push(&mut self, glyph: &Glyph) -> &mut Self {
self.extents.add(glyph);
self.seen.push(glyph.id());
self
}
#[must_use]
pub fn len(&self) -> usize {
self.seen.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.seen.is_empty()
}
pub fn advance_for(outline: &Outline, glyph: GlyphId) -> Result<(u16, i16), ModelError> {
Metrics::advance_for(outline, glyph)
}
#[must_use]
pub fn build(&self) -> FontMetrics {
let mut header = self
.extents
.into_header(self.ascender, self.descender, self.vertical);
header.line_gap = self.line_gap;
header
}
}
#[cfg(test)]
mod tests {
#![allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::indexing_slicing,
clippy::panic
)]
use super::{FontMetrics, Metrics, MetricsBuilder, VerticalMetrics};
use crate::{Glyph, GlyphId, ModelError, Outline, Path};
use alloc::vec::Vec;
fn box_at(x0: f32, y0: f32, x1: f32, y1: f32) -> Outline {
let mut o = Outline::new();
let mut p = Path::starting_at(x0, y0);
p.line_to(x1, y0);
p.line_to(x1, y1);
p.line_to(x0, y1);
p.close();
o.push_contour(p);
o
}
#[test]
fn metrics_pair_accessors() {
let m = Metrics::new(500, 42);
assert_eq!(m.advance_width(), 500);
assert_eq!(m.left_side_bearing(), 42);
assert_eq!(
m,
Metrics {
advance_width: 500,
left_side_bearing: 42
}
);
assert_eq!(Metrics::default(), Metrics::new(0, 0));
}
#[test]
fn right_side_bearing_from_outline() {
let m = Metrics::new(400, 100);
assert_eq!(
m.right_side_bearing(&box_at(100.0, 0.0, 500.0, 400.0)),
Some(0)
);
assert_eq!(
m.right_side_bearing(&box_at(100.0, 0.0, 300.0, 400.0)),
Some(200)
);
assert_eq!(
m.right_side_bearing(&box_at(0.0, 0.0, 500.0, 10.0)),
Some(-100)
);
let narrow = Metrics::new(0, 0);
assert_eq!(
narrow.right_side_bearing(&box_at(0.0, 0.0, 40_000.0, 10.0)),
None
);
assert_eq!(m.right_side_bearing(&Outline::new()), None);
}
#[test]
fn advance_for_computes_from_the_outline() {
let (advance, lsb) =
Metrics::advance_for(&box_at(100.0, 0.0, 500.0, 400.0), GlyphId::new(1))
.expect("computes");
assert_eq!(advance, 400);
assert_eq!(lsb, 100);
assert_eq!(
Metrics::advance_for(&Outline::new(), GlyphId::new(1)).expect("computes"),
(0, 0)
);
assert_eq!(
Metrics::advance_for(&box_at(-50.0, 0.0, 50.0, 10.0), GlyphId::new(1))
.expect("computes"),
(100, -50)
);
}
#[test]
fn advance_for_rounds_a_fractional_width_up() {
let (advance, _) = Metrics::advance_for(&box_at(0.0, 0.0, 100.4, 10.0), GlyphId::new(1))
.expect("computes");
assert_eq!(advance, 101, "a fractional ink width gets its full ink");
}
#[test]
fn advance_for_reports_overflow() {
match Metrics::advance_for(&box_at(0.0, 0.0, 70_000.0, 10.0), GlyphId::new(3)).unwrap_err()
{
ModelError::AdvanceOverflow { glyph, .. } => assert_eq!(glyph, GlyphId::new(3)),
other => panic!("expected AdvanceOverflow, got {other:?}"),
}
}
#[test]
fn advance_for_saturates_an_unrepresentable_bearing() {
let (advance, lsb) =
Metrics::advance_for(&box_at(-40_000.0, 0.0, -39_000.0, 10.0), GlyphId::new(1))
.expect("computes");
assert_eq!(advance, 1000);
assert_eq!(lsb, i16::MIN);
let (_, lsb) =
Metrics::advance_for(&box_at(40_000.0, 0.0, 41_000.0, 10.0), GlyphId::new(1))
.expect("computes");
assert_eq!(lsb, i16::MAX);
}
#[test]
fn font_metrics_defaults_and_line_height() {
let m = FontMetrics::default();
assert_eq!(m.ascender, 800);
assert_eq!(m.descender, -200);
assert_eq!(m.line_gap, 0);
assert_eq!(m.line_height(), 1000);
assert!(m.vertical.is_none());
assert!(m.vertical_line_height().is_none());
}
#[test]
fn font_metrics_vertical() {
let v = VerticalMetrics {
ascender: 500,
descender: -500,
line_gap: 100,
..VerticalMetrics::default()
};
assert_eq!(v.line_height(), 1100);
let m = FontMetrics::default().with_vertical(v);
assert_eq!(m.vertical, Some(v));
assert_eq!(m.vertical_line_height(), Some(1100));
}
#[test]
fn derive_computes_running_extents() {
let a = Glyph::new(GlyphId::new(0), 500, 100, box_at(100.0, 0.0, 500.0, 400.0));
let b = Glyph::new(
GlyphId::new(1),
700,
-20,
box_at(-20.0, -50.0, 200.0, 900.0),
);
let m = FontMetrics::derive(&[a, b]);
assert_eq!(m.advance_width_max, 700);
assert_eq!(m.min_left_side_bearing, -20);
assert_eq!(m.min_right_side_bearing, 100, "min of +100, +480");
let overhang = Glyph::new(GlyphId::new(0), 100, 0, box_at(0.0, 0.0, 200.0, 10.0));
assert_eq!(
FontMetrics::derive(&[overhang]).min_right_side_bearing,
-100
);
assert_eq!(m.x_max_extent, 600, "max of lsb + xMax");
assert_eq!(m.ascender, 900);
assert_eq!(m.descender, -200);
let e = FontMetrics::derive(&[]);
assert_eq!(e, FontMetrics::default());
}
#[test]
fn builder_accumulates_and_matches_derive() {
let mut g = Glyph::new(GlyphId::new(0), 0, 0, box_at(100.0, 0.0, 500.0, 400.0));
g.recompute_metrics().expect("recomputes");
let mut b = MetricsBuilder::new();
assert!(b.is_empty());
b.push(&g);
b.push(&Glyph::empty(GlyphId::new(1), 600));
assert_eq!(b.len(), 2);
let built = b.build();
assert_eq!(built.advance_width_max, 600);
assert_eq!(built.min_left_side_bearing, 0, "the empty glyph's lsb");
assert_eq!(built.x_max_extent, 600);
let derived = FontMetrics::derive(&[g, Glyph::empty(GlyphId::new(1), 600)]);
assert_eq!(built, derived);
}
#[test]
fn builder_overrides_survive() {
let m = MetricsBuilder::new()
.with_ascender(1000)
.with_descender(-300)
.with_line_gap(90)
.with_vertical(VerticalMetrics {
ascender: 1,
descender: -1,
line_gap: 0,
..VerticalMetrics::default()
})
.build();
assert_eq!(m.ascender, 1000);
assert_eq!(m.descender, -300);
assert_eq!(m.line_gap, 90);
assert_eq!(m.line_height(), 1390);
assert_eq!(m.vertical.map(|v| v.ascender), Some(1));
}
#[test]
fn builder_advance_for_matches_glyph_recompute() {
let outline = box_at(120.0, 0.0, 480.0, 400.0);
let (advance, lsb) =
MetricsBuilder::advance_for(&outline, GlyphId::new(2)).expect("computes");
let mut g = Glyph::new(GlyphId::new(2), 0, 0, outline);
g.recompute_metrics().expect("recomputes");
assert_eq!(advance, g.advance_width());
assert_eq!(lsb, g.left_side_bearing());
assert_eq!(advance, 360);
assert_eq!(lsb, 120);
}
#[test]
fn builder_round_trips_a_whole_store() {
let outlines: Vec<Outline> = (0..4)
.map(|i| {
let x = i as f32 * 10.0;
box_at(x, 0.0, x + 300.0, 500.0)
})
.collect();
let mut glyphs: Vec<Glyph> = Vec::new();
let mut b = MetricsBuilder::new();
for (i, o) in outlines.into_iter().enumerate() {
let mut g = Glyph::new(GlyphId::new(u16::try_from(i).unwrap_or(0)), 0, 0, o);
g.recompute_metrics().expect("recomputes");
b.push(&g);
glyphs.push(g);
}
assert_eq!(b.build(), FontMetrics::derive(&glyphs));
assert_eq!(b.build().advance_width_max, 300);
}
}