def main(): freqs, freq_to_amp = y.record(5, 2, 10) readings = list() for reading in freqs: cr_reading = y.CustomRound(reading) temp = y.clst(reading, 0.98, 1.02) temp.sort(key=lambda elem: freq_to_amp[cr_reading(elem)]) temp2 = temp[-3:] temp2.sort() readings.append(temp2[-3:]) chords = y.convList(readings) c = abjad.Container() time = 1 prev = chords[0] for i in range(len(chords) - 1): i += 1 a = chords[i] if prev != a: show_chord(prev, time, c) prev = a time = 1 else: time += 1 show_chord(chords[-1], time, c) abjad.show(c)
def main(): objects = (ephem.Mercury(), ephem.Venus(), ephem.Mars(), ephem.Jupiter(), ephem.Saturn(), ephem.Uranus(), ephem.Neptune()) observer = ephem.Observer() observer.lat = '57:10' observer.lon = '-135:15' object_events = [] for o in objects: events = [] observer.date = START_DATE while observer.date < ephem.Date(END_DATE): next_rising = observer.next_rising(o) next_setting = observer.next_setting(o) events.append((next_rising, next_setting, o.earth_distance)) observer.date = next_setting object_events.append(events) staves = [] for object_events in object_events: staff = abjad.Staff() staves.append(staff) current_time = ephem.Date(START_DATE) for event_start, event_stop, distance in object_events: # add rest to fill time until event start rest_duration = get_duration_from_interval(event_start - current_time) staff.extend(make_rests(rest_duration)) note_duration = get_duration_from_interval(event_stop - event_start) staff.extend(make_notes(note_duration, get_pitch(distance))) current_time = event_stop abjad.show(abjad.Score(staves))
def treble(): trebleclef = ab.Clef('treble') treblestaff = ab.Staff(listnotes(combinedlist)) ab.attach(trebleclef, treblestaff[0]) ab.attach(ksignature, treblestaff[0]) ab.attach(tsignature, treblestaff[0]) ab.show(treblestaff)
def draw_the_score(time_sec, key_pressed, bpm): key_as_abjad_number = convert_key_pressed_to_abjad_number(key_pressed) beats, key_temp = how_many_beats(time_sec, key_as_abjad_number, bpm) #print(beats) beats = [i * 4 for i in beats] #print(beats) notes = [] for i in range(len(beats)): # note: beats has been scaled up earlier by multiplying by 4! duration = abjad.Duration(beats[i], 16) if (key_as_abjad_number[i] == 100): #notes.append(abjad.Rest('r16')) rest = abjad.Rest(duration) notes.append(rest) else: notes.append(abjad.Note(key_as_abjad_number[i], duration)) staff = abjad.Staff(notes) abjad.show(staff)
def show_demo(): talea = abjad.rhythmmakertools.Talea( counts=[1, 2, 3], denominator=16, ) tie_specifier = abjad.rhythmmakertools.TieSpecifier( tie_across_divisions=True, ) burnish_specifier = abjad.rhythmmakertools.BurnishSpecifier( left_classes=(abjad.Rest, abjad.Note), left_counts=(1,), ) talea_rhythm_maker = abjad.rhythmmakertools.TaleaRhythmMaker( talea=talea, extra_counts_per_division=[0, 1, 1], burnish_specifier=burnish_specifier, tie_specifier=tie_specifier, ) divisions = [(3, 8), (5, 4), (1, 4), (13, 16)] score = abjad.Score() for i in range(8): selections = talea_rhythm_maker(divisions, rotation=i) voice = abjad.Voice(selections) staff = abjad.Staff([voice], context_name='RhythmicStaff') score.append(staff) divisions = rotate(divisions, 1) lilypond_file = make_sketch_lilypond_file(score) abjad.show(lilypond_file)
def render_score(score, beats, jigs): # adapted from https://github.com/Abjad/abjad/blob/5c7f5f7abd8013f99b60c9ceb3a91c771abbca7c/abjad/demos/ligeti/make_desordre_lilypond_file.py file = abjad.LilyPondFile.new(score, global_staff_size=18) context_block = abjad.ContextBlock(source_context_name='Score') file.layout_block.items.append(context_block) # for future reference: http://lilypond.org/doc/v2.18/Documentation/learning/engravers-explained.en.html context_block.remove_commands.append('Bar_number_engraver') context_block.remove_commands.append('Default_bar_line_engraver') abjad.override(context_block).clef.transparent = True abjad.override(context_block).spacing_spanner.strict_grace_spacing = True abjad.override(context_block).spacing_spanner.strict_note_spacing = True abjad.override(context_block).spacing_spanner.uniform_stretching = True abjad.override(context_block).text_script.staff_padding = 0 abjad.override(context_block).time_signature.transparent = True abjad.override(context_block).rest.transparent = True abjad.override(context_block).dots.transparent = True file.header_block.tagline = ' ' file.paper_block.paper_width = beats * 15 file.paper_block.paper_height = jigs * 20 file.paper_block.bottom_margin = 0 file.paper_block.left_margin = 0 vector = abjad.SpacingVector(0, 0, 15, 0) #file.paper_block.system_system_spacing = vector abjad.show(file)
def bass(): bassclef = ab.Clef('bass') bassstaff = ab.Staff(listnotes(combinedlist)) ab.attach(bassclef, bassstaff[0]) ab.attach(ksignature, bassstaff[0]) ab.attach(tsignature, bassstaff[0]) ab.show(bassstaff)
def show(self): lilypond_file = abjad.lilypondfiletools.make_basic_lilypond_file(self.score) lilypond_file.score_block.append(abjad.lilypondfiletools.MIDIBlock() ) layout_block = abjad.lilypondfiletools.LayoutBlock() layout_block.is_formatted_when_empty = True lilypond_file.score_block.append(layout_block) abjad.show( lilypond_file)
def see_pitches(pitches): G_staff = abjad.Staff() F_staff = abjad.Staff() staff_group = abjad.StaffGroup([G_staff, F_staff]) pitch_range = abjad.pitch.PitchRange("[C4, +inf]") for pitch in pitches: test = pitch in pitch_range if test is True: note = abjad.Note.from_pitch_and_duration(pitch, (1, 1)) G_staff.append(note) F_staff.append(abjad.Skip((1, 1))) if test is False: note = abjad.Note.from_pitch_and_duration(pitch, (1, 1)) G_staff.append(abjad.Skip((1, 1))) F_staff.append(note) for i, note in enumerate(F_staff): abjad.attach(abjad.Markup(i), note) clef3 = abjad.Clef("treble^8") clef3_range = abjad.pitch.PitchRange("[G6, +inf]") clef2 = abjad.Clef("treble") clef2_range = abjad.pitch.PitchRange("[E4, E5]") clef1 = abjad.Clef("bass") clef1_range = abjad.pitch.PitchRange("[A1, G3]") clef0 = abjad.Clef("bass_8") clef0_range = abjad.pitch.PitchRange("[-inf, C1]") selection = abjad.select(G_staff).leaves() for i, leaf in enumerate(selection): if isinstance(leaf, abjad.Note): test3 = leaf in clef3_range test2 = leaf in clef2_range if test3 is True: abjad.attach(clef3, G_staff[i]) elif test2 is True: abjad.attach(clef2, G_staff[i]) selection2 = abjad.select(F_staff).leaves() for i, leaf in enumerate(selection2): if isinstance(leaf, abjad.Note): test3 = leaf in clef3_range test2 = leaf in clef2_range test1 = leaf in clef1_range test0 = leaf in clef0_range if test2 is True: abjad.attach(clef2, F_staff[i]) elif test1 is True: abjad.attach(clef1, F_staff[i]) elif test0 is True: abjad.attach(clef0, F_staff[i]) abjad.show(staff_group) return staff_group
def generate_n_random_notes(cls, n: int, scale: str=None, scale_type: str='base'): duration = abjad.Duration(1, 4) if not scale: scale = cls.select_random_scale() print('selected scale is ' + scale) signature = KeySignature(scale.lower(), 'major') random_scale = cls.scale_shift[scale] notes = cls.get_random_notes_for_a_scale(n, scale_type) new_notes = [abjad.Note(i + random_scale, duration) for i in notes] staff = abjad.Staff(new_notes) abjad.attach(signature, staff[0]) abjad.show(staff)
def make_score(sequence, chords, midi=False): print("Length of sequence:", len(sequence), "of", len(chords)) staff = make_one_part(sequence) abjad.show(staff) if midi: abjad.play(staff) # make csv filename = 'chords.csv' with open(filename, 'w') as csvfile: chord_writer = csv.writer(csvfile, delimiter=',') for chord in sequence: chord_writer.writerow([chord])
def treblebass(): trebleclef = ab.Clef('treble') treblestaff = ab.Staff(listnotes(toplist)) ab.attach(trebleclef, treblestaff[0]) ab.attach(ksignature, treblestaff[0]) ab.attach(tsignature, treblestaff[0]) bassclef = ab.Clef('bass') bassstaff = ab.Staff(listnotes(bottomlist)) ab.attach(bassclef, bassstaff[0]) ab.attach(ksignature, bassstaff[0]) ab.attach(tsignature, bassstaff[0]) group = ab.StaffGroup([treblestaff, bassstaff]) ab.show(group)
def generate_random_interval_sequences(cls, n: int, scale: str=None, scale_type: str='base'): duration = abjad.Duration(1, 4) if not scale: scale = cls.select_random_scale() print('selected scale is ' + scale) signature = KeySignature(scale.lower(), 'major') random_scale = cls.scale_shift[scale] notes = cls.get_random_notes_for_a_scale(n, scale_type=scale_type) new_notes = [] for note in notes: new_notes.append(abjad.Note(random_scale, duration)) new_notes.append(abjad.Note(note + random_scale, duration)) staff = abjad.Staff(new_notes) abjad.attach(signature, staff[0]) abjad.show(staff)
def plot_notes(notes_list, time_list): #number_of_measures = math.ceil(len(notes_inp)/bpm) notes = [] print(time_list) print(len(time_list)) print(len(notes_list)) for i in range(len(notes_list)): duration = abjad.Duration(time_list[i], 16) notes.append(abjad.Note(notes_list[i], duration)) staff = abjad.Staff(notes) abjad.show(staff)
def getSheetMusic(Melody, scale): print(scale) melodyNotes = [note_name(n,name_to_number(scale[0])).lower() for n in [note.value for note in Melody]] print(melodyNotes) durations = [int(1/note.dur) for note in Melody] octaves = [note.octave for note in Melody] abjadArr = [] for i in zip(melodyNotes, durations, octaves): abjadArr.append(i[0] + octaveDict[i[2]] + str(i[1])) abjadString = ' '.join(abjadArr) staff = Staff(abjadString) #attach(KeySignature('c','major'), staff[0]) attach(KeySignature(scale[0],scale[1]), staff[0]) attach(TimeSignature((3,4)),staff[0]) #attach(Clef("bass"), staff[0]) show(staff)
def show_notes(notes): """ notes: array-like of pretty_midi Note Shows the notes in a standard music sheet format using abjad """ import abjad notes_abjad = list() for n in notes: notes_abjad.append( abjad.Note( n.pitch - 5 * 12, abjad.Duration(n.get_duration() / 2).equal_or_greater_assignable)) staff = abjad.Staff(notes_abjad) abjad.show(staff)
def ChordProgToPic(pop): chords = [] for chord in pop.chords: chordString = "" for note in chord: chordString += convert[note % 12] if np.floor(note / 12) - 1 == 4: chordString += "' " elif np.floor(note / 12) - 1 == 5: chordString += "'' " elif np.floor(note / 12) - 1 == 6: chordString += "''' " else: chordString += " " chords.append(abjad.Chord("<" + chordString + ">4")) container = abjad.Container(chords) abjad.show(container)
def make_vla_vln_score(chords, midi=False): vla_chords = [] vln_chords = [] for chord in chords: vla_chord = chord[:4] vln_chord = chord[1:] vla_chords.append(vla_chord) vln_chords.append(vln_chord) vla_staff = make_one_part(vla_chords, parenthesis=3) clef = abjad.Clef(name='alto') abjad.attach(clef, vla_staff[0]) viola = abjad.instrumenttools.Viola() abjad.attach(viola, vla_staff) #vla_staff.name = 'Viola' vln_staff = make_one_part(vln_chords, parenthesis=0) violin = abjad.instrumenttools.Violin() abjad.attach(violin, vln_staff) #vln_staff.name = 'Violin' score = abjad.Score([vln_staff, vla_staff]) score.add_final_bar_line() lilypond_file = abjad.LilyPondFile.new(score, default_paper_size=('letter', 'landscape'), global_staff_size=20) #postscript = abjad.Postscript() lilypond_file.header_block.title = abjad.Markup("tuning no. 4:") lilypond_file.header_block.title.setfont("Arial") lilypond_file.header_block.subtitle = abjad.Markup('Pythagorean chains') lilypond_file.header_block.composer = abjad.Markup('John Eagle') lilypond_file.header_block.tagline = " " lilypond_file.paper_block.top_margin = 15 lilypond_file.paper_block.left_margin = 20 abjad.show(lilypond_file) if midi: abjad.play(score)
def show_score(voiced_chords): def add2staff(voice1, voice2, staff): voice1 = abjad.Voice(voice1) command = abjad.indicatortools.LilyPondCommand('voiceOne') abjad.attach(command, voice1) voice2 = abjad.Voice(voice2) command = abjad.indicatortools.LilyPondCommand('voiceTwo') abjad.attach(command, voice2) staff.extend([voice1, voice2]) staff.is_simultaneous = True #right format notes = [] satb = [""] * 4 for chord in voiced_chords: for i, note in enumerate(chord): octave = note.octave name = str.lower(note.name) name += ("'" * (octave - 3) * (octave > 3) + "," * (3 - octave) * (octave < 3) + "4 ") #builds the voices satb[i] += name soprano, alto, tenor, bass = satb #build the score upper_staff = abjad.Staff() lower_staff = abjad.Staff() satb_staff = abjad.StaffGroup([upper_staff, lower_staff]) add2staff(soprano, alto, upper_staff) add2staff(tenor, bass, lower_staff) abjad.attach(abjad.Clef('bass'), lower_staff[0]) abjad.show(satb_staff) abjad.play(satb_staff)
def make_note_sheet(music): violin = abjad.Violin() notes=[] for row in music: if row[0]=='r': if row[-1]: note=abjad.Rest(row[-2]) else: note=abjad.Rest(abjad.Duration(1,int(lilypod_dur[row[-2]]))) else: x=notes_ann[row[0]].lower() if x[-1]=='#' or x[-1]=='b': x=x[0] x=x+'s' note_=x oct_=Helmholtz_octave[row[1]] due_=lilypod_dur[row[-2]] note=abjad.Note(note_+oct_+due_) notes.append(note) abjad.attach(violin, notes[0]) container = abjad.Container(notes) abjad.show(container) return
def _show_chords(self, chords): lilypond_file, score = self._make_lilypond_file_and_score_from_chords(chords) abjad.show(lilypond_file)
for handler, staff in zip(handlers_3, quartet_group): handler(staff) moment = "#(ly:make-moment 1 10)" abjad.setting(score).proportional_notation_duration = moment block = abjad.Block(name="score") block.items.append(score) style = '"dodecaphonic"' layout = abjad.Block(name="layout") layout.items.append(rf"\accidentalStyle {style}") file = abjad.LilyPondFile(items=[ r'\include "/Users/gregoryevans/abjad/abjad/_stylesheets/ekmelos-ji-accidental-markups.ily"', r'\include "/Users/gregoryevans/scores/polillas/polillas/build/score_stylesheet.ily"', layout, block, ]) evans.make_sc_file( score=score, tempo=tempo_pair, current_directory=pathlib.Path(__file__).parent, ) abjad.mutate.transpose(group_2, abjad.NamedInterval("+P8")) abjad.show(file)
from abjad import Duration from abjad import show from SegmentMaker import SegmentMaker durations = [Duration(4, 4)] * 4 segment_maker = SegmentMaker(durations) if __name__ == '__main__': show(segment_maker)
voice_1_timespan_list, voice_2_timespan_list, voice_3_timespan_list, voice_4_timespan_list, voice_5_timespan_list, voice_6_timespan_list, voice_7_timespan_list, voice_8_timespan_list, voice_9_timespan_list, voice_10_timespan_list, voice_11_timespan_list, voice_12_timespan_list, voice_13_timespan_list, voice_14_timespan_list, voice_15_timespan_list, voice_16_timespan_list, voice_17_timespan_list, voice_18_timespan_list, voice_19_timespan_list, voice_20_timespan_list, voice_21_timespan_list, ] all_timespan_lists = abjad.TimespanList([]) all_timespan_lists = make_showable_list(all_timespans) abjad.show(all_timespan_lists, key='annotation', scale=2 )
#! /usr/bin/env python import abjad if __name__ == '__main__': lilypond_file = abjad.demos.mozart.make_mozart_lilypond_file() abjad.show(lilypond_file)
def main(): image_bgr = cv2.imread(IMAGE) image_hsv = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2HSV) staves = [abjad.Staff() for _ in range(3)] # oboe, clarinet, bassoon abjad.attach(abjad.Clef('bass'), staves[2]) abjad.attach(abjad.instrumenttools.Oboe(), staves[0]) abjad.attach(abjad.instrumenttools.ClarinetInBFlat(short_instrument_name_markup='Cl.'), staves[1]) abjad.attach(abjad.instrumenttools.Bassoon(), staves[2]) # walk the image's pixels, in a 'square spiral' towards the center pixels = get_square_spiral_positions(20) prev_dynamics = [None] * 3 prev_octave_shifts = [None] * 3 prev_pitch = None for i, (x, y) in enumerate(pixels): pixel = (y, x) B, G, R = image_bgr[pixel] H, S, V = image_hsv[pixel] dynamic = get_dynamic(V) soloist = get_soloist(S) pitch = get_pitch(H) dynamics = [dynamic] * 3 dynamics[soloist] += 2 instrument_channels = [R, B, G] instrument_base_octaves = [0, -1, -2] for instrument in range(3): staff = staves[instrument] channel = instrument_channels[instrument] octave_shift = get_octave_shift(instrument, channel) if octave_shift == -1: if prev_octave_shifts[instrument] == -1 and i % 4 != 0: staff[-1].written_duration += abjad.Duration(1, 4) if staff[-1].written_duration == 1: staff[-1] = abjad.scoretools.MultimeasureRest(1) note = None else: note = abjad.Rest(NOTE_DURATION) else: base_pitch = pitch + instrument_base_octaves[instrument] * 12 note = abjad.Note(base_pitch + octave_shift * 12, NOTE_DURATION) if dynamics[instrument] != prev_dynamics[instrument]: dynamic = abjad.Dynamic(DYNAMICS[dynamics[instrument]]) abjad.attach(dynamic, note) if prev_octave_shifts[instrument] == octave_shift and prev_pitch == pitch: if dynamics[instrument] != prev_dynamics[instrument] or i % 4 == 0: staff.append(note) note = None abjad.attach(abjad.Tie(), staff[-2:]) else: staff[-1].written_duration += abjad.Duration(1, 4) note = None prev_octave_shifts[instrument] = octave_shift if note is not None: staff.append(note) prev_pitch = pitch prev_dynamics = dynamics for staff in staves: bar_line = abjad.indicatortools.BarLine('|.') abjad.attach(bar_line, staff[-1]) abjad.show(abjad.Score(staves))
def main(): score = crawl_to_target_chord(TARGET_CHORD) show(score)
# -*- coding: utf-8 -*- #! /usr/bin/env python if __name__ == '__main__': from abjad import show from abjad.demos import part lilypond_file = part.make_part_lilypond_file() show(lilypond_file)
#! /usr/bin/env python import abjad import sys if __name__ == '__main__': arguments = sys.argv[1:] if len(arguments) != 3: print('USAGE: tuplet_duration row_count column_count') print(' e.g.: python main.py 1/4 11 6') sys.exit(0) tuplet_duration = abjad.Duration(arguments[0]) row_count = int(arguments[1]) column_count = int(arguments[2]) assert 0 < tuplet_duration assert 0 < row_count assert 0 < column_count demo = abjad.demos.ferneyhough.FerneyhoughDemo() lilypond_file = demo( tuplet_duration=tuplet_duration, row_count=row_count, column_count=column_count, ) abjad.show(lilypond_file)
]) # 1 - process source file vc_list, bt_list= process_src(src_file) # 2 - create a container for both abjad measures and SC events beat_measures, events_container= blank_containers(bt_list, vc_list) # 3 - adjust durations before filling out beat_measures, as folows: # 3.1 - compressing tuplets in a single event with notes list events_container= resolve_tuplets(events_container) # 3.2 - span long notes (dur > bar_size) over bars events_container= note_spanner(events_container) # 3.2 - fill rests events_container= fill_rest(events_container) # 3.3(3.1) - rests inflated beats, spanning should be repeated events_container= note_spanner(events_container) # 4 - adjust durations to the current measure events_container= adjust_durations(events_container) report_events( events_container ) # 5 - fill the score ajscore= fill_score(vc_list, events_container) # 6 - markup and layout ajlily= lily_file(ajscore) # 7 - produce ly # 8 - show the score if showpdf: print "Producing PDF..." try: aj.show(ajlily) except Exception as e: print "ERROR: %s" % e
fixed = fixNotes(newNote) print fixed staff.append(fixed) pass # except LilyPondParserError: # m = re.search('\w.\d',letters) # shortenedNote = m.group(0) # newNote = shortenedNote[0]+shortenedNote[-1] # fixed = fixNotes(newNote) # try: # staff.append(fixed) # except DurationError: # pass abjad.show(staff) '''Code to turn the xlsx into a more useable xlsx''' #freqs = pd.read_csv('Book1.csv',delimiter='\t',header=None) # #column1 = [] #column2 = [] #notes = [] #for i,v in enumerate(freqs[9]): # if i>4: # if i%2==0: # column2.append(v) # else: # column1.append(v) # notes.append(freqs[8][i]) # #z = pd.DataFrame([notes,column1,column2])
def show(staff): """Render and show.""" return abj.show(make_lilyfile(staff))
import abjad pitches = ["e'4", "c'4", "cs'8", "ef'8", "d'4"] notes = [abjad.Note(x) for x in pitches] container = abjad.Container(notes) selection = abjad.select(container[:2]) for x in selection: abjad.override(x).note_head.color = "red" abjad.show(container)
stack.append(child) def build_score_from_tree(tree): stack = [tree.root] while len(stack) > 0: node = stack.pop() if node.tag == 'measure': pass if __name__ == '__main__': tree = build_tree_from_xml('./castle.xml') print_tree(tree.root) score = build_score_from_tree(tree) show(score) # clef = abjad.Clef('treble_8') # abjad.attach(clef, measures[0][0]) # staff = abjad.Staff(measures) # show(staff) # duration = abjad.Duration(1, 4) # rests = [abjad.Rest(abjad.Duration(1, 4)), abjad.Rest(abjad.Duration(2, 4))] # notes = [ # abjad.Note(16, abjad.Duration(1, 8)), # abjad.Note("e4", abjad.Duration(1, 8)), # abjad.Note(18, abjad.Duration(1, 8)), # # 这两个是一个 chord # abjad.Chord([19, -8], abjad.Duration(1, 8)),
for scaled_staff, duplicate_index in zip(scaled_staves, reversed(range(3))): scale_factor = 2**duplicate_index staff = duplicate_music(scale_factor, scaled_staff) score.append(staff) return score def format_score(score, key_signature, time_signature): for staff in score: key_sig = abjad.KeySignature(key_signature.tonic, key_signature.mode) abjad.attach(key_sig, staff[0]) time_sig = abjad.TimeSignature(time_signature) abjad.attach(time_sig, staff[0]) abjad.attach(abjad.Clef('bass'), score[2][0]) def make_canon(melody_staff, key_signature, time_signature): # make a three-voice prolation canon from a melody scaled_staves = make_scaled_staves(melody_staff, time_signature) score = duplicate_score(scaled_staves) format_score(score, key_signature, time_signature) return score # # "Arirang" melody_staff = abjad.Staff("e'4. fs'8 e'4 a'4. b'8 a' b' cs''4 b'8 cs''16 b' a'8 fs' e'4. fs'8 e' fs' a'4. b'8 a' b' cs'' b' a' fs' e' fs' a'4. b'8 a'4 a'2.") melody_staff.extend("e''2 e''4 e'' cs'' b' cs'' b'8 cs''16 b' a'8 fs' e'4. fs'8 e' fs' a'4. b'8 a' b' cs'' b' a' fs' e' fs' a'4. b'8 a'4 a'2.") for note in melody_staff: note.written_pitch += 12 score = make_canon(melody_staff, abjad.KeySignature('d', 'major'), abjad.TimeSignature((3,4))) abjad.show(score)
[ abjad.Voice( "c'8 c'8 c'8 c'8 c'8 c'8 c'8 c'8", name="Voice 2", ) ], name="Staff 2", ), ], name="group", ) ], name="Score", ) h = evans.IntermittentVoiceHandler( evans.RhythmHandler( rmakers.stack(evans.RTMMaker([ "(1 (1 1 1))", ]), ), forget=False, ), direction=abjad.Up, ) selector = abjad.select().leaf(1) target = selector(score["Voice 1"]) h(target) abjad.show(score)
def show(self): """Show ``self.score``.""" return abjad.show(self.score)
else: upper_staff_components.append( abjad.Rest(abjad.Duration(1, 1))) lower_staff = abjad.Staff(lower_staff_components) upper_staff = abjad.Staff(upper_staff_components) if len(lower_staff_components) > 0: leaf = abjad.get.leaf(lower_staff, 0) abjad.attach(abjad.Clef('bass'), leaf) piano_staff = abjad.StaffGroup([], lilypond_type='PianoStaff') piano_staff.append(upper_staff) piano_staff.append(lower_staff) abjad.show(piano_staff) else: print("Nothing to notate!") elif mode_text.lower() == "write": if len(sys.argv) < 4: raise ValueError("No string provided to write to file") chord_string = sys.argv[3] # make sure the chord string is of valid format try: c = Chord.from_string(chord_string)
lilypond_file.layout.indent = 0 lilypond_file.layout.ragged_right = True lilypond_file.paper.top_margin = 20 lilypond_file.paper.left_margin = 15 lilypond_file.paper.print_page_number = False lilypond_file.paper.minimal_page_breaking = True lilypond_file.paper.ragged_last_bottom = True lilypond_file.paper.ragged_bottom = True lilypond_file.paper.between_system_padding = 10 lilypond_file.global_staff_size = 14 lilypond_file.default_paper_size = 'letter', 'portrait' apply_footer(score) return lilypond_file def apply_footer(score): lilypond_file = score.lilypond_file footer_string = 'désir - fleur pitch sets by arithmetic mean' footer_markup = abjad.Markup(r'\fill-line { "%s" }' % footer_string) lilypond_file.paper.oddFooterMarkup = footer_markup lilypond_file.paper.evenFooterMarkup = footer_markup if __name__ == '__main__': chords = make_chords() label.leaf_numbers(chords, direction = 'above') chords.sort(lambda x, y: cmp(x.center, y.center)) score = leaftools.show_leaves(chords, suppress_pdf = True) configure_score(score) abjad.show(score.lilypond_file)
leaf = abjad.inspect(staff).leaf(0) abjad.attach(time_signature, leaf) score.append(staff) return score if __name__ == "__main__": from abjad import show arguments = sys.argv[1:] if len(arguments) != 3: print("USAGE: tuplet_duration row_count column_count") print(" e.g.: python main.py 1/4 11 6") sys.exit(0) tuplet_duration = abjad.Duration(arguments[0]) row_count = int(arguments[1]) column_count = int(arguments[2]) assert 0 < tuplet_duration assert 0 < row_count assert 0 < column_count demo = abjad.demos.ferneyhough.FerneyhoughDemo() lilypond_file = demo( tuplet_duration=tuplet_duration, row_count=row_count, column_count=column_count, ) show(lilypond_file)
print fixed staff.append(fixed) pass # except LilyPondParserError: # m = re.search('\w.\d',letters) # shortenedNote = m.group(0) # newNote = shortenedNote[0]+shortenedNote[-1] # fixed = fixNotes(newNote) # try: # staff.append(fixed) # except DurationError: # pass abjad.show(staff) '''Code to turn the xlsx into a more useable xlsx''' #freqs = pd.read_csv('Book1.csv',delimiter='\t',header=None) # #column1 = [] #column2 = [] #notes = [] #for i,v in enumerate(freqs[9]): # if i>4: # if i%2==0: # column2.append(v) # else: # column1.append(v) # notes.append(freqs[8][i])
import abjad chord = [-12, -5, 2, 9, 16] new_chord = abjad.Chord(chord, 1) new_chord.note_heads[4].is_parenthesized = True #staff = abjad.Staff(new_chord) abjad.show(new_chord)
for i in range(number_of_notes): # Make staves periodically have same duration upper_notes(number_of_notes) lower_notes(number_of_notes) print("Starting duration equalization, should take about {} notes".format( int( float( abs( ab.inspect(lower_staff).duration() - ab.inspect(upper_staff).duration()))) * 3)) equalize_durations() print( "There are a total of {} notes in the right hand and {} notes in the left hand" .format(len(ab.select(upper_staff).leaves()), len(ab.select(lower_staff).leaves()))) # Stuff that has to be done at the end # For some stupid reason print("Finalizing") leaf = ab.inspect(lower_staff).leaf(0) ab.attach(ab.Clef('bass'), leaf) ab.attach(ab.TimeSignature(time_signature), staff[0][0]) ab.attach(key_signature, staff[0][0]) ab.attach(key_signature, staff[1][0]) score.add_final_bar_line() # Generate PDF print("Generating PDF") ab.show(score)