def notate_score(musician_names, instrument_names, music):
score = Score()
for musician_name, instrument_name in zip(musician_names,
instrument_names):
instrument = get_instrument(instrument_name)
instrument.partName = instrument.instrumentName
instrument.partAbbreviation = instrument.instrumentAbbreviation
parts = []
part = Part()
parts.append(part)
part.insert(0, instrument)
score.insert(0, part)
score.insert(0, StaffGroup(parts))
notes = music[musician_name]
for pitches in notes:
if not pitches or pitches == 'stop':
note = Rest()
elif len(pitches) == 1:
pitch = Pitch(pitches[0] + 60)
note = Note(pitch)
else:
note = Chord(notes=[Pitch(p + 60) for p in pitches])
duration = Duration()
duration.fill([4.0])
note.duration = duration
part.append(note)
score.show('musicxml', '/Applications/Sibelius 7.5.app')
def _matrix_to_part(self, submatrix):
'''
Takes a submatrix of size (T, D) and turn it into a music21.stream.Part
object, where T is the number of time slices, and dim is the note
vector.
'''
part = Part()
pitches = submatrix[:, 0]
articulations = submatrix[:, 1]
current_note = None
for current_tick in range(len(submatrix)):
if articulations[current_tick]: # if articulate
# append the old note
if current_note is not None: # for the first note
part.append(current_note)
# create a new note
if pitches[current_tick] < self.rest:
current_note = Note()
# assign pitch, inverse of self._midi_to_input()
current_note.pitch.midi = pitches[current_tick]
else:
current_note = Rest()
# resets the duration to the smallest amount
current_note.duration.quarterLength = self.unit_length
else:
current_note.duration.quarterLength += self.unit_length
return part
def write_notation_cell(music, path, event_index):
score = Score()
metadata = Metadata()
metadata.title = ''
metadata.composer = ''
score.insert(0, metadata)
layout = ScoreLayout()
layout.scalingMillimeters = 1.25
layout.scalingTenths = 40
score.insert(0, layout)
for musician in music:
instrument_name = musician['instrument']
instrument = get_instrument(instrument_name)
instrument.partName = instrument.instrumentName
if instrument.instrumentName is 'Violoncello':
instrument.partName = 'Cello'
instrument.partAbbreviation = instrument.instrumentAbbreviation
parts = []
part = Part()
parts.append(part)
part.insert(0, instrument)
score.insert(0, part)
# score.insert(0, StaffGroup(parts))
for event in musician['music']:
pitches = event['pitches']
dur = event['duration']
# if not pitches or pitches == 'stop':
# note = Rest()
if len(pitches) == 1:
pitch = Pitch(pitches[0] + 60)
note = Note(pitch)
else:
note = Chord(notes=[Pitch(p + 60) for p in pitches])
duration = Duration()
duration.fill([dur])
note.duration = duration
part.append(note)
file_path = os.path.join(path, str(event_index).zfill(2))
musicxml_file_path = file_path + '.xml'
png_output_file_path = file_path + '.png'
score.write('musicxml', musicxml_file_path)
write_png_with_musescore(musicxml_file_path, png_output_file_path, dpi=600)
def matchParts(referencePart: stream.Part, partToAdjust: stream.Part):
"""
Resolve differences between two parts (here a score template and analysis part) with
one defined as the reference part (score) and the other to be adjusted (analysis).
Changes made:
1. Number of measures.
Often analyses have fewer measures than scores as the last chord is reached
before the last measure, and those 'empty' measures are not explicitly encoded.
This function adds empty measures to the analysis, padding it out so that they match up.
2. Last measure duration.
In the case of a part with an anacrusis, the first measures and last measure are incomplete:
their combined value is equal to one full measure.
Romantext supports the encoding of an anacrustic initial measure (e.g. m0 b3) but there
is no equivalent way of setting the final measure's duration.
This function shortens the final measure's duration to match that of the score
in the case of a part with anacrusis (no action otherwise).
3. Remove duplicated (redundant) time signatures.
Where analyses have repeat measures, and where those measures have a time signature,
the time signature is repeated leading to duplicates that are redundant.
This is especially common when repeating the first measure.
This function removes those redundant time signatures.
TODO: promote this up to Roman text itself.
:param referencePart: the 'model' part, defining the 'correct' values.
:param partToAdjust: the part to alter according to values in the referencePart.
:return: partToAdjust, altered.
"""
# First and last measure duration
referenceMeasures = referencePart.getElementsByClass('Measure')
adjustMeasures = partToAdjust.getElementsByClass('Measure')
measureDiff = len(referenceMeasures) - len(adjustMeasures)
if measureDiff > 0:
for x in range(measureDiff):
partToAdjust.append(stream.Measure())
# Anacrusis: incomplete first and last measures
refFirst = referenceMeasures[0]
if refFirst.duration != refFirst.barDuration: # i.e. anacrusis
refLast = referenceMeasures[-1]
if refLast.duration != refLast.barDuration:
adjustLast = adjustMeasures.getElementsByClass('Measure')[-1]
adjustLast.splitAtQuarterLength(refLast.duration.quarterLength)
removeDuplicateTimeSigs(partToAdjust)
return partToAdjust
def to_music21(music: "Music") -> Score:
"""Return a Music object as a music21 Score object.
Parameters
----------
music : :class:`muspy.Music`
Music object to convert.
Returns
-------
`music21.stream.Score`
Converted music21 Score object.
"""
# Create a new score
score = Score()
# Metadata
if music.metadata:
score.append(to_music21_metadata(music.metadata))
# Tracks
for track in music.tracks:
# Create a new part
part = Part()
part.partName = track.name
# Add tempos
for tempo in music.tempos:
part.append(to_music21_metronome(tempo))
# Add time signatures
for time_signature in music.time_signatures:
part.append(to_music21_time_signature(time_signature))
# Add key signatures
for key_signature in music.key_signatures:
part.append(to_music21_key(key_signature))
# Add notes to part
for note in track.notes:
m21_note = M21Note(_get_pitch_name(note.pitch))
m21_note.offset = note.time / music.resolution
m21_note.quarterLength = note.duration / music.resolution
part.append(m21_note)
# Append the part to score
score.append(part)
return score
def make_music21_score(
part_names=('violin', 'flute', 'oboe', 'clarinet', 'alto_saxophone',
'trumpet', 'bass', 'percussion'),
title='Title',
composer='Jonathan Marmor',
time_signature=None,
starting_tempo_bpm=60,
starting_tempo_quarter_duration=1.0,
timestamp=None,
):
if not timestamp:
timestamp = datetime.datetime.utcnow()
metadata = Metadata()
metadata.title = title
metadata.composer = composer
metadata.date = timestamp.strftime('%Y/%m/%d')
score = Score()
score.insert(0, metadata)
for part_name in part_names:
instrument_name, instrument_number = parse_part_name(part_name)
instrument = instrument_data[instrument_name]
part = Part()
metronome_mark = MetronomeMark(
number=starting_tempo_bpm,
referent=Duration(starting_tempo_quarter_duration))
part.append(metronome_mark)
if time_signature:
# Should be a string like '12/8'
music21_time_signature = TimeSignature(time_signature)
part.append(music21_time_signature)
m21_instrument = instrument['class']()
m21_instrument.partName = instrument['name']
m21_instrument.partAbbreviation = instrument['abbreviation']
if instrument_number > 1:
m21_instrument.partName = '{} {}'.format(instrument['name'],
instrument_number)
m21_instrument.partAbbreviation = '{} {}'.format(
instrument['abbreviation'], instrument_number)
part.insert(0, m21_instrument)
clef = instrument.get('clef')
if clef:
part.append(clef())
score.insert(0, part)
return score
def part(sequence):
part = Part()
for elem in sequence:
part.append(elem)
return part
def tensors_to_stream(outputs, config, metadata=None):
cur_measure_number = 0
parts = {}
for part_name in outputs.keys():
if part_name == 'extra':
continue
part = Part(id=part_name)
parts[part_name] = part
last_time_signature = None
cur_time_signature = '4/4'
for step in range(outputs['soprano'].shape[0]):
extra = outputs['extra'][step]
if extra[indices_extra['has_time_signature_3/4']].item() == 1:
cur_time_signature = '3/4'
elif extra[indices_extra['has_time_signature_4/4']].item() == 1:
cur_time_signature = '4/4'
elif extra[indices_extra['has_time_signature_3/2']].item() == 1:
cur_time_signature = '3/2'
cur_time_pos = extra[indices_extra['time_pos']].item()
has_fermata = extra[indices_extra['has_fermata']].item() == 1
if cur_time_pos == 1.0 or cur_measure_number == 0:
for part_name, part in parts.items():
part.append(Measure(number=cur_measure_number))
if cur_measure_number == 0:
if part_name in ['soprano', 'alto']:
part[-1].append(clef.TrebleClef())
else:
part[-1].append(clef.BassClef())
key = int(
torch.argmax(
outputs['extra'][0, indices_extra['has_sharps_0']:
indices_extra['has_sharps_11'] +
1],
dim=0).item())
if key >= 6:
key -= 12
part[-1].append(KeySignature(key))
part[-1].append(MetronomeMark(number=90))
cur_measure_number += 1
if last_time_signature is None or cur_time_signature != last_time_signature:
for part in parts.values():
part[-1].append(TimeSignature(cur_time_signature))
last_time_signature = cur_time_signature
for part_name, part in parts.items():
idx = torch.argmax(outputs[part_name][step]).item()
if idx == indices_parts['is_continued']:
try:
last_element = part[-1].flat.notesAndRests[-1]
cur_element = deepcopy(last_element)
if last_element.tie is not None and last_element.tie.type == 'stop':
last_element.tie = Tie('continue')
else:
last_element.tie = Tie('start')
cur_element.tie = Tie('stop')
except IndexError:
logging.debug(
'Warning: "is_continued" on first beat. Replaced by rest.'
)
cur_element = Rest(quarterLength=config.time_grid)
part[-1].append(cur_element)
elif idx == indices_parts['is_rest']:
part[-1].append(Rest(quarterLength=config.time_grid))
else:
pitch = Pitch()
part[-1].append(Note(pitch, quarterLength=config.time_grid))
# Set pitch value AFTER appending to measure in order to avoid unnecessary accidentals
pitch.midi = idx + min_pitches[part_name] - len(indices_parts)
if has_fermata:
for part in parts.values():
fermata = Fermata()
fermata.type = 'upright'
part[-1][-1].expressions.append(fermata)
score = Score()
if metadata is not None:
score.append(Metadata())
score.metadata.title = f"{metadata.title} ({metadata.number})"
score.metadata.composer = f"Melody: {metadata.composer}\nArrangement: BachNet ({datetime.now().year})"
for part in parts.values():
part[-1].rightBarline = 'light-heavy'
score.append(parts['soprano'])
if 'alto' in parts:
score.append(parts['alto'])
score.append(parts['tenor'])
score.append(parts['bass'])
score.stripTies(inPlace=True, retainContainers=True)
return score
key_name = key.step.upper() if key.mode == "major" else key.step.lower()
for note in notes:
if note.part == key.part and note.measure == key.measure:
note.step = Interval(noteStart=Note(Key(key_name).asKey().tonic), noteEnd=note._music21_object).semitones % 12
return notes
if __name__ == "__main__":
"""
How to create Mupix Objects.
"""
from music21.stream import Score, Part, Measure
from music21.key import KeySignature
from music21.note import Note # noqa
s = Score()
p1 = Part(id="part1")
m1 = Measure(number=1)
m1.append(KeySignature(3))
m1.append(Note("C4", type="eighth"))
m2 = Measure(number=2)
m2.append(KeySignature(0))
m2.append(Note("G4", type="eighth"))
p1.append([m1, m2])
s.append([p1])
notes = [NoteObject(item, 1) for item in s.recurse().notes if not item.isChord]
print(notes)
from music21.instrument import fromString as get_instrument
from music21.clef import BassClef
timestamp = datetime.datetime.utcnow()
metadata = Metadata()
metadata.title = 'The Title'
metadata.composer = 'Jonathan Marmor'
metadata.date = timestamp.strftime('%Y/%m/%d')
score = Score()
score.insert(0, metadata)
part = Part()
parts = [part]
oboe = get_instrument('oboe')
part.insert(0, oboe)
score.insert(0, part)
score.insert(0, StaffGroup(parts))
for dur in [[1, .5], [.25], [.25, 2]]:
pitch = Pitch(60)
note = Note(pitch)
duration = Duration()
duration.fill(dur)
note.duration = duration
part.append(note)
score.show('musicxml', '/Applications/Sibelius 7.5.app')
def _setup_parts():
top = Part()
top.append(TimeSignature('4/4'))
bottom = Part()
bottom.append(TimeSignature('4/4'))
return top, bottom