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 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 generate_bar(difficulty: float):
some_bar = Bar('C', (4, 4))
values = [
value.whole, value.half, value.quarter,
value.dots(value.half), value.eighth,
value.dots(value.quarter), value.sixteenth,
value.dots(value.eighth), value.quarter,
value.dots(value.quarter)
]
actual_values = []
pitches = [
Note("A", 3),
Note("B", 3),
Note("C", 4),
Note("D", 4),
Note("E", 4),
Note("F", 4),
Note("G", 4),
Note("A", 4),
Note("B", 4),
Note("C", 5),
Note("D", 5),
Note("E", 5),
Note("F", 5),
Note("G", 5),
Note("A", 5),
Note("B", 5),
Note("C", 6)
]
if difficulty >= 10:
actual_values = values
else:
index = math.ceil(difficulty)
actual_values = values[0:index]
while some_bar.place_notes(choice(pitches), choice(actual_values)):
pass
if not some_bar.is_full():
some_bar.place_notes(choice(pitches), some_bar.value_left())
return some_bar
#randomly invert before adding
if random() > 0.7: # and randVal < 0.8:
modChord = chords.second_inversion(modChord)
elif random() > 0.7:
modChord = chords.third_inversion(modChord)
container = NoteContainer(modChord)
#write a melody
leadBar = Bar(key, meter)
noteLengths = [2, 4, 8]
lastNote = Note()
lastNoteLength = 4
while leadBar.is_full() == False:
if random() < 0.8:
currentBeat = leadBar.current_beat
# add a note
# if random() < 0.5 and len(leadBar) > 0:
# n = Note(intervals.second(lastNote.name, key))
# print("second of last")
if random() < 0.5 and currentBeat != 0.0:
n = Note(intervals.second(choice(container).name, key))
# print("second")
elif random() < 0.5 and currentBeat != 0.0:
n = Note(intervals.seventh(choice(container).name, key))
# print("seventh")
else:
n = Note(choice(container).name)
# print("in chord")
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)
