def load_from_song(self, song): ''' Fills a mingus-composition object with the data of a Song object ''' if 'bar_length' in song.info: try: self.bar_length = song.info['bar_length'] except: print ("You need to specify length of a Bar first before you can do this") for line in song.lines: track = Track() bar = Bar() for segment in line.segments: if segment.type == 'pause': int_val = None elif segment.type == 'note': int_val = segment.pitch n = Note().from_int(int_val + 48) note_length = float(self.bar_length) / segment.duration if not bar.place_notes(n, note_length): track.add_bar(bar) bar = Bar() bar.place_notes(n, note_length) track.add_bar(bar) self.composition.add_track(track) self.path = song.path self.song_name = song.reader.file_name[:-4]
def load_from_song(self, song): ''' Fills a mingus-composition object with the data of a Song object ''' if 'bar_length' in song.info: try: self.bar_length = song.info['bar_length'] except: print "You need to specify length of a Bar first before you can do this" for line in song.lines: track = Track() bar = Bar() for segment in line.segments: if segment.type == 'pause': int_val = None elif segment.type == 'note': int_val = segment.pitch n = Note().from_int(int_val + 48) note_length = float(self.bar_length) / segment.duration if not bar.place_notes(n, note_length): track.add_bar(bar) bar = Bar() bar.place_notes(n, note_length) track.add_bar(bar) self.composition.add_track(track) self.path = song.path self.song_name = song.reader.file_name[:-4]
def generate(self): nr_of_bars = random.randint(3,10) diatonic = self.get_major_scale("A") # example : ['C', 'Db', 'Eb', 'F', 'G', 'Ab', 'Bb'] arrangement = self.basic_song_structure() # arragement.structure and arragement.parts are used generated_parts = [] for i in range(0,len(arrangement["parts"])): proggresion = self.random_progression(diatonic,"-2") rhythm = self.gen_rhythm(proggresion) generated_bar_with_rhythm = self.gen_with_rhythm(proggresion,rhythm,diatonic) print "proggresiion ="+ str(proggresion) print "rhythm= " + str(rhythm) generated_bar = self.gen_simple(diatonic,4,proggresion) generated_parts.append(generated_bar_with_rhythm) song = Track() for i in arrangement["structure"]: song.add_bar(generated_parts[i]) self.gen_rhythm(proggresion) return song
def shift(track, pause_duration): key = track[0].key shifted_track = Track() bar = Bar(key=key) bar.place_rest(pause_duration) input_note_containers = track.get_notes() for note in input_note_containers: placed = bar.place_notes(note[-1], note[1]) if not placed: beat_left = 1.0 - bar.current_beat beats_part_1 = beat_left beats_part_2 = 1 / note[1] - beats_part_1 if beats_part_1 != 0: duration_part_1 = 1 / beats_part_1 bar.place_notes(note[-1], duration_part_1) shifted_track.add_bar(copy.deepcopy(bar)) bar = Bar(key=key) duration_part_2 = 1 / beats_part_2 bar.place_notes(note[-1], duration_part_2) shifted_track.add_bar(copy.deepcopy(bar)) return shifted_track
def createMingusComposition(intermed, timesig, bIsTreble, bSharps): comp = Composition() comp.set_title('Trilled Results') comp.set_author('Author') if bIsTreble: ins = TrebleInstrument('') else: ins = BassInstrument('') track = Track(ins) track.name = 'Part 1' comp.add_track(track) assert len(timesig) == 2 and isinstance(timesig[0], int) and isinstance( timesig[1], int) firstbar = Bar(meter=timesig) track.add_bar(firstbar) mapDurs = { int(intermed.baseDivisions * 4): 1.0, #whole note, int(intermed.baseDivisions * 2): 2.0, #half note int(intermed.baseDivisions * 1): 4.0, #qtr note, and so on int(intermed.baseDivisions * 0.5): 8.0, int(intermed.baseDivisions * 0.25): 16.0, int(intermed.baseDivisions * 0.125): 32.0, int(intermed.baseDivisions * 0.0625): 64.0, } for note in intermed.noteList: if note.pitch == 0 or note.pitch == (0, ): # a rest thepitches = tuple() else: # a note thepitches = [] for pitch in note.pitch: pname, poctave = music_util.noteToName(pitch, bSharps) thepitches.append(pname + '-' + str(poctave)) dur = note.end - note.start if dur not in mapDurs: raise NotesinterpretException('Unknown duration:' + str(dur)) notecontainer = NoteContainer(thepitches) notecontainer.tied = note.isTied bFit = track.add_notes(notecontainer, mapDurs[dur]) assert bFit #note that, naturally, will enforce having correct measure lines, since going across barline throughs exception return comp
def reverse(track, key='C'): # Copy value of reference to aviod problems with overwriting input_track = copy.deepcopy(track) #empty track to write to later reversed_track = Track() b = Bar(key) reversed_track.add_bar(b) #create a reversed list of notes from input track input_notes = input_track.get_notes() reversed_notes = reversed(list(input_notes)) #Add notes to reversed_track for note in reversed_notes: reversed_track.add_notes(note[-1], duration=note[1]) # Return reversed track return reversed_track
def play_smart_solo_over_chords(chord_list): fluidsynth.set_instrument(13, 45) fluidsynth.set_instrument(10, 108) fluidsynth.main_volume(13, 75) fluidsynth.main_volume(10, 100) solo = Track() bars = generate_solo(chord_list) for i in range(len(bars)): chord = NoteContainer(chords.from_shorthand(chord_list[i])) bar = bars[i] fluidsynth.play_NoteContainer(chord, 13) fluidsynth.play_Bar(bar, 10) fluidsynth.stop_NoteContainer(chord, 13) solo.add_bar(bar) return solo
def createMingusComposition(intermed, timesig, bIsTreble, bSharps): comp = Composition() comp.set_title('Trilled Results') comp.set_author('Author') if bIsTreble: ins = TrebleInstrument('') else: ins=BassInstrument('') track = Track(ins) track.name = 'Part 1' comp.add_track(track) assert len(timesig)==2 and isinstance(timesig[0],int) and isinstance(timesig[1],int) firstbar = Bar(meter=timesig) track.add_bar(firstbar) mapDurs={ int(intermed.baseDivisions*4): 1.0, #whole note, int(intermed.baseDivisions*2): 2.0, #half note int(intermed.baseDivisions*1): 4.0, #qtr note, and so on int(intermed.baseDivisions*0.5): 8.0, int(intermed.baseDivisions*0.25): 16.0, int(intermed.baseDivisions*0.125): 32.0, int(intermed.baseDivisions*0.0625): 64.0, } for note in intermed.noteList: if note.pitch==0 or note.pitch==(0,): # a rest thepitches = tuple() else: # a note thepitches = [] for pitch in note.pitch: pname, poctave = music_util.noteToName(pitch,bSharps) thepitches.append(pname+'-'+str(poctave)) dur = note.end - note.start if dur not in mapDurs: raise NotesinterpretException('Unknown duration:' + str(dur)) notecontainer = NoteContainer(thepitches) notecontainer.tied = note.isTied bFit = track.add_notes(notecontainer, mapDurs[dur]) assert bFit #note that, naturally, will enforce having correct measure lines, since going across barline throughs exception return comp
def notes_durations_to_track(_notes, durations=None): ''' params: - _notes: list of list of Notes [['G','B','D','F'], ['C','E','G','B']] - durations: Durations should be a list of integers e.g. [2,2,1] will give | chord 1 chord 2 | chord 3 | TO-DO: - mingus durations are limited to =< 1 bar; we want to be able to parse a duration of '0.5' (because in mingus '4'=crotchet i.e. num subdivs) to refer to 2 bars (just use 1/d) ''' if durations is None: durations = [1] * len(_notes) t = Track() for i, _note in enumerate(_notes): b = Bar() b.place_notes(_note, durations[i]) t.add_bar(b) return t
def sheets_from_peaks(peaks): """Generate and open the sheet music pdf that represents the notes contained in peaks.""" bass_range = Instrument() bass_range.set_range(['A-0', 'C-4']) bass_track = Track(bass_range) treble_range = Instrument() treble_range.set_range(['C-4', 'C-8']) treble_track = Track(treble_range) treble_track.add_bar(Bar()) bass_track.add_bar(Bar()) for time_slice in peaks: bass_chord, treble_chord = [], [] for note_index, note_value in enumerate(time_slice): if note_value: # add 9 to note_index to start at A-0 note = Note().from_int(note_index + 9) if bass_range.note_in_range(note): bass_chord.append(note) elif treble_range.note_in_range(note): treble_chord.append(note) if bass_chord == treble_chord == []: continue for chord, track in ((bass_chord, bass_track), (treble_chord, treble_track)): if track.bars[-1].is_full(): track.add_bar(Bar()) if chord: print chord track.bars[-1] + chord print track else: track.bars[-1].place_rest(4) print bass_track print treble_track merge_rests(treble_track, bass_track) save_and_print(treble_track, bass_track)
class TrackBuilder(object): def __init__(self): self.track = Track() def fill_bars(self, arpeggio, note_duration=16, bars=1): generator = arpeggio.get_generator() while bars > 0: b = Bar() b.key = 'C' while not b.is_full(): b.place_notes(generator.next(), note_duration) self.track.add_bar(b) bars -= 1 return self.track def from_dsl(self, string): plan, bpm, loop = dsl.parse_string(string) for x in range(loop): for arpeggio, duration in plan: self.fill_bars(arpeggio, duration[0], duration[1]) return self.track, bpm
def change_speed(track, factor, key, up=True): changed_track = Track() #if factor is 0 we return an empty track if (factor != 0.0): input_track = copy.deepcopy(track) input_notes = input_track.get_notes() b = Bar(key=key) changed_track.add_bar(b) #if we want to speed up (notespeed *= factor) if up: for note in input_notes: changed_track.add_notes(note[-1], int(note[1] * factor)) #if we want to slow down (notespeed *= (1/factor)) else: for note in input_notes: changed_track.add_notes(note[-1], int(note[1] / factor)) return changed_track
class TrackBuilder(object): def __init__(self): self.track = Track() def fill_bars(self, arpeggio, note_duration = 16, bars = 1): generator = arpeggio.get_generator() while bars > 0: b = Bar() b.key = 'C' while not b.is_full(): b.place_notes(generator.next(), note_duration) self.track.add_bar(b) bars -= 1 return self.track def from_dsl(self, string): plan, bpm, loop = dsl.parse_string(string) for x in range(loop): for arpeggio, duration in plan: self.fill_bars(arpeggio, duration[0], duration[1]) return self.track, bpm
def main(config_path): pickle_in = open("saved_winners.pickle", "rb") genomes = pickle.load(pickle_in) pickle_in.close() config = neat.config.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_path) for x, genome in enumerate(genomes): trainer.eval_fitness([(1, genome)], config) fitness = genome.fitness float_name = fitness * 1000 int_name = int(float_name) name = str(int_name) os.mkdir(name) for i in range(15): song = trainer.generate_song(x + 1) track = Track() for bar in song: track.add_bar(bar) xml = musicxml.from_Track(track) path = name + "\\" + str(i) + ".musicxml" xml_file = open(path, "w") xml_file.write( '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 2.0 Partwise//EN"\n "http://www.musicxml.org/dtds/partwise.dtd">\n' + xml)
# that's stupid # http://www.youtube.com/watch?v=5pidokakU4I prg = [tr("C"), tr("G"), tr("A"), tr("F")] bars = [] for chord in prg: b = Bar() b.place_notes(chord, 4) bars.append(b) t = Track() for b in bars: t.add_bar(b) instrs = list(enumerate(MidiInstrument.names)) shuffle(instrs) for i, name in instrs: print i, name fluidsynth.set_instrument(1, i) fluidsynth.play_Track(t)
def init_preset_track(num): track = Track() if num == 1: #C-chord track.add_notes(None) track.add_notes(None) nc = NoteContainer(["C", "E"]) track.add_notes(nc) track + "E-5" track + "A-3" track.add_notes(None) track + "C-5" track + "E-5" nc2 = NoteContainer(["F", "G"]) track.add_notes(nc2) track + "G-5" track + "C-6" if num == 2: track + "E" track + "D" track + "E" track + "A-2" track + "C" track + "D" track + "E" track + "F-5" track + "D" track + "E" track + "E-5" if num == 3: test_scale = scales.Major("C") for i in range(7): track + test_scale[i] if num == 4 or num == 'blinka': bar = Bar() bar.place_notes('C-4', 8) bar.place_notes('C-4', 8) bar.place_notes('G-4', 8) bar.place_notes('G-4', 8) bar.place_notes('A-4', 8) bar.place_notes('A-4', 8) bar.place_notes('G-4', 4) track.add_bar(bar) if num == "nokia": #scale A track.add_notes('E-4', 16) track.add_notes('D-4', 16) track.add_notes('F#-3', 8) track.add_notes('G#-3', 8) track.add_notes('C#-4', 16) track.add_notes('B-3', 16) track.add_notes('D-3', 8) track.add_notes('E-3', 8) track.add_notes('B-3', 16) track.add_notes('A-3', 16) track.add_notes('A-3', 8) if num == "windows": #scale C# track.add_notes('D#-5', 4) track.add_notes('A#-4', 8) track.add_notes('G#-4', 4) track.add_notes('D#-5', 8) track.add_notes(['A#-3', 'D#-4', 'A#-4'], 4) if num == "brick": #scale C track.add_notes('E-4', 4) track.add_notes('B-3', 8) track.add_notes('C-4', 8) track.add_notes('D-4', 4) track.add_notes('C-4', 8) track.add_notes('B-3', 8) if num == "panther": #Scale E track.add_notes('D#-4', 8) track.add_notes('E-4', 8 / 3) track.add_notes('F#-4', 8) track.add_notes('G-4', 8 / 3) return track
def generate_midi(instrument, key, chord_progression, pad, octave=None, applause=False): composition = Composition() how_many_bars = 16 # Make all these configurable # Or make them all random from a range track = Track(instrument, channel=1) drone_track = track_creator(pad, channel=2) # drone_track = track_creator("Pad4 (choir)", channel=2) # It's one of the few pitched drums timpani_track = track_creator("Timpani", channel=3) applause_track = track_creator("Applause", channel=4) bar = Bar(key, (4, 4)) nc = NoteContainer("C", octave=2) bar.place_notes(nc, 1) applause_track.add_bar(bar) for _ in range(how_many_bars): # Can we get an index # We can with enumerate, but why do we want it for chord in chord_progression: # The Chord Progression bar = Bar(key, (4, 4)) if not octave: octave = INSTRUMENT_OCTAVE.get(instrument.name, 4) for length in random.sample(CHORD_RHYTHMS, 1)[0]: some_notes = random.sample(chord, random.randint(1, len(chord))) nc = NoteContainer(some_notes, octave=int(octave)) bar.place_notes(nc, length) track.add_bar(bar) drone_bar = Bar(key, (4, 4)) nc = NoteContainer(chord[0], octave=2) drone_bar.place_notes(nc, 1) drone_track.add_bar(drone_bar) timpani_bar = Bar(key, (4, 4)) nc = NoteContainer(key, octave=2) for length in [4, 4, 4, 4]: timpani_bar.place_notes(nc, length) timpani_track.add_bar(timpani_bar) composition.add_track(timpani_track, channel=5) composition.add_track(drone_track) composition.add_track(track) # Do we want to add the channel when adding or creating the track? if applause: composition.add_track(applause_track) instrument_name = MidiInstrument.names[instrument.instrument_nr] write_Composition(midi_file_name(instrument_name), composition, bpm=120)
def __init__(self, name): self.name = name Instrument.__init__(self) comp = Composition() comp.set_title('The Mingus') comp.set_author('Ben') ins = TrebleInstrument('kazoo') track = Track(ins) track.name = 'WWW' #instead of 'untitled' comp.add_track(track) firstbar = Bar(meter=(3,4)) track.add_bar(firstbar) print track.add_notes(['C-5'], 4.0) print track.add_notes(['E-5'], 2.0) print track.add_notes(['C-4','D-4'], 8.0) print track.add_notes(['C-4','D-4','F-4'], 8.0) print track.add_notes([], 8.0) #treated as rest? print track.add_notes(['C-4','D-4'], 8.0) print track.add_notes(['C-4','D-4'], 8.0) print track.add_notes(['C-4','D-4'], 8.0) print track.add_notes(['C-4','D-4'], 24.0) print track.add_notes(['C-4','D-4'], 24.0) print track.add_notes(['C-4','D-4'], 24.0) print track.add_notes(['C-4','D-4'], 8.0) s = MusicXML.from_Composition(comp)
def gen_midi(self, tracks_data): c = Composition() all_tracks = tracks_data["tracks_data"] curr_track = 0; for track_data in all_tracks: #TODO: set author, title, more specific instrument (that has a #range set data_max = max(track_data["note_data"]) data_min = min(track_data["note_data"]) data_dur_max = max(track_data["dur_data"]) data_dur_min = min(track_data["dur_data"]) data_range = data_max - data_min ####DURATIONS#### midi_durs = [self.map_range(0, len(self.mapping_dur_vals) - 1, data_dur_min, data_dur_max, x, "dur") for x in track_data["dur_data"]] midi_durs = [self.mapping_dur_vals[int(x)] for x in midi_durs] print "midi_durs: " print midi_durs ####PITCHES#### midi_vals = [self.map_range(0, len(self.overall_mapping_vals) - 1, data_min, data_max, x, "notes") for x in track_data["note_data"]] midi_vals = [self.overall_mapping_vals[int(x)] for x in midi_vals] print "midi_pitches: " print midi_vals for instr in self.instrs: t = Track() b = Bar() for index, midi_val in enumerate(midi_vals): print "-----------------" print "space left in bar" print b.space_left() if midi_val in instr["mapping_vals"]: print "inserting NON-REST NOTE" print "inserting NON-REST NOTE" val_to_insert = Note().from_int(int(midi_val)) print "DONE INSERTING NON-REST NOTE" else: print "INSERTING REST" val_to_insert = None #insert rest instead print "ABOUT TO INSERT" dur_to_insert_1 = 1.0/((1.0/float(midi_durs[index])) * 0.99) dur_to_insert_2 = 1.0/((1.0/float(midi_durs[index])) * 0.01) b, insert_result_1 = self.insert_into_bar(curr_track, b, val_to_insert, dur_to_insert_1) print "trying to insert note..." print insert_result_1 print "midi note DURATION is: " print midi_durs[index] if insert_result_1: b, insert_result_2 = self.insert_into_bar(curr_track, b, None, dur_to_insert_2) print "trying to insert note..." print insert_result_2 print "midi note DURATION is: " print midi_durs[index] if not insert_result_1: if b.space_left() == 0.0: print "hit edge case!!!!" t.add_bar(b) b = Bar() b, insert_result = self.insert_into_bar(curr_track, b, val_to_insert, dur_to_insert_1) b, insert_result = self.insert_into_bar(curr_track, b, None, dur_to_insert_2) print "bar is now (after edge case): " print b continue space_p = b.space_left() space = 1.0/space_p print "space percentage left: " print space_p print "note space left: " print space note_remainder = value.subtract(midi_durs[index], space) print "note duration: " print midi_durs[index] print "note remainder: " print note_remainder print "bar before INSERTING PART 1 OF TIE: " print b dur_to_insert_1_space = 1.0/((1.0/float(space)) * 0.99) dur_to_insert_2_space = 1.0/((1.0/float(space)) * 0.01) if space <= 16.0: print "NOTE IS LARGER THAN 16 NOTE" b, insert_result = self.insert_into_bar(curr_track, b, val_to_insert, dur_to_insert_1_space) b, insert_result = self.insert_into_bar(curr_track, b, None, 1.0/b.space_left()) else: print "NOTE IS *NOT* LARGER THAN 16 NOTE" b, insert_result = self.insert_into_bar(curr_track, b, None, space) print "bar AFTER: " print b print "inserting part one of tie result: " print insert_result print "is bar full??? (IT SHOULD BE)" print b.is_full() t.add_bar(b) b = Bar() b, insert_result = self.insert_into_bar(curr_track, b, None, note_remainder) print "inserting part TWO of tie result: " print insert_result print "bar after inserting remaining piece: " print b print "BAR IS NOW" print b #end for #add last bar if b.space_left() == 0.0: t.add_bar(b) else: #need to fill remaining space with rest space_p = b.space_left() space = 1.0/space_p #b, insert_result = self.insert_into_bar(curr_track, b, # Note(None), space) print "result for filling rest of last bar with rest: " print insert_result print "is bar full after adding rest to end of last bar??? (IT SHOULD BE)" print b.is_full() print "bar WITH REST is now: " print b t.add_bar(b) logger.debug("Track: ") logger.debug(t) #at very end of loop add track to composition c.add_track(t) curr_track += 1 #write_Composition("midi_success.mid", c); return self.gen_midi_data(c)
leadBar.place_notes(n, lastNoteLength) else: # add a rest leadBar.place_rest(choice(noteLengths)) lead.append(leadBar) for note in container: note = note.octave_down() noteLengths = [1] bar = Bar(key, meter) bar.place_notes(container, choice(noteLengths)) comp.append(bar) track = Track() for bar in comp: track.add_bar(bar) leadTrack = Track() for bar in lead: leadTrack.add_bar(bar) composition = Composition() composition.add_track(track) # composition.add_track(leadTrack) MidiFile.write_Composition("musgen.mid", composition) MidiFile.write_Track("musgenLead.mid", leadTrack)
def compose(primary_pc_sets, rhythm_cycles, ensemble, meter, bpm, stability, repeat_chance, repeat_attempts, repeat_loops, repetitions, filename = 'output.mid'): """ Generates a post-tonal composition and resultant midi file using the given materials (function arguments) in conjunction with stochastic processes. Takes a list of PcSets, a list of Rythm_cycles, a list of Instruments, an integer tuple for meter (time signature), an integer for bpm (tempo), a floats for stability and repeat_chance, integers for repeat_loops and repetitions, and a string for output filename. """ for pc_set in primary_pc_sets: assert isinstance(pc_set, PcSet) for rhythm_cycle in rhythm_cycles: assert isinstance(rhythm_cycle, Rhythm_cycle) for instrument in ensemble: assert isinstance(instrument, Instrument) assert isinstance(meter, tuple) assert isinstance(bpm, int) assert isinstance(stability, int) or isinstance(stability, float) assert stability >= 0 and stability <= 100 assert isinstance(repeat_chance, int) or isinstance(repeat_chance, float) assert repeat_chance >= 0 and repeat_chance <= 100 assert isinstance(repeat_attempts, int) assert repeat_attempts in range(0, 101) assert isinstance(repeat_loops, int) assert repeat_loops in range(0, 101) assert isinstance(repetitions, int) assert repetitions in range(0, 101) assert isinstance(filename, str) # print parameters: print "\nBasic Parameters:\n" print "Meter: " + str(meter) print "BPM: " + str(bpm) print "Repeat chance:" + str(repeat_chance) print "Repeat attempts:" + str(repeat_attempts) print "Repeat loops:" + str(repeat_loops) print "Repetitions: " + str(repetitions) print "Output Destination: " + filename print "\nPrimary Pitch-Class Sets:" for index, item in enumerate(primary_pc_sets): interval_vector = item.ivec() common_tone_vector = ctvec(item) print "\n#" + str(index+1) + ":" print "Pitch-Class Set: " + str(item) print "Interval Vector: " + str(interval_vector) print "Common-Tone Vector: " + str(common_tone_vector) print "\nRhythm Cycles:" for index, rhythm in enumerate(rhythm_cycles): print "\n#" + str(index+1) + ":" rhythm_cycles[-1].display() # compose pc_set_progression sections: pc_set_progression = list() section_length = list() # section 1: for index in range(len(primary_pc_sets)): for primary_pc_set in primary_pc_sets[0:index+1]: spectrum = transposition_spectrum(primary_pc_set) contrast = index if contrast not in range(len(spectrum)): contrast = len(spectrum)-1 pc_set_progression.extend(neighbor_by_contrast(primary_pc_set, contrast)) section_length.append(len(pc_set_progression)) # section 2: for index, primary_pc_set in enumerate(primary_pc_sets[0:-1]): spectrum = transposition_spectrum(primary_pc_set) contrast = index if contrast not in range(len(spectrum)): contrast = len(spectrum)-1 pc_set_progression.extend(palindrome_successive_neighbor_by_contrast(primary_pc_set, contrast, len(primary_pc_sets[0:-1])-index)) section_length.append(len(pc_set_progression)) # section 3: primary_pc_set = primary_pc_sets[-1] spectrum = transposition_spectrum(primary_pc_set) contrast = len(spectrum)-1 pc_set_progression.extend(cadential_progressive_successive_neighbor(primary_pc_set)) section_length.append(len(pc_set_progression)) # section 4: for index, primary_pc_set in enumerate(reversed(primary_pc_sets)): spectrum = transposition_spectrum(primary_pc_set) contrast = len(spectrum)-(1+index) if contrast not in range(len(spectrum)): contrast = 0 pc_set_progression.extend(neighbor_by_contrast(primary_pc_set, contrast)) section_length.append(len(pc_set_progression)) print "\nSection lengths:" for item in section_length: print str(item) print "\nPitch-Class Set Progression:" for index, item in enumerate(pc_set_progression): print str(index) + ": " + str(item) # compose pc_sequence: pc_sequence = list() print "\nPitch-Class Sequence:" for pc_set in pc_set_progression: seq = Pc_sequence(pc_set, repeat_chance, repeat_attempts, repeat_loops) pc_sequence.append(seq) print str(pc_sequence[-1].sequence) instrument = ensemble[0] track = Track(instrument) track.name = instrument.name composition = Composition() #title = "my title" #composition.set_title(title) #print composition.title #author = "Pierrot" #composition.set_author(author) #print composition.author note = Note() track.add_bar(Bar()) track.bars[-1].set_meter(meter) count = 0 cur_rhythm_cycle = 0 cur_section = 0 first_note = False for index, item in enumerate(pc_sequence): orchestrator = Orchestrator(item, instrument, stability) while not orchestrator.completed(): # select rhythm cycle if index == len(pc_sequence)-1: cycle = rhythm_cycles[cur_rhythm_cycle] else: if count == 0: cycle = rhythm_cycles[cur_rhythm_cycle] elif count % section_length[cur_section] == 0: cur_rhythm_cycle += 1 cur_section += 1 if cur_rhythm_cycle == len(rhythm_cycles): cur_rhythm_cycle = 0 if cur_section == len(section_length): cur_section = 0 cycle = rhythm_cycles[cur_rhythm_cycle] print "\ncount = " + str(count) print "rhythm cycle # " + str(cur_rhythm_cycle) print "section # " + str(cur_section) print "section length = " + str(section_length[cur_section]) unit = cycle.get_next_unit() print "cycle position = " + str(cycle.get_index()) print "unit value = " + str(unit.get_value()) if track.bars[-1].is_full(): track.add_bar(Bar()) track.bars[-1].set_meter(meter) if unit.is_rest(): print "unit is rest" if not track.bars[-1].place_rest(unit.get_value()): print "not enough room in bar" if track.bars[-1].space_left() == 0: print "adding new bar" track.add_bar(Bar()) track.bars[-1].set_meter(meter) value_left = track.bars[-1].value_left() if track.bars[-1].space_left >= 1.0/unit.get_value(): print "placing rest" track.bars[-1].place_rest(unit.get_value()) else: difference = subtract(unit.get_value(), value_left) while difference != 0: print "spliting rest across bars" track.bars[-1].place_rest(value_left) track.add_bar(Bar()) track.bars[-1].set_meter(meter) if space_left >= 1.0/difference: track.bars[-1].place_rest(difference) break else: print "unit is note" note = orchestrator.next() if not first_note: first_note = note print str(next) if not track.bars[-1].place_notes(note, unit.get_value()): print "not enough room in bar" if track.bars[-1].space_left() != 0: value_left = track.bars[-1].value_left() print "value left = " + str(value_left) cur_beat = track.bars[-1].current_beat print "filling in remaining space" track.bars[-1].place_notes(note, value_left) value_needed = subtract(unit.get_value(), value_left) print "adding bars to fit full value" track.add_bar(Bar()) track.bars[-1].set_meter(meter) value_bar = track.bars[-1].value_left() bars_added = 1 while 1.0/value_needed > 1.0/value_bar: print "adding bar" track.add_bar(Bar()) track.bars[-1].set_meter(meter) value_needed = subtract(value_needed, value_bar) bars_added+=1 if not track.bars[-bars_added].place_notes_at(cur_beat, unit.get_value()): print "could not fit value" count+=1 note = first_note composition.add_track(track) write_Composition(filename, composition, bpm, repetitions) print "\n" print repr(composition) print "\nCompleted." print "\nOutput saved as: " + filename + "\n" return
def play_Music(filename): f = open(filename, 'rb') data = json.loads(f.read(), encoding='utf8') f.close() n = data['音符'] h = data['音高'] r = data['节拍'] l = data['组成'] k = data['调性'] t = Track() b = Bar('C', (4, 4)) b.place_rest(1) t.add_bar(b) name = 'CDEFGAB' symbol = '!@#$%^&' def tran(x): if x >= 'a': return ord(x) - 87 elif x == '0': return 0.5 else: return float(x) f = open(filename, 'rb') data = json.loads(f.read(), encoding='utf8') f.close() n = data['音符'] h = data['音高'] r = data['节拍'] l = data['组成'] k = data['调性'] t = Track() b = Bar('C', (4, 4)) b.place_rest(1) t.add_bar(b) name = 'CDEFGAB' symbol = '!@#$%^&' for i in range(len(l)): rn = list(map(tran, r[l[i]])) b = Bar('C', (4 * sum(rn)/8, 4)) for j in range(len(n[l[i]])): if n[l[i]][j] == '0': b.place_rest(8 / rn[j]) else: x = symbol.find(n[l[i]][j]) if x == -1: x = int(n[l[i]][j]) - 1 y = name[x] else: y = name[x] + '#' print(y) note = Note(y, int(h[l[i]][j])) note.transpose(k[i]) b.place_notes(note, 8 / rn[j]) t.add_bar(b) t2 = Track() b = Bar('C', (4, 4)) b.place_rest(1) t2.add_bar(b) for i in range(int(sum(map(sum, map(lambda x: map(tran, r[x]), l)))) // 8): b = Bar('C', (4, 4)) b.place_notes('C-3', 4) b.place_notes('C-7', 4) b.place_notes('C-5', 4) b.place_notes('C-7', 4) t2.add_bar(b) m = MidiFile() mt = MidiTrack(150) mt2 = MidiTrack(150) mt3 = MidiTrack(150) m.tracks = [mt,mt2,mt3] mt.set_instrument(1, 25) mt.play_Track(t) # for _, _, i in t2.get_notes(): # if i is not None: # i[0].set_channel(2) # mt2.set_instrument(2, 115) # mt2.play_Track(t2) # for _, _, i in t.get_notes(): # if i is not None: # i[0].set_channel(3) # mt3.set_instrument(3, 100) # mt3.track_data += mt3.controller_event(3, 7, 30) # mt3.play_Track(t) # m.write_file('D:/test.midi', False) # for i in range(len(l)): # rn = list(map(tran, r[l[i]])) # b = Bar('C', (4 * sum(rn) / 8, 4)) # for j in range(len(n[l[i]])): # # if i==0 and j==0: # # b.place_notes('D-4', 3) # # el # if n[l[i]][j] == '0': # b.place_rest(1 / rn[j]) # else: # x = symbol.find(n[l[i]][j]) # if x == -1: # x = int(n[l[i]][j]) - 1 # y = name[x] # else: # y = name[x] + '#' # print(y) # # note = Note(y, int(h[l[i]][j])) # note.transpose(k[i]) # #print(note) # print(rn[j]) # #print(b) # b.place_notes(note, 1 / rn[j]) # t.add_bar(b) # print(b) fluidsynth.init("D:\MyCode\MyPython\AiMusicCoach\GeneralUserSoftSynth\GeneralUserSoftSynth.sf2") fluidsynth.set_instrument(1, 1) #24=Nylon Guitar # 25=Steel Guitar # 26=Jazz Guitar # 27=Clean Guitar # 28=Muted Guitar # 29=Overdrive Guitar # 30=Distortion Guitar m.write_file('D:\MyCode\MyPython\AiMusicCoach\Backend\music_file\mysong.midi', False) os.system("d: && cd D:\\MyCode\\MyPython\\AiMusicCoach\\fluidsynth-x64\\bin && fluidsynth -F mysong.wav D:/MyCode/MyPython/AiMusicCoach/GeneralUserSoftSynth/GeneralUserSoftSynth.sf2 D:\MyCode\MyPython\AiMusicCoach\Backend\music_file\mysong.midi") fluidsynth.play_Track(t, channel=1, bpm=150)
from improv import generate_solo from subprocess import call num_progressions = 4 chords_list = ['CM', 'G7', 'CM7', 'FM7', 'G7', 'Am7', 'G7', 'C#+'] chords_bars = [] for chord in chords_list: chord_nc = NoteContainer(chords.from_shorthand(chord)) bar = Bar() bar.place_notes(chord_nc, 1) chords_bars.append(bar) solo_track = Track() chords_track = Track() for _ in range(num_progressions): for bar in generate_solo(chords_list): solo_track.add_bar(bar) for bar in chords_bars: chords_track.add_bar(bar) guitar = MidiInstrument() guitar.instrument_nr = 26 solo_track.instrument = guitar piano = MidiInstrument() piano.instrument_nr = 0 chords_track.instrument = piano song = Composition() song.add_track(solo_track) song.add_track(chords_track)
def write_song(melody): unl = keys.get_notes(melody.key) note_list = randomList() note_list.setDefaultWeight(100) note_list.add(unl, recursive=True) note_list.add(None, (random.gauss(25, 10))) print(note_list.normalisedWeights()) print(note_list.list) wds = randomList() td = melody.tempo - 120.0 #scaling for these is kinda wonky but whatever full = 0 half = 0 quarter = 0 eighth = 0 sixteenth = 0 if (td < 0): #half notes - more often (180) for faster tempos, less often (90) for slower tempos half = max(0, random.gauss(120.0 + (td / 2), 60)) #full notes - 1.25x as often for faster tempos, half as often for slower tempos full = max(0, random.gauss((120.0 + (td / 2)) / 2, 60)) #sixteenth notes - less often (90) for faster tempos, more often (180) for slower tempos sixteenth = max(0, random.gauss((120.0 - td), 60)) else: half = max(0, random.gauss(120.0 + (td / 2), 60)) full = max(0, random.gauss((120.0 + (td / 2)) * 1.25, 60)) sixteenth = max(0, random.gauss((120.0 - (td / 4)), 60)) #quarter notes - 120 median always quarter = max(0, random.gauss(120, 60)) #eighth notes - 120 median always eighth = max(0, random.gauss(120, 60)) wds.add(1, full) wds.add(2, half) wds.add(4, quarter) wds.add(8, eighth) wds.add(16, sixteenth) melody.weights = wds.normalisedWeights() sig = random.choice(signatures) print(sig) t = Track() i = 0 numBars = melody.length while (i < numBars): b = Bar(melody.key, sig) while (b.current_beat != b.length): duration = wds.pickWeighted() n = note_list.pickWeighted() while (n == None and (duration <= 2 or duration > 8 or b.current_beat == 0 or melody.raw_song[-1][0] == None)): n = note_list.pickWeighted() if (b.place_notes(n, duration)): melody.raw_song.append((n, duration)) t.add_bar(b) i = i + 1 return t
import mingus import mingus.extra.musicxml as musicxml import mingus.core.notes as notes import mingus.core.value as value from mingus.containers import Note from mingus.containers import Bar from mingus.containers import Track import pickle song = Track() bar = Bar() bar.place_notes(Note('C', 4), value.whole) song.add_bar(bar) bar = Bar() bar.place_notes(Note('C', 4), value.half) bar.place_notes(Note('C', 4), value.half) song.add_bar(bar) bar = Bar() bar.place_notes(Note('C', 4), value.quarter) bar.place_notes(Note('C', 4), value.quarter) bar.place_notes(Note('C', 4), value.quarter) bar.place_notes(Note('C', 4), value.quarter) song.add_bar(bar) bar = Bar()
def main(): repo = Repo(sys.argv[1]) factory = cf.ConverterFactory() converter = factory.get_converter("mod") curtime = datetime.datetime.now() if (len(sys.argv) == 3): target_file = sys.argv[2] else: target_file = "gitmelody" + str(curtime.year) + str(curtime.month) + str(curtime.hour) \ + str(curtime.minute) + str(curtime.second) + ".mid" commits = list(repo.iter_commits('master')) timesignature = converter.getTimeSignature(commits) tsValue = timesignature[0] / timesignature[1] print(tsValue) print(timesignature) #nc = NoteContainer() bar = Bar() if timesignature != None: bar.set_meter((timesignature[0], timesignature[1])) t = Track() t2 = Track() dursum = 0 tsValue = 1 c = Composition() #durations are between 1 and 128 for item in commits: #note_item = get_note_from_commit(item.stats.total) note_item = converter.getNoteFromCommit(item.stats.total) if (dursum + (1 / note_item[1]) <= tsValue): dursum = dursum + 1 / note_item[1] bar.place_notes(note_item[0], note_item[1]) else: dursum = 0 if (bar.space_left() > 0): booleanValue = bool(random.getrandbits(1)) if booleanValue == True: bar.place_notes(note_item[0], bar.space_left()) else: bar.place_rest(bar.space_left()) t.add_bar(bar) second_line = converter.getChordOrArpeggio(bar) t2.add_bar(second_line) bar = Bar() bar.set_meter((timesignature[0], timesignature[1])) c.add_track(t) c.add_track(t2) print(bar.meter) #bar.place_notes(note_item[0], note_item[1]) #t.add_notes(note_item[0]) #print(item.stats.total['insertions']) #print(item.stats.additions) #print(item.stats.deletions) #print(item.stats.total)a #nc = NoteContainer(["A", "C", "E"]) #midi_file_out.write_Track(target_file, t) midi_file_out.write_Composition(target_file, c)
# Generate the first note generator = NoteGenerator(notes=notes, duration=4)#, conditions={0: condition1}) generator.add_notes_to(bar1, count=4) # This line add the first note to the bar defined above prev_notes = generator.added_notes ''' # Generate the second note notes = note_collection(['D', 'F#', 'A']) allowed_condition_1 = lambda parameters: True if (parameters['prev_note'] != parameters['current_note']) else False generator = NoteGenerator(notes=notes, duration=4, allowed_conditions=[allowed_condition_1], parameters={'prev_note': prev_notes[FIRST]}) generator.add_notes_to(bar, count=1) # This line add the second note to the bar defined above ''' # Add bar to the track track.add_bar(bar1) bar2 = Bar() generator.add_notes_to(bar2, count=4) track.add_bar(bar2) bar3 = Bar() generator.add_notes_to(bar3, count=4) track.add_bar(bar3) bar4 = Bar() generator.add_notes_to(bar4, count=3) last_note_collection = note_collection(['C', 'E', 'G', 'B']) last_generator = NoteGenerator(notes=last_note_collection, duration=4) last_generator.add_notes_to(bar4, count=1)
def generate_longer_fugue(key, subject, nr_parts=1, order_of_parts=None): #If subject doesn't fill full bars fill out rest of last bar of subject with rest #if last bar is not full if not (subject[-1].is_full()): #place a rest at the end of the last bar with the length of 1/(remaining fraction of bar) subject[-1].place_rest(int(1.0 / subject[-1].space_left())) # Create first bar with subject in first voice and rest in second voice. rest_1bar = Bar(key) rest_1bar.place_rest(1) first_voice = copy.deepcopy(subject) #Add same amount of "rest bars" as the number of bars in the subject for i in range(len(subject)): second_voice.add_bar(copy.deepcopy(rest_1bar)) total_nr_evolutionary_parts = 3 + 3 * nr_parts # Create second bar with answer in second voice. answer = Track_Functions.create_answer(subject, key) Track_Functions.add_tracks(second_voice, answer) # Generate countersubject nr_current_generated = 1 eg_counter = EvolutionaryGenerator(key, nr_bars=1, fitness_function='counter', input_melody=subject, nr_generations=counter_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_counter.run_evolution() counter_subject = copy.deepcopy(eg_counter.best_individual) Track_Functions.add_tracks(first_voice, counter_subject) # Save subject, answer and countersubject first_voice_first_part = copy.deepcopy(first_voice) second_voice_first_part = copy.deepcopy(second_voice) # Save bar 2 for later modulation bar_prev = first_voice[-1] variants = ['Minor', 'Reverse', 'Inverse'] iParts = 0 if order_of_parts is None: order_of_parts = [] for i in range(nr_parts): rVariant = rnd.choice(variants) order_of_parts.append(rVariant) while iParts < nr_parts: current_variant = order_of_parts[iParts] if current_variant == 'Minor': # Generate development in minor # Transposed -3 to minor (stämma i second voice tills vidare tom) new_first_voice = Track_Functions.transpose_to_relative_minor( first_voice, key, False) new_second_voice = Track_Functions.transpose_to_relative_minor( second_voice, key, False) bar_after = new_first_voice[0] # Generate harmony in second voice first bar eg_harmony = EvolutionaryGenerator( key, nr_bars=1, fitness_function='harmony', input_melody=Track().add_bar(copy.deepcopy( new_first_voice[0])), nr_generations=harmony_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_harmony.run_evolution() new_second_voice[0] = eg_harmony.best_individual[0] elif current_variant == 'Reverse': # Generate reverse development new_first_voice = Track_Functions.reverse(first_voice_first_part, key) new_second_voice = Track_Functions.reverse(second_voice_first_part, key) bar_after = new_first_voice[0] # Generate harmony in second voice first bar eg_harmony = EvolutionaryGenerator( key, nr_bars=1, fitness_function='harmony', input_melody=Track().add_bar(copy.deepcopy( new_first_voice[1])), nr_generations=harmony_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_harmony.run_evolution() new_second_voice[1] = eg_harmony.best_individual[0] elif current_variant == 'Inverse': # Generate inverse development new_first_voice = Track_Functions.inverse(first_voice_first_part) new_second_voice = Track_Functions.inverse(second_voice_first_part) bar_after = new_first_voice[0] # Generate harmony in second voice first bar eg_harmony = EvolutionaryGenerator( key, nr_bars=1, fitness_function='harmony', input_melody=Track().add_bar(copy.deepcopy( new_first_voice[0])), nr_generations=harmony_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_harmony.run_evolution() new_second_voice[0] = eg_harmony.best_individual[0] # Generate the two bars linking this new part to the previous parts eg_modulate = EvolutionaryGenerator( key, nr_bars=2, fitness_function='modulate', from_bar=bar_prev, to_bar=bar_after, nr_generations=modulate_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_modulate.run_evolution() modulate_first_voice = copy.deepcopy(eg_modulate.best_individual) # Generate second voice as harmony to this linking part eg_second_voice_modulate = EvolutionaryGenerator( key, nr_bars=2, fitness_function='harmony', input_melody=modulate_first_voice, nr_generations=harmony_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_second_voice_modulate.run_evolution() modulate_second_voice = copy.deepcopy( eg_second_voice_modulate.best_individual) # Add new bars to the voice tracks Track_Functions.add_tracks(first_voice, modulate_first_voice) Track_Functions.add_tracks(second_voice, modulate_second_voice) Track_Functions.add_tracks(first_voice, new_first_voice) Track_Functions.add_tracks(second_voice, new_second_voice) bar_prev = first_voice[-1] iParts += 1 # Create canon in bar 9 and 10. # subject i first voice # second voice is subject but shifted (half a bar for now) canon_first_voice = Track() canon_first_voice.add_bar(copy.deepcopy(subject[0])) bar_after = canon_first_voice[0] canon_second_voice = Track_Functions.shift(subject, 2) # Create modulation from minor to major in 7 and 8 eg_modulate_to_major = EvolutionaryGenerator( key, nr_bars=2, fitness_function='modulate', from_bar=bar_prev, to_bar=bar_after, nr_generations=modulate_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_modulate_to_major.run_evolution() modulate_back_first_voice = copy.deepcopy( eg_modulate_to_major.best_individual) # Generate second voice as harmony to the first voice in bar 7 and 8 eg_second_voice_modulate_back = EvolutionaryGenerator( key, nr_bars=2, fitness_function='harmony', input_melody=modulate_first_voice, nr_generations=harmony_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) nr_current_generated += 1 eg_second_voice_modulate_back.run_evolution() modulate_back_second_voice = copy.deepcopy( eg_second_voice_modulate.best_individual) # Add bar 7-10 to the voice tracks Track_Functions.add_tracks(first_voice, modulate_back_first_voice) Track_Functions.add_tracks(second_voice, modulate_back_second_voice) Track_Functions.add_tracks(first_voice, canon_first_voice) Track_Functions.add_tracks(second_voice, canon_second_voice) # Add cadence ending to second voice Track_Functions.second_voice_ending(second_voice, key) second_voice_ending = Track().add_bar(copy.deepcopy(second_voice[-3])) second_voice_ending.add_bar(copy.deepcopy(second_voice[-2])) # Generate harmony to cadence in first voice first_voice_last_bar = Track_Functions.first_voice_ending(first_voice, key) eg_first_voice_ending = EvolutionaryGenerator( key, nr_bars=2, fitness_function='ending', input_melody=second_voice_ending, from_bar=subject[0], to_bar=first_voice_last_bar[0], nr_generations=harmony_nr_generations) print( f"Generating evolutionary part {nr_current_generated} of {total_nr_evolutionary_parts}" ) eg_first_voice_ending.run_evolution() first_voice_ending = copy.deepcopy(eg_first_voice_ending.best_individual) Track_Functions.add_tracks(first_voice, first_voice_ending) Track_Functions.add_tracks(first_voice, first_voice_last_bar) #Add voices together to create a final composition fugue.add_track(first_voice) fugue.add_track(second_voice) #Generate lilypond file for fugue named final_fugue (removed for submission) finished_fugue = LilyPond.from_Composition(fugue) to_LilyPond_file(finished_fugue, "final_fugue") #Generate MIDI output for fugue named final_fugue midi_file_out.write_Composition("final_fugue.mid", fugue) return
def Track_from_list(listt=[[[0.0, 8.0, None], [0.125, 16.0, ['C-6']]]]): t = Track() for bars in listt: t.add_bar(bars) return t
def generate_fugue(key, subject): #If subject doesn't fill full bars fill out rest of last bar of subject with rest #if last bar is not full if not (subject[-1].is_full()): #place a rest at the end of the last bar with the length of 1/(remaining fraction of bar) subject[-1].place_rest(int(1.0 / subject[-1].space_left())) # Create first bar with subject in first voice and rest in second voice. rest_1bar = Bar(key) rest_1bar.place_rest(1) first_voice = copy.deepcopy(subject) #Add same amount of "rest bars" as the number of bars in the subject for i in range(len(subject)): second_voice.add_bar(copy.deepcopy(rest_1bar)) # Create second bar with answer in second voice. answer = Track_Functions.create_answer(subject, key) #second_voice = second_voice + answer Track_Functions.add_tracks(second_voice, answer) # Generate countersubject eg_counter = EvolutionaryGenerator(key, nr_bars=1, fitness_function='counter', input_melody=subject, nr_generations=counter_nr_generations) print('Generating evolutionary part 1 of 7') eg_counter.run_evolution() counter_subject = copy.deepcopy(eg_counter.best_individual) Track_Functions.add_tracks(first_voice, counter_subject) # Save bar 2 for later modulation bar_2 = first_voice[-1] # Generate development in minor in bar 5 and 6. # Transposed -3 to minor + (stämma i för second voice tills vidare tom) minor_first_voice = Track_Functions.transpose_to_relative_minor( first_voice, key, False) minor_second_voice = Track_Functions.transpose_to_relative_minor( second_voice, key, False) bar_5 = minor_first_voice[0] # Generate harmony in second voice in bar 5 eg_harmony_minor = EvolutionaryGenerator( key, nr_bars=1, fitness_function='harmony', input_melody=Track().add_bar(copy.deepcopy(minor_first_voice[0])), nr_generations=harmony_nr_generations) print('Generating evolutionary part 2 of 7') eg_harmony_minor.run_evolution() minor_second_voice[0] = eg_harmony_minor.best_individual[0] # Generate bar 3 and 4 as a modulation between bar 2 and 5 eg_modulate_to_minor = EvolutionaryGenerator( key, nr_bars=2, fitness_function='modulate', from_bar=bar_2, to_bar=bar_5, nr_generations=modulate_nr_generations) print('Generating evolutionary part 3 of 7') eg_modulate_to_minor.run_evolution() modulate_first_voice = copy.deepcopy(eg_modulate_to_minor.best_individual) # Generate second voice as harmony to the first voice in bar 3 and 4 eg_second_voice_modulate = EvolutionaryGenerator( key, nr_bars=2, fitness_function='harmony', input_melody=modulate_first_voice, nr_generations=harmony_nr_generations) print('Generating evolutionary part 4 of 7') eg_second_voice_modulate.run_evolution() modulate_second_voice = copy.deepcopy( eg_second_voice_modulate.best_individual) # Add bar 3-6 to the voice tracks Track_Functions.add_tracks(first_voice, modulate_first_voice) Track_Functions.add_tracks(second_voice, modulate_second_voice) Track_Functions.add_tracks(first_voice, minor_first_voice) Track_Functions.add_tracks(second_voice, minor_second_voice) bar_6 = first_voice[-1] # Create canon in bar 9 and 10. # subject i first voice # second voice is subject but shifted (half a bar for now) canon_first_voice = Track() canon_first_voice.add_bar(copy.deepcopy(subject[0])) bar_9 = canon_first_voice[0] canon_second_voice = Track_Functions.shift(subject, 2) # Create modulation from minor to major in 7 and 8 eg_modulate_to_major = EvolutionaryGenerator( key, nr_bars=2, fitness_function='modulate', from_bar=bar_6, to_bar=bar_9, nr_generations=modulate_nr_generations) print('Generating evolutionary part 5 of 7') eg_modulate_to_major.run_evolution() modulate_back_first_voice = copy.deepcopy( eg_modulate_to_major.best_individual) # Generate second voice as harmony to the first voice in bar 7 and 8 eg_second_voice_modulate_back = EvolutionaryGenerator( key, nr_bars=2, fitness_function='harmony', input_melody=modulate_first_voice, nr_generations=harmony_nr_generations) print('Generating evolutionary part 6 of 7') eg_second_voice_modulate_back.run_evolution() modulate_back_second_voice = copy.deepcopy( eg_second_voice_modulate.best_individual) # Add bar 7-10 to the voice tracks Track_Functions.add_tracks(first_voice, modulate_back_first_voice) Track_Functions.add_tracks(second_voice, modulate_back_second_voice) Track_Functions.add_tracks(first_voice, canon_first_voice) Track_Functions.add_tracks(second_voice, canon_second_voice) # Add cadence ending to second voice Track_Functions.second_voice_ending(second_voice, key) second_voice_ending = Track().add_bar(copy.deepcopy(second_voice[-3])) second_voice_ending.add_bar(copy.deepcopy(second_voice[-2])) # Generate harmony to cadence in first voice first_voice_last_bar = Track_Functions.first_voice_ending(first_voice, key) eg_first_voice_ending = EvolutionaryGenerator( key, nr_bars=2, fitness_function='ending', input_melody=second_voice_ending, from_bar=subject[0], to_bar=first_voice_last_bar[0], nr_generations=harmony_nr_generations) print('Generating evolutionary part 7 of 7') eg_first_voice_ending.run_evolution() first_voice_ending = copy.deepcopy(eg_first_voice_ending.best_individual) Track_Functions.add_tracks(first_voice, first_voice_ending) Track_Functions.add_tracks(first_voice, first_voice_last_bar) #Add voices together to create a final composition fugue.add_track(first_voice) fugue.add_track(second_voice) #Generate lilypond file for fugue named final_fugue finished_fugue = LilyPond.from_Composition(fugue) to_LilyPond_file(finished_fugue, "final_fugue") #Generate MIDI output for fugue named final_fugue midi_file_out.write_Composition("final_fugue.mid", fugue)
first = random.choice([0, 1, 2, 3, 4]) second = random.choice([-1, 1]) third = second * 2 # if you get a triplet just put three in there for good measure gypsy_bar.place_notes(gypsy_scale[first], duration=duration) gypsy_bar.place_notes(gypsy_scale[first + second], duration=duration) gypsy_bar.place_notes(gypsy_scale[first + third], duration=duration) else: note = random.choice(gypsy_scale) if note is None: gypsy_bar.place_rest(duration=duration) else: gypsy_bar.place_notes(note, duration=duration) print(gypsy_bar) midi_file_out.write_Bar("gypsy_bar_" + version + ".mid", gypsy_bar) gypsy_track.add_bar(gypsy_bar) print(gypsy_track) drum_track = Track() kick = drums["kick"] snare = drums["snare"] hat = drums["hatclosed"] # for dbar in range(0, 20): drum_bar = Bar() drum_bar.place_notes(NoteContainer([kick, hat]), value.eighth) drum_bar.place_notes(hat, value.eighth) drum_bar.place_notes(NoteContainer([kick, hat, snare]), value.eighth) drum_bar.place_notes(hat, value.eighth) drum_bar.place_notes(NoteContainer([kick, hat]), value.eighth) drum_bar.place_notes(hat, value.eighth)
from mingus.containers import Note from mingus.containers import NoteContainer from mingus.containers import Bar from mingus.containers import Track from mingus.containers.instrument import Instrument, Piano, Guitar from mingus.containers import Composition from mingus.midi.midi_file_out import write_Composition eb = Note("Eb", 4) g = Note("G", 4) bb = Note("Bb", 4) n = NoteContainer([eb, g, bb]) c = Composition() c.set_author('Dusty Carver', '*****@*****.**') c.set_title('Late Nights') t = Track(Guitar()) b = Bar('Eb', (4, 4)) b.place_notes(n, 4) b.place_notes(n, 4) b.place_notes(n, 4) b.place_notes(None, 4) t.add_bar(b) c.add_track(t) write_Composition("one.mid", c)