def __call__(self): """Return ``self.ready_staff``.""" abjad_instrument = self.abjad_instrument staves = self.append_staves(self) self.append_voices(self, staves) staff_count = self.staff_count if staff_count == 1: abjad.annotate(staves[0], "default_instrument", abjad_instrument) self.ready_staff = staves[0] else: if abjad_instrument == abjad.Piano(): staffgroup = abjad.StaffGroup( lilypond_type="PianoStaff", name="Piano_StaffGroup", tag=self.tag, simultaneous=True, ) for staff in staves: staffgroup.append(staff) else: staffgroup = abjad.StaffGroup(name=self.name, tag=self.tag) for staff in staves: staffgroup.append(staff) abjad.annotate(staffgroup, "default_instrument", abjad_instrument) self.ready_staff = staffgroup return self.ready_staff
def __call__(self): """ Calls two-staff piano score template. Returns score. """ import abjad tag = 'TwoStaffPianoScoreTemplate' # GLOBAL CONTEXT global_context = self._make_global_context() # RH STAFF rh_voice = abjad.Voice( name='RH_Voice', tag=tag, ) rh_staff = abjad.Staff( [rh_voice], name='RH_Staff', tag=tag, ) # LH STAFF lh_voice = abjad.Voice( name='LH_Voice', tag=tag, ) lh_staff = abjad.Staff( [lh_voice], name='LH_Staff', tag=tag, ) abjad.annotate( lh_staff, 'default_clef', abjad.Clef('bass'), ) # PIANO STAFF staff_group = abjad.StaffGroup( [rh_staff, lh_staff], lilypond_type='PianoStaff', name='Piano_Staff', tag=tag, ) abjad.annotate( staff_group, 'default_instrument', abjad.Piano(), ) # SCORE score = abjad.Score( [global_context, staff_group], name='Two_Staff_Piano_Score', tag=tag, ) return score
def make_mozart_score(): """ Makes Mozart score. """ score_template = abjad.TwoStaffPianoScoreTemplate() score = score_template() # select the measures to use choices = abjad.demos.mozart.choose_mozart_measures() # create and populate the volta containers treble_volta = abjad.Container() bass_volta = abjad.Container() for choice in choices[:7]: treble, bass = abjad.demos.mozart.make_mozart_measure(choice) treble_volta.append(treble) bass_volta.append(bass) # abjad.attach indicators to the volta containers command = abjad.LilyPondLiteral(r"\repeat volta 2", "before") abjad.attach(command, treble_volta) command = abjad.LilyPondLiteral(r"\repeat volta 2", "before") abjad.attach(command, bass_volta) # append the volta containers to our staves score["RH_Voice"].append(treble_volta) score["LH_Voice"].append(bass_volta) # create and populate the alternative ending containers treble_alternative = abjad.Container() bass_alternative = abjad.Container() for choice in choices[7:9]: treble, bass = abjad.demos.mozart.make_mozart_measure(choice) treble_alternative.append(treble) bass_alternative.append(bass) # abjad.attach indicators to the alternative containers command = abjad.LilyPondLiteral(r"\alternative", "before") abjad.attach(command, treble_alternative) command = abjad.LilyPondLiteral(r"\alternative", "before") abjad.attach(command, bass_alternative) # append the alternative containers to our staves score["RH_Voice"].append(treble_alternative) score["LH_Voice"].append(bass_alternative) # create the remaining measures for choice in choices[9:]: treble, bass = abjad.demos.mozart.make_mozart_measure(choice) score["RH_Voice"].append(treble) score["LH_Voice"].append(bass) # abjad.attach indicators time_signature = abjad.TimeSignature((3, 8)) leaf = abjad.inspect(score["RH_Staff"]).leaf(0) abjad.attach(time_signature, leaf) bar_line = abjad.BarLine("|.") leaf = abjad.inspect(score["RH_Staff"]).leaf(-1) abjad.attach(bar_line, leaf) # remove the default piano instrument and add a custom one: abjad.detach(abjad.Instrument, score["Piano_Staff"]) klavier = abjad.Piano(name="Katzenklavier", short_name="kk.") leaf = abjad.inspect(score["Piano_Staff"]).leaf(0) abjad.attach(klavier, leaf) return score
def instruments(): return dict([("Piano", abjad.Piano())])
class MidDrones(calliope.Staff): instrument=abjad.Piano( name="Mid Drones", short_name="m.drn.") midi_instrument = "string ensemble 2"
class BassDrones(calliope.Staff): instrument=abjad.Piano( name="Bass Drones", short_name="b.drn.") clef="bass" midi_instrument = "fretless bass"
import abjad instrument_one = abjad.Piano() instrument_one_range = instrument_one.pitch_range instrument_one_range_lowest = 0 instrument_one_range_highest = abjad.NumberedPitch( instrument_one_range.stop_pitch ).number instrument_two = abjad.Piano() instrument_two_range = instrument_two.pitch_range instrument_two_range_lowest = 0 instrument_two_range_highest = abjad.NumberedPitch( instrument_two_range.stop_pitch ).number instrument_three = abjad.Piano() instrument_three_range = instrument_three.pitch_range instrument_three_range_lowest = abjad.NumberedPitch( instrument_three_range.start_pitch ).number instrument_three_range_highest = 6 instrument_four = abjad.Piano() instrument_four_range = instrument_four.pitch_range instrument_four_range_lowest = abjad.NumberedPitch( instrument_four_range.start_pitch ).number instrument_four_range_highest = 6 instruments = [instrument_one, instrument_two, instrument_three, instrument_four]
class HighDrones(calliope.Staff): instrument=abjad.Piano( name="High Drones", short_name="h.drn.") midi_instrument = "piccolo"
import abjad import mccartney instruments = abjad.OrderedDict([ ( "Violin", abjad.Violin( markup=mccartney.markups.instrument("Violin"), short_markup=mccartney.markups.short_instrument("vln"), ), ), ( "MonoSynth", abjad.ClarinetInBFlat( markup=mccartney.markups.instrument("MonoSynth"), short_markup=mccartney.markups.short_instrument("msy"), ), ), ( "PolySynth", abjad.Piano( markup=mccartney.markups.instrument("PolySynth"), short_markup=mccartney.markups.short_instrument("psy"), ), ), ]) if __name__ == '__main__': for key, item in instruments.items(): print(key, item)
class S2(calliope.Staff): instrument = abjad.Piano(name="S 2", short_name="s.2")
class MelodyLine2(calliope.Staff): instrument=abjad.Piano( name="Melody Line 2", short_name="mel.2") midi_instrument = "misc2"
class CounterLine(calliope.Staff): instrument=abjad.Piano( name="Counter Line", short_name="count.") midi_instrument = "misc3"
def instruments(): return { "Piano": abjad.Piano(), "Violin": abjad.Violin(), }
class S4(calliope.Staff): instrument = abjad.Piano(name="S 4", short_name="s.4")
class S3(calliope.Staff): instrument = abjad.Piano(name="S 3", short_name="s.3")
>>> """ lilypond = abjad.lilypond(self.score) print(lilypond) return lilypond def show(self): """Show ``self.score``.""" return abjad.show(self.score) def play(self): pass def save_ly(self, file_name: str): lilypond_file = abjad.LilyPondFile(items=[self.score], ) abjad.persist.as_ly(lilypond_file, file_name) print("Current working directory: {0}".format(os.getcwd())) def make_group(instruments: list, group_name: str): group = abjad.StaffGroup(name=group_name) for instrument in instruments: group.append(instrument.ready_staff) return group if __name__ == "__main__": inst = Instrument(abjad.Piano(), "Piano", 2, [2, 2]) score = Score() score.append([inst])
import baca from abjadext import rmakers instruments = dict([ ("BassClarinet", abjad.BassClarinet()), ("Bassoon", abjad.Bassoon()), ("Cello", abjad.Cello()), ("Clarinet", abjad.ClarinetInBFlat()), ("Contrabass", abjad.Contrabass(pitch_range="[E1, D6]")), ("EnglishHorn", abjad.EnglishHorn()), ("Flute", abjad.Flute()), ("Harp", abjad.Harp()), ("Horn", abjad.FrenchHorn()), ("Oboe", abjad.Oboe()), ("Percussion", abjad.Percussion()), ("Piano", abjad.Piano()), ("Trombone", abjad.TenorTrombone()), ("Trumpet", abjad.Trumpet()), ("Tuba", abjad.Tuba()), ("Vibraphone", abjad.Vibraphone()), ("Viola", abjad.Viola()), ("Violin", abjad.Violin()), ]) def instrument(key): return baca.instrument(instruments[key]) def margin_markup(key, alert=None,
class BassLine(calliope.Staff): instrument=abjad.Piano( name="Bass Line", short_name="bass.") clef="bass" midi_instrument = "electric bass (finger)"
alto_flute = muda.score.Instrument( abjad_instrument=abjad.AltoFlute(), lilypond_name="AltoFlute", nstaffs=1, nvoices=[1], ) # Note: the markup for "instrumentName" in lilypond will be the lilypond_name variable with a espace between the words. bass_clarinet = muda.score.Instrument( abjad_instrument=abjad.BassClarinet(), lilypond_name="BassClarinet", nstaffs=1, nvoices=[1], ) piano = muda.score.Instrument( abjad_instrument=abjad.Piano(), lilypond_name="Piano", nstaffs=2, nvoices=[2, 2], piano=True, ) violin = muda.score.Instrument(abjad_instrument=abjad.Violin(), lilypond_name="Violin", nstaffs=1, nvoices=[1]) viola = muda.score.Instrument(abjad_instrument=abjad.Viola(), lilypond_name="Viola", nstaffs=1, nvoices=[1]) cello = muda.score.Instrument(abjad_instrument=abjad.Cello(), lilypond_name="Cello",
def __call__(self) -> abjad.Score: """ Calls score template. """ # GLOBAL CONTEXT global_context = abjad.Voice(name="Global_Context") global_context_ii = abjad.Voice(name="Global_Context_II") global_context_iii = abjad.Voice(name="Global_Context_III") # RH STAFF rh_voice_one = abjad.Voice(name="RH_Voice_One") # command = abjad.LilyPondLiteral(r"\voiceOne") # abjad.attach(command, rh_voice_one) # abjad.override(rh_voice_one).stem.direction = abjad.Up # abjad.override(rh_voice_one).tie.direction = abjad.Up rh_voice_two = abjad.Voice(name="RH_Voice_Two") # command = abjad.LilyPondLiteral(r"\voiceTwo") # abjad.attach(command, rh_voice_two) # abjad.override(rh_voice_two).stem.direction = abjad.Down # abjad.override(rh_voice_two).tie.direction = abjad.Down rh_voice_three = abjad.Voice(name="RH_Voice_Three") # command = abjad.LilyPondLiteral(r"\voiceThree") # abjad.attach(command, rh_voice_three) # abjad.override(rh_voice_three).stem.direction = abjad.Down # abjad.override(rh_voice_three).tie.direction = abjad.Down rh_staff = abjad.Staff( [global_context, rh_voice_one, rh_voice_two, rh_voice_three], name="RH_Staff") rh_staff.simultaneous = True # LH STAFF lh_voice_one = abjad.Voice(name="LH_Voice_Four") lh_voice_two = abjad.Voice(name="LH_Voice_Five") lh_staff = abjad.Staff([global_context_ii, lh_voice_one, lh_voice_two], name="LH_Staff") lh_staff.simultaneous = True # ORGAN STAFF piano_group = abjad.StaffGroup( [rh_staff, lh_staff], lilypond_type="PianoStaff", name="Piano_Staff", ) abjad.annotate(piano_group, "default_instrument", abjad.Piano()) instrumentName_piano = abjad.LilyPondLiteral( r"\set PianoStaff.instrumentName = \markup{Organ}") abjad.attach(instrumentName_piano, piano_group) # ELECTRONICS # ELECTRONICS RH STAFF voice_one_elec = abjad.Voice(name="RH_Voice_One_Electronics") electronics = abjad.Staff([global_context_iii, voice_one_elec], name="Electronics_Staff") electronics.simultaneous = True abjad.annotate(electronics, "default_instrument", abjad.Piano()) instrumentName_electronics = abjad.LilyPondLiteral( r"\set Staff.instrumentName = \markup{Electronics}") abjad.attach(instrumentName_electronics, electronics) # SCORE score = abjad.Score( [piano_group, electronics], name="Score", ) # abjad.override(score).script.padding = 1.1 # abjad.override(score).spacing_spanner.strict_grace_spacing = True # abjad.override(score).spacing_spanner.strict_note_spacing = True # abjad.override(score).spacing_spanner.uniform_stretching = True # abjad.override(score).stem.length = 8 # abjad.override(score).text_script.outside_staff_padding = 1 # abjad.override(score).tuplet_bracket.bracket_visibility = True # abjad.override(score).tuplet_bracket.minimum_length = 3 # abjad.override(score).tuplet_bracket.outside_staff_padding = 1.5 # abjad.override(score).tuplet_bracket.padding = 1.5 # abjad.override(score).tuplet_bracket.springs_and_rods = \ # abjad.scheme.Scheme('ly:spanner::set-spacing-rods', verbatim=True) # abjad.override(score).tuplet_bracket.staff_padding = 2.25 # abjad.override(score).tuplet_number.text = \ # abjad.scheme.Scheme( # 'tuplet-number::calc-fraction-text', verbatim=True) # abjad.setting(score).proportional_notation_duration = \ # abjad.scheme.SchemeMoment((1, 24)) # abjad.setting(score).tuplet_full_length = True return score
class Riff(calliope.Staff): instrument=abjad.Piano( name="Riff", short_name="riff.") midi_instrument = "electric guitar (clean)"
for instr in scale_per_instrument: for p in scale_per_instrument[instr]: d.update({p.normalize(): instr}) return d PITCH2SCALE_DEGREE = _make_pitch2scale_degree_dict(INTONATIONS_PER_SCALE_DEGREE) PITCH2INSTRUMENT = _make_pitch2instrument_dict(SCALE_PER_INSTRUMENT) INSTRUMENT_NAME2OBJECT = { "cello": abjad.Cello(), "violin": abjad.Violin(), "viola": abjad.Viola(), "keyboard": abjad.Piano(name="keyboard", short_name="kbd."), } STANDARD_TEMPI = ( 35, 36, 37, 38, 39, 40, 42, 44, 46, 48, 50,
class Chords(calliope.Staff): instrument=abjad.Piano( name="Chords", short_name="chrd.") midi_instrument = "french horn"