def post_process_voice_four(voice_four, score):
# print(score['LH_Voice_Four'][-3:])
del voice_four[-6:]
voice_four[-2] = abjad.Chord("cs' fs'", (1, 4))
voice_four[-1] = abjad.Chord("cs' fs'", (3, 4))
abjad.attach(abjad.Tie(), voice_four[-3])
abjad.attach(abjad.Tie(), voice_four[-2])
abjad.attach(abjad.Tie(), voice_four[-1])
voice_four.extend("<cs'~ fs'>8 cs'4 ~ cs'4.")
# voice_four[-5].written_duration = (1, 2)
# del voice_four[-5].note_heads[0]
# del voice_four[-4].note_heads[0]
# del voice_four[-3].note_heads[0]
# del voice_four[-2].note_heads[0]
# voice_four[-3].written_duration = (1, 8)
# voice_four[-2].written_duration = (2, 4)
# del voice_four[-1]
# voice_four[-2].written_duration = (1, 4)
# voice_four[-1].written_duration = (3, 8)
clef_bass = abjad.Clef("bass")
abjad.attach(clef_bass, voice_four[19])
# final_chord = abjad.Chord("c e", (3, 4))
# final_chord.written_pitches = voice_four[-1].written_pitches
# voice_four.append(final_chord)
# abjad.attach(abjad.Fermata(), voice_four[-1])
# REGISTER TRANSPOSITION
abjad.mutate(voice_four).transpose(-12)
return voice_four
def custom_ties(music):
tuplets = abjad.select(music).tuplets()
for tuplet in tuplets:
leaves = abjad.select(tuplet).leaves()
for leaf in leaves:
if not isinstance(leaf, abjad.Rest):
pitch = [leaf.written_pitch]
abjad.mutate(leaf).replace(
abjad.Chord(pitch, leaf.written_duration))
leaves2 = abjad.select(tuplet).leaves()
# print(leaves2)
for leaf1, leaf2 in zip(leaves2, leaves2[1:]):
if isinstance(leaf1, abjad.Chord):
pitch1 = leaf1.written_pitches
pitch2 = leaf2.written_pitches
interval = abjad.NumberedPitch(
pitch2[0]) - abjad.NumberedPitch(pitch1[0])
interval = abs(interval.number)
if interval <= 10 and interval != 0:
leaf2.written_pitches = [pitch1[0], pitch2[0]]
# TIES
selection = abjad.select(music).leaves().logical_ties()
# verify next leave to apply ties correctly
for leave, next_leave in zip(selection, selection[1:]):
if isinstance(leave[-1], abjad.Note) and isinstance(
next_leave[0], abjad.Chord):
# verify if there are same pitches in both leaves
for item in next_leave[0].written_pitches:
if item == leave[-1].written_pitch:
# print("note-chord tie:" + str(leave[-1]))
abjad.attach(abjad.Tie(), leave[-1])
if isinstance(leave[-1], abjad.Note) and isinstance(
next_leave[0], abjad.Note):
if leave[-1].written_pitch == next_leave[0].written_pitch:
# print("note-note tie:" + str(leave[-1]))
abjad.attach(abjad.Tie(), leave[-1])
# if leave is chord
if isinstance(leave[-1], abjad.Chord) and isinstance(
next_leave[0], abjad.Chord):
# verify if there are same pitches in both leaves
if set(leave[-1].written_pitches) & set(
next_leave[0].written_pitches):
# print("chord-chord tie:" + str(leave[-1]))
abjad.attach(abjad.Tie(), leave[-1])
if isinstance(leave[-1], abjad.Chord) and isinstance(
next_leave[0], abjad.Note):
for item in leave[-1].written_pitches:
# print("chord-note tie:" + str(leave[-1]))
if item == next_leave[0].written_pitch:
abjad.attach(abjad.Tie(), leave[-1])
tuplets = abjad.select(music).tuplets()
for tuplet in tuplets:
if tuplet.multiplier == 1:
abjad.mutate(tuplet).extract()
return music
def _set_duration(self, new_duration, repeat_ties=False):
import abjad
new_duration = abjad.Duration(new_duration)
# change LilyPond multiplier if leaf already has LilyPond multiplier
if self._get_indicators(abjad.Multiplier):
abjad.detach(abjad.Multiplier, self)
multiplier = new_duration.__div__(self.written_duration)
abjad.attach(multiplier, self)
return abjad.select(self)
# change written duration if new duration is assignable
try:
self.written_duration = new_duration
return abjad.select(self)
except AssignabilityError:
pass
# make new notes or tuplets if new duration is nonassignable
maker = abjad.NoteMaker(repeat_ties=repeat_ties, )
components = maker(0, new_duration)
if isinstance(components[0], abjad.Leaf):
tied_leaf_count = len(components) - 1
tied_leaves = tied_leaf_count * self
all_leaves = [self] + tied_leaves
for leaf, component in zip(all_leaves, components):
leaf.written_duration = component.written_duration
self._splice(tied_leaves, grow_spanners=True)
parentage = abjad.inspect(self).get_parentage()
if not abjad.inspect(parentage).get_spanners(abjad.Tie):
tie = abjad.Tie()
if tie._attachment_test(self):
tie = abjad.Tie(repeat_ties=repeat_ties, )
abjad.attach(tie, all_leaves)
return abjad.select(all_leaves)
else:
assert isinstance(components[0], abjad.Tuplet)
tuplet = components[0]
components = tuplet[:]
tied_leaf_count = len(components) - 1
tied_leaves = tied_leaf_count * self
all_leaves = [self] + tied_leaves
for leaf, component in zip(all_leaves, components):
leaf.written_duration = component.written_duration
self._splice(tied_leaves, grow_spanners=True)
if not self._get_spanners(abjad.Tie):
tie = abjad.Tie()
if tie._attachment_test(self):
tie = abjad.Tie(repeat_ties=repeat_ties, )
abjad.attach(tie, all_leaves)
multiplier = tuplet.multiplier
tuplet = abjad.Tuplet(multiplier, [])
abjad.mutate(all_leaves).wrap(tuplet)
return abjad.select(tuplet)
def test_quantizationtools_QEventSequence_from_tempo_scaled_leaves_02():
staff = abjad.Staff([])
staff.append(abjad.Note(0, (1, 4)))
staff.append(abjad.Rest((1, 4)))
staff.append(abjad.Rest((1, 8)))
staff.append(abjad.Note(1, (1, 8)))
staff.append(abjad.Note(1, (1, 8)))
staff.append(abjad.Note(2, (1, 8)))
staff.append(abjad.Note(2, (1, 8)))
staff.append(abjad.Note(3, (1, 8)))
staff.append(abjad.Skip((1, 4)))
staff.append(abjad.Rest((1, 4)))
staff.append(abjad.Note(3, (1, 8)))
staff.append(abjad.Chord([0, 1, 4], (1, 4)))
tie = abjad.Tie()
abjad.attach(tie, staff[3:5])
tie = abjad.Tie()
abjad.attach(tie, staff[5:7])
tempo = abjad.MetronomeMark((1, 4), 58)
abjad.attach(tempo, staff[0], context='Staff')
tempo = abjad.MetronomeMark((1, 4), 77)
abjad.attach(tempo, staff[9], context='Staff')
leaves = abjad.select(staff).leaves()
q_events = quantizationtools.QEventSequence.from_tempo_scaled_leaves(
leaves)
assert q_events == quantizationtools.QEventSequence(
(quantizationtools.PitchedQEvent(abjad.Offset(0, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.SilentQEvent(abjad.Offset(30000, 29)),
quantizationtools.PitchedQEvent(abjad.Offset(75000, 29),
(abjad.NamedPitch("cs'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(105000, 29),
(abjad.NamedPitch("d'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(135000, 29),
(abjad.NamedPitch("ef'"), )),
quantizationtools.SilentQEvent(abjad.Offset(150000, 29)),
quantizationtools.PitchedQEvent(abjad.Offset(15600000, 2233),
(abjad.NamedPitch("ef'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(16470000, 2233), (
abjad.NamedPitch("c'"),
abjad.NamedPitch("cs'"),
abjad.NamedPitch("e'"),
)), quantizationtools.TerminalQEvent(abjad.Offset(18210000, 2233))))
def tieitup(held_notes, staff):
#print "tie held {0}".format(held_notes)
# don't think i can tie before i add to staff b/c logical voice contiguity error
# F*****G for now tie is just <yes or no> b/c we can't specify a partial tie
if held_notes:
#print "doing one"
# previous note: last leaf of the previus tuplet
# F*****G hardcoded assumes everything is a tuplet.
# not_first_beat = len(staff[-1])!=0
not_first_beat = len(staff[-1]) != 1
# print not_first_beat
# print len(staff)
# print staff[-1][-1]
# print 'no'
last_prev = staff[-1 if not_first_beat else -2][
-2 if not_first_beat else -1][-1]
# last_prev = staff[-1 if not_first_beat else -2][-1 if not_first_beat else -1][-1]
# print last_prev
# current note: first leaf of the current tuplet
firs_curr = staff[-1][-1][0]
# tie them
abj.attach(abj.Tie(), [last_prev, firs_curr])
def _tie_consecutive_notes_(self, divisions):
import abjad
if not self.tie_consecutive_notes:
return
leaves = list(abjad.iterate(divisions).leaves())
for leaf in leaves:
abjad.detach(abjad.Tie, leaf)
pairs = itertools.groupby(leaves, lambda _: _.__class__)
def _get_pitches(component):
if isinstance(component, abjad.Note):
return component.written_pitch
elif isinstance(component, abjad.Chord):
return component.written_pitches
else:
raise TypeError(component)
for class_, group in pairs:
group = list(group)
if not isinstance(group[0], (abjad.Note, abjad.Chord)):
continue
subpairs = itertools.groupby(group, lambda _: _get_pitches(_))
for pitches, subgroup in subpairs:
subgroup = list(subgroup)
if len(subgroup) == 1:
continue
tie = abjad.Tie()
assert tie._attachment_test_all(subgroup) is True
abjad.attach(tie, abjad.select(subgroup))
def converteToPdf(self, filename):
# this function will use special lib ans converte markuped array to really Notes notation, then it saves it
# as pdf
for note in self.data:
norm, time = self.abj_duration(note[1])
if norm:
if note[0] < 0:
self.notes.append(
abjad.Rest(
abjad.Note(note[0] - BASE_NOTE,
abjad.Duration(time, MIN_NOTE))))
else:
self.notes.append(
abjad.Note(note[0] - BASE_NOTE,
abjad.Duration(time, MIN_NOTE)))
else:
# beg_tie = len(notes)
if note[0] < 0:
for t in time:
self.notes.append(
abjad.Rest(
abjad.Note(note[0] - BASE_NOTE,
abjad.Duration(t, MIN_NOTE))))
# abjad.attach(tie,notes[len(notes)-1])
else:
tie = abjad.Tie()
for t in time:
self.notes.append(
abjad.Note(note[0] - BASE_NOTE,
abjad.Duration(t, MIN_NOTE)))
abjad.attach(tie, self.notes[len(self.notes) - 1])
del tie
abjad.persist(self.notes).as_pdf(''.join([PATH_TO_PDF, filename]))
return filename
def _notate_glissando(name: str) -> None:
staff = abjad.Staff([
abjad.Note("a'", 3 / 16),
abjad.Note("a'", 1 / 16),
abjad.Note("a'", 1 / 8),
abjad.Note("a'", 1 / 8),
])
abjad.attach(
abjad.LilyPondLiteral("#(define afterGraceFraction (cons 15 16))"),
staff[0])
abjad.attach(
abjad.LilyPondLiteral('\\override Flag.stroke-style = #"grace"'),
staff[0],
)
for n in (0, 2):
attachments._GlissandoAttachment._set_glissando_layout(
staff[n + 1], minimum_length=3)
abjad.attach(abjad.AfterGraceContainer([abjad.Note("f'", 1 / 8)]),
staff[n + 1])
abjad.attach(abjad.Tie(), staff[n])
abjad.attach(abjad.StartBeam(), staff[n])
abjad.attach(abjad.StopBeam(), staff[n + 1])
abjad.attach(abjad.GlissandoIndicator(), staff[n + 1])
abjad.attach(lily.mk_no_time_signature(), staff[0])
abjad.attach(abjad.TimeSignature((len(staff), 1)), staff[0])
abjad.attach(abjad.Clef("treble"), staff[0])
sco = abjad.Score([staff])
lily.make_small_example(sco, name, ragged_last=True, ragged_right=True)
def output_n(
self,
n: int,
*,
tie_identical_pitches: bool = False,
) -> abjad.Selection:
r"""Goes through ``n`` iterations of the looping process and outputs a
single |abjad.Selection|.
"""
if not isinstance(n, int):
raise TypeError("first positional argument must be 'int'")
if n < 1:
raise ValueError("first positional argument must be a positive "
"'int'")
if not isinstance(tie_identical_pitches, bool):
raise TypeError("'tie_identical_pitches' must be 'bool'")
dummy_container = abjad.Container()
for _ in range(n):
if not tie_identical_pitches or len(dummy_container) == 0:
dummy_container.append(self.__call__())
else:
new_window = self.__call__()
leaf1 = abjad.select(new_window).leaf(0)
leaf2 = abjad.select(dummy_container).leaf(-1)
if get.leaves_are_tieable((leaf1, leaf2)):
abjad.attach(abjad.Tie(), dummy_container[-1])
dummy_container.append(new_window)
mutate.remove_repeated_time_signatures(dummy_container[:])
mutate.reposition_dynamics(dummy_container[:])
output = dummy_container[:]
dummy_container[:] = []
return output
def output_all(
self,
*,
tie_identical_pitches: bool = False,
) -> abjad.Selection:
r"""Goes through the whole looping process and outputs a single
|abjad.Selection|.
"""
if not isinstance(tie_identical_pitches, bool):
raise TypeError("'tie_identical_pitches' must be 'bool'")
dummy_container = abjad.Container()
while True:
try:
if not tie_identical_pitches or len(dummy_container) == 0:
dummy_container.append(self.__call__())
else:
new_window = self.__call__()
leaf1 = abjad.select(new_window).leaf(0)
leaf2 = abjad.select(dummy_container).leaf(-1)
if get.leaves_are_tieable((leaf1, leaf2)):
abjad.attach(abjad.Tie(), dummy_container[-1])
dummy_container.append(new_window)
except RuntimeError:
break
mutate.remove_repeated_time_signatures(dummy_container[:])
mutate.reposition_dynamics(dummy_container[:])
output = dummy_container[:]
dummy_container[:] = []
return output
def recurse(node, tuplet_duration):
basic_prolated_duration = \
tuplet_duration / node._get_contents_duration()
basic_written_duration = \
basic_prolated_duration.equal_or_greater_power_of_two
tuplet = abjad.Tuplet(1, [])
for child in node.children:
if isinstance(child, type(self)):
tuplet.extend(
recurse(
child, child.preprolated_duration *
basic_written_duration))
else:
leaves = child(basic_written_duration)
tuplet.extend(leaves)
if 1 < len(leaves):
tie = abjad.Tie()
abjad.attach(tie, leaves)
assert tuplet.multiplier == 1, repr(tuplet.multiplier)
contents_duration = abjad.inspect(tuplet).duration()
target_duration = tuplet_duration
multiplier = target_duration / contents_duration
tuplet.multiplier = multiplier
if tuplet.multiplier == 1:
return tuplet[:]
return [tuplet]
def edit_second_violin_voice(score, durated_reservoir):
"""
Edits second violin voice.
"""
voice = score['Second Violin Voice']
descents = durated_reservoir['Second Violin']
last_descent = abjad.Selection(descents[-1])
copied_descent = abjad.mutate(last_descent).copy()
copied_descent = list(copied_descent)
copied_descent[-1].written_duration = abjad.Duration(1, 1)
copied_descent.append(abjad.Note('a2'))
for leaf in copied_descent:
articulation = abjad.Articulation('accent')
abjad.attach(articulation, leaf)
articulation = abjad.Articulation('tenuto')
abjad.attach(articulation, leaf)
voice.extend(copied_descent)
final_sustain = []
for _ in range(32):
final_sustain.append(abjad.Note('a1.'))
final_sustain.append(abjad.Note('a2'))
final_sustain = abjad.Selection(final_sustain)
articulation = abjad.Articulation('accent')
abjad.attach(articulation, final_sustain[0])
articulation = abjad.Articulation('tenuto')
abjad.attach(articulation, final_sustain[0])
voice.extend(final_sustain)
tie = abjad.Tie()
abjad.attach(tie, final_sustain)
voice.extend('r4 r2.')
def test_lilypondparsertools_LilyPondParser__spanners__Tie_01():
target = abjad.Container([abjad.Note(0, 1), abjad.Note(0, 1)])
tie = abjad.Tie()
abjad.attach(tie, target[:])
parser = abjad.lilypondparsertools.LilyPondParser()
result = parser(format(target))
assert format(target) == format(result) and target is not result
def test_quantizationtools_QEventSequence_from_tempo_scaled_leaves_01():
staff = abjad.Staff([])
staff.append(abjad.Note(0, (1, 4)))
staff.append(abjad.Rest((1, 4)))
staff.append(abjad.Rest((1, 8)))
staff.append(abjad.Note(1, (1, 8)))
staff.append(abjad.Note(1, (1, 8)))
staff.append(abjad.Note(2, (1, 8)))
staff.append(abjad.Note(2, (1, 8)))
staff.append(abjad.Note(3, (1, 8)))
staff.append(abjad.Skip((1, 4)))
staff.append(abjad.Rest((1, 4)))
staff.append(abjad.Note(3, (1, 8)))
staff.append(abjad.Chord([0, 1, 4], (1, 4)))
tie = abjad.Tie()
abjad.attach(tie, staff[3:5])
tie = abjad.Tie()
abjad.attach(tie, staff[5:7])
tempo = abjad.MetronomeMark((1, 4), 55)
leaves = abjad.select(staff).leaves()
q_events = quantizationtools.QEventSequence.from_tempo_scaled_leaves(
leaves, tempo)
assert q_events == quantizationtools.QEventSequence(
(quantizationtools.PitchedQEvent(abjad.Offset(0, 1),
(abjad.NamedPitch("c'"), )),
quantizationtools.SilentQEvent(abjad.Offset(12000, 11)),
quantizationtools.PitchedQEvent(abjad.Offset(30000, 11),
(abjad.NamedPitch("cs'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(42000, 11),
(abjad.NamedPitch("d'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(54000, 11),
(abjad.NamedPitch("ef'"), )),
quantizationtools.SilentQEvent(abjad.Offset(60000, 11)),
quantizationtools.PitchedQEvent(abjad.Offset(84000, 11),
(abjad.NamedPitch("ef'"), )),
quantizationtools.PitchedQEvent(abjad.Offset(90000, 11), (
abjad.NamedPitch("c'"),
abjad.NamedPitch("cs'"),
abjad.NamedPitch("e'"),
)), quantizationtools.TerminalQEvent(abjad.Offset(102000, 11))))
def _add_or_remove_notes_to_achieve_written_duration(
self, new_written_duration):
import abjad
new_written_duration = abjad.Duration(new_written_duration)
maker = abjad.NoteMaker()
if new_written_duration.is_assignable:
self[0].written_duration = new_written_duration
for leaf in self[1:]:
parent = leaf._parent
if parent:
index = parent.index(leaf)
del (parent[index])
first = self[0]
for spanner in first._get_spanners(abjad.Tie):
spanner._sever_all_leaves()
#detach(abjad.Tie, first)
elif new_written_duration.has_power_of_two_denominator:
durations = maker(0, [new_written_duration])
for leaf, token in zip(self, durations):
leaf.written_duration = token.written_duration
if len(self) == len(durations):
pass
elif len(durations) < len(self):
for leaf in self[len(durations):]:
parent = leaf._parent
if parent:
index = parent.index(leaf)
del (parent[index])
elif len(self) < len(durations):
for spanner in self[0]._get_spanners(abjad.Tie):
spanner._sever_all_leaves()
#detach(abjad.Tie, self[0])
difference = len(durations) - len(self)
extra_leaves = self[0] * difference
for extra_leaf in extra_leaves:
for spanner in extra_leaf._get_spanners():
spanner._remove(extra_leaf)
extra_tokens = durations[len(self):]
for leaf, token in zip(extra_leaves, extra_tokens):
leaf.written_duration = token.written_duration
ties = self[-1]._get_spanners(abjad.Tie)
if not ties:
tie = abjad.Tie()
if all(tie._attachment_test(_) for _ in self):
abjad.attach(tie, self.leaves)
self[-1]._splice(extra_leaves, grow_spanners=True)
else:
durations = maker(0, new_written_duration)
assert isinstance(durations[0], abjad.Tuplet)
tuplet = durations[0]
logical_tie = tuplet[0]._get_logical_tie()
duration = logical_tie._get_preprolated_duration()
self._add_or_remove_notes_to_achieve_written_duration(duration)
multiplier = tuplet.multiplier
tuplet = abjad.Tuplet(multiplier, [])
abjad.mutate(self.leaves).wrap(tuplet)
return self[0]._get_logical_tie()
def _rewrite_meter_and_tie(self, music, time_signature_pairs):
# I made this separate function because I needed
# to rewrite meter before to attach ties :/
time_signatures = []
for item in time_signature_pairs:
time_signatures.append(abjad.TimeSignature(item))
abjad.mutate(music[:]).split(time_signature_pairs, cyclic=True)
selector = abjad.select(music).leaves()
measures = selector.group_by_measure()
for time, measure in zip(time_signatures, measures):
abjad.mutate(measure).rewrite_meter(time)
# TIES
selection = abjad.select(music).leaves().logical_ties()
# verify next leave to apply ties correctly
for leave, next_leave in zip(selection, selection[1:]):
if isinstance(leave[-1], abjad.Note) and isinstance(
next_leave[0], abjad.Chord):
# verify if there are same pitches in both leaves
for item in next_leave[0].written_pitches:
if item == leave[-1].written_pitch:
# print("note-chord tie:" + str(leave[-1]))
abjad.attach(abjad.Tie(), leave[-1])
if isinstance(leave[-1], abjad.Note) and isinstance(
next_leave[0], abjad.Note):
if leave[-1].written_pitch == next_leave[0].written_pitch:
# print("note-note tie:" + str(leave[-1]))
abjad.attach(abjad.Tie(), leave[-1])
# if leave is chord
if isinstance(leave[-1], abjad.Chord) and isinstance(
next_leave[0], abjad.Chord):
# verify if there are same pitches in both leaves
if set(leave[-1].written_pitches) & set(
next_leave[0].written_pitches):
# print("chord-chord tie:" + str(leave[-1]))
abjad.attach(abjad.Tie(), leave[-1])
if isinstance(leave[-1], abjad.Chord) and isinstance(
next_leave[0], abjad.Note):
for item in leave[-1].written_pitches:
# print("chord-note tie:" + str(leave[-1]))
if item == next_leave[0].written_pitch:
abjad.attach(abjad.Tie(), leave[-1])
return measures
def apply_rhythm(this_notes, spelled_rhythm, rhythm_strings,
notes_with_lily_features):
#print 'notes_with_lily_features {0}'.format(notes_with_lily_features)
lily_features = map(
lambda n: filter(lambda f: f[0] == 'lily', n.features),
notes_with_lily_features)[0] if notes_with_lily_features else []
#print lily_features
lily_features = map(lambda x: x[1], lily_features)
#print lily_features
lily_features = reduce(lambda x, y: x + y,
lily_features) if lily_features else ""
#print 'lily_features {0}'.format(lily_features)
subnotes = []
for (num, base) in spelled_rhythm:
for i in range(num):
# F*****G (efficiency) this all happens for each num. can do it outside just once
# empty => rest
if this_notes == []:
thisone = abj.Rest('r' + rhythm_strings(base) + '\mp')
# one note
elif len(this_notes) == 1:
thisone = abj.Note(
mid_2_lil(this_notes[0].pitch) + rhythm_strings(base) +
lily_features)
# chord
else:
thisone = abj.Chord(
"<" + reduce(lambda x, y: x + " " + y,
[mid_2_lil(n.pitch) for n in this_notes]) +
">" + rhythm_strings(base) + lily_features)
# append to subnotes
subnotes.append(thisone)
# if more than one subnote then tie them all up
# first count how many
# then reach back into subnotes and tie themup
# wait this shouldn't work... meaning it probs doesn't...
how_many = sum([x for (x, y) in spelled_rhythm])
#print how_many
if how_many > 1:
#print "tieing"
abj.attach(abj.Tie(), subnotes[how_many * -1::])
return subnotes
def _rtm_maker(self, divisions, starting_index=0):
rtm = self.rtm[starting_index:starting_index + len(divisions)]
selections = []
for rtm_string, division in zip(rtm, divisions):
selection = self._rhythm_cell(division, rtm_string)
selections.append(selection)
for selection_ in selections[:-1]:
if self.tie_across_divisions is True:
last_leaf = abjad.select(selection_).leaves()[-1]
abjad.attach(abjad.Tie(), last_leaf)
return selections
def test_scoretools_Selection__attach_tie_spanner_to_leaf_pair_02():
r'''Span left leaf with spanner and right leaf with spanner.
'''
voice = abjad.Voice("c'8 c'8 c'8 c'8")
tie = abjad.Tie()
abjad.attach(tie, voice[:2])
tie = abjad.Tie()
abjad.attach(tie, voice[2:])
assert format(voice) == abjad.String.normalize(r'''
\new Voice
{
c'8
~
c'8
c'8
~
c'8
}
''')
selector = abjad.select().leaves()
leaves = selector(voice)
leaves[1:3]._attach_tie_spanner_to_leaf_pair()
assert format(voice) == abjad.String.normalize(r'''
\new Voice
{
c'8
~
c'8
~
c'8
~
c'8
}
''')
assert abjad.inspect(voice).is_well_formed()
def edit_first_violin_voice(score, durated_reservoir):
"""
Edits first violin voice.
"""
voice = score['First Violin Voice']
descents = durated_reservoir['First Violin']
last_descent = abjad.Selection(descents[-1])
copied_descent = abjad.mutate(last_descent).copy()
voice.extend(copied_descent)
final_sustain_rhythm = [(6, 4)] * 43 + [(1, 2)]
maker = abjad.NoteMaker()
final_sustain_notes = maker(["c'"], final_sustain_rhythm)
voice.extend(final_sustain_notes)
tie = abjad.Tie()
abjad.attach(tie, final_sustain_notes)
voice.extend('r4 r2.')
def test_scoretools_Leaf__split_by_durations_12():
r'''Lone spanned leaf results in two spanned leaves.
'''
staff = abjad.Staff([abjad.Note("c'4")])
tie = abjad.Tie()
abjad.attach(tie, staff[:])
halves = staff[0]._split_by_durations([abjad.Duration(1, 8)])
assert len(staff) == 2
for leaf in staff[:]:
assert abjad.inspect(leaf).get_spanners() == [tie]
prototype = (abjad.Tie, )
assert abjad.inspect(leaf).get_spanner(prototype) is tie
assert abjad.inspect(staff).is_well_formed()
def _notate_leaves(
self,
grace_handler=None,
voice=None,
):
import abjad
for leaf in abjad.iterate(voice).leaves():
if leaf._has_indicator(dict):
annotation = leaf._get_indicator(dict)
q_events = annotation['q_events']
pitches, grace_container = grace_handler(q_events)
if not pitches:
new_leaf = abjad.Rest(leaf)
elif 1 < len(pitches):
new_leaf = abjad.Chord(leaf)
new_leaf.written_pitches = pitches
else:
new_leaf = abjad.Note(leaf)
new_leaf.written_pitch = pitches[0]
if grace_container:
abjad.attach(grace_container, new_leaf)
tie = abjad.Tie()
if tie._attachment_test(new_leaf):
abjad.attach(tie, abjad.select(new_leaf))
abjad.mutate(leaf).replace(new_leaf)
else:
previous_leaf = leaf._get_leaf(-1)
if isinstance(previous_leaf, abjad.Rest):
new_leaf = type(previous_leaf)(leaf.written_duration, )
elif isinstance(previous_leaf, abjad.Note):
new_leaf = type(previous_leaf)(
previous_leaf.written_pitch,
leaf.written_duration,
)
else:
new_leaf = type(previous_leaf)(
previous_leaf.written_pitch,
leaf.written_duration,
)
abjad.mutate(leaf).replace(new_leaf)
tie = abjad.inspect(previous_leaf).get_spanner(abjad.Tie)
if tie is not None:
tie._append(new_leaf)
if leaf._has_indicator(abjad.MetronomeMark):
tempo = leaf._get_indicator(abjad.MetronomeMark)
abjad.detach(indicatortools.MetronomeMark, leaf)
abjad.attach(tempo, new_leaf)
def _tie_across_divisions_(self, divisions):
import abjad
if not self.tie_across_divisions:
return
if self.strip_ties:
return
if self.tie_consecutive_notes:
return
length = len(divisions)
tie_across_divisions = self.tie_across_divisions
if isinstance(tie_across_divisions, bool):
tie_across_divisions = [tie_across_divisions]
if not isinstance(tie_across_divisions, abjad.Pattern):
tie_across_divisions = abjad.Pattern.from_vector(
tie_across_divisions)
pairs = abjad.sequence(divisions).nwise()
rest_prototype = (abjad.Rest, abjad.MultimeasureRest)
for i, pair in enumerate(pairs):
if not tie_across_divisions.matches_index(i, length):
continue
division_one, division_two = pair
leaf_one = next(abjad.iterate(division_one).leaves(reverse=True))
leaf_two = next(abjad.iterate(division_two).leaves())
leaves = [leaf_one, leaf_two]
if isinstance(leaf_one, rest_prototype):
continue
if isinstance(leaf_two, rest_prototype):
continue
pitched_prototype = (abjad.Note, abjad.Chord)
if not all(isinstance(_, pitched_prototype) for _ in leaves):
continue
logical_tie_one = abjad.inspect(leaf_one).get_logical_tie()
logical_tie_two = abjad.inspect(leaf_two).get_logical_tie()
if logical_tie_one == logical_tie_two:
continue
combined_logical_tie = logical_tie_one + logical_tie_two
for leaf in combined_logical_tie:
abjad.detach(abjad.Tie, leaf)
tie = abjad.Tie(repeat=self.repeat_ties)
tie._unconstrain_contiguity()
if tie._attachment_test_all(combined_logical_tie) is True:
try:
abjad.attach(tie, combined_logical_tie)
except:
raise Exception(tie, combined_logical_tie)
tie._constrain_contiguity()
def test_scoretools_Leaf__set_duration_02():
r'''Change tied leaf to tied value.
Duplicate ties are not created.
'''
voice = abjad.Voice("c'8 c'8 c'8 c'8")
tie = abjad.Tie()
abjad.attach(tie, voice[:2])
beam = abjad.Beam()
abjad.attach(beam, voice[:2])
assert format(voice) == abjad.String.normalize(
r'''
\new Voice
{
c'8
~
[
c'8
]
c'8
c'8
}
'''
)
voice[1]._set_duration(abjad.Duration(5, 32))
assert format(voice) == abjad.String.normalize(
r'''
\new Voice
{
c'8
~
[
c'8
~
c'32
]
c'8
c'8
}
'''
)
assert abjad.inspect(voice).is_well_formed()
def _make_music(self, divisions):
import abjad
from abjad.tools import rhythmmakertools
selections = []
duration_specifier = self._get_duration_specifier()
tie_specifier = self._get_tie_specifier()
tuplet_specifier = self._get_tuplet_specifier()
leaf_maker = abjad.LeafMaker(
decrease_monotonic=duration_specifier.decrease_monotonic,
forbidden_duration=duration_specifier.forbidden_duration,
diminution=tuplet_specifier.diminution,
repeat_ties=tie_specifier.repeat_ties,
)
for division in divisions:
if (duration_specifier.spell_metrically is True
or (duration_specifier.spell_metrically == 'unassignable'
and not abjad.mathtools.is_assignable_integer(
division.numerator))):
meter = abjad.Meter(division)
rhythm_tree_container = meter.root_node
durations = [_.duration for _ in rhythm_tree_container]
elif isinstance(duration_specifier.spell_metrically,
rhythmmakertools.PartitionTable):
partition_table = duration_specifier.spell_metrically
durations = partition_table.respell_division(division)
else:
durations = [division]
selection = leaf_maker(pitches=0, durations=durations)
if (1 < len(selection)
and not selection[0]._has_spanner(abjad.Tie)):
tie = abjad.Tie(repeat=tie_specifier.repeat_ties)
abjad.attach(tie, selection[:])
selections.append(selection)
selections = self._apply_burnish_specifier(selections)
beam_specifier = self._get_beam_specifier()
beam_specifier(selections)
selections = self._apply_division_masks(selections)
if duration_specifier.rewrite_meter:
selections = duration_specifier._rewrite_meter_(
selections,
divisions,
repeat_ties=tie_specifier.repeat_ties,
)
return selections
def test_scoretools_Leaf__split_by_durations_14():
r'''Returns three leaves with two tied.
Spanner is shared by all 3 leaves.
'''
staff = abjad.Staff([abjad.Note("c'4")])
tie = abjad.Tie()
abjad.attach(tie, staff[:])
halves = staff[0]._split_by_durations([abjad.Duration(5, 32)])
assert len(halves) == 2
assert len(halves[0]) == 2
assert len(halves[1]) == 1
for l in staff:
assert abjad.inspect(l).get_spanners() == [tie]
assert abjad.inspect(l).get_spanner(abjad.Tie) is tie
assert abjad.inspect(staff).is_well_formed()
def convert_abjad_pitches_and_mu_rhythms2abjad_notes(
self, harmonies: list, delays: list, grid) -> list:
leading_pulses = grid.leading_pulses
absolute_leading_pulses = tuple(
itertools.accumulate([0] + list(leading_pulses)))
converted_delays = grid.apply_delay(delays)
absolute_delays = tuple(
itertools.accumulate([0] + list(converted_delays)))
# 1. generate notes
notes = abjad.Measure(abjad.TimeSignature(grid.absolute_meter), [])
resulting_durations = []
for harmony, delay, start, end in zip(harmonies, converted_delays,
absolute_delays,
absolute_delays[1:]):
subnotes = abjad.Voice()
seperated_by_grid = Instrument.seperate_by_grid(
delay, start, end, absolute_leading_pulses, leading_pulses,
grid)
assert sum(seperated_by_grid) == delay
for d in seperated_by_grid:
seperated_by_assignable = Instrument.seperate_by_assignablity(
d, grid)
assert sum(seperated_by_assignable) == d
for assignable in seperated_by_assignable:
resulting_durations.append(assignable)
if harmony:
chord = abjad.Chord(harmony,
abjad.Duration(assignable))
else:
chord = abjad.Rest(abjad.Duration(assignable))
subnotes.append(chord)
if len(subnotes) > 1 and len(harmony) > 0:
abjad.attach(abjad.Tie(), subnotes[:])
notes.extend(subnotes)
assert sum(resulting_durations) == sum(converted_delays)
voice = Instrument.mk_voice(notes)
# 2. apply beams
voice = Instrument.apply_beams(voice, resulting_durations,
absolute_leading_pulses)
return voice
def edit_viola_voice(score, durated_reservoir):
r'''Edits viola voice.
'''
voice = score['Viola Voice']
descents = durated_reservoir['Viola']
for leaf in descents[-1]:
articulation = abjad.Articulation('accent')
abjad.attach(articulation, leaf)
articulation = abjad.Articulation('tenuto')
abjad.attach(articulation, leaf)
last_descent = abjad.Selection(descents[-1])
copied_descent = abjad.mutate(last_descent).copy()
for leaf in copied_descent:
if leaf.written_duration == abjad.Duration(4, 4):
leaf.written_duration = abjad.Duration(8, 4)
else:
leaf.written_duration = abjad.Duration(4, 4)
voice.extend(copied_descent)
bridge = abjad.Note('e1')
articulation = abjad.Articulation('tenuto')
abjad.attach(articulation, bridge)
articulation = abjad.Articulation('accent')
abjad.attach(articulation, bridge)
voice.append(bridge)
final_sustain_rhythm = [(6, 4)] * 21 + [(1, 2)]
maker = abjad.NoteMaker()
final_sustain_notes = maker(['e'], final_sustain_rhythm)
articulation = abjad.Articulation('accent')
abjad.attach(articulation, final_sustain_notes[0])
articulation = abjad.Articulation('tenuto')
abjad.attach(articulation, final_sustain_notes[0])
voice.extend(final_sustain_notes)
tie = abjad.Tie()
abjad.attach(tie, final_sustain_notes)
voice.extend('r4 r2.')
def _apply_spanners(self, leaves):
import abjad
spanner_references = {
abjad.Beam: None,
abjad.Slur: None,
}
first_leaf = leaves[0]
pairs = abjad.sequence(leaves).nwise(wrapped=True)
for leaf, next_leaf in pairs:
span_events = self._get_span_events(leaf)
for current_class, directions in span_events.items():
starting, stopping = [], []
for direction in directions:
if direction is Left:
starting.append(Left)
else:
stopping.append(Right)
# apply undirected events immediately,
# and do not maintain a reference to them
if current_class is abjad.Tie:
if next_leaf is first_leaf:
message = 'unterminated {} at {}.'
message = message.format(current_class.__name__, leaf)
raise Exception(message)
previous_tie = [
x for x in leaf._get_spanners()
if isinstance(x, abjad.Tie)
]
if previous_tie:
previous_tie[0]._append(next_leaf)
else:
tie = abjad.Tie()
selection = abjad.select([leaf, next_leaf])
attach(tie, selection)
elif current_class is abjad.Beam:
# A beam may begin and end on the same leaf
# but only one beam spanner may cover any given leaf,
# and starting events are processed before ending ones
for _ in starting:
if spanner_references[current_class] is not None:
message = 'already have beam.'
raise Exception(message)
else:
spanner_references[current_class] = current_class()
for _ in stopping:
if spanner_references[current_class] is not None:
spanner_references[current_class]._append(leaf)
spanner_references[current_class] = None
elif current_class is spanners.Slur:
# Slurs process stop events before start events,
# they must contain more than one leaf,
# but they can stop on a leaf and start on the same leaf.
for _ in stopping:
if spanner_references[current_class] is not None:
spanner_references[current_class]._append(leaf)
spanner_references[current_class] = None
else:
message = 'can not end: {}.'
message = message.format(current_class.__name)
raise Exception(message)
for _ in starting:
if spanner_references[current_class] is None:
spanner_references[current_class] = current_class()
else:
message = 'already have: {}.'
message = message.format(current_class.__name)
raise Exception(message)
# append leaf to all tracked spanners,
for current_class, instance in spanner_references.items():
if instance is not None:
instance._append(leaf)
# check for unterminated spanners
for current_class, instance in spanner_references.items():
if instance is not None:
message = 'unterminated {}.'
message = message.format(current_class.__name__)
raise Exception(message)
def _notate_music(
self,
dummy_container: abjad.Container,
start: int,
end: int,
) -> None:
r'Handles the notation aspects of the looping window.'
window_size = self._window_size
# passing on indicators from the head of an initial splitted leaf
for index in range(start - 1, -1, -1):
if abjad.inspect(dummy_container[index]).indicator(abjad.Tie):
inspect_contents = abjad.inspect(dummy_container[index - 1])
if index == 0 or not inspect_contents.indicator(abjad.Tie):
inspect_contents = abjad.inspect(dummy_container[index])
for indicator in inspect_contents.indicators():
inspector = abjad.inspect(dummy_container[start])
if (not isinstance(indicator,
(abjad.TimeSignature, abjad.Tie))
and
inspector.indicator(type(indicator)) is None):
abjad.attach(indicator, dummy_container[start])
# removing ties generated by the split mutation
abjad.detach(abjad.Tie(), dummy_container[start - 1])
abjad.detach(abjad.Tie(), dummy_container[end - 1])
# handling initial dynamics and slurs
start_head = abjad.select(dummy_container[start:]).logical_tie(0)[0]
start_tail = abjad.select(dummy_container[start:]).logical_tie(0)[-1]
if (abjad.inspect(start_head).indicator(abjad.StartSlur) is None and
abjad.inspect(start_tail).indicator(abjad.StopSlur) is None):
for leaf in dummy_container[start - 1::-1].leaves():
if abjad.inspect(leaf).indicator(abjad.StartSlur) is not None:
abjad.attach(abjad.StartSlur(), start_head)
break
elif abjad.inspect(leaf).indicator(abjad.StopSlur) is not None:
break
if (abjad.inspect(start_head).indicator(abjad.Dynamic) is None
and not isinstance(start_head, (
abjad.Rest,
abjad.MultimeasureRest,
))):
for leaf in dummy_container[start - 1::-1].leaves():
dynamic = abjad.inspect(leaf).indicator(abjad.Dynamic)
if dynamic is not None:
abjad.attach(dynamic, start_head)
break
# appending rests if necessary
contents_dur = abjad.inspect(dummy_container[start:end]).duration()
if contents_dur < window_size.duration:
missing_dur = window_size.duration - contents_dur
rests = abjad.LeafMaker()(None, missing_dur)
dummy_container.extend(rests)
end += len(rests)
# transforming abjad.Selection -> abjad.Container for rewrite_meter
dummy_container = abjad.Container(
abjad.mutate(dummy_container[start:end]).copy())
# rewriting meter
if not self._disable_rewrite_meter:
mutate(dummy_container).auto_rewrite_meter(
meter_list=[abjad.TimeSignature(window_size)],
boundary_depth=self._boundary_depth,
maximum_dot_count=self._maximum_dot_count,
rewrite_tuplets=self._rewrite_tuplets,
prettify_rewrite_meter=self._prettify_rewrite_meter,
extract_trivial_tuplets=self._extract_trivial_tuplets,
fuse_across_groups_of_beats=self._fuse_across_groups_of_beats,
fuse_quadruple_meter=self._fuse_quadruple_meter,
fuse_triple_meter=self._fuse_triple_meter,
)
abjad.attach(
abjad.TimeSignature(window_size),
abjad.select(dummy_container).leaf(0),
)
mutate(dummy_container[:]).reposition_dynamics()
mutate(dummy_container[:]).reposition_slurs()
self._current_window = dummy_container[:]
dummy_container[:] = []
