def get_chord(self, root, is_major):
third = root + 4 if is_major else root + 3
fifth = root + 7
return Chord(
[self.get_note(root),
self.get_note(third),
self.get_note(fifth)])
def get_real_universe_dist(cls, U, V):
zero_hit = (Chord([Note('c0')]), 0)
if len(U) == 0:
U = [zero_hit]
if len(V) == 0:
V = [zero_hit]
# sum(dist(u,v) for all u,v)
total_sum = 0
for u in U:
for v in V:
total_sum += cls.get_real_pairwise_dist(u, v)
normed_sum = total_sum / (len(U) * len(V))
return normed_sum
def generate_song(
notes_per_chord,
num_repeats,
note_time=0.25,
prog_intervals=(7, 2, -4j, 5)
):
# generate a random major key
root = Note(rand.choice(Note.NOTES))
scale_notes = Scale(root, 'major')
octave = 3
progression = Chord.progression(
Scale(
root,
[int(p.real + p.imag) for p in prog_intervals]
),
octave
)
for i, z in enumerate(prog_intervals):
if z.imag != 0:
# TODO: cannot have a repeated chord be minor
progression[i] = major_to_minor(progression[i])
# generates a melody for the progression
low_octave = 4
prev_note = rand.choice(list(scale_notes)).at_octave(low_octave)
melody = []
for _ in range(notes_per_chord * len(progression) * num_repeats):
note_dist = int(round(rand.gauss(0, 2)))
prev_note = scale_notes.transpose(prev_note, note_dist)
melody.append(prev_note)
# build up the HLR from the melody progression
song = []
t = 0
for i in range(num_repeats):
for chord in progression:
song.append(
(t*note_time, chord, note_time*notes_per_chord)
)
t += notes_per_chord
for i in range(len(melody)):
note = melody[i]
song.append((i*note_time, Chord([note]), note_time))
return song
def get_hlr_from_latent(self, latent):
song = []
t = 0
for i in range(self.num_repeats):
for j in range(self.num_chords):
chord_root = latent[2 * j]
is_major = latent[2 * j + 1]
chord = self.get_chord(chord_root, is_major)
song.append((t * self.time_per_note, chord,
self.time_per_note * self.notes_per_chord))
t += self.notes_per_chord
num_melody_notes = self.num_repeats * self.num_chords
num_melody_notes *= self.notes_per_chord
offset = 2 * self.num_chords
for i in range(num_melody_notes):
song.append((i * self.time_per_note,
Chord([self.get_note(latent[offset + i])]),
self.time_per_note))
return song
def major_to_minor(chord):
root = chord.notes[0]
third = chord.notes[1]
minor_third = third.transpose(-1)
fifth = chord.notes[2]
return Chord([root, minor_third, fifth])
