label.rs

//! 原子のラベルを組む
//!
//! `H_2O` や `SO_4^{2-}` のような、下付きと上付きを含む文字列を字形の並びに直す。
//! 座標は、x がラベルの左端から、y がベースラインから下向きを正として測る。
//!
//! ラベルは大文字ごとに部分へ切れる。`CH_3` なら `C` と `H_3` の 2 つである。
//! 結合は、この部分か、ラベル全体の墨の縁で止まる。

use crate::font::{self, Font};
use crate::style::Style;


/// 置かれた 1 つの字形
#[derive(Debug, Clone, PartialEq)]
pub struct Placed {
    /// 字形番号。フォントがその文字を持たなければ None
    pub glyph: Option<u16>,
    pub character: char,
    /// ラベルの左端からの位置
    pub x: f64,
    /// ベースラインからの位置。下向きが正
    pub y: f64,
    /// 大きさ。1 なら素の大きさ
    pub size: f64,
}


/// 墨の占める範囲
#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct Extent {
    pub left: f64,
    pub right: f64,
    /// ベースラインより上は負
    pub top: f64,
    pub bottom: f64,
}


impl Extent {
    /// 墨がまったくないかどうか
    pub fn is_blank(&self) -> bool {
        self.right <= self.left && self.bottom <= self.top
    }

    /// 2 つを包む範囲
    pub fn union(&self, other: &Extent) -> Extent {
        if self.is_blank() {
            return *other;
        }

        if other.is_blank() {
            return *self;
        }

        Extent {
            left: self.left.min(other.left),
            right: self.right.max(other.right),
            top: self.top.min(other.top),
            bottom: self.bottom.max(other.bottom),
        }
    }

    /// 四方へ広げる
    pub fn grow(&self, amount: f64) -> Extent {
        Extent {
            left: self.left - amount,
            right: self.right + amount,
            top: self.top - amount,
            bottom: self.bottom + amount,
        }
    }
}


/// 組み上がったラベル
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Label {
    pub placed: Vec<Placed>,
    /// 大文字ごとに切った部分の墨の範囲
    pub part: Vec<Extent>,
    /// ラベル全体の墨の範囲
    pub extent: Extent,
    /// 送り幅の合計
    pub width: f64,
}


/// ラベルの文字列を組む
pub fn build(source: &str, font: &Font, style: &Style) -> Label {
    let character: Vec<char> = source.chars().collect();
    let mut work = Work {placed: Vec::new(), boundary: Vec::new(), pen: 0.0};
    let start = Setting {size: 1.0, shift: 0.0, depth: 0, charge: false};
    place(&mut work, &character, &mut 0, start, font, style);

    let part = measure_part(&work, font);
    let extent = part.iter().fold(Extent::default(), |found, one| found.union(one));

    Label {placed: work.placed, part, extent, width: work.pen}
}


/// 結合を切り詰めるときに使う範囲。番号を書かなければラベル全体
pub fn clip_extent(label: &Label, number: Option<usize>) -> Option<Extent> {
    match number {
        None => Some(label.extent),
        Some(order) => label.part.get(order.checked_sub(1)?).copied(),
    }
}


/// 組み立ての途中の持ち物
struct Work {
    placed: Vec<Placed>,
    /// 部分の切れ目。placed の添字
    boundary: Vec<usize>,
    pen: f64,
}


/// いま置いている場所の決まりごと
#[derive(Debug, Clone, Copy)]
struct Setting {
    size: f64,
    /// ベースラインからの位置。下向きが正
    shift: f64,
    /// 波括弧の入れ子の深さ
    depth: usize,
    /// 上付きの中かどうか。電荷の記号をここで持ち上げる
    charge: bool,
}


/// 文字を順に置いていく。波括弧と下付き・上付きで自分を呼び直す
fn place(
    work: &mut Work,
    character: &[char],
    index: &mut usize,
    setting: Setting,
    font: &Font,
    style: &Style,
) {
    while *index < character.len() {
        match character[*index] {
            '}' => {
                if setting.depth > 0 {
                    *index += 1;

                    return;
                }

                *index += 1;
            }
            '{' => {
                *index += 1;
                let inner = Setting {depth: setting.depth + 1, ..setting};
                place(work, character, index, inner, font, style);
            }
            '_' => {
                *index += 1;
                let inner = Setting {
                    size: shrink(setting.size, style),
                    shift: setting.shift + style.subscript_drop * setting.size,
                    ..setting
                };
                unit(work, character, index, inner, font, style);
                loosen(work, character, *index, setting, style);
            }
            '^' => {
                *index += 1;
                let inner = Setting {
                    size: shrink(setting.size, style),
                    shift: setting.shift - style.superscript_rise * setting.size,
                    charge: true,
                    ..setting
                };
                unit(work, character, index, inner, font, style);
                loosen(work, character, *index, setting, style);
            }
            found => {
                *index += 1;

                if setting.depth == 0 && found.is_ascii_uppercase() && !work.placed.is_empty() {
                    work.boundary.push(work.placed.len());
                }

                put(work, sign(found), setting, font);
            }
        }
    }
}


/// 下付きと上付きが連れていく 1 つ。波括弧のまとまりか、そうでなければ 1 文字
fn unit(
    work: &mut Work,
    character: &[char],
    index: &mut usize,
    setting: Setting,
    font: &Font,
    style: &Style,
) {
    match character.get(*index) {
        None => {}
        Some('{') => {
            *index += 1;
            let inner = Setting {depth: setting.depth + 1, ..setting};
            place(work, character, index, inner, font, style);
        }
        Some(found) => {
            let one = sign(*found);
            *index += 1;
            put(work, one, setting, font);
        }
    }
}


/// 添字の後ろに空きを入れる
///
/// 次に来るのが素の字のときだけ入れる。添字が続くとき（`O_4^{2-}` の 4 と 2）や、
/// まとまりの終わりでは入れない
fn loosen(work: &mut Work, character: &[char], at: usize, setting: Setting, style: &Style) {
    if matches!(character.get(at), Some('_' | '^' | '}') | None) {
        return;
    }

    work.pen += style.script_space * setting.size;
}


/// 字形を 1 つ置き、送り幅だけ筆を進める
fn put(work: &mut Work, character: char, setting: Setting, font: &Font) {
    let glyph = font::glyph_of(font, character);
    let advance = match glyph {
        Some(found) => font::advance(font, found),
        None => font::fallback_metric(character).0,
    };
    let lift = match glyph {
        Some(found) if setting.charge && is_sign(character) => raise(font, found) * setting.size,
        _ => 0.0,
    };

    work.placed.push(Placed {
        glyph,
        character,
        x: work.pen,
        y: setting.shift - lift,
        size: setting.size,
    });
    work.pen += advance * setting.size;
}


/// 数式の軸を中心に描かれた記号かどうか
fn is_sign(character: char) -> bool {
    matches!(character, '+' | '\u{2212}' | '\u{b1}' | '\u{2213}')
}


/// 電荷の記号を持ち上げる量。その字の大きさを 1 として測る
///
/// 数字はベースラインに乗るが、+ や − は数式の軸を中心に描かれるので、
/// そのまま並べると数字より低く見える。中心が数字の中心に来るまで持ち上げる
fn raise(font: &Font, glyph: u16) -> f64 {
    let (height, depth) = font::extent(font, glyph);
    let middle = (height - depth) / 2.0;

    (font::digit_height(font) / 2.0 - middle).max(0.0)
}


/// 下付きと上付きの大きさ。掛けるだけだと入れ子で際限なく小さくなるので、下限で止める
fn shrink(size: f64, style: &Style) -> f64 {
    (size * style.script_size).max(style.script_floor).min(size)
}


/// ラベルの中のハイフンは負電荷の記号である。見た目の合う字形に替える
fn sign(character: char) -> char {
    match character {
        '-' => '\u{2212}',
        other => other,
    }
}


/// 部分ごとの墨の範囲を測る
fn measure_part(work: &Work, font: &Font) -> Vec<Extent> {
    if work.placed.is_empty() {
        return Vec::new();
    }

    let mut edge = vec![0];
    edge.extend(work.boundary.iter().copied());
    edge.push(work.placed.len());

    let mut found = Vec::new();

    for window in edge.windows(2) {
        let mut extent = Extent::default();

        for placed in &work.placed[window[0]..window[1]] {
            extent = extent.union(&measure_one(placed, font));
        }

        found.push(extent);
    }

    found
}


/// 字形 1 つの墨の範囲
fn measure_one(placed: &Placed, font: &Font) -> Extent {
    match placed.glyph {
        Some(glyph) => {
            let (left, right) = font::bearing(font, glyph);
            let (height, depth) = font::extent(font, glyph);
            let advance = font::advance(font, glyph);

            Extent {
                left: placed.x + left * placed.size,
                right: placed.x + (advance - right) * placed.size,
                top: placed.y - height * placed.size,
                bottom: placed.y + depth * placed.size,
            }
        }
        None => {
            let (advance, height, depth) = font::fallback_metric(placed.character);

            Extent {
                left: placed.x,
                right: placed.x + advance * placed.size,
                top: placed.y - height * placed.size,
                bottom: placed.y + depth * placed.size,
            }
        }
    }
}


#[cfg(test)]
mod tests {
    use super::*;
    use crate::font::sample;

    #[test]
    fn an_empty_label_takes_no_room() {
        let label = build("", &sample(), &Style::default());
        assert!(label.placed.is_empty());
        assert!(label.part.is_empty());
        assert_eq!(label.width, 0.0);
        assert!(label.extent.is_blank());
    }

    #[test]
    fn letters_line_up_from_the_left() {
        let font = sample();
        let label = build("OH", &font, &Style::default());
        assert_eq!(label.placed.len(), 2);
        assert_eq!(label.placed[0].x, 0.0);
        assert!(label.placed[1].x > 0.0);
        assert_eq!(label.placed[1].y, 0.0);
        assert!(label.extent.right > label.extent.left);
        assert!(label.extent.top < 0.0);
    }

    #[test]
    fn a_subscript_is_smaller_and_sits_lower() {
        let font = sample();
        let style = Style::default();
        let label = build("H_2O", &font, &style);
        assert_eq!(label.placed.len(), 3);
        assert_eq!(label.placed[1].character, '2');
        assert_eq!(label.placed[1].size, style.script_size);
        assert!(label.placed[1].y > 0.0);
        assert_eq!(label.placed[2].character, 'O');
        assert_eq!(label.placed[2].size, 1.0);
        assert_eq!(label.placed[2].y, 0.0);
    }

    #[test]
    fn a_superscript_sits_higher() {
        let font = sample();
        let label = build("Na^+", &font, &Style::default());
        assert_eq!(label.placed.len(), 3);
        assert!(label.placed[2].y < 0.0);
        assert!(label.placed[2].size < 1.0);
    }

    #[test]
    fn a_letter_after_a_subscript_gets_a_little_room() {
        let font = sample();
        let style = Style::default();
        let tight = Style {script_space: 0.0, ..style};
        let loose = build("H_2SO_4", &font, &style);
        let close = build("H_2SO_4", &font, &tight);
        // S は 3 番目
        assert_eq!(loose.placed[2].character, 'S');
        let room = loose.placed[2].x - close.placed[2].x;
        assert!((room - style.script_space).abs() < 1e-9, "空きが {room} です");
    }

    #[test]
    fn scripts_that_follow_each_other_stay_tight() {
        let font = sample();
        let style = Style::default();
        let tight = Style {script_space: 0.0, ..style};
        // O_4^{2-} の 4 と 2 のあいだには入れない
        let loose = build("SO_4^{2-}", &font, &style);
        let close = build("SO_4^{2-}", &font, &tight);
        let places = |label: &Label| label.placed.iter().map(|one| one.x).collect::<Vec<f64>>();
        assert_eq!(places(&loose), places(&close));
    }

    #[test]
    fn the_room_does_not_hang_off_the_end() {
        let font = sample();
        let style = Style::default();
        let tight = Style {script_space: 0.0, ..style};
        assert_eq!(
            build("H_2O", &font, &style).width,
            build("H_2O", &font, &tight).width + style.script_space
        );
        // 末尾の添字の後ろには入れない
        assert_eq!(
            build("SO_4", &font, &style).width,
            build("SO_4", &font, &tight).width
        );
    }

    #[test]
    fn a_charge_sign_lines_up_with_a_digit() {
        let font = sample();
        let style = Style::default();
        let plus = build("Na^+", &font, &style);
        let two = build("Na^2", &font, &style);
        let sign = &plus.placed[2];
        let digit = &two.placed[2];
        let box_of = |placed: &Placed| {
            let glyph = placed.glyph.unwrap();
            let (height, depth) = font::extent(&font, glyph);

            (placed.y - height * placed.size, placed.y + depth * placed.size)
        };
        let (sign_top, sign_bottom) = box_of(sign);
        let (digit_top, digit_bottom) = box_of(digit);
        let sign_middle = (sign_top + sign_bottom) / 2.0;
        let digit_middle = (digit_top + digit_bottom) / 2.0;
        assert!((sign_middle - digit_middle).abs() < 1e-9, "+ が数字と高さで揃っていません");
        assert!(sign.y < two.placed[1].y, "+ が上がっていません");
    }

    #[test]
    fn a_minus_in_a_charge_rises_too() {
        let font = sample();
        let style = Style::default();
        let charge = build("SO_4^{2-}", &font, &style);
        let digit = &charge.placed[3];
        let minus = &charge.placed[4];
        assert_eq!(minus.character, '\u{2212}');
        assert!(minus.y < digit.y, "負号が持ち上がっていません");
    }

    #[test]
    fn a_sign_outside_a_charge_stays_where_it_is() {
        let font = sample();
        let style = Style::default();
        let plain = build("A+B", &font, &style);
        assert_eq!(plain.placed[1].character, '+');
        assert_eq!(plain.placed[1].y, 0.0, "上付きでない + が動いています");
    }

    #[test]
    fn a_group_holds_more_than_one_character() {
        let font = sample();
        let label = build("SO_4^{2-}", &font, &Style::default());
        let text: String = label.placed.iter().map(|placed| placed.character).collect();
        assert_eq!(text, "SO42\u{2212}");
        assert!(label.placed[3].y < 0.0);
        assert!(label.placed[4].y < 0.0);
    }

    #[test]
    fn nested_scripts_stop_shrinking() {
        let font = sample();
        let style = Style::default();
        let label = build("H_{2_{2_{2}}}", &font, &style);
        let size: Vec<f64> = label.placed.iter().map(|placed| placed.size).collect();
        assert_eq!(size[0], 1.0);
        assert_eq!(size[1], style.script_size);
        assert_eq!(size[2], style.script_floor);
        assert_eq!(size[3], style.script_floor, "下限を割り込んでいます");
    }

    #[test]
    fn capitals_cut_the_label_into_parts() {
        let font = sample();
        let style = Style::default();
        assert_eq!(build("CH_3", &font, &style).part.len(), 2);
        assert_eq!(build("H_3C", &font, &style).part.len(), 2);
        assert_eq!(build("H_2SO_4", &font, &style).part.len(), 3);
        assert_eq!(build("C", &font, &style).part.len(), 1);
    }

    #[test]
    fn the_first_part_of_ch3_is_the_carbon() {
        let font = sample();
        let label = build("CH_3", &font, &Style::default());
        let carbon = label.part[0];
        let rest = label.part[1];
        assert!(carbon.right <= rest.left + 1e-9);
        assert_eq!(carbon.left, label.extent.left);
        assert!(rest.right > carbon.right);
    }

    #[test]
    fn the_whole_box_is_the_default_for_clipping() {
        let font = sample();
        let label = build("CH_3", &font, &Style::default());
        assert_eq!(clip_extent(&label, None), Some(label.extent));
        assert_eq!(clip_extent(&label, Some(1)), Some(label.part[0]));
        assert_eq!(clip_extent(&label, Some(3)), None);
        assert_eq!(clip_extent(&label, Some(0)), None);
    }

    #[test]
    fn a_character_the_font_does_not_have_still_takes_room() {
        let font = sample();
        let label = build("\u{3042}", &font, &Style::default());
        assert_eq!(label.placed.len(), 1);
        assert_eq!(label.placed[0].glyph, None);
        assert!(label.width > 0.0);
    }
}