1use crate::{
2 AccidentalMark, BeamGroup, ConcertKeyOverride, CourtesyAccidental, LayoutConfig, LayoutResult,
3 RowLayout, SourceVoiceAddress, SpanMark, TupletGroup,
4};
5use acorde_core::{
6 AccidentalDisplay, BeamState, HairpinKind, NotationSpanner, NotationSpannerKind, NoteAddr,
7 OttavaKind, Score, Step, TupletBoundary, compute_beams,
8};
9use std::collections::{HashMap, HashSet};
10
11fn transpose_key_fifths(fifths: i8, semitones: i8) -> i8 {
16 let raw = (semitones as i16 * 7).rem_euclid(12) as i8;
17 let delta = if raw > 6 { raw - 12 } else { raw };
18 (fifths + delta).clamp(-7, 7)
19}
20
21pub fn compute_layout(score: &Score, config: &LayoutConfig) -> LayoutResult {
25 let per_row = config.measures_per_row.max(1);
26 let first_row = config.first_row_measures.map(|n| n.max(1));
27 let vis_slots = build_vis_slots(score);
28 let rows = build_rows(score, &vis_slots, per_row, first_row);
29 let spans = resolve_spans(&score.with_legacy_spanner_flags(), &score.spanners);
32
33 let mut concert_key_overrides = Vec::new();
34 if config.concert_pitch {
35 let base_fifths = score.settings.key_signature.fifths;
36 for (pi, part) in score.parts.iter().enumerate() {
37 for (si, staff) in part.staves.iter().enumerate() {
38 if staff.transpose_semitones != 0 {
39 concert_key_overrides.push(ConcertKeyOverride {
40 part_index: pi,
41 staff_index: si,
42 fifths: transpose_key_fifths(base_fifths, staff.transpose_semitones),
43 });
44 }
45 }
46 }
47 }
48
49 let beam_groups = collect_beam_groups(score, false);
50 let tuplet_groups = collect_tuplet_groups(score);
51 let courtesy_accidentals = collect_courtesy_accidentals(score);
52 let accidentals = collect_accidental_marks(score);
53 let source_voice_addresses = collect_source_voice_addresses(score);
54
55 LayoutResult {
56 vis_slots,
57 rows,
58 spans,
59 typed_spanners: score.spanners.clone(),
60 concert_key_overrides,
61 beam_groups,
62 tuplet_groups,
63 courtesy_accidentals,
64 accidentals,
65 source_voice_addresses,
66 }
67}
68
69pub fn compute_layout_with_display_beams(score: &Score, config: &LayoutConfig) -> LayoutResult {
71 let mut layout = compute_layout(score, config);
72 add_display_beams(score, &mut layout);
73 layout
74}
75
76pub fn add_display_beams(score: &Score, layout: &mut LayoutResult) {
79 layout.beam_groups = collect_beam_groups(score, true);
80}
81
82fn collect_source_voice_addresses(score: &Score) -> Vec<SourceVoiceAddress> {
83 let mut addresses = Vec::new();
84 for (part, part_value) in score.parts.iter().enumerate() {
85 for (staff, staff_value) in part_value.staves.iter().enumerate() {
86 for (measure, measure_value) in staff_value.measures.iter().enumerate() {
87 for (voice, source_voice_number) in
88 measure_value.source_voice_numbers.iter().enumerate()
89 {
90 if let Some(source_voice_number) = source_voice_number {
91 addresses.push(SourceVoiceAddress {
92 part,
93 staff,
94 measure,
95 voice,
96 source_voice_number: *source_voice_number,
97 });
98 }
99 }
100 }
101 }
102 }
103 addresses
104}
105
106fn build_vis_slots(score: &Score) -> Vec<usize> {
109 let measure_count = score
110 .parts
111 .first()
112 .and_then(|p| p.staves.first())
113 .map(|s| s.measures.len())
114 .unwrap_or(0);
115
116 let mut slots = Vec::new();
117 for phys in 0..measure_count {
118 let count = multi_rest_count(score, phys).max(1);
119 for _ in 0..count {
120 slots.push(phys);
121 }
122 }
123 slots
124}
125
126fn multi_rest_count(score: &Score, measure_index: usize) -> usize {
127 score
128 .parts
129 .iter()
130 .flat_map(|p| p.staves.iter())
131 .filter_map(|s| s.measures.get(measure_index))
132 .filter_map(|m| m.multi_rest_count)
133 .map(|c| c as usize)
134 .max()
135 .unwrap_or(1)
136}
137
138fn force_break_after(score: &Score, phys: usize) -> bool {
141 score
142 .parts
143 .iter()
144 .flat_map(|p| p.staves.iter())
145 .filter_map(|s| s.measures.get(phys))
146 .any(|m| m.system_break || m.page_break)
147}
148
149pub(crate) fn build_rows(
150 score: &Score,
151 vis_slots: &[usize],
152 per_row: usize,
153 first_row_limit: Option<usize>,
154) -> Vec<RowLayout> {
155 if vis_slots.is_empty() {
156 return vec![RowLayout {
157 measure_indices: Vec::new(),
158 }];
159 }
160
161 let mut rows: Vec<RowLayout> = Vec::new();
162 let mut current: Vec<usize> = Vec::new();
163 let mut current_width = 0usize;
164 let mut last_phys = usize::MAX;
165
166 for &phys in vis_slots {
167 if phys != last_phys {
168 let limit = if rows.is_empty() {
169 first_row_limit.unwrap_or(per_row)
170 } else {
171 per_row
172 };
173 let span_width = multi_rest_count(score, phys).max(1);
174 if !current.is_empty() && current_width.saturating_add(span_width) > limit {
175 rows.push(RowLayout {
176 measure_indices: std::mem::take(&mut current),
177 });
178 current_width = 0;
179 }
180 current.push(phys);
181 current_width = current_width.saturating_add(span_width);
182 if force_break_after(score, phys) {
183 rows.push(RowLayout {
184 measure_indices: std::mem::take(&mut current),
185 });
186 current_width = 0;
187 }
188 }
189 last_phys = phys;
190 }
191
192 if !current.is_empty() {
193 rows.push(RowLayout {
194 measure_indices: current,
195 });
196 }
197 rows
198}
199
200pub fn notation_density_units(score: &Score, measure: usize) -> usize {
205 let mut widest_staff = 3usize;
206 for staff in score.parts.iter().flat_map(|part| &part.staves) {
207 let Some(measure) = staff.measures.get(measure) else {
208 continue;
209 };
210 let voice_width = measure
211 .voices
212 .iter()
213 .map(|voice| {
214 voice
215 .iter()
216 .filter(|note| !note.hidden)
217 .map(|note| {
218 let notehead_width = if note.is_rest { 1 } else { 2 };
219 let chord_width = note.pitches.len().saturating_sub(1);
220 let accidental_width =
221 note.pitches.iter().filter(|pitch| pitch.alter != 0).count();
222 let lyric_width = note
223 .lyric
224 .as_ref()
225 .map_or(0, |lyric| lyric.text.chars().count().div_ceil(3));
226 notehead_width
227 + chord_width
228 + accidental_width
229 + usize::from(note.dot_count)
230 + lyric_width
231 + usize::from(note.chord_symbol.is_some()) * 2
232 + note.articulations.len().div_ceil(2)
233 })
234 .sum::<usize>()
235 })
236 .max()
237 .unwrap_or(0);
238 let text_width = measure
239 .texts
240 .iter()
241 .map(|text| text.text.chars().count().div_ceil(4))
242 .sum::<usize>();
243 widest_staff = widest_staff.max(voice_width + text_width + 3);
244 }
245 widest_staff
246}
247
248fn resolve_staff_hairpins(
253 spans: &mut Vec<SpanMark>,
254 part: usize,
255 staff_index: usize,
256 staff: &acorde_core::Staff,
257) {
258 let mut events = Vec::new();
259 for (mi, measure) in staff.measures.iter().enumerate() {
260 for (voice, notes) in measure.voices.iter().enumerate().take(4) {
261 let mut onset = 0.0f64;
262 for (ni, note) in notes.iter().enumerate() {
263 if note.hairpin_start.is_some() || note.hairpin_end {
264 events.push((mi, onset, voice, ni, note.hairpin_start, note.hairpin_end));
265 }
266 onset += note.beats();
267 }
268 }
269 }
270 events.sort_by(|a, b| {
271 a.0.cmp(&b.0)
272 .then(a.1.total_cmp(&b.1))
273 .then(a.2.cmp(&b.2))
274 .then(a.3.cmp(&b.3))
275 });
276 let mut open_hairpin: Option<(NoteAddr, HairpinKind)> = None;
277 for (measure, _, voice, note, start_kind, end) in events {
278 let addr = NoteAddr {
279 part,
280 staff: staff_index,
281 measure,
282 voice,
283 note,
284 };
285 let ends_earlier = end && open_hairpin.is_some();
288 if ends_earlier && let Some((start, kind)) = open_hairpin.take() {
289 spans.push(SpanMark::Hairpin {
290 kind,
291 start,
292 end: addr.clone(),
293 });
294 }
295 if let Some(kind) = start_kind {
296 open_hairpin = Some((addr.clone(), kind));
297 }
298 if end
299 && !ends_earlier
300 && let Some((start, kind)) = open_hairpin.take()
301 {
302 spans.push(SpanMark::Hairpin {
303 kind,
304 start,
305 end: addr,
306 });
307 }
308 }
309}
310
311fn resolve_spans(score: &Score, typed_spanners: &[NotationSpanner]) -> Vec<SpanMark> {
312 let mut spans = Vec::new();
313 let typed_slur_endpoints = typed_spanners
314 .iter()
315 .filter(|span| span.kind == NotationSpannerKind::Slur)
316 .flat_map(|span| [&span.start, &span.end])
317 .map(|addr| (addr.part, addr.staff, addr.measure, addr.voice, addr.note))
318 .collect::<HashSet<_>>();
319
320 for (pi, part) in score.parts.iter().enumerate() {
321 for (si, staff) in part.staves.iter().enumerate() {
322 resolve_staff_hairpins(&mut spans, pi, si, staff);
323 for voice in 0..4usize {
324 let mut open_ottava: Option<(NoteAddr, OttavaKind)> = None;
325 let mut open_pedal: Option<NoteAddr> = None;
326 let mut open_slurs: Vec<NoteAddr> = Vec::new();
327 let mut open_trill_line: Option<NoteAddr> = None;
328 let mut open_glissando: Option<NoteAddr> = None;
329
330 for (mi, measure) in staff.measures.iter().enumerate() {
331 for (ni, note) in measure.voices[voice].iter().enumerate() {
332 let addr = NoteAddr {
333 part: pi,
334 staff: si,
335 measure: mi,
336 voice,
337 note: ni,
338 };
339
340 if let Some(kind) = note.ottava_start {
341 open_ottava = Some((addr.clone(), kind));
342 }
343 if note.ottava_end
344 && let Some((start, kind)) = open_ottava.take()
345 {
346 spans.push(SpanMark::Ottava {
347 kind,
348 start,
349 end: addr.clone(),
350 });
351 }
352
353 let onset: f64 = measure.voices[voice]
354 .iter()
355 .take(ni)
356 .map(|note| note.beats())
357 .sum();
358 let timed_here = |down| {
359 measure.timed_pedals.iter().any(|pedal| {
360 pedal.down == down && (pedal.position_beats - onset).abs() < 1e-9
361 })
362 };
363 if note.pedal_start && !timed_here(true) {
364 open_pedal = Some(addr.clone());
365 }
366 if note.pedal_end
367 && !timed_here(false)
368 && let Some(start) = open_pedal.take()
369 {
370 spans.push(SpanMark::Pedal {
371 start,
372 end: addr.clone(),
373 });
374 }
375
376 if !typed_slur_endpoints.contains(&(pi, si, mi, voice, ni)) {
380 if note.slur_end
381 && let Some(start) = open_slurs.pop()
382 {
383 spans.push(SpanMark::Slur {
384 start,
385 end: addr.clone(),
386 });
387 }
388 if note.slur_start {
389 open_slurs.push(addr.clone());
390 }
391 }
392
393 if note.trill_line_start {
394 open_trill_line = Some(addr.clone());
395 }
396 if note.trill_line_end
397 && let Some(start) = open_trill_line.take()
398 {
399 spans.push(SpanMark::TrillLine {
400 start,
401 end: addr.clone(),
402 });
403 }
404
405 if note.glissando_start {
406 open_glissando = Some(addr.clone());
407 }
408 if note.glissando_end
409 && let Some(start) = open_glissando.take()
410 {
411 spans.push(SpanMark::Glissando {
412 start,
413 end: addr.clone(),
414 });
415 }
416
417 if let Some(chord) = ¬e.chord_symbol
418 && let Some(end) = &chord.range_end
419 {
420 spans.push(SpanMark::Harmony {
421 label: chord.display_text(),
422 start: addr.clone(),
423 end: end.clone(),
424 });
425 }
426 }
427 }
428 }
429 }
430 }
431
432 spans.extend(
433 typed_spanners
434 .iter()
435 .filter(|span| span.kind == NotationSpannerKind::Slur)
436 .map(|span| SpanMark::Slur {
437 start: span.start.clone(),
438 end: span.end.clone(),
439 }),
440 );
441 spans
442}
443
444fn collect_beam_groups(score: &Score, infer_unmarked: bool) -> Vec<BeamGroup> {
447 let mut groups = Vec::new();
448 for (pi, part) in score.parts.iter().enumerate() {
449 for (si, staff) in part.staves.iter().enumerate() {
450 let mut meter = score.settings.time_signature.clone();
451 for (mi, measure) in staff.measures.iter().enumerate() {
452 if let Some(change) = &measure.time_sig {
453 meter = change.clone();
454 }
455 for (vi, voice) in measure.voices.iter().enumerate() {
456 let mut current: Option<Vec<usize>> = None;
457
458 for (ni, note) in voice.iter().enumerate() {
459 match note.beam {
460 BeamState::Begin => {
461 current = Some(vec![ni]);
462 }
463 BeamState::BeginEnd => {
464 groups.push(BeamGroup {
465 part: pi,
466 staff: si,
467 measure: mi,
468 voice: vi,
469 note_indices: vec![ni],
470 });
471 }
472 BeamState::Continue
473 | BeamState::ForwardHook
474 | BeamState::BackwardHook => {
475 if let Some(ref mut g) = current {
476 g.push(ni);
477 }
478 }
479 BeamState::End => {
480 if let Some(mut g) = current.take() {
481 g.push(ni);
482 groups.push(BeamGroup {
483 part: pi,
484 staff: si,
485 measure: mi,
486 voice: vi,
487 note_indices: g,
488 });
489 }
490 }
491 BeamState::None => {
492 current = None;
493 }
494 }
495 }
496 if infer_unmarked {
497 let recommended = compute_beams(voice, &meter);
498 let mut candidate = Vec::new();
499 let mut flush = |candidate: &mut Vec<usize>| {
500 if candidate.len() >= 2 {
501 groups.push(BeamGroup {
502 part: pi,
503 staff: si,
504 measure: mi,
505 voice: vi,
506 note_indices: std::mem::take(candidate),
507 });
508 } else {
509 candidate.clear();
510 }
511 };
512 for (ni, (note, suggested)) in voice.iter().zip(&recommended).enumerate() {
513 if matches!(suggested, BeamState::Begin | BeamState::None)
514 || matches!(
515 note.tuplet_boundary,
516 Some(TupletBoundary::Start | TupletBoundary::StartStop)
517 )
518 {
519 flush(&mut candidate);
520 }
521 if *suggested != BeamState::None
522 && note.beam == BeamState::None
523 && !note.explicit_unbeamed
524 && !note.is_grace
525 && !note.is_cue
526 && !note.hidden
527 {
528 candidate.push(ni);
529 } else {
530 flush(&mut candidate);
531 }
532 if *suggested == BeamState::End
533 || matches!(
534 note.tuplet_boundary,
535 Some(TupletBoundary::Stop | TupletBoundary::StartStop)
536 )
537 {
538 flush(&mut candidate);
539 }
540 }
541 flush(&mut candidate);
542 }
543 }
544 }
545 }
546 }
547 groups
548}
549
550fn collect_tuplet_groups(score: &Score) -> Vec<TupletGroup> {
553 let mut groups = Vec::new();
554 for (pi, part) in score.parts.iter().enumerate() {
555 for (si, staff) in part.staves.iter().enumerate() {
556 for (mi, measure) in staff.measures.iter().enumerate() {
557 for (vi, voice) in measure.voices.iter().enumerate() {
558 for (first, last) in acorde_core::tuplet_group_ranges(voice) {
559 let note_indices: Vec<_> = (first..=last)
560 .filter(|&index| {
561 !voice[index].is_grace && voice[index].tuplet.is_some()
562 })
563 .collect();
564 if note_indices.len() >= 2
565 && let Some(ti) = voice[first].tuplet.as_ref()
566 {
567 groups.push(TupletGroup {
568 part: pi,
569 staff: si,
570 measure: mi,
571 voice: vi,
572 note_indices,
573 actual_notes: ti.actual_notes,
574 normal_notes: ti.normal_notes,
575 });
576 }
577 }
578 }
579 }
580 }
581 }
582 groups
583}
584
585fn step_idx(step: &Step) -> u8 {
586 match step {
587 Step::C => 0,
588 Step::D => 1,
589 Step::E => 2,
590 Step::F => 3,
591 Step::G => 4,
592 Step::A => 5,
593 Step::B => 6,
594 }
595}
596
597fn key_alter(fifths: i8, step: &Step) -> i8 {
599 const SHARPS: [Step; 7] = [
600 Step::F,
601 Step::C,
602 Step::G,
603 Step::D,
604 Step::A,
605 Step::E,
606 Step::B,
607 ];
608 const FLATS: [Step; 7] = [
609 Step::B,
610 Step::E,
611 Step::A,
612 Step::D,
613 Step::G,
614 Step::C,
615 Step::F,
616 ];
617 if fifths > 0 && SHARPS[..fifths as usize].contains(step) {
618 1
619 } else if fifths < 0 && FLATS[..(-fifths) as usize].contains(step) {
620 -1
621 } else {
622 0
623 }
624}
625
626fn collect_courtesy_accidentals(score: &Score) -> Vec<CourtesyAccidental> {
627 let mut result = Vec::new();
628 let base_fifths = score.settings.key_signature.fifths;
629
630 for (pi, part) in score.parts.iter().enumerate() {
631 for (si, staff) in part.staves.iter().enumerate() {
632 let mut prev_alters: HashMap<(u8, i8), i8> = HashMap::new();
634 let mut current_fifths = base_fifths;
635
636 for (mi, measure) in staff.measures.iter().enumerate() {
637 if let Some(key_sig) = measure.key_sig.as_ref() {
638 current_fifths = key_sig.fifths;
639 prev_alters.clear();
640 }
641
642 for (vi, voice) in measure.voices.iter().enumerate() {
644 for (ni, note) in voice.iter().enumerate() {
645 for (pitch_idx, pitch) in note.pitches.iter().enumerate() {
646 let key = (step_idx(&pitch.step), pitch.octave);
647 let requested = note.accidental_display(pitch_idx)
649 == AccidentalDisplay::Parenthesized;
650 let previous = prev_alters.remove(&key);
654 let natural_reminder = !note.tie_end
655 && note.accidental_display(pitch_idx) == AccidentalDisplay::Auto
656 && pitch.alter == 0
657 && key_alter(current_fifths, &pitch.step) == 0
658 && previous.is_some_and(|alter| alter != 0);
659 if requested || natural_reminder {
660 result.push(CourtesyAccidental {
661 part: pi,
662 staff: si,
663 measure: mi,
664 voice: vi,
665 note_index: ni,
666 pitch_index: pitch_idx,
667 alter: pitch.alter,
668 });
669 }
670 }
671 }
672 }
673
674 prev_alters.clear();
676 for voice in &measure.voices {
677 for note in voice {
678 for pitch in note.pitches.iter() {
679 if pitch.alter != key_alter(current_fifths, &pitch.step) {
680 prev_alters
681 .insert((step_idx(&pitch.step), pitch.octave), pitch.alter);
682 }
683 }
684 }
685 }
686 }
687 }
688 }
689 result
690}
691
692fn collect_accidental_marks(score: &Score) -> Vec<AccidentalMark> {
701 let mut result = Vec::new();
702 let base_fifths = score.settings.key_signature.fifths;
703
704 for (pi, part) in score.parts.iter().enumerate() {
705 for (si, staff) in part.staves.iter().enumerate() {
706 let mut current_fifths = base_fifths;
707
708 for (mi, measure) in staff.measures.iter().enumerate() {
709 if let Some(key_sig) = measure.key_sig.as_ref() {
710 current_fifths = key_sig.fifths;
711 }
712
713 let mut active: HashMap<(u8, i8), i8> = HashMap::new();
715
716 for (vi, voice) in measure.voices.iter().enumerate() {
717 for (ni, note) in voice.iter().enumerate() {
718 for (pitch_idx, pitch) in note.pitches.iter().enumerate() {
719 let key = (step_idx(&pitch.step), pitch.octave);
720 let baseline = active
721 .get(&key)
722 .copied()
723 .unwrap_or_else(|| key_alter(current_fifths, &pitch.step));
724 let display = note.accidental_display(pitch_idx);
725 let parenthesized = display == AccidentalDisplay::Parenthesized;
726 if pitch.alter != baseline {
727 if (!note.tie_end || display == AccidentalDisplay::Explicit)
729 && !parenthesized
730 {
731 result.push(AccidentalMark {
732 part: pi,
733 staff: si,
734 measure: mi,
735 voice: vi,
736 note_index: ni,
737 pitch_index: pitch_idx,
738 alter: pitch.alter,
739 });
740 }
741 active.insert(key, pitch.alter);
742 } else if matches!(
743 display,
744 AccidentalDisplay::Explicit
745 | AccidentalDisplay::Cautionary
746 | AccidentalDisplay::Editorial
747 ) {
748 result.push(AccidentalMark {
751 part: pi,
752 staff: si,
753 measure: mi,
754 voice: vi,
755 note_index: ni,
756 pitch_index: pitch_idx,
757 alter: pitch.alter,
758 });
759 }
760 }
761 }
762 }
763 }
764 }
765 }
766 result
767}
768
769#[cfg(test)]
770mod tests {
771 use super::*;
772 use acorde_core::{Clef, Measure, Part, Score, Staff};
773
774 fn score_with_measures(n: usize) -> Score {
775 let mut score = Score::default();
776 score.parts.clear();
777 let mut staff = Staff::new(Clef::Treble);
778 for i in 0..n {
779 let mut m = Measure::empty(4, 4);
780 m.number = i as u32 + 1;
781 staff.measures.push(m);
782 }
783 let mut part = Part::new("P1", "P1");
784 part.staves.push(staff);
785 score.parts.push(part);
786 score
787 }
788
789 #[test]
790 fn default_score_has_one_row_of_four() {
791 let score = Score::default();
793 let result = compute_layout(&score, &LayoutConfig::default());
794 assert_eq!(result.rows.len(), 1);
795 assert_eq!(result.rows[0].measure_indices, vec![0, 1, 2, 3]);
796 assert_eq!(result.vis_slots.len(), 4);
797 assert!(result.spans.is_empty());
798 }
799
800 #[test]
801 fn vis_slots_expand_multi_rest() {
802 let mut score = score_with_measures(1);
803 score.parts[0].staves[0].measures[0].multi_rest_count = Some(4);
804
805 let result = compute_layout(
806 &score,
807 &LayoutConfig {
808 measures_per_row: 8,
809 concert_pitch: false,
810 first_row_measures: None,
811 },
812 );
813 assert_eq!(result.vis_slots.len(), 4);
814 assert!(result.vis_slots.iter().all(|&v| v == 0));
815 }
816
817 #[test]
818 fn measures_split_into_rows() {
819 let score = score_with_measures(6);
820 let result = compute_layout(
821 &score,
822 &LayoutConfig {
823 measures_per_row: 4,
824 concert_pitch: false,
825 first_row_measures: None,
826 },
827 );
828 assert_eq!(result.rows.len(), 2);
829 assert_eq!(result.rows[0].measure_indices, vec![0, 1, 2, 3]);
830 assert_eq!(result.rows[1].measure_indices, vec![4, 5]);
831 }
832
833 #[test]
834 fn single_measure_single_row() {
835 let score = score_with_measures(1);
836 let result = compute_layout(
837 &score,
838 &LayoutConfig {
839 measures_per_row: 4,
840 concert_pitch: false,
841 first_row_measures: None,
842 },
843 );
844 assert_eq!(result.rows.len(), 1);
845 assert_eq!(result.rows[0].measure_indices, vec![0]);
846 }
847
848 #[test]
849 fn exactly_full_rows() {
850 let score = score_with_measures(8);
851 let result = compute_layout(
852 &score,
853 &LayoutConfig {
854 measures_per_row: 4,
855 concert_pitch: false,
856 first_row_measures: None,
857 },
858 );
859 assert_eq!(result.rows.len(), 2);
860 assert_eq!(result.rows[0].measure_indices.len(), 4);
861 assert_eq!(result.rows[1].measure_indices.len(), 4);
862 }
863
864 #[test]
865 fn concert_pitch_bb_clarinet_transposes_key() {
866 let mut score = score_with_measures(1);
869 score.parts[0].staves[0].transpose_semitones = -2;
870 let result = compute_layout(
871 &score,
872 &LayoutConfig {
873 measures_per_row: 4,
874 concert_pitch: true,
875 first_row_measures: None,
876 },
877 );
878 assert_eq!(result.concert_key_overrides.len(), 1);
879 assert_eq!(result.concert_key_overrides[0].part_index, 0);
880 assert_eq!(result.concert_key_overrides[0].staff_index, 0);
881 assert_eq!(result.concert_key_overrides[0].fifths, -2);
882 }
883
884 #[test]
885 fn concert_pitch_false_no_override() {
886 let mut score = score_with_measures(1);
887 score.parts[0].staves[0].transpose_semitones = -2;
888 let result = compute_layout(
889 &score,
890 &LayoutConfig {
891 measures_per_row: 4,
892 concert_pitch: false,
893 first_row_measures: None,
894 },
895 );
896 assert!(result.concert_key_overrides.is_empty());
897 }
898
899 #[test]
900 fn concert_pitch_zero_transpose_no_override() {
901 let score = score_with_measures(1);
903 let result = compute_layout(
904 &score,
905 &LayoutConfig {
906 measures_per_row: 4,
907 concert_pitch: true,
908 first_row_measures: None,
909 },
910 );
911 assert!(result.concert_key_overrides.is_empty());
912 }
913
914 #[test]
915 fn transpose_key_formula_eb_alto_sax() {
916 assert_eq!(transpose_key_fifths(0, -9), -3);
919 }
920
921 #[test]
922 fn transpose_key_formula_perfect_fifth_up() {
923 assert_eq!(transpose_key_fifths(0, 7), 1);
925 }
926
927 #[test]
928 fn system_break_splits_row() {
929 let mut score = score_with_measures(3);
931 score.parts[0].staves[0].measures[1].system_break = true;
932 let result = compute_layout(
933 &score,
934 &LayoutConfig {
935 measures_per_row: 4,
936 concert_pitch: false,
937 first_row_measures: None,
938 },
939 );
940 assert_eq!(result.rows.len(), 2);
941 assert_eq!(result.rows[0].measure_indices, vec![0, 1]);
942 assert_eq!(result.rows[1].measure_indices, vec![2]);
943 }
944
945 #[test]
946 fn page_break_splits_row() {
947 let mut score = score_with_measures(3);
948 score.parts[0].staves[0].measures[0].page_break = true;
949 let result = compute_layout(
950 &score,
951 &LayoutConfig {
952 measures_per_row: 4,
953 concert_pitch: false,
954 first_row_measures: None,
955 },
956 );
957 assert_eq!(result.rows.len(), 2);
958 assert_eq!(result.rows[0].measure_indices, vec![0]);
959 assert_eq!(result.rows[1].measure_indices, vec![1, 2]);
960 }
961
962 #[test]
963 fn system_break_overrides_per_row() {
964 let mut score = score_with_measures(5);
966 score.parts[0].staves[0].measures[1].system_break = true;
967 let result = compute_layout(
968 &score,
969 &LayoutConfig {
970 measures_per_row: 4,
971 concert_pitch: false,
972 first_row_measures: None,
973 },
974 );
975 assert_eq!(result.rows.len(), 2);
976 assert_eq!(result.rows[0].measure_indices, vec![0, 1]);
977 assert_eq!(result.rows[1].measure_indices, vec![2, 3, 4]);
978 }
979
980 #[test]
981 fn no_break_unchanged() {
982 let score = score_with_measures(3);
983 let result = compute_layout(
984 &score,
985 &LayoutConfig {
986 measures_per_row: 4,
987 concert_pitch: false,
988 first_row_measures: None,
989 },
990 );
991 assert_eq!(result.rows.len(), 1);
992 assert_eq!(result.rows[0].measure_indices, vec![0, 1, 2]);
993 }
994
995 #[test]
998 fn first_row_measures_limits_first_row() {
999 let score = score_with_measures(5);
1001 let result = compute_layout(
1002 &score,
1003 &LayoutConfig {
1004 measures_per_row: 4,
1005 concert_pitch: false,
1006 first_row_measures: Some(2),
1007 },
1008 );
1009 assert_eq!(result.rows.len(), 2);
1010 assert_eq!(result.rows[0].measure_indices, vec![0, 1]);
1011 assert_eq!(result.rows[1].measure_indices, vec![2, 3, 4]);
1012 }
1013
1014 #[test]
1015 fn first_row_measures_none_unchanged() {
1016 let score = score_with_measures(5);
1018 let without = compute_layout(
1019 &score,
1020 &LayoutConfig {
1021 measures_per_row: 4,
1022 concert_pitch: false,
1023 first_row_measures: None,
1024 },
1025 );
1026 let with_none = compute_layout(&score, &LayoutConfig::default());
1027 assert_eq!(without.rows.len(), with_none.rows.len());
1028 for (a, b) in without.rows.iter().zip(with_none.rows.iter()) {
1029 assert_eq!(a.measure_indices, b.measure_indices);
1030 }
1031 }
1032
1033 #[test]
1034 fn beam_groups_empty_for_default_score() {
1035 let score = Score::default();
1036 let result = compute_layout(&score, &LayoutConfig::default());
1037 assert!(result.beam_groups.is_empty());
1038 }
1039
1040 #[test]
1041 fn display_beams_follow_simple_and_compound_meter_without_changing_score() {
1042 use acorde_core::{Duration, Note, Pitch, Step, TimeSignature};
1043 let note = || Note::new(Pitch::new(Step::C, 4), Duration::Eighth);
1044 let mut score = score_with_measures(2);
1045 score.parts[0].staves[0].measures[0].voices[0] = vec![note(); 4];
1046 score.parts[0].staves[0].measures[1].time_sig = Some(TimeSignature {
1047 numerator: 6,
1048 denominator: 8,
1049 });
1050 score.parts[0].staves[0].measures[1].voices[0] = vec![note(); 6];
1051 let original = score.clone();
1052
1053 assert!(
1054 compute_layout(&score, &LayoutConfig::default())
1055 .beam_groups
1056 .is_empty()
1057 );
1058 let layout = compute_layout_with_display_beams(&score, &LayoutConfig::default());
1059 let groups: Vec<_> = layout
1060 .beam_groups
1061 .iter()
1062 .map(|g| (g.measure, g.note_indices.clone()))
1063 .collect();
1064 assert_eq!(
1065 groups,
1066 vec![
1067 (0, vec![0, 1]),
1068 (0, vec![2, 3]),
1069 (1, vec![0, 1, 2]),
1070 (1, vec![3, 4, 5])
1071 ]
1072 );
1073 assert_eq!(
1074 serde_json::to_value(&score).unwrap(),
1075 serde_json::to_value(&original).unwrap()
1076 );
1077 }
1078
1079 #[test]
1080 fn display_beams_respect_authored_unbeamed_rest_grace_and_barlines() {
1081 use acorde_core::{BeamState, Duration, Note, Pitch, Step};
1082 let note = || Note::new(Pitch::new(Step::C, 4), Duration::Eighth);
1083 let mut score = score_with_measures(2);
1084 let mut authored = note();
1085 authored.beam = BeamState::Begin;
1086 let mut authored_end = note();
1087 authored_end.beam = BeamState::End;
1088 let mut no = note();
1089 no.explicit_unbeamed = true;
1090 let mut grace = note();
1091 grace.is_grace = true;
1092 score.parts[0].staves[0].measures[0].voices[0] = vec![
1093 authored,
1094 authored_end,
1095 no,
1096 note(),
1097 Note::rest(Duration::Eighth),
1098 note(),
1099 grace,
1100 note(),
1101 ];
1102 score.parts[0].staves[0].measures[1].voices[0] = vec![note(), note()];
1103
1104 let layout = compute_layout_with_display_beams(&score, &LayoutConfig::default());
1105 let groups: Vec<_> = layout
1106 .beam_groups
1107 .iter()
1108 .map(|g| (g.measure, g.note_indices.clone()))
1109 .collect();
1110 assert_eq!(groups, vec![(0, vec![0, 1]), (1, vec![0, 1])]);
1111 }
1112
1113 #[test]
1114 fn display_beams_keep_pickup_and_tuplet_boundaries_separate() {
1115 use acorde_core::{Duration, Note, Pitch, Step, TupletBoundary, TupletInfo};
1116 let mut score = score_with_measures(2);
1117 let mut notes: Vec<_> = (0..6)
1118 .map(|_| Note::new(Pitch::new(Step::C, 4), Duration::Eighth))
1119 .collect();
1120 for note in &mut notes[..3] {
1121 note.tuplet = Some(TupletInfo {
1122 actual_notes: 3,
1123 normal_notes: 2,
1124 });
1125 }
1126 notes[0].tuplet_boundary = Some(TupletBoundary::Start);
1127 notes[2].tuplet_boundary = Some(TupletBoundary::Stop);
1128 score.parts[0].staves[0].measures[0].voices[0] = notes;
1130 score.parts[0].staves[0].measures[1].voices[0] = (0..2)
1131 .map(|_| Note::new(Pitch::new(Step::D, 4), Duration::Eighth))
1132 .collect();
1133
1134 let layout = compute_layout_with_display_beams(&score, &LayoutConfig::default());
1135 assert_eq!(layout.beam_groups[0].note_indices, vec![0, 1, 2]);
1136 assert!(
1137 layout
1138 .beam_groups
1139 .iter()
1140 .any(|group| group.measure == 1 && group.note_indices == vec![0, 1])
1141 );
1142 assert!(
1143 layout
1144 .beam_groups
1145 .iter()
1146 .all(|g| !g.note_indices.contains(&2) || !g.note_indices.contains(&3))
1147 );
1148 }
1149
1150 #[test]
1151 fn layout_exposes_source_voice_number_for_canonical_slot() {
1152 let mut score = score_with_measures(1);
1153 score.parts[0].staves[0].measures[0].source_voice_numbers[1] = Some(5);
1154
1155 let result = compute_layout(&score, &LayoutConfig::default());
1156 assert_eq!(
1157 result.source_voice_addresses,
1158 vec![SourceVoiceAddress {
1159 part: 0,
1160 staff: 0,
1161 measure: 0,
1162 voice: 1,
1163 source_voice_number: 5,
1164 }]
1165 );
1166 }
1167
1168 #[test]
1169 fn beam_groups_begin_end_collected() {
1170 use acorde_core::{BeamState, Duration, Note, Pitch, Step};
1171 let mut score = score_with_measures(1);
1172 let mut n1 = Note::new(Pitch::new(Step::C, 4), Duration::Eighth);
1173 n1.beam = BeamState::Begin;
1174 let mut n2 = Note::new(Pitch::new(Step::D, 4), Duration::Eighth);
1175 n2.beam = BeamState::Continue;
1176 let mut n3 = Note::new(Pitch::new(Step::E, 4), Duration::Eighth);
1177 n3.beam = BeamState::End;
1178 score.parts[0].staves[0].measures[0].voices[0] = vec![n1, n2, n3];
1179
1180 let result = compute_layout(&score, &LayoutConfig::default());
1181 assert_eq!(result.beam_groups.len(), 1);
1182 assert_eq!(result.beam_groups[0].note_indices, vec![0, 1, 2]);
1183 assert_eq!(result.beam_groups[0].part, 0);
1184 assert_eq!(result.beam_groups[0].measure, 0);
1185 assert_eq!(result.beam_groups[0].voice, 0);
1186 }
1187
1188 #[test]
1189 fn beam_groups_beginend_is_standalone_group() {
1190 use acorde_core::{BeamState, Duration, Note, Pitch, Step};
1191 let mut score = score_with_measures(1);
1192 let mut n = Note::new(Pitch::new(Step::C, 4), Duration::Eighth);
1193 n.beam = BeamState::BeginEnd;
1194 score.parts[0].staves[0].measures[0].voices[0] = vec![n];
1195
1196 let result = compute_layout(&score, &LayoutConfig::default());
1197 assert_eq!(result.beam_groups.len(), 1);
1198 assert_eq!(result.beam_groups[0].note_indices, vec![0]);
1199 }
1200
1201 #[test]
1202 fn tuplet_groups_empty_for_default_score() {
1203 let score = Score::default();
1204 let result = compute_layout(&score, &LayoutConfig::default());
1205 assert!(result.tuplet_groups.is_empty());
1206 }
1207
1208 #[test]
1209 fn tuplet_groups_triplet_collected() {
1210 use acorde_core::{Duration, Note, Pitch, Step, TupletInfo};
1211 let ti = TupletInfo {
1212 actual_notes: 3,
1213 normal_notes: 2,
1214 };
1215 let mut score = score_with_measures(1);
1216 let notes: Vec<Note> = (0..3)
1217 .map(|i| {
1218 let step = [Step::C, Step::D, Step::E][i].clone();
1219 let mut n = Note::new(Pitch::new(step, 4), Duration::Quarter);
1220 n.tuplet = Some(ti.clone());
1221 n
1222 })
1223 .collect();
1224 score.parts[0].staves[0].measures[0].voices[0] = notes;
1225
1226 let result = compute_layout(&score, &LayoutConfig::default());
1227 assert_eq!(result.tuplet_groups.len(), 1);
1228 assert_eq!(result.tuplet_groups[0].note_indices, vec![0, 1, 2]);
1229 assert_eq!(result.tuplet_groups[0].actual_notes, 3);
1230 assert_eq!(result.tuplet_groups[0].normal_notes, 2);
1231 assert_eq!(result.tuplet_groups[0].part, 0);
1232 assert_eq!(result.tuplet_groups[0].measure, 0);
1233 }
1234
1235 #[test]
1236 fn tuplet_groups_no_group_for_single_tuplet_note() {
1237 use acorde_core::{Duration, Note, Pitch, Step, TupletInfo};
1238 let mut score = score_with_measures(1);
1239 let mut n = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
1240 n.tuplet = Some(TupletInfo {
1241 actual_notes: 3,
1242 normal_notes: 2,
1243 });
1244 score.parts[0].staves[0].measures[0].voices[0] = vec![n];
1245
1246 let result = compute_layout(&score, &LayoutConfig::default());
1247 assert!(result.tuplet_groups.is_empty());
1249 }
1250
1251 #[test]
1252 fn hairpin_span_resolved() {
1253 use acorde_core::{Duration, HairpinKind, Note, Pitch, Step};
1254 let mut score = score_with_measures(1);
1255 let mut n1 = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
1256 n1.hairpin_start = Some(HairpinKind::Crescendo);
1257 let mut n2 = Note::new(Pitch::new(Step::D, 4), Duration::Quarter);
1258 n2.hairpin_end = true;
1259 score.parts[0].staves[0].measures[0].voices[0] = vec![n1, n2];
1260
1261 let result = compute_layout(&score, &LayoutConfig::default());
1262 assert_eq!(result.spans.len(), 1);
1263 if let SpanMark::Hairpin { kind, start, end } = &result.spans[0] {
1264 assert_eq!(*kind, HairpinKind::Crescendo);
1265 assert_eq!(start.note, 0);
1266 assert_eq!(end.note, 1);
1267 } else {
1268 panic!("expected Hairpin span");
1269 }
1270 }
1271
1272 #[test]
1273 fn slur_span_resolved() {
1274 use acorde_core::{Duration, Note, Pitch, Step};
1275 let mut score = score_with_measures(1);
1276 let mut n1 = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
1277 n1.slur_start = true;
1278 let mut n2 = Note::new(Pitch::new(Step::D, 4), Duration::Quarter);
1279 n2.slur_end = true;
1280 score.parts[0].staves[0].measures[0].voices[0] = vec![n1, n2];
1281
1282 let result = compute_layout(&score, &LayoutConfig::default());
1283 let slur = result
1284 .spans
1285 .iter()
1286 .find(|s| matches!(s, SpanMark::Slur { .. }));
1287 assert!(slur.is_some(), "expected a Slur span");
1288 if let Some(SpanMark::Slur { start, end }) = slur {
1289 assert_eq!(start.note, 0);
1290 assert_eq!(end.note, 1);
1291 }
1292 }
1293
1294 #[test]
1295 fn adjacent_legacy_slurs_share_an_endpoint_without_zero_length() {
1296 use acorde_core::{Duration, Note, Pitch, Step};
1297 let mut score = score_with_measures(1);
1298 let mut notes = [Step::C, Step::D, Step::E, Step::F]
1299 .map(|step| Note::new(Pitch::new(step, 4), Duration::Quarter));
1300 notes[0].slur_start = true;
1301 notes[1].slur_end = true;
1302 notes[1].slur_start = true;
1303 notes[2].slur_end = true;
1304 score.parts[0].staves[0].measures[0].voices[0] = notes.to_vec();
1305 let slurs = compute_layout(&score, &LayoutConfig::default())
1306 .spans
1307 .into_iter()
1308 .filter_map(|span| match span {
1309 SpanMark::Slur { start, end } => Some((start.note, end.note)),
1310 _ => None,
1311 })
1312 .collect::<Vec<_>>();
1313 assert_eq!(slurs, vec![(0, 1), (1, 2)]);
1314 }
1315
1316 #[test]
1317 fn nested_legacy_slurs_close_in_last_in_first_out_order() {
1318 use acorde_core::{Duration, Note, Pitch, Step};
1319 let mut score = score_with_measures(1);
1320 let mut notes = [Step::C, Step::D, Step::E, Step::F]
1321 .map(|step| Note::new(Pitch::new(step, 4), Duration::Quarter));
1322 notes[0].slur_start = true;
1323 notes[1].slur_start = true;
1324 notes[2].slur_end = true;
1325 notes[3].slur_end = true;
1326 score.parts[0].staves[0].measures[0].voices[0] = notes.to_vec();
1327 let slurs = compute_layout(&score, &LayoutConfig::default())
1328 .spans
1329 .into_iter()
1330 .filter_map(|span| match span {
1331 SpanMark::Slur { start, end } => Some((start.note, end.note)),
1332 _ => None,
1333 })
1334 .collect::<Vec<_>>();
1335 assert_eq!(slurs, vec![(1, 2), (0, 3)]);
1336 }
1337
1338 #[test]
1339 fn typed_slurs_keep_overlapping_pairs_without_legacy_duplicates() {
1340 use acorde_core::{Duration, Note, Pitch, Step};
1341 let mut score = score_with_measures(1);
1342 let mut notes = [Step::C, Step::D, Step::E, Step::F]
1343 .map(|step| Note::new(Pitch::new(step, 4), Duration::Quarter));
1344 notes[0].slur_start = true;
1345 notes[1].slur_start = true;
1346 notes[2].slur_end = true;
1347 notes[3].slur_end = true;
1348 score.parts[0].staves[0].measures[0].voices[0] = notes.to_vec();
1349 for (id, start, end) in [("outer", 0, 2), ("overlap", 1, 3)] {
1350 score.spanners.push(NotationSpanner {
1351 id: id.into(),
1352 kind: NotationSpannerKind::Slur,
1353 start: NoteAddr {
1354 part: 0,
1355 staff: 0,
1356 measure: 0,
1357 voice: 0,
1358 note: start,
1359 },
1360 end: NoteAddr {
1361 part: 0,
1362 staff: 0,
1363 measure: 0,
1364 voice: 0,
1365 note: end,
1366 },
1367 number: None,
1368 line_type: None,
1369 text: None,
1370 placement: None,
1371 ottava_size: None,
1372 ottava_type: None,
1373 });
1374 }
1375 let slurs = compute_layout(&score, &LayoutConfig::default())
1376 .spans
1377 .into_iter()
1378 .filter_map(|span| match span {
1379 SpanMark::Slur { start, end } => Some((start.note, end.note)),
1380 _ => None,
1381 })
1382 .collect::<Vec<_>>();
1383 assert_eq!(slurs, vec![(0, 2), (1, 3)]);
1384 }
1385
1386 #[test]
1387 fn typed_spanners_keep_stable_identity_in_layout_result() {
1388 use acorde_core::{Duration, NotationSpanner, NotationSpannerKind, Note, Pitch, Step};
1389 let mut score = score_with_measures(1);
1390 score.parts[0].staves[0].measures[0].voices[0] = vec![
1391 Note::new(Pitch::new(Step::C, 4), Duration::Quarter),
1392 Note::new(Pitch::new(Step::D, 4), Duration::Quarter),
1393 ];
1394 score.spanners.push(NotationSpanner {
1395 id: "typed-slur-7".to_string(),
1396 kind: NotationSpannerKind::Slur,
1397 start: NoteAddr {
1398 part: 0,
1399 staff: 0,
1400 measure: 0,
1401 voice: 0,
1402 note: 0,
1403 },
1404 end: NoteAddr {
1405 part: 0,
1406 staff: 0,
1407 measure: 0,
1408 voice: 0,
1409 note: 1,
1410 },
1411 number: Some(7),
1412 line_type: Some("dashed".to_string()),
1413 text: None,
1414 placement: Some("above".to_string()),
1415 ottava_size: None,
1416 ottava_type: None,
1417 });
1418
1419 let result = compute_layout(&score, &LayoutConfig::default());
1420 assert_eq!(result.typed_spanners.len(), 1);
1421 assert_eq!(result.typed_spanners[0].id, "typed-slur-7");
1422 assert_eq!(result.typed_spanners[0].number, Some(7));
1423 }
1424
1425 #[test]
1426 fn harmony_range_span_resolved_from_typed_end_address() {
1427 use acorde_core::{ChordSymbol, Duration, Note, NoteAddr, Pitch, Step};
1428 let mut score = score_with_measures(2);
1429 score.parts[0].staves[0].measures[0].voices[0] =
1430 vec![Note::new(Pitch::new(Step::C, 4), Duration::Whole)];
1431 score.parts[0].staves[0].measures[1].voices[0] =
1432 vec![Note::new(Pitch::new(Step::G, 4), Duration::Whole)];
1433 score.parts[0].staves[0].measures[0].voices[0][0].chord_symbol = Some(ChordSymbol {
1434 root: "C".to_owned(),
1435 kind: "major".to_owned(),
1436 bass: None,
1437 placement: None,
1438 extender: true,
1439 harmonic_degree: None,
1440 harmony_function: None,
1441 harmony_type: None,
1442 chord_ref: None,
1443 range_end: Some(NoteAddr {
1444 part: 0,
1445 staff: 0,
1446 measure: 1,
1447 voice: 0,
1448 note: 0,
1449 }),
1450 degrees: Vec::new(),
1451 });
1452
1453 let result = compute_layout(&score, &LayoutConfig::default());
1454 assert!(matches!(
1455 result.spans.as_slice(),
1456 [SpanMark::Harmony { label, start, end }]
1457 if label == "C" && start.measure == 0 && end.measure == 1
1458 ));
1459 }
1460
1461 #[test]
1464 fn courtesy_none_for_clean_score() {
1465 let score = Score::default();
1467 let result = compute_layout(&score, &LayoutConfig::default());
1468 assert!(result.courtesy_accidentals.is_empty());
1469 }
1470
1471 #[test]
1472 fn courtesy_after_chromatic_alteration() {
1473 use acorde_core::{Duration, Note, Pitch, Step};
1476 let mut score = score_with_measures(2);
1477
1478 let mut fsharp = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1479 fsharp.pitches[0].alter = 1;
1480 score.parts[0].staves[0].measures[0].voices[0] = vec![fsharp];
1481
1482 let fnat = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1483 score.parts[0].staves[0].measures[1].voices[0] = vec![fnat];
1485
1486 let result = compute_layout(&score, &LayoutConfig::default());
1487 assert_eq!(result.courtesy_accidentals.len(), 1);
1488 let ca = &result.courtesy_accidentals[0];
1489 assert_eq!(ca.measure, 1);
1490 assert_eq!(ca.alter, 0); }
1492
1493 #[test]
1494 fn courtesy_same_alteration_no_courtesy() {
1495 use acorde_core::{Duration, Note, Pitch, Step};
1498 let mut score = score_with_measures(2);
1499
1500 let mut fsharp1 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1501 fsharp1.pitches[0].alter = 1;
1502 score.parts[0].staves[0].measures[0].voices[0] = vec![fsharp1];
1503
1504 let mut fsharp2 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1505 fsharp2.pitches[0].alter = 1;
1506 score.parts[0].staves[0].measures[1].voices[0] = vec![fsharp2];
1507
1508 let result = compute_layout(&score, &LayoutConfig::default());
1509 assert!(result.courtesy_accidentals.is_empty());
1510 }
1511
1512 #[test]
1513 fn courtesy_tied_note_excluded() {
1514 use acorde_core::{Duration, Note, Pitch, Step};
1516 let mut score = score_with_measures(2);
1517
1518 let mut fsharp = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1519 fsharp.pitches[0].alter = 1;
1520 score.parts[0].staves[0].measures[0].voices[0] = vec![fsharp];
1521
1522 let mut tied = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1523 tied.pitches[0].alter = 1;
1524 tied.tie_end = true;
1525 score.parts[0].staves[0].measures[1].voices[0] = vec![tied];
1526
1527 let result = compute_layout(&score, &LayoutConfig::default());
1528 assert!(result.courtesy_accidentals.is_empty());
1529 }
1530
1531 #[test]
1532 fn courtesy_key_change_resets() {
1533 use acorde_core::{Duration, KeySignature, Note, Pitch, Step};
1536 let mut score = score_with_measures(2);
1537
1538 let mut fsharp = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1539 fsharp.pitches[0].alter = 1;
1540 score.parts[0].staves[0].measures[0].voices[0] = vec![fsharp];
1541
1542 score.parts[0].staves[0].measures[1].key_sig = Some(KeySignature {
1544 fifths: 1,
1545 mode: "major".to_string(),
1546 });
1547 let mut fsharp2 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1549 fsharp2.pitches[0].alter = 1;
1550 score.parts[0].staves[0].measures[1].voices[0] = vec![fsharp2];
1551
1552 let result = compute_layout(&score, &LayoutConfig::default());
1553 assert!(result.courtesy_accidentals.is_empty());
1555 }
1556
1557 #[test]
1560 fn requested_accidentals_are_drawn_where_the_rules_imply_them() {
1561 use acorde_core::{Duration, Note, Pitch, Step};
1562 let mut score = score_with_measures(1);
1563 let mut cautionary = Note::new(Pitch::new(Step::C, 4), Duration::Quarter);
1564 cautionary.set_accidental_display(0, AccidentalDisplay::Cautionary);
1565 let mut sharp = Note::new(Pitch::with_alter(Step::F, 4, 1), Duration::Quarter);
1566 sharp.set_accidental_display(0, AccidentalDisplay::Parenthesized);
1567 let mut bracketed = Note::new(Pitch::new(Step::G, 4), Duration::Quarter);
1568 bracketed.set_accidental_display(0, AccidentalDisplay::Parenthesized);
1569 let plain = Note::new(Pitch::new(Step::A, 4), Duration::Quarter);
1570 score.parts[0].staves[0].measures[0].voices[0] = vec![cautionary, sharp, bracketed, plain];
1571
1572 let result = compute_layout(&score, &LayoutConfig::default());
1573 let mandatory: Vec<usize> = result.accidentals.iter().map(|a| a.note_index).collect();
1574 let courtesy: Vec<usize> = result
1575 .courtesy_accidentals
1576 .iter()
1577 .map(|a| a.note_index)
1578 .collect();
1579 assert_eq!(mandatory, vec![0]);
1582 assert_eq!(courtesy, vec![1, 2]);
1583 }
1584
1585 #[test]
1586 fn accidental_none_for_clean_score() {
1587 let score = Score::default();
1588 let result = compute_layout(&score, &LayoutConfig::default());
1589 assert!(result.accidentals.is_empty());
1590 }
1591
1592 #[test]
1593 fn accidental_first_chromatic_note_in_measure() {
1594 use acorde_core::{Duration, Note, Pitch, Step};
1596 let mut score = score_with_measures(1);
1597 let mut fsharp = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1598 fsharp.pitches[0].alter = 1;
1599 score.parts[0].staves[0].measures[0].voices[0] = vec![fsharp];
1600
1601 let result = compute_layout(&score, &LayoutConfig::default());
1602 assert_eq!(result.accidentals.len(), 1);
1603 assert_eq!(result.accidentals[0].alter, 1);
1604 assert_eq!(result.accidentals[0].measure, 0);
1605 }
1606
1607 #[test]
1608 fn accidental_repeat_same_alter_in_measure_not_marked_again() {
1609 use acorde_core::{Duration, Note, Pitch, Step};
1611 let mut score = score_with_measures(1);
1612 let mut f1 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1613 f1.pitches[0].alter = 1;
1614 let mut f2 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1615 f2.pitches[0].alter = 1;
1616 score.parts[0].staves[0].measures[0].voices[0] = vec![f1, f2];
1617
1618 let result = compute_layout(&score, &LayoutConfig::default());
1619 assert_eq!(result.accidentals.len(), 1);
1620 }
1621
1622 #[test]
1623 fn accidental_reverts_to_natural_within_same_measure() {
1624 use acorde_core::{Duration, Note, Pitch, Step};
1626 let mut score = score_with_measures(1);
1627 let mut f1 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1628 f1.pitches[0].alter = 1;
1629 let f2 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter); score.parts[0].staves[0].measures[0].voices[0] = vec![f1, f2];
1631
1632 let result = compute_layout(&score, &LayoutConfig::default());
1633 assert_eq!(result.accidentals.len(), 2);
1634 assert_eq!(result.accidentals[0].alter, 1);
1635 assert_eq!(result.accidentals[1].alter, 0);
1636 }
1637
1638 #[test]
1639 fn accidental_does_not_carry_across_barline() {
1640 use acorde_core::{Duration, Note, Pitch, Step};
1644 let mut score = score_with_measures(2);
1645 let mut f1 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1646 f1.pitches[0].alter = 1;
1647 score.parts[0].staves[0].measures[0].voices[0] = vec![f1];
1648 let mut f2 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1649 f2.pitches[0].alter = 1;
1650 score.parts[0].staves[0].measures[1].voices[0] = vec![f2];
1651
1652 let result = compute_layout(&score, &LayoutConfig::default());
1653 assert_eq!(result.accidentals.len(), 2);
1654 assert!(result.accidentals.iter().any(|a| a.measure == 1));
1655 assert!(result.courtesy_accidentals.is_empty());
1656 }
1657
1658 #[test]
1659 fn accidental_tied_note_excluded() {
1660 use acorde_core::{Duration, Note, Pitch, Step};
1661 let mut score = score_with_measures(1);
1662 let mut tied = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1663 tied.pitches[0].alter = 1;
1664 tied.tie_end = true;
1665 score.parts[0].staves[0].measures[0].voices[0] = vec![tied];
1666
1667 let result = compute_layout(&score, &LayoutConfig::default());
1668 assert!(result.accidentals.is_empty());
1669 }
1670
1671 #[test]
1672 fn accidental_shared_across_voices_on_same_staff() {
1673 use acorde_core::{Duration, Note, Pitch, Step};
1675 let mut score = score_with_measures(1);
1676 let mut f_v0 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1677 f_v0.pitches[0].alter = 1;
1678 score.parts[0].staves[0].measures[0].voices[0] = vec![f_v0];
1679 let mut f_v1 = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1680 f_v1.pitches[0].alter = 1;
1681 score.parts[0].staves[0].measures[0].voices[1] = vec![f_v1];
1682
1683 let result = compute_layout(&score, &LayoutConfig::default());
1684 assert_eq!(result.accidentals.len(), 1);
1685 }
1686
1687 #[test]
1688 fn accidental_double_sharp_marked() {
1689 use acorde_core::{Duration, Note, Pitch, Step};
1690 let mut score = score_with_measures(1);
1691 let mut n = Note::new(Pitch::new(Step::F, 4), Duration::Quarter);
1692 n.pitches[0].alter = 2;
1693 score.parts[0].staves[0].measures[0].voices[0] = vec![n];
1694
1695 let result = compute_layout(&score, &LayoutConfig::default());
1696 assert_eq!(result.accidentals.len(), 1);
1697 assert_eq!(result.accidentals[0].alter, 2);
1698 }
1699}