khodowany
108 lines
4.2 KiB
Python
108 lines
4.2 KiB
Python
from __future__ import annotations
|
|
|
|
from itertools import product
|
|
from typing import NamedTuple
|
|
|
|
from generator.transposition import mod12
|
|
from generator import harmony
|
|
from generator.model import NATURAL
|
|
|
|
STANDARD_TUNING = ((6, 40), (5, 45), (4, 50), (3, 55), (2, 59), (1, 64))
|
|
WRITTEN_GUITAR_OCTAVE_OFFSET = 12
|
|
|
|
|
|
class TabPosition(NamedTuple):
|
|
string_number: int
|
|
fret: int
|
|
midi: int
|
|
|
|
|
|
def chord_pitch_classes(symbol: str | dict) -> tuple[int, ...]:
|
|
return harmony.pitch_classes(harmony.parse_symbol(symbol) if isinstance(symbol, str) else symbol)
|
|
|
|
|
|
def positions_for_string(string_number: int, open_midi: int, pitch_classes: tuple[int, ...]) -> list[TabPosition]:
|
|
result: list[TabPosition] = []
|
|
for fret in range(0, 13):
|
|
midi = open_midi + fret
|
|
if mod12(midi) in pitch_classes:
|
|
result.append(TabPosition(string_number, fret, midi))
|
|
return result
|
|
|
|
|
|
def candidate_score(candidate: tuple[TabPosition, ...], pitch_classes: tuple[int, ...]) -> int:
|
|
fretted = [position.fret for position in candidate if position.fret > 0]
|
|
if not fretted:
|
|
span = 0
|
|
low = 0
|
|
else:
|
|
span = max(fretted) - min(fretted)
|
|
low = min(fretted)
|
|
covered = {mod12(position.midi) for position in candidate}
|
|
missing = len(set(pitch_classes) - covered)
|
|
open_penalty = sum(1 for position in candidate if position.fret == 0)
|
|
return missing * 1000 + span * 80 + abs(low - 5) * 12 + open_penalty * 8 + sum(position.fret for position in candidate)
|
|
|
|
|
|
def find_playable_voicing(symbol: str | dict) -> list[TabPosition]:
|
|
definition = harmony.parse_symbol(symbol) if isinstance(symbol, str) else symbol
|
|
semantic_degrees = harmony.degrees(definition)
|
|
voicing = dict(semantic_degrees)
|
|
if 7 in voicing and voicing.get(5) == 0:
|
|
del voicing[5]
|
|
if len(voicing) > 4:
|
|
for degree in (11, 9, 5):
|
|
if len(voicing) > 4 and voicing.get(degree) == 0:
|
|
del voicing[degree]
|
|
root = definition.get('root', {'letter':'c','alter':0})
|
|
root_pc = NATURAL[root['letter']] + root['alter']
|
|
pitch_classes = tuple(dict.fromkeys((root_pc + harmony.degree_semitones(d,a)) % 12 for d,a in voicing.items()))
|
|
bass = definition.get('bass')
|
|
bass_pc = (NATURAL[bass['letter']] + bass['alter']) % 12 if bass else None
|
|
if bass_pc is not None and bass_pc not in pitch_classes:
|
|
pitch_classes += (bass_pc,)
|
|
if not pitch_classes:
|
|
return []
|
|
|
|
string_sets = ((6, 4, 3, 2), (5, 4, 3, 2), (4, 3, 2, 1), (6, 5, 4, 3), (5, 3, 2, 1))
|
|
by_string = {string_number: positions_for_string(string_number, open_midi, pitch_classes) for string_number, open_midi in STANDARD_TUNING}
|
|
best: tuple[TabPosition, ...] | None = None
|
|
best_score = 10**9
|
|
for string_set in string_sets:
|
|
options = [by_string[string_number][:8] for string_number in string_set]
|
|
if any(not item for item in options):
|
|
continue
|
|
for candidate in product(*options):
|
|
if bass_pc is not None and min(candidate, key=lambda p:p.midi).midi % 12 != bass_pc:
|
|
continue
|
|
fretted = [position.fret for position in candidate if position.fret > 0]
|
|
if fretted and max(fretted) - min(fretted) > 4:
|
|
continue
|
|
covered = {mod12(position.midi) for position in candidate}
|
|
if not set(pitch_classes).issubset(covered):
|
|
continue
|
|
score = candidate_score(candidate, pitch_classes)
|
|
if score < best_score:
|
|
best = candidate
|
|
best_score = score
|
|
return sorted(best or [], key=lambda item: item.midi)
|
|
|
|
|
|
def pitches_for_voicing(symbol: str | dict) -> list[dict[str, int | str]]:
|
|
definition = harmony.parse_symbol(symbol) if isinstance(symbol, str) else symbol
|
|
from generator.transposition import shift_pitch
|
|
root = definition.get('root', {'letter':'c', 'alter':0})
|
|
spellings = {}
|
|
for degree, alter in harmony.degrees(definition).items():
|
|
p = shift_pitch(root, degree-1, harmony.degree_semitones(degree, alter))
|
|
spellings[(NATURAL[p['letter']]+p['alter']) % 12] = p
|
|
if bass := definition.get('bass'):
|
|
spellings[(NATURAL[bass['letter']]+bass['alter']) % 12] = bass
|
|
result = []
|
|
for position in find_playable_voicing(definition):
|
|
midi = position.midi + WRITTEN_GUITAR_OCTAVE_OFFSET
|
|
p = spellings[midi % 12].copy()
|
|
p['octave'] = (midi - NATURAL[p['letter']] - p['alter']) // 12 - 1
|
|
result.append(p)
|
|
return result
|