khodowany
96 lines
4.4 KiB
Python
96 lines
4.4 KiB
Python
from __future__ import annotations
|
|
|
|
import copy
|
|
|
|
from generator import harmony
|
|
from generator.model import LETTERS, NATURAL, alteration, fraction, key_from_fifths, key_label, pitch_number, rational
|
|
|
|
def shift_pitch(pitch: dict, steps: int, semitones: int) -> dict:
|
|
output = copy.deepcopy(pitch)
|
|
if 'unpitched' in pitch:
|
|
return output
|
|
original_octave = pitch.get('octave', 4)
|
|
diatonic = original_octave * 7 + LETTERS.index(pitch['letter']) + steps
|
|
octave, index = divmod(diatonic, 7)
|
|
output['letter'] = LETTERS[index]
|
|
output['octave'] = octave
|
|
output['alter'] = rational(pitch_number({**pitch, 'octave': original_octave}) + semitones - (12 * (octave + 1) + NATURAL[output['letter']]))
|
|
if 'octave' not in pitch:
|
|
output.pop('octave')
|
|
if 'accidental_display' in output:
|
|
from generator.model import accidental_name
|
|
output['accidental_display']['name'] = accidental_name(alteration(output['alter']))
|
|
return output
|
|
|
|
def shift_key(key: dict, steps: int, semitones: int) -> dict:
|
|
tonic = shift_pitch(key['tonic'], steps, semitones) if key.get('tonic') else None
|
|
alterations = [0] * 7
|
|
for index, letter in enumerate(LETTERS):
|
|
p = shift_pitch({'letter': letter, 'alter': key['alterations'][index]}, steps, semitones)
|
|
alterations[LETTERS.index(p['letter'])] = p['alter']
|
|
result = {**copy.deepcopy(key), 'tonic': tonic, 'alterations': alterations}
|
|
if 'steps' in key:
|
|
result['steps'] = [shift_pitch(step, steps, semitones) for step in key['steps']]
|
|
if not key.get('custom') and tonic:
|
|
for fifths in range(-14, 15):
|
|
candidate = key_from_fifths(fifths, key['mode'])
|
|
if candidate['tonic'] == tonic and candidate['alterations'] == alterations:
|
|
result['fifths'] = fifths
|
|
break
|
|
else:
|
|
result['custom'] = True
|
|
if 'cancel' in key:
|
|
# A cancellation references the old signature, not a count of naturals.
|
|
cancelled = shift_key(key_from_fifths(key['cancel']), steps, semitones)
|
|
if cancelled.get('custom'):
|
|
raise ValueError('transposed key cancellation cannot be represented by fifths')
|
|
result['cancel'] = cancelled['fifths']
|
|
return result
|
|
|
|
def concert_document(document: dict, *, octave_transposing: bool = False) -> dict:
|
|
"""Resolve source instrument pitch once, before arranging in concert pitch."""
|
|
output = copy.deepcopy(document)
|
|
zero = {'diatonic': 0, 'chromatic': 0, 'octave_change': 0, 'explicit': True}
|
|
for staff in output['staves']:
|
|
for measure in staff['measures']:
|
|
initial = {key: measure[key] for key in ('transpose', 'clef')}
|
|
changes = copy.deepcopy(measure.get('attributes', []))
|
|
|
|
def interval(onset):
|
|
state = dict(initial)
|
|
for change in changes:
|
|
if fraction(change['onset']) <= onset:
|
|
state.update({key: change[key] for key in initial if key in change})
|
|
transpose, clef = state['transpose'], state['clef']
|
|
steps = transpose['diatonic'] + 7 * transpose['octave_change']
|
|
semitones = transpose['chromatic'] + 12 * transpose['octave_change']
|
|
if octave_transposing and not transpose.get('explicit') and not (steps or semitones) and not clef['octave_change']:
|
|
return -7, -12
|
|
return steps, semitones
|
|
|
|
measure['key'] = shift_key(measure['key'], *interval(0))
|
|
measure['key_signature'] = key_label(measure['key'])
|
|
for n in (n for v in measure['voices'] for n in v['notes']):
|
|
n['pitches'] = [shift_pitch(p, *interval(fraction(n['onset']))) for p in n['pitches']]
|
|
for h in measure['harmonies']:
|
|
for field in ('root', 'bass'):
|
|
if field in h:
|
|
h[field] = shift_pitch(h[field], *interval(fraction(h['onset'])))
|
|
h['symbol'] = harmony.symbol(h)
|
|
for change in measure.get('attributes', []):
|
|
if 'key' in change:
|
|
change['key'] = shift_key(change['key'], *interval(fraction(change['onset'])))
|
|
if 'transpose' in change:
|
|
change['transpose'] = copy.deepcopy(zero)
|
|
measure['transpose'] = copy.deepcopy(zero)
|
|
first = output['staves'][0]['measures'][0]
|
|
output['metadata']['key'] = copy.deepcopy(first['key'])
|
|
output['metadata']['key_signature'] = first['key_signature']
|
|
return output
|
|
|
|
def sounding_pitch(pitch: dict, state: dict):
|
|
if 'unpitched' in pitch:
|
|
raise ValueError('unpitched notes have no fretted or generated-tone interpretation')
|
|
transpose = state['transpose']
|
|
return pitch_number(pitch) + transpose['chromatic'] + 12 * transpose['octave_change']
|