From f4380758ee94fc137073471f52bf8a20fda34f1b Mon Sep 17 00:00:00 2001 From: jacksonfu14 Date: Tue, 18 Nov 2025 21:47:55 +0100 Subject: calculate ledger lines correctly --- morphology-img/src/note.rs | 86 ++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 79 insertions(+), 7 deletions(-) (limited to 'morphology-img/src/note.rs') diff --git a/morphology-img/src/note.rs b/morphology-img/src/note.rs index 408884d..e3f44ef 100644 --- a/morphology-img/src/note.rs +++ b/morphology-img/src/note.rs @@ -191,25 +191,97 @@ pub fn sequence_to_staff(sequence: &morphology::Sequence) -> Vec { rungs } -/// Converts staff line positions to a LilyPond Scheme list string. +/// Converts an integer vector to a LilyPond Scheme list string. /// /// # Arguments -/// - `rungs`: Vector of staff line positions +/// - `values`: Vector of integers /// /// # Returns /// A string representing a Scheme list, e.g., "#'(-5 0 5)" /// /// # Examples /// ``` -/// use morphology_img::note::staff_to_scheme_string; +/// use morphology_img::note::vector_to_scheme; /// -/// let rungs = vec![-5, 0, 5]; -/// assert_eq!(staff_to_scheme_string(&rungs), "#'(-5 0 5)"); +/// let values = vec![-5, 0, 5]; +/// assert_eq!(vector_to_scheme(&values), "#'(-5 0 5)"); /// ``` -pub fn staff_to_scheme_string(rungs: &[i32]) -> String { +pub fn vector_to_scheme(values: &[i32]) -> String { use itertools::Itertools; - format!("#'({})", rungs.iter().map(|r| r.to_string()).join(" ")) + format!("#'({})", values.iter().map(|v| v.to_string()).join(" ")) +} + +/// Converts a meta-affine sequence to ledger line positions. +/// +/// This function computes ledger line positions based on even inner values +/// in each subset of values grouped by outer value. +/// +/// # Algorithm +/// For each subset of values with the same outer value: +/// 1. Find min and max inner values in the subset +/// 2. For all even integers in the range [min_inner, max_inner]: +/// - Include (outer * factor) + n in the ledger positions +/// +/// # Arguments +/// - `sequence`: The meta-affine sequence to analyze +/// +/// # Returns +/// A sorted vector of ledger line positions +/// +/// # Examples +/// ``` +/// use morphology::{Sequence, Value}; +/// use morphology_img::note::sequence_to_ledgers; +/// +/// let seq = Sequence::new(vec![ +/// Value::new(1, 0), +/// Value::new(-1, -1), +/// Value::new(-1, -2), +/// Value::new(-1, 0), +/// Value::new(0, 0), +/// ]); +/// +/// // Subsets by outer: +/// // outer=1: inner=[0], range [0,0], even: 0 -> ledger: (1*5)+0 = 5 +/// // outer=-1: inner=[-1,-2,0], range [-2,0], even: -2,0 -> ledgers: -7, -5 +/// // outer=0: inner=[0], range [0,0], even: 0 -> ledger: (0*5)+0 = 0 +/// let ledgers = sequence_to_ledgers(&seq); +/// assert_eq!(ledgers, vec![-7, -5, 0, 5]); +/// ``` +pub fn sequence_to_ledgers(sequence: &morphology::Sequence) -> Vec { + use std::collections::HashMap; + + let factor = calculate_factor(sequence); + + // Group values by outer + let mut groups: HashMap> = HashMap::new(); + for value in sequence.values() { + groups.entry(value.outer) + .or_insert_with(Vec::new) + .push(value.inner); + } + + let mut ledgers = Vec::new(); + + // Process each group + for (outer, inners) in groups { + let min_inner = *inners.iter().min().unwrap(); + let max_inner = *inners.iter().max().unwrap(); + + // Find all even integers in [min_inner, max_inner] + for n in min_inner..=max_inner { + if n % 2 == 0 { + ledgers.push((outer * factor) + n); + } + } + } + + // Sort and deduplicate + ledgers.sort(); + ledgers.dedup(); + + ledgers } /// Converts a vector of LilyPond notes into a space-separated string. -- cgit v1.2.3