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