khodowany
174 lines
9.3 KiB
Python
174 lines
9.3 KiB
Python
from __future__ import annotations
|
|
|
|
from dataclasses import dataclass
|
|
from bisect import bisect_left, bisect_right
|
|
from fractions import Fraction
|
|
|
|
from generator.model import LETTERS, NOTE_TYPES, alteration, fraction, written_for
|
|
from generator.engraving.fonts import Fonts
|
|
from generator.engraving.types import EngravingError, Primitive, bounds
|
|
|
|
ACCIDENTAL_GLYPHS = {Fraction(0): 'accidentalNatural', Fraction(1): 'accidentalSharp', Fraction(-1): 'accidentalFlat', Fraction(2): 'accidentalDoubleSharp', Fraction(-2): 'accidentalDoubleFlat', Fraction(3): 'accidentalTripleSharp', Fraction(-3): 'accidentalTripleFlat', Fraction(1, 2): 'accidentalQuarterToneSharpStein', Fraction(-1, 2): 'accidentalQuarterToneFlatStein', Fraction(3, 2): 'accidentalThreeQuarterTonesSharpStein', Fraction(-3, 2): 'accidentalThreeQuarterTonesFlatZimmermann'}
|
|
HEADS = {'x': 'X', 'diamond': 'Diamond', 'triangle': 'TriangleUp', 'inverted triangle': 'TriangleDown', 'circle-x': 'CircleX', 'cross': 'Plus', 'slash': 'Slash', 'normal': '', 'do': 'TriangleUp', 're': 'Moon', 'mi': 'Diamond', 'fa': 'TriangleRight', 'fa up': 'TriangleLeft', 'so': 'Round', 'la': 'Square', 'ti': 'TriangleRoundDown', 'rectangle': 'Square', 'square': 'Square', 'arrow down': 'LargeArrowDown', 'arrow up': 'LargeArrowUp'}
|
|
|
|
@dataclass(frozen=True)
|
|
class Event:
|
|
measure: dict
|
|
voice: str
|
|
lane: int
|
|
lanes: int
|
|
start: Fraction
|
|
end: Fraction
|
|
value: dict
|
|
|
|
class ScoreIndex:
|
|
def __init__(self, document: dict):
|
|
self.staff = document['staves'][0]
|
|
self.measures = []
|
|
self.events = []
|
|
self.by_id = {}
|
|
self.tones = {}
|
|
self.boundaries = {Fraction()}
|
|
self.columns = {Fraction()}
|
|
self._states = {}
|
|
self._beam_groups = None
|
|
time = Fraction()
|
|
for measure in self.staff['measures']:
|
|
end = time + fraction(measure['duration'])
|
|
self.measures.append((time, end, measure))
|
|
self.boundaries.add(end)
|
|
self.columns.update((time, end))
|
|
for lane, voice in enumerate(measure['voices']):
|
|
for note in voice['notes']:
|
|
onset = time + fraction(note['onset'])
|
|
event = Event(measure, voice['id'], lane, len(measure['voices']), onset, onset + fraction(note['duration']), note)
|
|
self.events.append(event)
|
|
self.by_id[note['id']] = event
|
|
self.columns.add(onset)
|
|
for tone in note['pitches']:
|
|
self.tones[tone['id']] = (event, tone)
|
|
for field in ('attributes', 'harmonies', 'tempos'):
|
|
self.columns.update(time + fraction(item['onset']) for item in measure.get(field, []))
|
|
time = end
|
|
self.end = time
|
|
self.measure_starts = [item[0] for item in self.measures]
|
|
self.events.sort(key=lambda e: (e.start, not bool(e.value.get('grace')), e.lane))
|
|
self.lyric_lanes = list(dict.fromkeys((e.voice, verse['number']) for e in self.events for verse in e.value.get('lyrics', [])))
|
|
self.accidentals = self.accidental_state()
|
|
def state(self, time: Fraction, before: bool = False) -> dict:
|
|
if (time, before) in self._states:
|
|
return self._states[time, before]
|
|
position = bisect_left(self.measure_starts, time) if before else bisect_right(self.measure_starts, time)
|
|
start, _, measure = self.measures[max(0, position - 1)]
|
|
state = {key: measure[key] for key in ('key', 'meter', 'clef', 'transpose', 'staff_details')}
|
|
for change in measure.get('attributes', []):
|
|
onset = start + fraction(change['onset'])
|
|
if onset < time or (onset == time and not before):
|
|
state.update({key: value for key, value in change.items() if key != 'onset'})
|
|
self._states[time, before] = state
|
|
return state
|
|
def pitch_position(self, tone: dict, time: Fraction) -> float:
|
|
state = self.state(time)
|
|
clef = state['clef']
|
|
if clef['sign'] == 'TAB':
|
|
if 'tablature' not in tone:
|
|
raise EngravingError(f'{tone["id"]}: TAB notes require explicit string and fret')
|
|
string = tone['tablature']['string']
|
|
if not 1 <= string <= state['staff_details']['lines']:
|
|
raise EngravingError(f'{tone["id"]}: TAB string is outside the staff')
|
|
return 2 * (state['staff_details']['lines'] - string)
|
|
pitch = tone.get('unpitched', tone)
|
|
sign = clef['sign']
|
|
reference = {'G': 4 * 7 + 4, 'F': 3 * 7 + 3, 'C': 4 * 7}.get(sign, 4 * 7 + 4)
|
|
clef_line = clef.get('line', 2) if sign in ('G', 'F', 'C') else 2
|
|
octave = 0 if 'unpitched' in tone else clef.get('octave_change', 0)
|
|
shift = sum(s['octaves'] for s in self.staff.get('octave_shifts', []) if fraction(s['start']) <= time < fraction(s['end'])) if 'unpitched' not in tone else 0
|
|
return pitch['octave'] * 7 + LETTERS.index(pitch['letter']) + 7 * (shift - octave) - reference + 2 * (clef_line - 1)
|
|
def accidental_state(self) -> dict[str, bool]:
|
|
result = {}
|
|
for start, end, measure in self.measures:
|
|
memory = {}
|
|
key = None
|
|
onsets = sorted({e.start for e in self.events if start <= e.start < end})
|
|
for onset in onsets:
|
|
state = self.state(onset)
|
|
if key != state['key']:
|
|
key, memory = state['key'], {}
|
|
simultaneous = {}
|
|
for event in (e for e in self.events if e.start == onset):
|
|
for tone in event.value['pitches']:
|
|
hidden_head = isinstance(tone.get('notehead'), dict) and tone['notehead'].get('name') == 'none'
|
|
if event.value.get('hidden') or tone.get('print', {}).get('print-object') == 'no' or hidden_head:
|
|
result[tone['id']] = False
|
|
continue
|
|
if 'unpitched' in tone or state['clef']['sign'] == 'TAB':
|
|
result[tone['id']] = False
|
|
continue
|
|
identity = (tone['letter'], tone['octave'])
|
|
value = alteration(tone['alter'])
|
|
signature = Fraction() if key.get('custom') else alteration(key['alterations'][LETTERS.index(tone['letter'])])
|
|
for step in key.get('steps', []):
|
|
if step['letter'] == tone['letter'] and step.get('octave', tone['octave']) == tone['octave']:
|
|
signature = alteration(step['alter'])
|
|
result[tone['id']] = bool(tone.get('accidental_display')) or (not tone.get('tie_from') and memory.get(identity, signature) != value)
|
|
simultaneous.setdefault(identity, set()).add(value)
|
|
for identity, values in simultaneous.items():
|
|
memory[identity] = next(iter(values)) if len(values) == 1 else None
|
|
if any(len(values) > 1 for values in simultaneous.values()):
|
|
for event in (e for e in self.events if e.start == onset):
|
|
for tone in event.value['pitches']:
|
|
if 'letter' in tone and len(simultaneous.get((tone['letter'], tone['octave']), ())) > 1:
|
|
result[tone['id']] = True
|
|
return result
|
|
|
|
def fragment_written(written: dict, original_start: Fraction, original_end: Fraction, start: Fraction, end: Fraction) -> dict:
|
|
return written if (original_start, original_end) == (start, end) else written_for(end - start)
|
|
|
|
def flags(written: dict) -> int:
|
|
return max(0, NOTE_TYPES.index(written['type']) - NOTE_TYPES.index('quarter'))
|
|
|
|
def head_glyph(written: dict, head: dict | str | None) -> str:
|
|
head = {'name': head} if isinstance(head, str) else head or {'name': 'normal'}
|
|
if head.get('smufl'):
|
|
return head['smufl']
|
|
name = head['name']
|
|
if name == 'none':
|
|
return ''
|
|
kind = written['type']
|
|
suffix = 'DoubleWhole' if kind in ('maxima', 'long', 'breve') else 'Whole' if kind == 'whole' else 'Half' if kind == 'half' else 'Black'
|
|
if head.get('filled') in ('yes', 'no'):
|
|
suffix = 'Black' if head['filled'] == 'yes' else 'Half'
|
|
if name == 'slash':
|
|
return {'DoubleWhole': 'noteheadSlashWhiteDoubleWhole', 'Whole': 'noteheadSlashWhiteWhole', 'Half': 'noteheadSlashWhiteHalf', 'Black': 'noteheadSlashVerticalEnds'}[suffix]
|
|
if name in ('slashed', 'back slashed'):
|
|
return 'noteheadSlashed' + suffix + ('1' if name == 'slashed' else '2')
|
|
if name in ('circled', 'circle dot'):
|
|
return 'noteheadCircled' + suffix
|
|
if name not in HEADS:
|
|
raise EngravingError(f'no SMuFL mapping for notehead {name!r}; specify its smufl glyph name')
|
|
shape = HEADS[name]
|
|
if shape in ('Moon', 'Round', 'Square', 'TriangleRight', 'TriangleLeft', 'TriangleRoundDown'):
|
|
suffix = 'Black' if suffix == 'Black' else 'White'
|
|
return 'notehead' + shape + suffix
|
|
|
|
def accidental(fonts: Fonts, value: Fraction, display: dict, size: float, sources: tuple[str, ...]) -> list[Primitive]:
|
|
glyph = display.get('smufl') or ACCIDENTAL_GLYPHS.get(value)
|
|
special = {'natural-sharp': ('accidentalNatural', 'accidentalSharp'), 'natural-flat': ('accidentalNatural', 'accidentalFlat')}
|
|
if display.get('name') in special and not display.get('smufl'):
|
|
items = []
|
|
x = 0
|
|
for name in special[display['name']]:
|
|
part = fonts.glyph(name, x, 0, size, 'accidental', sources)
|
|
items.append(part)
|
|
x = part.box.right + 2
|
|
elif glyph:
|
|
items = [fonts.glyph(glyph, 0, 0, size, 'accidental', sources)]
|
|
else:
|
|
sign = '+' if value > 0 else ''
|
|
items = [fonts.text(f'({sign}{value} st)', 0, 0, size * 1.15, 'accidental', sources)]
|
|
if display.get('parentheses') == 'yes' or display.get('bracket') == 'yes':
|
|
box = bounds(items)
|
|
left, right = ('[', ']') if display.get('bracket') == 'yes' else ('(', ')')
|
|
items.extend((fonts.text(left, box.left - 7, size / 2, size * 1.8, 'accidental', sources), fonts.text(right, box.right + 2, size / 2, size * 1.8, 'accidental', sources)))
|
|
return items
|