def make_desordre_lilypond_file(score):
"""
Makes Désordre LilyPond file.
"""
lilypond_file = abjad.LilyPondFile.new(music=score,
default_paper_size=("a4", "letter"),
global_staff_size=14)
lilypond_file.layout_block.indent = 0
lilypond_file.layout_block.ragged_right = True
lilypond_file.layout_block.merge_differently_dotted = True
lilypond_file.layout_block.merge_differently_headed = True
context_block = abjad.ContextBlock(source_lilypond_type="Score")
lilypond_file.layout_block.items.append(context_block)
context_block.remove_commands.append("Bar_number_engraver")
context_block.remove_commands.append("Default_bar_line_engraver")
context_block.remove_commands.append("Timing_translator")
abjad.override(context_block).beam.breakable = True
abjad.override(context_block).glissando.breakable = True
abjad.override(context_block).note_column.ignore_collision = True
abjad.override(context_block).spacing_spanner.uniform_stretching = True
abjad.override(context_block).text_script.staff_padding = 4
abjad.override(context_block).text_spanner.breakable = True
abjad.override(context_block).tuplet_bracket.bracket_visibility = True
abjad.override(context_block).tuplet_bracket.minimum_length = 3
abjad.override(context_block).tuplet_bracket.padding = 2
scheme = abjad.Scheme("ly:spanner::set-spacing-rods")
abjad.override(context_block).tuplet_bracket.springs_and_rods = scheme
scheme = abjad.Scheme("tuplet-number::calc-fraction-text")
abjad.override(context_block).tuplet_number.text = scheme
abjad.setting(context_block).autoBeaming = False
moment = abjad.SchemeMoment((1, 12))
abjad.setting(context_block).proportionalNotationDuration = moment
abjad.setting(context_block).tupletFullLength = True
context_block = abjad.ContextBlock(source_lilypond_type="Staff")
lilypond_file.layout_block.items.append(context_block)
# LilyPond CAUTION: Timing_translator must appear
# before Default_bar_line_engraver!
context_block.consists_commands.append("Timing_translator")
context_block.consists_commands.append("Default_bar_line_engraver")
scheme = abjad.Scheme("'numbered")
abjad.override(context_block).time_signature.style = scheme
context_block = abjad.ContextBlock(source_lilypond_type="RhythmicStaff")
lilypond_file.layout_block.items.append(context_block)
# LilyPond CAUTION: Timing_translator must appear
# before Default_bar_line_engraver!
context_block.consists_commands.append("Timing_translator")
context_block.consists_commands.append("Default_bar_line_engraver")
scheme = abjad.Scheme("'numbered")
abjad.override(context_block).time_signature.style = scheme
pair = (-2, 4)
abjad.override(context_block).vertical_axis_group.minimum_Y_extent = pair
context_block = abjad.ContextBlock(source_lilypond_type="Voice")
lilypond_file.layout_block.items.append(context_block)
context_block.remove_commands.append("Forbid_line_break_engraver")
return lilypond_file
def make_sketch_lilypond_file(component):
abjad.override(component).bar_line.stencil = False
abjad.override(component).bar_number.stencil = False
abjad.override(component).beam.positions = abjad.SchemePair((4, 4))
abjad.override(component).spacing_spanner.strict_grace_spacing = True
abjad.override(component).spacing_spanner.strict_note_spacing = True
abjad.override(component).spacing_spanner.uniform_stretching = True
abjad.override(component).stem.length = 8.25
abjad.override(component).text_script.outside_staff_padding = 1
abjad.override(component).time_signature.stencil = False
abjad.override(component).tuplet_bracket.bracket_visibility = True
abjad.override(component).tuplet_bracket.minimum_length = 3
abjad.override(component).tuplet_bracket.outside_staff_padding = 1.5
abjad.override(component).tuplet_bracket.padding = 1.5
abjad.override(component).tuplet_bracket.springs_and_rods = \
abjad.Scheme('ly:spanner::set-spacing-rods', verbatim=True)
abjad.override(component).tuplet_bracket.staff_padding = 2.25
abjad.override(component).tuplet_number.text = \
abjad.Scheme('tuplet-number::calc-fraction-text', verbatim=True)
abjad.setting(component).proportional_notation_duration = \
abjad.SchemeMoment((1, 24))
abjad.setting(component).tuplet_full_length = True
lilypond_file = abjad.LilyPondFile.new(component)
lilypond_file.layout_block.indent = 0
lilypond_file.paper_block.system_system_spacing = abjad.Scheme(
"#'((basic-distance . 28)(minimum-distance . 1)(padding . 4)(stretchability . 1))",
verbatim=True)
return lilypond_file
def _make_markup_score_block(selection):
import abjad
selection = copy.deepcopy(selection)
staff = abjad.Staff(selection)
staff.lilypond_type = 'RhythmicStaff'
staff.remove_commands.append('Time_signature_engraver')
staff.remove_commands.append('Staff_symbol_engraver')
abjad.override(staff).stem.direction = abjad.Up
abjad.override(staff).stem.length = 5
abjad.override(staff).tuplet_bracket.bracket_visibility = True
abjad.override(staff).tuplet_bracket.direction = abjad.Up
abjad.override(staff).tuplet_bracket.minimum_length = 4
abjad.override(staff).tuplet_bracket.padding = 1.25
abjad.override(staff).tuplet_bracket.shorten_pair = (-1, -1.5)
scheme = abjad.Scheme('ly:spanner::set-spacing-rods')
abjad.override(staff).tuplet_bracket.springs_and_rods = scheme
abjad.override(staff).tuplet_number.font_size = 0
scheme = abjad.Scheme('tuplet-number::calc-fraction-text')
abjad.override(staff).tuplet_number.text = scheme
abjad.setting(staff).tuplet_full_length = True
layout_block = abjad.Block(name='layout')
layout_block.indent = 0
layout_block.ragged_right = True
score = abjad.Score([staff])
abjad.override(score).spacing_spanner.spacing_increment = 0.5
abjad.setting(score).proportional_notation_duration = False
return score, layout_block
def format_lilypond_value(argument):
r'''Formats LilyPond `argument` according to Scheme formatting
conventions.
Returns string.
'''
import abjad
if '_get_lilypond_format' in dir(argument) and not isinstance(argument, str):
pass
elif argument in (True, False):
argument = abjad.Scheme(argument)
elif argument in (
abjad.Up, abjad.Down, abjad.Left, abjad.Right, abjad.Center):
argument = abjad.Scheme(repr(argument).lower())
elif isinstance(argument, int) or isinstance(argument, float):
argument = abjad.Scheme(argument)
elif argument in LilyPondFormatManager.lilypond_color_constants:
argument = abjad.Scheme(argument)
elif isinstance(argument, str) and '::' in argument:
argument = abjad.Scheme(argument)
elif isinstance(argument, tuple) and len(argument) == 2:
argument = abjad.SchemePair(argument)
elif isinstance(argument, str) and ' ' not in argument:
argument = abjad.Scheme(argument, quoting="'")
elif isinstance(argument, str) and ' ' in argument:
argument = abjad.Scheme(argument)
else:
argument = abjad.Scheme(argument, quoting="'")
return format(argument, 'lilypond')
def _construct_fingering_tablature(
self,
logical_tie,
fingering,
previous_fingering
):
# create 'chords' at particular staff positions
staff_positions = [4, 7, 11, 14]
if self._hand == 'left':
staff_positions.append(17)
finger_names = ['thumb', 'index', 'middle', 'ring', 'pinky']
finger_names.reverse()
for i, leaf in enumerate(logical_tie):
chord = abjad.Chord(staff_positions, leaf.written_duration)
abjad.mutate(leaf).replace(chord)
if i == 0:
# first leaf
for j, note_head in enumerate(chord.note_heads):
finger_name = finger_names[j]
current_keys = None
if finger_name in fingering.keys.keys():
current_keys = fingering.keys[finger_name]
previous_keys = None
if previous_fingering is not None:
previous_keys = previous_fingering.keys[finger_name]
if current_keys is not None:
# continuation: hide note head
if previous_keys == current_keys:
note_head.tweak.stencil = \
abjad.Scheme('point-stencil')
# new left_hand: set note head to markup
else:
markup = self._make_note_head_markup(current_keys)
if markup is not None:
note_head.tweak.stencil = \
'ly:text-interface::print'
note_head.tweak.text = markup
else:
note_head.tweak.stencil = abjad.Scheme('point-stencil')
else:
# non-first leaf
for note_head in chord.note_heads:
note_head.tweak.stencil = abjad.Scheme('point-stencil')
def test_LilyPondGrobNameManager___setattr___03():
"""
Override LilyPond BarNumber grob.
"""
score = abjad.Score([abjad.Staff("c'8 d'8 e'8 f'8 g'8 a'8 b'8 c''8")])
abjad.override(score).bar_number.break_visibility = abjad.Scheme(
"end-of-line-invisible")
assert format(score) == abjad.String.normalize(r"""
\new Score
\with
{
\override BarNumber.break-visibility = #end-of-line-invisible
}
<<
\new Staff
{
c'8
d'8
e'8
f'8
g'8
a'8
b'8
c''8
}
>>
""")
assert abjad.inspect(score).wellformed()
def _make_bow_contact_point_overrides(
self,
bow_contact_point=None,
bundle=None,
):
import abjad
if bow_contact_point is None:
return
override_ = abjad.LilyPondGrobOverride(
grob_name='NoteHead',
once=True,
property_path='stencil',
value=abjad.Scheme('ly:text-interface::print'),
)
string = override_.override_string
bundle.grob_overrides.append(string)
override_ = abjad.LilyPondGrobOverride(
grob_name='NoteHead',
once=True,
property_path='text',
value=bow_contact_point.markup,
)
string = override_.override_string
bundle.grob_overrides.append(string)
y_offset = float((4 * bow_contact_point.contact_point) - 2)
override_ = abjad.LilyPondGrobOverride(
grob_name='NoteHead',
once=True,
property_path='Y-offset',
value=y_offset,
)
string = override_.override_string
bundle.grob_overrides.append(string)
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___03():
r'''Override LilyPond BarNumber grob.
'''
score = abjad.Score([abjad.Staff("c'8 d'8 e'8 f'8 g'8 a'8 b'8 c''8")])
abjad.override(score).bar_number.break_visibility = \
abjad.Scheme('end-of-line-invisible')
assert format(score) == abjad.String.normalize(r'''
\new Score
\with
{
\override BarNumber.break-visibility = #end-of-line-invisible
}
<<
\new Staff
{
c'8
d'8
e'8
f'8
g'8
a'8
b'8
c''8
}
>>
''')
assert abjad.inspect(score).is_well_formed()
def configure_score(score):
"""
Configures score.
"""
# configure bell staff
bell_staff = score["Bell Staff"]
leaf = abjad.inspect(bell_staff).leaf(0)
clef = abjad.Clef("treble")
abjad.attach(clef, leaf)
bells = abjad.Instrument(name="Campana in La",
short_name="Camp.",
pitch_range="[C4, C6]")
abjad.attach(bells, leaf)
mark = abjad.MetronomeMark((1, 4), (112, 120))
abjad.attach(mark, leaf)
# time_signature = abjad.TimeSignature((6, 4))
# abjad.attach(time_signature, leaf)
# configure first violin staff
first_violin_staff = score["First Violin Staff"]
leaf = abjad.inspect(first_violin_staff).leaf(0)
clef = abjad.Clef("treble")
abjad.attach(clef, leaf)
violin = abjad.Violin(markup=abjad.Markup("Violin I"),
short_markup=abjad.Markup("Vl. I"))
abjad.attach(violin, leaf)
# configure second violin staff
second_violin_staff = score["Second Violin Staff"]
leaf = abjad.inspect(second_violin_staff).leaf(0)
clef = abjad.Clef("treble")
abjad.attach(clef, leaf)
violin = abjad.Violin(markup=abjad.Markup("Violin II"),
short_markup=abjad.Markup("Vl. II"))
abjad.attach(violin, leaf)
# configure viola staff
leaf = abjad.inspect(score["Viola Staff"]).leaf(0)
clef = abjad.Clef("alto")
abjad.attach(clef, leaf)
viola = abjad.Viola()
abjad.attach(viola, leaf)
# configure cello staff
leaf = abjad.inspect(score["Cello Staff"]).leaf(0)
clef = abjad.Clef("bass")
abjad.attach(clef, leaf)
cello = abjad.Cello()
abjad.attach(cello, leaf)
# configure bass staff
leaf = abjad.inspect(score["Bass Staff"]).leaf(0)
clef = abjad.Clef("bass")
abjad.attach(clef, leaf)
contrabass = abjad.Contrabass(short_markup=abjad.Markup("Cb."))
abjad.attach(contrabass, leaf)
# configure score
vector = abjad.SpacingVector(0, 0, 8, 0)
abjad.override(score).vertical_axis_group.staff_staff_spacing = vector
abjad.override(score).staff_grouper.staff_staff_spacing = vector
abjad.override(score).staff_symbol.thickness = 0.5
scheme = abjad.Scheme("format-mark-box-numbers")
abjad.setting(score).mark_formatter = scheme
def _configure_rehearsal_mark(self):
mark_num = self.rehearsal_mark
voices = self._music_voices
for voice in voices:
leaf = abjad.inspect(voice).leaf(0)
abjad.attach(abjad.RehearsalMark(number=mark_num), leaf)
scheme = abjad.Scheme('format-mark-box-alphabet')
score = self._score
abjad.setting(score).markFormatter = scheme
def _handle_dynamics(self):
voice = self._score[f"{self.instrument_name}_Music_Voice"]
leaves = abjad.select(voice).leaves()
if not leaves:
return
music_durations = [abjad.inspect(_).duration() for _ in leaves]
maker = rmakers.multiplied_duration(abjad.Skip)
dynamics_skips = maker(music_durations)
dynamics_voice = self._score[f"{self.instrument_name}_Dynamics_Voice"]
dynamics_voice.extend(dynamics_skips)
for expression in self.dynamics:
index = expression[0]
string = expression[1]
leaf = dynamics_voice[index]
if string in ("<", ">"):
indicator = abjad.LilyPondLiteral("\\" + string, "after")
elif string == "-|":
indicator = abjad.LilyPondLiteral(r"\<", "after")
stencil = abjad.Scheme("constante-hairpin")
abjad.override(leaf).hairpin.stencil = stencil
elif string == "<!":
indicator = abjad.LilyPondLiteral(r"\<", "after")
stencil = abjad.Scheme("abjad-flared-hairpin")
abjad.override(leaf).hairpin.stencil = stencil
elif string == "!>":
indicator = abjad.LilyPondLiteral(r"\>", "after")
stencil = abjad.Scheme("abjad-flared-hairpin")
abjad.override(leaf).hairpin.stencil = stencil
else:
indicator = abjad.Dynamic(string)
abjad.attach(indicator, leaf)
if len(expression) == 3:
staff_padding = expression[2]
string = r"\override DynamicLineSpanner.staff-padding ="
string += f" {staff_padding}"
command = abjad.LilyPondLiteral(string)
abjad.attach(command, leaf)
last_leaf = dynamics_voice[-1]
prototype = abjad.LilyPondLiteral
if not abjad.inspect(last_leaf).has_indicator(prototype):
if not abjad.inspect(last_leaf).has_indicator(abjad.Dynamic):
indicator = abjad.LilyPondLiteral(r"\!", "after")
abjad.attach(indicator, last_leaf)
def _get_lilypond_format_bundle(self, leaf):
import abjad
bundle = abjad.LilyPondFormatBundle()
if len(self) == 1 and self._left_broken:
strings = [r'\stopTrillSpan']
strings = self._tag_show(strings)
bundle.right.spanner_stops.extend(strings)
return bundle
if leaf is self[0]:
strings = abjad.override(self)._list_format_contributions(
'override',
once=False,
)
if self._left_broken:
strings = self._tag_hide(strings)
bundle.grob_overrides.extend(strings)
if self.pitch is not None:
pitch_string = str(self.pitch)
elif self.interval is not None:
pitch = leaf.written_pitch + self.interval
pitch_string = str(pitch)
else:
pitch_string = None
string = r'\startTrillSpan'
if pitch_string:
string += ' ' + pitch_string
strings = [string]
if self._left_broken:
strings = self._tag_hide(strings)
# important: pitch trill must start AFTER markup
bundle.after.spanner_starts.extend(strings)
if self.pitch is not None or self.interval is not None:
strings = [r'\pitchedTrill']
if self._left_broken:
strings = self._tag_hide(strings)
bundle.opening.spanners.extend(strings)
if self.is_harmonic:
string = '(lambda (grob) (grob-interpret-markup grob'
string += r' #{ \markup \musicglyph #"noteheads.s0harmonic" #}))'
scheme = abjad.Scheme(string, verbatim=True)
# TODO: use strings instead of override interface:
abjad.override(leaf).trill_pitch_head.stencil = scheme
if leaf is self[-1]:
manager = abjad.override(self)
strings = manager._list_format_contributions('revert')
if self._right_broken:
strings = self._tag_hide(strings)
bundle.grob_reverts.extend(strings)
if 1 < len(self):
strings = [r'\stopTrillSpan']
if self._right_broken:
strings = self._tag_hide(strings)
bundle.right.spanner_stops.extend(strings)
return bundle
def test_lilypondproxytools_LilyPondGrobNameManager___setattr___42():
r'''Override LilyPond Stem grob.
'''
note = abjad.Note(0, (1, 16))
abjad.override(note).stem.stroke_style = \
abjad.Scheme('grace', force_quotes=True)
assert format(note) == abjad.String.normalize(r'''
\once \override Stem.stroke-style = #"grace"
c'16
''')
def test_LilyPondGrobNameManager___setattr___34():
"""
Override LilyPond Stem grob.
"""
note = abjad.Note(0, (1, 16))
abjad.override(note).stem.stroke_style = abjad.Scheme("grace",
force_quotes=True)
assert format(note) == abjad.String.normalize(r"""
\once \override Stem.stroke-style = #"grace"
c'16
""")
def __call__(self):
'''Calls woodwind fingering.
Returns markup command.
'''
import abjad
key_groups_as_scheme = []
cc_scheme_pair = abjad.SchemePair(('cc', self._center_column))
key_groups_as_scheme.append(cc_scheme_pair)
lh_scheme_pair = abjad.SchemePair(('lh', self._left_hand))
key_groups_as_scheme.append(lh_scheme_pair)
rh_scheme_pair = abjad.SchemePair(('rh', self._right_hand))
key_groups_as_scheme.append(rh_scheme_pair)
key_groups_as_scheme = abjad.Scheme(
key_groups_as_scheme,
quoting="'",
)
instrument_as_scheme = abjad.Scheme(self._name, quoting="'")
return abjad.MarkupCommand(
'woodwind-diagram',
instrument_as_scheme,
key_groups_as_scheme,
)
def configure_score(self, score):
r'''Configures `score`.
'''
moment = abjad.SchemeMoment((1, 56))
abjad.setting(score).proportional_notation_duration = moment
abjad.setting(score).tuplet_full_length = True
abjad.override(score).bar_line.stencil = False
abjad.override(score).bar_number.transparent = True
abjad.override(score).spacing_spanner.uniform_stretching = True
abjad.override(score).spacing_spanner.strict_note_spacing = True
abjad.override(score).time_signature.stencil = False
abjad.override(score).tuplet_bracket.padding = 2
abjad.override(score).tuplet_bracket.staff_padding = 4
scheme = abjad.Scheme('tuplet-number::calc-fraction-text')
abjad.override(score).tuplet_number.text = scheme
def make_mozart_lilypond_file():
"""
Makes Mozart LilyPond file.
"""
score = abjad.demos.mozart.make_mozart_score()
lilypond_file = abjad.LilyPondFile.new(music=score, global_staff_size=12)
title = abjad.Markup(r'\bold \sans "Ein Musikalisches Wuerfelspiel"')
composer = abjad.Scheme("W. A. Mozart (maybe?)")
lilypond_file.header_block.title = title
lilypond_file.header_block.composer = composer
lilypond_file.layout_block.ragged_right = True
list_ = abjad.SchemeAssociativeList([("basic_distance", 8)])
lilypond_file.paper_block.markup_system_spacing = list_
lilypond_file.paper_block.paper_width = 180
return lilypond_file
def post_process_staffgroup(score):
print("post processing staff group")
# rh_staff = score['Piano_Staff'][0]
# lh_staff = score['Piano_Staff'][1]
# voice_four = score['LH_Voice_Four']
#
# staff_change1 = abjad.StaffChange(lh_staff)
# staff_change2 = abjad.StaffChange(rh_staff)
# abjad.attach(staff_change2, voice_four[-3])
# abjad.attach(staff_change1, voice_four[-2])
# rehearsal mark box
scheme = abjad.Scheme("format-mark-box-alphabet")
abjad.setting(score).markFormatter = scheme
return score
def post_process_voice_one(voice_one, score):
print("post processing voice one")
voice_one[-2] = abjad.Skip((3, 4))
voice_one[-1] = abjad.Skip((3, 4))
# change staff
voice_one = score['RH_Voice_One']
rh_staff = score['Piano_Staff'][0]
lh_staff = score['Piano_Staff'][1]
staff_change1 = abjad.StaffChange(lh_staff)
staff_change2 = abjad.StaffChange(rh_staff)
abjad.attach(staff_change1, voice_one[6][0])
# change clef
clef1 = abjad.Clef("bass")
abjad.attach(clef1, voice_one[8])
# tempos
lento = abjad.MetronomeMark(None, None, "Lento")
quasi_statico = abjad.MetronomeMark(None, None, "Quasi Statico")
# metronome mark I
abjad.attach(lento, voice_one[0])
# metronome mark II
abjad.attach(quasi_statico, voice_one[8])
# metronome mark III
abjad.attach(lento, voice_one[15][0])
# metronome mark IV
abjad.attach(abjad.MetronomeMark(None, None, "subito Quasi Statico"),
voice_one[18])
# metronome mark V
abjad.attach(lento, voice_one[22])
# metronome mark VI
abjad.attach(abjad.MetronomeMark(None, None, "più mosso"), voice_one[25])
# rehearsal mark
markI = abjad.RehearsalMark(number=3)
abjad.attach(markI, voice_one[0])
scheme = abjad.Scheme("format-mark-box-alphabet")
abjad.setting(score).markFormatter = scheme
return voice_one
def _get_formatted_user_attributes(self):
import abjad
result = []
#prototype = (abjad.Scheme, abjad.LilyPondLiteral)
prototype = abjad.Scheme
for value in self.items:
if isinstance(value, prototype):
result.append(format(value, 'lilypond'))
prototype = (
abjad.Scheme,
abjad.LilyPondDimension,
abjad.LilyPondCommand,
#abjad.LilyPondLiteral,
)
for key in self._public_attribute_names:
assert not key.startswith('_'), repr(key)
value = getattr(self, key)
# format subkeys via double underscore
formatted_key = key.split('__')
for i, k in enumerate(formatted_key):
formatted_key[i] = k.replace('_', '-')
if 0 < i:
string = "#'{}".format(formatted_key[i])
formatted_key[i] = string
formatted_key = ' '.join(formatted_key)
# format value
if isinstance(value, abjad.Markup):
formatted_value = value._get_format_pieces()
elif isinstance(value, prototype):
formatted_value = [format(value, 'lilypond')]
else:
formatted_value = abjad.Scheme(value)
formatted_value = format(formatted_value, 'lilypond')
formatted_value = [formatted_value]
setting = '{!s} = {!s}'
setting = setting.format(
formatted_key,
formatted_value[0],
)
result.append(setting)
result.extend(formatted_value[1:])
return result
def _make_full_score_pdf_notation_for_each_instrument(self) -> None:
for paper_format in (mus.A3, mus.A4):
for meta_track in globals_.ORCHESTRATION:
notation_path = "{}/notation/full_score/{}/{}".format(
self.path, paper_format.name, meta_track)
is_first = True
for verse in self.verses:
track = getattr(verse, meta_track)
track.format = paper_format
if is_first:
track.indent_first = True
track.global_staff_size = 20
lpf = track._make_lilypond_file(
make_layout_block_global=False)
else:
track.indent_first = False
lpf.items.append(
track._make_score_block(make_layout_block=True))
last_score_block = lpf.items[-1]
instr_staff = abjad.mutate(
last_score_block.items[0][0][1]).copy()
instr_obj = globals_.INSTRUMENT_NAME2OBJECT[meta_track]
if is_first:
abjad.setting(
instr_staff).instrument_name = instr_obj.markup
else:
abjad.setting(
instr_staff
).instrument_name = instr_obj.short_markup
abjad.setting(
instr_staff
).short_instrument_name = instr_obj.short_markup
last_score_block.items[0] = abjad.Score([instr_staff])
for other_meta_track in reversed(
tuple(iter(globals_.ORCHESTRATION))):
if meta_track != other_meta_track:
other_track = getattr(verse, other_meta_track)
new_staff = abjad.mutate(
other_track.score[0][1]).copy()
if type(new_staff) == abjad.StaffGroup:
for sub_staff in new_staff:
self._detach_optional_tone_tweaks(
sub_staff)
else:
self._detach_optional_tone_tweaks(new_staff)
instr_obj = globals_.INSTRUMENT_NAME2OBJECT[
other_meta_track]
magstep = abjad.Scheme(
["magstep", self._orientation_staff_size])
abjad.override(
new_staff).staff_symbol.thickness = magstep
abjad.override(
new_staff).staff_symbol.staff_space = magstep
abjad.setting(
new_staff
).font_size = self._orientation_staff_size
if is_first:
instrument_name_markup = instr_obj.name
else:
instrument_name_markup = instr_obj.short_name
instrument_name_markup = (
instrument_name_markup[0].capitalize() +
instrument_name_markup[1:].lower())
if is_first:
short_instrument_name_markup = instr_obj.short_name
short_instrument_name_markup = (
short_instrument_name_markup[0].capitalize(
) +
short_instrument_name_markup[1:].lower())
else:
short_instrument_name_markup = instrument_name_markup
if other_meta_track == "keyboard":
instrument_name_markup = abjad.Markup([
abjad.MarkupCommand(
"fontsize",
self._orientation_staff_size),
instrument_name_markup,
])
short_instrument_name_markup = abjad.Markup([
abjad.MarkupCommand(
"fontsize",
self._orientation_staff_size),
short_instrument_name_markup,
])
else:
instrument_name_markup = abjad.Markup(
instrument_name_markup)
short_instrument_name_markup = abjad.Markup(
short_instrument_name_markup)
abjad.setting(
new_staff
).instrument_name = instrument_name_markup
abjad.setting(
new_staff
).short_instrument_name = short_instrument_name_markup
last_score_block.items[0].insert(0, new_staff)
else:
copied_staff = abjad.mutate(
last_score_block.items[0][-1]).copy()
del last_score_block.items[0][-1]
last_score_block.items[0].insert(0, copied_staff)
is_first = False
if self._title:
lpf.header_block.title = abjad.Markup(self._title)
track._notate(notation_path, lpf)
def configure_score(score):
r'''Configures score.
'''
# configure bell staff
bell_staff = score['Bell Staff']
leaf = abjad.inspect(bell_staff).get_leaf(0)
clef = abjad.Clef('treble')
abjad.attach(clef, leaf)
bells = abjad.instrumenttools.Instrument(
name='Campana in La',
short_name='Camp.',
pitch_range='[C4, C6]',
)
abjad.attach(bells, leaf)
mark = abjad.MetronomeMark((1, 4), (112, 120))
abjad.attach(mark, leaf)
time_signature = abjad.TimeSignature((6, 4))
abjad.attach(time_signature, leaf)
# configure first violin staff
first_violin_staff = score['First Violin Staff']
leaf = abjad.inspect(first_violin_staff).get_leaf(0)
clef = abjad.Clef('treble')
abjad.attach(clef, leaf)
violin = abjad.instrumenttools.Violin(
markup=abjad.Markup('Violin I'),
short_markup=abjad.Markup('Vl. I'),
)
abjad.attach(violin, leaf)
# configure second violin staff
second_violin_staff = score['Second Violin Staff']
leaf = abjad.inspect(second_violin_staff).get_leaf(0)
clef = abjad.Clef('treble')
abjad.attach(clef, leaf)
violin = abjad.instrumenttools.Violin(
markup=abjad.Markup('Violin II'),
short_markup=abjad.Markup('Vl. II'),
)
abjad.attach(violin, leaf)
# configure viola staff
leaf = abjad.inspect(score['Viola Staff']).get_leaf(0)
clef = abjad.Clef('alto')
abjad.attach(clef, leaf)
viola = abjad.instrumenttools.Viola()
abjad.attach(viola, leaf)
# configure cello staff
leaf = abjad.inspect(score['Cello Staff']).get_leaf(0)
clef = abjad.Clef('bass')
abjad.attach(clef, leaf)
cello = abjad.instrumenttools.Cello()
abjad.attach(cello, leaf)
# configure bass staff
leaf = abjad.inspect(score['Bass Staff']).get_leaf(0)
clef = abjad.Clef('bass')
abjad.attach(clef, leaf)
contrabass = abjad.instrumenttools.Contrabass(
short_markup=abjad.Markup('Cb.'), )
abjad.attach(contrabass, leaf)
# configure score
vector = abjad.SpacingVector(0, 0, 8, 0)
abjad.override(score).vertical_axis_group.staff_staff_spacing = vector
abjad.override(score).staff_grouper.staff_staff_spacing = vector
abjad.override(score).staff_symbol.thickness = 0.5
scheme = abjad.Scheme('format-mark-box-numbers')
abjad.setting(score).mark_formatter = scheme
def post_process_voice_one(voice_one, score):
print("post processing voice one")
custom_ties(voice_one)
respell(voice_one)
# metronome mark I
abjad.attach(
abjad.MetronomeMark((1, 8), (128, 144), "Andante, molto liberamente"),
voice_one[0])
# rehearsal mark
markI = abjad.RehearsalMark(number=5)
abjad.attach(markI, voice_one[0])
scheme = abjad.Scheme("format-mark-box-alphabet")
abjad.setting(score).markFormatter = scheme
change_clef(voice_one)
# numbered leaves
selection = abjad.select(voice_one).leaves()
for i, leaf in enumerate(selection):
# abjad.attach(abjad.Markup(i, direction=abjad.Up), leaf) ###################################### numerate leaves
pass
abjad.Accidental.respell_with_sharps(selection[22:28])
abjad.Accidental.respell_with_flats(selection[28:32])
del selection[70].note_heads[0]
selection[70].note_heads.extend([0])
abjad.mutate(selection[71]).transpose(+12)
del selection[73].note_heads[-1]
# ritardando mark
rit_text_span = abjad.LilyPondLiteral(
r'\once \override TextSpanner.bound-details.left.text = "ritardando"' +
" " + r"\once \override TextSpanner.style = #'dashed-line")
start_rit = abjad.LilyPondLiteral(r"\startTextSpan")
stop_accel_text_span = abjad.StopTextSpan(command=r"\stopTextSpan")
abjad.attach(rit_text_span, selection[40])
abjad.attach(start_rit, selection[40])
abjad.attach(stop_accel_text_span, selection[44])
abjad.attach(rit_text_span, selection[72])
abjad.attach(start_rit, selection[72])
abjad.attach(stop_accel_text_span, selection[75])
abjad.override(voice_one).tuplet_bracket.direction = abjad.Up
# tempos
lento = abjad.MetronomeMark((1, 8), (64, 72), "Lento")
quasi_statico = abjad.MetronomeMark((1, 8), (32, 36), "Quasi Statico")
# metronome mark I
# abjad.attach(lento, voice_one[0])
# metronome mark II
abjad.attach(abjad.MetronomeMark(None, None, "più mosso"), selection[13])
# metronome mark III
abjad.attach(lento, selection[45])
abjad.attach(quasi_statico, selection[76])
del voice_one[-4:]
abjad.attach(abjad.Tie(), selection[89])
voice_one.append('<gs, a, b,>2.')
voice_one.append('r2.')
abjad.attach(abjad.Fermata(), voice_one[-1])
return voice_one
def post_process_voice_two(voice_two, score):
# REGISTER TRANSPOSITION
abjad.mutate(voice_two).transpose(-12)
# registers
abjad.attach(abjad.LilyPondLiteral(r"\override TextScript.outside-staff-priority = #'1100"), voice_two[0])
register_one = abjad.Markup(
r"""\scale #'(0.5 . 0.5)
\column{
\line{
\draw-circle #1.1 #0.3 ##t
\draw-circle #1.1 #0.3 ##f
}
\line{
\draw-circle #1.1 #0.3 ##t
\draw-circle #1.1 #0.3 ##t
}
\line{
\draw-circle #1.1 #0.3 ##f
\draw-circle #1.1 #0.3 ##t
}
\line{
\draw-circle #1.1 #0.3 ##f
\draw-circle #1.1 #0.3 ##f
}
}""", direction=abjad.Up)
abjad.attach(register_one, voice_two[0])
# metronome mark I
abjad.attach(
abjad.MetronomeMark((1, 8), (64, 72), "Lento"), voice_two[0])
# rehearsal mark
markI = abjad.RehearsalMark(number=4)
abjad.attach(markI, voice_two[0])
scheme = abjad.Scheme("format-mark-box-alphabet")
abjad.setting(score).markFormatter = scheme
# numbered leaves
selection = abjad.select(voice_two).leaves()
for i, leaf in enumerate(selection):
# abjad.attach(abjad.Markup(i), leaf)
pass
# slurs
start_slur = abjad.StartSlur()
start_slur_down = abjad.StartSlur(direction=abjad.Down)
stop_slur = abjad.StopSlur()
abjad.attach(start_slur, voice_two[6])
abjad.attach(stop_slur, voice_two[8])
abjad.attach(abjad.LilyPondLiteral(
r"""
\shape #'((0 . 0) (0 . 0) (-1.5 . -3) (0 . -8)) Slur
"""), voice_two[16])
abjad.attach(start_slur, voice_two[16])
abjad.attach(stop_slur, voice_two[17])
abjad.attach(start_slur, voice_two[23])
abjad.attach(stop_slur, voice_two[25])
abjad.attach(start_slur, voice_two[26])
abjad.attach(stop_slur, voice_two[27])
abjad.attach(start_slur, voice_two[34])
abjad.attach(stop_slur, voice_two[37])
abjad.attach(start_slur, voice_two[39])
abjad.attach(stop_slur, voice_two[40])
abjad.attach(start_slur, voice_two[43])
abjad.attach(stop_slur, voice_two[45])
abjad.attach(abjad.Clef("treble"), voice_two[0])
# accelerando mark
accel_text_span = abjad.LilyPondLiteral(
r'\once \override TextSpanner.bound-details.left.text = "accelerando poco a poco"' + " " +
r"\once \override TextSpanner.style = #'dashed-line"
)
start_accel = abjad.LilyPondLiteral(r"\startTextSpan")
abjad.attach(accel_text_span, voice_two[-20])
abjad.attach(start_accel, voice_two[-20])
stop_accel_text_span = abjad.StopTextSpan(command=r"\stopTextSpan")
abjad.attach(stop_accel_text_span, voice_two[-1])
# voice_two.append(abjad.Container(
# r"""cs'''2
# (
# g''8
# )
# r8
# r8
# fs'''4
# ~
# (
# fs'''4
# g'''8
# )
# """
# ))
voice_two[-1].written_pitch = "af''"
abjad.attach(abjad.Tie(), voice_two[-1])
return voice_two
