diff options
| -rw-r--r-- | morphology-img/src/file_gen.rs | 14 | ||||
| -rw-r--r-- | morphology-img/src/note.rs | 86 | ||||
| -rw-r--r-- | morphology-img/src/template.rs | 13 | ||||
| -rw-r--r-- | morphology-img/static/entry.ily | 6 | ||||
| -rw-r--r-- | morphology-img/static/template.ly | 2 | ||||
| -rw-r--r-- | morphology-img/tests/staff_and_ledgers.rs | 102 | ||||
| -rw-r--r-- | morphology-img/tests/template.rs | 37 |
7 files changed, 233 insertions, 27 deletions
diff --git a/morphology-img/src/file_gen.rs b/morphology-img/src/file_gen.rs index 7bcae49..8040674 100644 --- a/morphology-img/src/file_gen.rs +++ b/morphology-img/src/file_gen.rs @@ -6,7 +6,7 @@ use tempfile::TempDir; use morphology::Sequence; use crate::error::RenderError; use crate::template; -use crate::note::{sequence_to_notes, notes_to_markup, sequence_to_staff, staff_to_scheme_string}; +use crate::note::{sequence_to_notes, notes_to_markup, sequence_to_staff, sequence_to_ledgers, vector_to_scheme}; /// Generates a filename for a sequence with proper zero-padding. /// @@ -121,10 +121,16 @@ pub fn generate_ly_file( let staff = sequence_to_staff(sequence); // Convert staff to Scheme list string - let rungs = staff_to_scheme_string(&staff); + let rungs = vector_to_scheme(&staff); - // Substitute both values into template - let ly_content = template::substitute_template(&morpheme, &rungs)?; + // Convert sequence to ledger line positions + let ledger_positions = sequence_to_ledgers(sequence); + + // Convert ledgers to Scheme list string + let ledgers = vector_to_scheme(&ledger_positions); + + // Substitute all values into template + let ly_content = template::substitute_template(&morpheme, &rungs, &ledgers)?; // Write to file (UTF-8) fs::write(output_path, ly_content)?; 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<i32> { 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<i32> { + use std::collections::HashMap; + + let factor = calculate_factor(sequence); + + // Group values by outer + let mut groups: HashMap<i32, Vec<i32>> = 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. diff --git a/morphology-img/src/template.rs b/morphology-img/src/template.rs index e552843..9a66000 100644 --- a/morphology-img/src/template.rs +++ b/morphology-img/src/template.rs @@ -10,6 +10,7 @@ const ELEMENTS_ILY: &str = include_str!("../static/elements.ily"); const MORPHEME_PLACEHOLDER: &str = "%MORPHEME%"; const RUNGS_PLACEHOLDER: &str = "%RUNGS%"; +const LEDGERS_PLACEHOLDER: &str = "%LEDGERS%"; /// Returns the template .ly content pub fn get_template() -> &'static str { @@ -36,13 +37,14 @@ pub fn get_elements_ily() -> &'static str { /// # Arguments /// - `morpheme`: The LilyPond morpheme markup to substitute /// - `rungs`: The Scheme list string for staff line positions +/// - `ledgers`: The Scheme list string for ledger line positions /// /// # Returns /// The complete .ly file content with substitutions applied /// /// # Errors /// Returns `RenderError::Template` if placeholders are not found -pub fn substitute_template(morpheme: &str, rungs: &str) -> Result<String, RenderError> { +pub fn substitute_template(morpheme: &str, rungs: &str, ledgers: &str) -> Result<String, RenderError> { let template = get_template(); if !template.contains(MORPHEME_PLACEHOLDER) { @@ -57,9 +59,16 @@ pub fn substitute_template(morpheme: &str, rungs: &str) -> Result<String, Render )); } + if !template.contains(LEDGERS_PLACEHOLDER) { + return Err(RenderError::Template( + "Template does not contain placeholder '%LEDGERS%'".to_string() + )); + } + let result = template .replace(MORPHEME_PLACEHOLDER, morpheme) - .replace(RUNGS_PLACEHOLDER, rungs); + .replace(RUNGS_PLACEHOLDER, rungs) + .replace(LEDGERS_PLACEHOLDER, ledgers); Ok(result) } diff --git a/morphology-img/static/entry.ily b/morphology-img/static/entry.ily index b7b1a1b..8a3f97a 100644 --- a/morphology-img/static/entry.ily +++ b/morphology-img/static/entry.ily @@ -1,14 +1,14 @@ entry = #(define-music-function - (morpheme rungs) - (ly:music? list?) + (morpheme rungs ledgers) + (ly:music? list? list?) #{ \transpose c c' << \new StaffContainer { \override StaffContainer.Stem.transparent = ##t \override StaffContainer.StaffSymbol.color = #white \override StaffContainer.LedgerLineSpanner.color = #white - \override StaffContainer.StaffSymbol.ledger-positions = #'(-10 -5 -3 3 5 10) + \override StaffContainer.StaffSymbol.ledger-positions = #ledgers \override StaffContainer.StaffSymbol.line-count = 0 \override StaffContainer.StaffSymbol.line-positions = #(sort (append rungs '(-0.15 0.15)) <) diff --git a/morphology-img/static/template.ly b/morphology-img/static/template.ly index e4d2969..dbcc24d 100644 --- a/morphology-img/static/template.ly +++ b/morphology-img/static/template.ly @@ -7,6 +7,6 @@ \score { \entry { %MORPHEME% - } %RUNGS% + } %RUNGS% %LEDGERS% } diff --git a/morphology-img/tests/staff_and_ledgers.rs b/morphology-img/tests/staff_and_ledgers.rs new file mode 100644 index 0000000..6de6637 --- /dev/null +++ b/morphology-img/tests/staff_and_ledgers.rs @@ -0,0 +1,102 @@ +use morphology::{Sequence, Value}; +use morphology_img::note::{sequence_to_staff, sequence_to_ledgers, vector_to_scheme}; + +#[test] +fn test_sequence_to_staff_simple() { + let seq = Sequence::new(vec![ + Value::new(1, 0), + Value::new(-1, 0), + Value::new(0, 0), + ]); + + // Unique outers: [1, -1, 0] + // max_abs_inner = 0, factor = 3 + // Staff: [3, -3, 0] -> sorted: [-3, 0, 3] + let staff = sequence_to_staff(&seq); + assert_eq!(staff, vec![-3, 0, 3]); +} + +#[test] +fn test_sequence_to_staff_with_inner_values() { + let seq = Sequence::new(vec![ + Value::new(1, 0), + Value::new(-1, -1), + Value::new(0, 0), + ]); + + // Unique outers: [1, -1, 0] + // max_abs_inner = 1, factor = 4 + // Staff: [4, -4, 0] -> sorted: [-4, 0, 4] + let staff = sequence_to_staff(&seq); + assert_eq!(staff, vec![-4, 0, 4]); +} + +#[test] +fn test_sequence_to_ledgers_simple() { + let seq = Sequence::new(vec![ + Value::new(1, 0), + Value::new(0, 0), + ]); + + // Subsets by outer: + // outer=1: inner=[0], range [0,0], even: 0 -> (1*3)+0 = 3 + // outer=0: inner=[0], range [0,0], even: 0 -> (0*3)+0 = 0 + // max_abs_inner = 0, factor = 3 + let ledgers = sequence_to_ledgers(&seq); + assert_eq!(ledgers, vec![0, 3]); +} + +#[test] +fn test_sequence_to_ledgers_with_even_range() { + let seq = Sequence::new(vec![ + Value::new(1, -2), + Value::new(1, 0), + Value::new(0, 0), + ]); + + // Subsets by outer: + // outer=1: inner=[-2, 0], range [-2,0], even: -2,0 -> (1*5)+(-2)=3, (1*5)+0=5 + // outer=0: inner=[0], range [0,0], even: 0 -> (0*5)+0=0 + // max_abs_inner = 2, factor = 5 + let ledgers = sequence_to_ledgers(&seq); + assert_eq!(ledgers, vec![0, 3, 5]); +} + +#[test] +fn test_vector_to_scheme_basic() { + let values = vec![-3, 0, 3]; + assert_eq!(vector_to_scheme(&values), "#'(-3 0 3)"); +} + +#[test] +fn test_vector_to_scheme_empty() { + let values: Vec<i32> = vec![]; + assert_eq!(vector_to_scheme(&values), "#'()"); +} + +#[test] +fn test_integration_complete_workflow() { + // Simple sequence with all components + let seq = Sequence::new(vec![ + Value::new(1, 0), + Value::new(-1, -2), + Value::new(0, 0), + ]); + + // max_abs_inner = 2, factor = 5 + + // Staff: unique outers [1, -1, 0] * 5 = [5, -5, 0] -> sorted: [-5, 0, 5] + let staff = sequence_to_staff(&seq); + assert_eq!(staff, vec![-5, 0, 5]); + + // Ledgers: + // outer=1: inner=[0], range [0,0], even: 0 -> (1*5)+0=5 + // outer=-1: inner=[-2], range [-2,-2], even: -2 -> (-1*5)+(-2)=-7 + // outer=0: inner=[0], range [0,0], even: 0 -> (0*5)+0=0 + let ledgers = sequence_to_ledgers(&seq); + assert_eq!(ledgers, vec![-7, 0, 5]); + + // Verify Scheme conversion + assert_eq!(vector_to_scheme(&staff), "#'(-5 0 5)"); + assert_eq!(vector_to_scheme(&ledgers), "#'(-7 0 5)"); +} diff --git a/morphology-img/tests/template.rs b/morphology-img/tests/template.rs index 07a5f3b..b53689c 100644 --- a/morphology-img/tests/template.rs +++ b/morphology-img/tests/template.rs @@ -14,10 +14,11 @@ fn test_embedded_templates_non_empty() { #[test] fn test_template_contains_placeholders() { - // Verify the template contains both placeholders + // Verify the template contains all three placeholders let template = get_template(); assert!(template.contains("%MORPHEME%"), "template should contain '%MORPHEME%' placeholder"); assert!(template.contains("%RUNGS%"), "template should contain '%RUNGS%' placeholder"); + assert!(template.contains("%LEDGERS%"), "template should contain '%LEDGERS%' placeholder"); } #[test] @@ -25,19 +26,22 @@ fn test_successful_substitution() { // Test successful substitution with simple markup let morpheme = "c'4 d'4 e'4"; let rungs = "#'(-5 0 5)"; - let result = substitute_template(morpheme, rungs); + let ledgers = "#'(-3 3)"; + let result = substitute_template(morpheme, rungs, ledgers); assert!(result.is_ok(), "substitution should succeed"); let substituted = result.unwrap(); - // Verify both values are present in the result + // Verify all three values are present in the result assert!(substituted.contains(morpheme), "result should contain the morpheme"); assert!(substituted.contains(rungs), "result should contain the rungs"); + assert!(substituted.contains(ledgers), "result should contain the ledgers"); // Verify the placeholders are no longer present assert!(!substituted.contains("%MORPHEME%"), "result should not contain morpheme placeholder"); assert!(!substituted.contains("%RUNGS%"), "result should not contain rungs placeholder"); + assert!(!substituted.contains("%LEDGERS%"), "result should not contain ledgers placeholder"); // Verify the template structure is preserved assert!(substituted.contains(r#"\version "2.24.0""#), "version should be preserved"); @@ -50,7 +54,8 @@ fn test_substitution_with_empty_markup() { // Test with empty morpheme string let morpheme = ""; let rungs = "#'(0)"; - let result = substitute_template(morpheme, rungs); + let ledgers = "#'(0)"; + let result = substitute_template(morpheme, rungs, ledgers); assert!(result.is_ok(), "substitution with empty morpheme should succeed"); @@ -59,18 +64,21 @@ fn test_substitution_with_empty_markup() { // Placeholders should be replaced assert!(!substituted.contains("%MORPHEME%")); assert!(!substituted.contains("%RUNGS%")); + assert!(!substituted.contains("%LEDGERS%")); assert!(substituted.contains(rungs)); + assert!(substituted.contains(ledgers)); } #[test] fn test_error_when_placeholder_missing() { // Verify error handling works by checking that our current template - // has both required placeholders + // has all required placeholders let template = get_template(); - // Current template should have both placeholders + // Current template should have all three placeholders assert!(template.contains("%MORPHEME%"), "template should have morpheme placeholder"); assert!(template.contains("%RUNGS%"), "template should have rungs placeholder"); + assert!(template.contains("%LEDGERS%"), "template should have ledgers placeholder"); } #[test] @@ -91,7 +99,8 @@ fn test_substitution_preserves_whitespace() { // Test that substitution preserves indentation and whitespace let morpheme = "c'4 d'4"; let rungs = "#'(0)"; - let result = substitute_template(morpheme, rungs).unwrap(); + let ledgers = "#'(0)"; + let result = substitute_template(morpheme, rungs, ledgers).unwrap(); // The indented structure should be preserved // The markup should be indented within the entry block @@ -105,19 +114,25 @@ fn test_multiple_substitutions_independent() { let morpheme2 = "e'4 f'4"; let rungs1 = "#'(-3 0 3)"; let rungs2 = "#'(-5 0 5)"; + let ledgers1 = "#'(-3 3)"; + let ledgers2 = "#'(-5 5)"; - let result1 = substitute_template(morpheme1, rungs1).unwrap(); - let result2 = substitute_template(morpheme2, rungs2).unwrap(); + let result1 = substitute_template(morpheme1, rungs1, ledgers1).unwrap(); + let result2 = substitute_template(morpheme2, rungs2, ledgers2).unwrap(); assert!(result1.contains(morpheme1)); assert!(result1.contains(rungs1)); + assert!(result1.contains(ledgers1)); assert!(!result1.contains(morpheme2)); assert!(!result1.contains(rungs2)); + assert!(!result1.contains(ledgers2)); assert!(result2.contains(morpheme2)); assert!(result2.contains(rungs2)); + assert!(result2.contains(ledgers2)); assert!(!result2.contains(morpheme1)); assert!(!result2.contains(rungs1)); + assert!(!result2.contains(ledgers1)); } #[test] @@ -125,8 +140,9 @@ fn test_substitution_with_actual_sequence_markup() { // Test with markup that would come from the actual transformation pipeline let morpheme = "f'4 f4 e4 b4"; let rungs = "#'(-4 0 4)"; + let ledgers = "#'(-4 0 4)"; - let result = substitute_template(morpheme, rungs); + let result = substitute_template(morpheme, rungs, ledgers); assert!(result.is_ok()); let substituted = result.unwrap(); @@ -135,6 +151,7 @@ fn test_substitution_with_actual_sequence_markup() { assert!(substituted.contains(r#"\entry {"#)); assert!(substituted.contains(morpheme)); assert!(substituted.contains(rungs)); + assert!(substituted.contains(ledgers)); assert!(substituted.contains("}")); // The substituted values should be in the correct positions |