def make_bell_phrase():
phrase = []
for _ in range(3):
phrase.append(scoretools.Measure((6, 4), r"r2. a'2. \laissezVibrer"))
phrase.append(scoretools.Measure((6, 4), 'R1.'))
for _ in range(2):
phrase.append(scoretools.Measure((6, 4), 'R1.'))
return phrase
def p_measure__PIPE__FRACTION__component_list__PIPE(self, p):
r'''measure : PIPE FRACTION component_list PIPE
'''
measure = scoretools.Measure(p[2].pair)
for x in p[3]:
measure.append(x)
p[0] = measure
def add_string_music_to_score(score):
r'''Adds string music to score.
'''
# generate some pitch and rhythm information
pitch_contour_reservoir = \
abjad.demos.part.create_pitch_contour_reservoir()
shadowed_contour_reservoir = \
abjad.demos.part.shadow_pitch_contour_reservoir(
pitch_contour_reservoir)
durated_reservoir = abjad.demos.part.durate_pitch_contour_reservoir(
shadowed_contour_reservoir)
# add six dotted-whole notes and the durated contours to each string voice
for instrument_name, descents in durated_reservoir.items():
instrument_voice = score['%s Voice' % instrument_name]
instrument_voice.extend("R1. R1. R1. R1. R1. R1.")
for descent in descents:
instrument_voice.extend(descent)
# apply instrument-specific edits
abjad.demos.part.edit_first_violin_voice(score, durated_reservoir)
abjad.demos.part.edit_second_violin_voice(score, durated_reservoir)
abjad.demos.part.edit_viola_voice(score, durated_reservoir)
abjad.demos.part.edit_cello_voice(score, durated_reservoir)
abjad.demos.part.edit_bass_voice(score, durated_reservoir)
# chop all string parts into 6/4 measures
strings_staff_group = score['Strings Staff Group']
with systemtools.ForbidUpdate(score):
for voice in iterate(strings_staff_group).by_class(scoretools.Voice):
shards = mutate(voice[:]).split([(6, 4)], cyclic=True)
for shard in shards:
scoretools.Measure((6, 4), shard)
def to_measure(self, cell_duration_denominator=8):
r'''Changes pitch array row to measures.
Sets time signature numerators equal to pitch array row widths and time
signature denominators equal to `cell_duration_denominator`.
.. container:: example
**Example 1.** Changes row to measure:
::
>>> array = pitchtools.PitchArray([
... [1, (2, 1), ([-2, -1.5], 2)],
... [(7, 2), (6, 1), 1]])
::
>>> print(array)
[ ] [d'] [bf bqf ]
[g' ] [fs' ] [ ]
::
>>> measure = array.rows[0].to_measure()
>>> show(measure) # doctest: +SKIP
.. doctest::
>>> print(format(measure))
{
\time 4/8
r8
d'8
<bf bqf>4
}
Returns measure.
'''
from abjad.tools import scoretools
time_signature = indicatortools.TimeSignature(
(self.width, cell_duration_denominator))
measure = scoretools.Measure(time_signature, [])
basic_cell_duration = \
durationtools.Duration(1, cell_duration_denominator)
measure_pitches, measure_durations = [], []
for cell in self.cells:
cell_pitches = cell.pitches
if not cell_pitches:
measure_pitches.append(None)
elif len(cell_pitches) == 1:
measure_pitches.append(cell_pitches[0])
else:
measure_pitches.append(cell_pitches)
measure_duration = cell.width * basic_cell_duration
measure_durations.append(measure_duration)
leaves = scoretools.make_leaves(measure_pitches, measure_durations)
measure.extend(leaves)
return measure
def _notate(
self,
attach_tempos=True,
attack_point_optimizer=None,
grace_handler=None,
):
voice = scoretools.Voice()
# generate the first
q_target_measure = self.items[0]
measure = scoretools.Measure(q_target_measure.time_signature)
for beat in q_target_measure.beats:
measure.extend(beat.q_grid(beat.beatspan))
if attach_tempos:
tempo = copy.copy(q_target_measure.tempo)
attach(tempo, measure)
voice.append(measure)
# generate the rest pairwise, comparing tempi
for q_target_measure_one, q_target_measure_two in \
sequencetools.iterate_sequence_nwise(self.items):
measure = scoretools.Measure(q_target_measure_two.time_signature)
for beat in q_target_measure_two.beats:
measure.extend(beat.q_grid(beat.beatspan))
if (q_target_measure_two.tempo != q_target_measure_one.tempo) \
and attach_tempos:
tempo = copy.copy(q_target_measure_two.tempo)
attach(tempo, measure)
voice.append(measure)
# apply logical ties, pitches, grace containers
self._notate_leaves(
grace_handler=grace_handler,
voice=voice,
)
# partition logical ties in each measure
for measure in voice:
attack_point_optimizer(measure)
return voice
def add_bell_music_to_score(score):
r'''Adds bell music to score.
'''
bell_voice = score['Bell Voice']
def make_bell_phrase():
phrase = []
for _ in range(3):
phrase.append(scoretools.Measure((6, 4), r"r2. a'2. \laissezVibrer"))
phrase.append(scoretools.Measure((6, 4), 'R1.'))
for _ in range(2):
phrase.append(scoretools.Measure((6, 4), 'R1.'))
return phrase
for _ in range(11):
bell_voice.extend(make_bell_phrase())
for _ in range(19):
bell_voice.append(scoretools.Measure((6, 4), 'R1.'))
bell_voice.append(scoretools.Measure((6,4), r"a'1. \laissezVibrer"))
def make_spacer_skip_measures(time_signatures, implicit_scaling=False):
r'''Makes measures with full-measure spacer skips from `time_signatures`.
.. container:: example
::
>>> measures = scoretools.make_spacer_skip_measures(
... [(1, 8), (5, 16), (5, 16)])
>>> staff = Staff(measures)
>>> show(staff) # doctest: +SKIP
.. doctest::
>>> print(format(staff))
\new Staff {
{
\time 1/8
s1 * 1/8
}
{
\time 5/16
s1 * 5/16
}
{
s1 * 5/16
}
}
Returns selection of unincorporated measures.
'''
from abjad.tools import indicatortools
from abjad.tools import scoretools
# make measures
measures = []
for time_signature in time_signatures:
time_signature = indicatortools.TimeSignature(time_signature)
measure = scoretools.Measure(
time_signature,
implicit_scaling=implicit_scaling,
)
measures.append(measure)
scoretools.fill_measures_in_expr_with_full_measure_spacer_skips(measures)
# return measures
measures = selectiontools.Selection(measures)
return measures
def _fuse_measures(self):
from abjad.tools import scoretools
from abjad.tools import selectiontools
# check input
prototype=(scoretools.Measure,)
assert self._all_are_contiguous_components_in_same_parent(
self, prototype)
# return none on empty measures
if len(self) == 0:
return None
# TODO: instantiate a new measure
# instead of returning a reference to existing measure
if len(self) == 1:
return self[0]
implicit_scaling = self[0].implicit_scaling
assert all(
x.implicit_scaling == implicit_scaling for x in self)
selection = selectiontools.SliceSelection(self)
parent, start, stop = selection._get_parent_and_start_stop_indices()
old_denominators = []
new_duration = durationtools.Duration(0)
for measure in self:
effective_time_signature = measure.time_signature
old_denominators.append(effective_time_signature.denominator)
new_duration += effective_time_signature.duration
new_time_signature = \
measure._duration_and_possible_denominators_to_time_signature(
new_duration,
old_denominators,
)
music = []
for measure in self:
# scale before reassignment to prevent logical tie scale drama
signature = measure.time_signature
prolation = signature.implied_prolation
multiplier = prolation / new_time_signature.implied_prolation
measure._scale_contents(multiplier)
measure_music = measure[:]
measure_music._set_parents(None)
music += measure_music
new_measure = scoretools.Measure(new_time_signature, music)
new_measure.implicit_scaling = self[0].implicit_scaling
if parent is not None:
self._give_dominant_spanners([new_measure])
self._set_parents(None)
if parent is not None:
parent.insert(start, new_measure)
return new_measure
def make_desordre_measure(pitches):
'''Makes a measure composed of *Désordre cells*.
`pitches` is a list of lists of number (e.g., [[1, 2, 3], [2, 3, 4]])
The function returns a measure.
'''
for sequence in pitches:
container = abjad.demos.desordre.make_desordre_cell(sequence)
time_signature = inspect_(container).get_duration()
time_signature = mathtools.NonreducedFraction(time_signature)
time_signature = time_signature.with_denominator(8)
measure = scoretools.Measure(time_signature, [container])
return measure
