def inside(self): middle = float(len(self.items)) / 2 if middle % 2 != 0: return NoteSeq([self.items[int(middle - .5)]]) else: return NoteSeq( [self.items[int(middle - 1)], self.items[int(middle)]])
def determine_dominant_key(self, notes): ''' Takes a list of notes and compares it to each key, then returns the key which the notes match best. :param str notes: A list of notes in string format or as a pyknon.music.NoteSeq. :returns: A string representation of the dominant key (i.e. 'fminor') ''' if isinstance(notes, pyknon.music.NoteSeq): test_seq = notes else: if isinstance(notes, str): test_seq = NoteSeq(notes) elif isinstance(notes, list): test_seq = NoteSeq(''.join(notes)) else: raise ValueError( 'Notes supplied to determine_dominant_key not in a known format (list, string, NoteSeq)' ) key_score = {} for key in self.music_keys.keys(): key_score[key] = 0 for note in test_seq: for key, value in self.music_keys.items(): if note in value: key_score[key] = key_score[key] + 1 dominant_key = max(key_score, key=key_score.get) return dominant_key
def get_meter_notes(beats_sample, meter_signature, pitch_sample, octave_sample, volume_sample=120, shuffle_pitch_sample=True, shuffle_beats=True, n_beats=None): """ Return the sequence of notes """ notes = NoteSeq() # get the beats if shuffle_beats: beats = get_beats(beats_sample, meter_signature) else: beats = beats_sample if n_beats: beats = beats[:n_beats] vol = get_random_item(volume_sample) for ctr, beat in enumerate(beats): if shuffle_pitch_sample: pitch = get_random_item(pitch_sample) else: pitch = pitch_sample[ctr] note = pitch_to_note(pitch) octave = get_random_item(octave_sample) notes.append(Note(note, octave, beat, vol)) return notes
def test_stretch_inverval(self): seq1 = NoteSeq("C D E") seq2 = NoteSeq("C E G#") seq3 = NoteSeq("A Bb F#") seq4 = NoteSeq("A C#'' C''") self.assertEqual(seq1.stretch_inverval(2), seq2) self.assertEqual(seq3.stretch_inverval(3), seq4)
def strToMidi(msg, fileName): from pyknon.genmidi import Midi from pyknon.music import NoteSeq from pyknon.music import Note notes = { '0' : Note(value=0, octave=5), # Do '1' : Note(value=2, octave=5), # Re '2' : Note(value=4, octave=5), # Mi '3' : Note(value=5, octave=5), # Fa '4' : Note(value=7, octave=5), # Sol '5' : Note(value=9, octave=5), # La '6' : Note(value=11, octave=5), # Si '7' : Note(value=0, octave=6), '8' : Note(value=2, octave=6), '9' : Note(value=4, octave=6), 'a' : Note(value=5, octave=6), 'b' : Note(value=7, octave=6), 'c' : Note(value=9, octave=6), 'd' : Note(value=11, octave=6), 'e' : Note(value=0, octave=7), 'f' : Note(value=2, octave=7) } msgHex = msg.encode('hex'); sequence = NoteSeq('C1') before = '' for i in msgHex: if before == i: sequence.append(Note(value=4, octave=7)) sequence.append(notes[i]) before = i midi = Midi(1, tempo = 290) midi.seq_notes(sequence, track=0) midi.write(fileName)
def pix2noteseq(pixelmap, width, height): """ Convert a PIL pixel map to a PyKnon NoteSeq Use: pix2noteseq(pixelmap) Arguemnts: pixelmap: the PIL pixel map of the image width: the width in pixels height: height in pixels This function presumes the pixel map is in RGB and correct behavior when otherwise is not at all guaranteed. """ notes = NoteSeq() # Iterate over the pixels, starting at the top left and working # colomn by colomn for y in range(height): for x in range(width): notes.append(pix2note(pixelmap[x,y])) if y == math.ceil(height/2) and x == math.ceil(width/2): print("50% done...") return notes
def test_rotate(self): seq1 = NoteSeq("C E G") seq2 = NoteSeq("E G C") seq3 = NoteSeq("G C E") self.assertEqual(seq1.rotate(0), seq1) self.assertEqual(seq1.rotate(1), seq2) self.assertEqual(seq1.rotate(2), seq3) self.assertEqual(seq1.rotate(3), seq1)
def chord_prog(chords_note): cprog6251 = NoteSeq() count = 0 while count < 2: # while true if break for i in chords_note: cprog6251.append(Note(i, 4, 1, 100)) count += 1 return cprog6251
def crab_canon(filename): theme = NoteSeq("file://%s.notes" % filename) rev_theme = theme.transposition(-12).retrograde() midi = Midi(2, tempo=120) midi.seq_notes(theme) midi.seq_notes(rev_theme, track=1) midi.write("%s.mid" % filename)
def demo(): notes1 = NoteSeq("D4 F#8 A Bb4") notes2 = NoteSeq([Note(2, dur=1/4), Note(6, dur=1/8), Note(9, dur=1/8), Note(10, dur=1/4)]) midi = Midi(number_tracks=2, tempo=90) midi.seq_notes(notes1, track=0) midi.seq_notes(notes2, track=1) midi.write("midi/demo.mid")
def crab_canon(): theme2 = NoteSeq("file://canon-crab") rev_theme = theme2.transposition(-12).retrograde() midi = Midi(2, tempo=120) midi.seq_notes(theme2) midi.seq_notes(rev_theme, track=1) midi.write("midi/canon-crab.mid")
def random_notes(pitch_list, octave, duration, number_of_notes, volume=120): result = NoteSeq() for x in range(0, number_of_notes): pitch = choice(pitch_list) octave = choice_if_list(octave) dur = choice_if_list(duration) vol = choice_if_list(volume) result.append(Note(pitch, octave, dur, vol)) return result
def play_list(pitch_list, octave_list, duration, volume=120): result = NoteSeq() for pitch in pitch_list: note = pitch % 12 octave = choice_if_list(octave_list) dur = choice_if_list(duration) vol = choice_if_list(volume) result.append(Note(note, octave, dur, vol)) return result
def random_notes(pitch_list, octave_list, duration, volume): result = NoteSeq() number_of_notes = int(1 // duration) for x in range(0, number_of_notes, 1): pitch = choice(pitch_list) octave = choice(octave_list) dur = duration vol = volume result.append(Note(pitch, octave, dur, vol)) return result
def random_notes(pitch_list, octave_list, duration, number_of_notes, volume=120): result = NoteSeq() for x in range(0, number_of_notes): pitch = choice(pitch_list) octave = choice_if_list(octave_list) dur = choice_if_list(duration) vol = choice_if_list(volume) result.append(Note(pitch, octave, dur, vol)) return result
def test_init_empty(self): """Test if NoteSeq without arguments will clean previous values.""" seq = NoteSeq() seq.append(Note("C")) seq = NoteSeq() seq.append(Note("D")) self.assertEqual(seq, NoteSeq("D"))
def josquin(): main_theme = NoteSeq("file://josquin") theme1 = main_theme.stretch_dur(0.66666) theme2 = main_theme[0:24].stretch_dur(2).transp(Note("C")) theme3 = main_theme[0:50] midi = Midi(3, tempo=80) midi.seq_notes(theme1, track=0) midi.seq_notes(theme2, track=1) midi.seq_notes(theme3, track=2) midi.write("midi/josquin.mid")
def rhythm_16th_note_subdivided_right(self, chord: Chord) -> [NoteSeq]: # works best with subdivided = 20 chord = chord.stretch_dur(2 / self.subdivided) l1 = [NoteSeq([chord[0]])] + [NoteSeq([chord[1]])] l2 = [NoteSeq([chord[2]])] + [NoteSeq([chord[1]])] rhythm = [] for i in range(0, 4): rhythm += l1 + l2 return rhythm
def __init__(self, args, first_note=None, name=None): NoteSeq.__init__(self, args=args) if isinstance(first_note, Note): self.first_note = first_note elif first_note is None: self.first_note = self.items[0] if name is None: self.name = self.first_note.name else: self.name = name
def test_init(self): notes = [Note(0, 5), Note(2, 5)] seq1 = NoteSeq(notes) seq2 = NoteSeq("C#2' D#4''") seq3 = NoteSeq([Note(1, 5, 0.5), Note(3, 6, 0.25)]) self.assertEqual(seq1, NoteSeq(notes)) self.assertEqual(seq2, seq3) self.assertNotEqual(seq1, NoteSeq(notes + [Note(3, 5)])) self.assertRaises(MusiclibError, NoteSeq, [Note(1, 5, 0.5), Rest(2), 1]) self.assertRaises(MusiclibError, NoteSeq, 1)
def test_sum_with_rest(self): # Test adding in regular order rest1 = Rest(1) seq = NoteSeq("C2 D8 E4") expected = NoteSeq("C2 D8 E4 R1") self.assertEqual(seq + rest1, expected) # Test reverse adding, rest first seq = NoteSeq("C2 D8 E4") expected = NoteSeq("R1 C2 D8 E4") self.assertEqual(rest1 + seq, expected)
def test_sum_with_note(self): # Test adding in regular order note1 = Note("G1") seq = NoteSeq("C2 D8 E4") expected = NoteSeq("C2 D8 E4 G1") self.assertEqual(seq + note1, expected) # Test reverse adding, note first seq = NoteSeq("C2 D8 E4") expected = NoteSeq("G1 C2 D8 E4") self.assertEqual(note1 + seq, expected)
def getNotesFromNums(nums, scaleNum, durations): #convert back to noteSeq scale = majorScales[scaleNum] ans = NoteSeq() j = 0 for num in nums: for i in range(len(scale)): if num==i: ans.append(Note(scale[i], dur=durations[j])) j+=1 #print(ans) return ans
def test_harmonize(self): c_major = NoteSeq("C D E F G A B") c_major_harmonized = [ NoteSeq("C E G"), NoteSeq("D F A"), NoteSeq("E G B"), NoteSeq("F A C''"), NoteSeq("G B D''"), NoteSeq("A C'' E"), NoteSeq("B D'' F''") ] self.assertEqual(c_major.harmonize(), c_major_harmonized)
def rhythm_heart_and_soul_right(self, chord: Chord) -> [NoteSeq]: rhythm = [] new_chord = chord silence_chord = NoteSeq("R") rhythm.append(silence_chord.stretch_dur(8 / self.subdivided)) rhythm.append(new_chord.stretch_dur(4 / self.subdivided)) rhythm.append(new_chord.stretch_dur(4 / self.subdivided)) rhythm.append(silence_chord.stretch_dur(8 / self.subdivided)) rhythm.append(new_chord.stretch_dur(4 / self.subdivided)) rhythm.append(new_chord.stretch_dur(4 / self.subdivided)) return rhythm
def test_init_with_rest(self): seq1 = NoteSeq("C4 R4 D4") seq2 = NoteSeq("C8 R D") seq3 = NoteSeq([Note(0, dur=0.25), Rest(0.25), Note(2, dur=0.25)]) self.assertEqual(seq1[0].dur, 0.25) self.assertEqual(seq1[1].dur, 0.25) self.assertEqual(seq1[2].dur, 0.25) self.assertEqual(seq2[0].dur, 0.125) self.assertEqual(seq2[1].dur, 0.125) self.assertEqual(seq2[2].dur, 0.125) self.assertEqual(seq3[0].dur, 0.25) self.assertEqual(seq3[1].dur, 0.25) self.assertEqual(seq3[2].dur, 0.25)
def makemidi(self): note_names = 'c c# d d# e f f# g g# a a# b'.split() octav10 = { 'c10', 'c#10', 'd10', 'd#10', 'e10', 'f10', 'f#10', 'g10', 'g#10', 'a10', 'a#10', 'b10' } result = NoteSeq() for s in self.song: duration = 1. / s[1] if s[0] == 'r': result.append(Rest(dur=duration)) elif {s[0]}.issubset(octav10): md = s[0][:-2] octave = int(s[0][-2:]) + 1 note_number = note_names.index(md) result.append(Note(note_number, octave=octave, dur=duration)) else: md = s[0][:-1] octave = int(s[0][-1]) + 1 note_number = note_names.index(md) result.append(Note(note_number, octave=octave, dur=duration)) midi = Midi(number_tracks=1, tempo=self.bpm) midi.seq_notes(result, track=0) midi.write(self.path)
def test_stretch_interval(self): seq1 = NoteSeq("C D E") seq2 = NoteSeq("C E G#") seq3 = NoteSeq("A Bb F#") seq4 = NoteSeq("A C#'' C''") self.assertEqual(seq1.stretch_interval(2), seq2) self.assertEqual(seq3.stretch_interval(3), seq4)
def test_harmonize(self): c_major_scale = NoteSeq("C D E F G A B") scale_as_list = [ Note("C"), Note("D"), Note("E"), Note("F"), Note("G"), Note("A"), Note("B") ] c_major = Note("C").harmonize(c_major_scale, 3, 3) a_minor = Note("A").harmonize(scale_as_list, 3, 4) self.assertEqual(NoteSeq(c_major), NoteSeq("C E G")) self.assertEqual(NoteSeq(a_minor), NoteSeq("A C'' E G"))
def randomTune(): # creating a string of random notes from the pool noteString = '' for _ in range(NUMBER_OF_NOTES): noteString += random.choice(notesPoolA) + " " return NoteSeq(noteString)
def saveSong(self, filename): def nameFile(filename, iterator): return "".join(filename.split(".")[:-1]) + str( iterator) + "." + filename.split(".")[-1] if self.__notes != []: self.__addTrack() # for track in self.__tracks: # track.addPause() fileNameIterator = 0 for track in self.__tracks: midi = Midi(number_tracks=1, instrument=track.getInstrument().value) notes = NoteSeq(track.getNotes()) midi.seq_notes(notes, track=0) midi.write(nameFile(filename, fileNameIterator)) fileNameIterator += 1 fileNameIterator -= 1 if fileNameIterator > 0: for i in range(fileNameIterator): os.system("python midisox.py --combine concatenate " + nameFile(filename, i) + " " + nameFile(filename, i + 1) + " " + nameFile(filename, i + 1)) os.remove(nameFile(filename, i)) if os.path.exists(filename): os.remove(filename) os.rename(nameFile(filename, fileNameIterator), filename)
def randomTune(): #creamos un string de notas random para la agrupacion noteString = '' for _ in range(NUMBER_OF_NOTES): noteString += random.choice(notesPoolA) + " " return NoteSeq(noteString)
def midi_from_melodies(melodies): notes = [[Note(x%Octave, 4 + x//Octave, 1/4) for x in melody] for melody in melodies] chords = [NoteSeq([melody_notes[i] for melody_notes in notes]) for i in range(len(melody))] midi = Midi(tempo=120) midi.seq_chords(chords) return midi
def random_melody(note_list, octave_low, octave_high, dur_list): rm_seq = NoteSeq() #[] rm_data = [] melody_len = 0 while melody_len < 8: # while True if break bug pitch = random.choice(note_list) #refactor by root +2 +4 ... octave = random.randint(octave_low, octave_high) dur = random.choice(dur_list) vol = random.randrange(80, 125, 5) #refactor print([pitch, octave, dur, vol]) rm_seq.append(Note(pitch, octave, dur, vol)) #refactor rm_data.append([pitch, octave, dur, vol]) melody_len += dur print(melody_len) rm = [rm_seq, rm_data] return rm
def conform_notes_to_key(self, notes, music_key): ''' Takes a list of notes, and a music key and ensures that every note either belongs to that key or to its relative key. :param str notes: The notes to be matched :param str music_key: The name of the key to be matched (i.e. 'cmajor') :returns: A list of notes that are all in the specified key or its relative key. ''' if isinstance(notes, NoteSeq): test_notes = notes else: test_notes = NoteSeq(' '.join(notes)) new_note_list = [] key_notes = self.music_keys[music_key] relative_key = self.relative_keys[music_key] if relative_key: relative_key_notes = self.music_keys[relative_key] for note in test_notes: if note in key_notes or note in relative_key_notes: new_note_list.append(note) else: new_note = numpy.random.choice(key_notes + relative_key_notes) new_note_list.append(new_note) return new_note_list
def get_random_note_seq(notes: int, pitches: set, durations: set, rests=False): if rests: if random.randint(1, 20) is 1: pitches.add('r') notes *= random.randint(1, 2) this_seq = '' for i in range(notes): try: pitch = random.sample(pitches, 3) except: pitch = random.sample(pitches, 2) duration = random.sample(durations, 1) try: this_seq += pitch[0] + duration[0] + ' ' + pitch[1] + duration[ 1] + pitch[2] + duration[2] + pitch[0] + duration[ 0] + ' ' + pitch[1] + duration[1] + pitch[2] + duration[ 2] + pitch[0] + duration[0] + ' ' + pitch[ 1] + duration[1] + pitch[2] + duration[2] + ' ' except: try: this_seq += pitch[0] + duration[0] + ' ' + pitch[ 1] + duration[1] + ' ' except: this_seq += pitch[0] + duration[0] + ' ' return NoteSeq(this_seq)
def play_list(pitch_list, octave_list, duration, volume=120): result = NoteSeq() durl = [1/8, 1/8, 1/16, 1/16] cc = [choice([0,1,2,3,4,5,6,7,8,9,10,11]), choice([0,1,2,3,4,5,6,7,8,9,10,11]), choice([0,1,2,3,4,5,6,7,8,9,10,11]), choice([0,1,2,3,4,5,6,7,8,9,10,11])] st = 0 for pitch in pitch_list: note1 = pitch note = cc[st%4] #octave = choice_if_list(octave_list) octave = change_range(note1, 0, 11, 1, 7) #dur = choice_if_list(duration) dur = durl[st%4] st += 1 vol = choice_if_list(volume) result.append(Note(note, octave, dur, vol)) return result
def random_notes_with_memory(pitch_list, octave_list, duration_list, number_of_notes, memory_weights, volume=120): assert len(memory_weights) > 1, "more than 1 weight expected for memory" result = NoteSeq() for offset in range(0, number_of_notes): if 1+offset >= len(memory_weights): weights = memory_weights else: weights = memory_weights[0:1+offset] pitch_selection = weighted_random(weights) if pitch_selection == 0: # new note pitch = choice(pitch_list) else: pitch = result[-pitch_selection].value octave_selection = weighted_random(weights) if octave_selection == 0: # new note octave = choice_if_list(octave_list) else: # previous note at given position starting from the end octave = result[-octave_selection].octave duration_selection = weighted_random(weights) if duration_selection == 0: # new note dur = choice_if_list(duration_list) else: # previous note at given position starting from the end dur = result[-duration_selection].dur volume_selection = weighted_random(weights) if volume_selection == 0: # new note vol = choice_if_list(volume) else: # previous note at given position starting from the end vol = result[-volume_selection].volume result.append(Note(pitch, octave, dur, vol)) return result
def test_inversion_startswith_integer(self): seq1 = NoteSeq("C E G") seq2 = NoteSeq("C Ab, F,") self.assertEqual(seq1.inversion_startswith(0), seq2)
def test_transposition(self): seq = NoteSeq("C E G") self.assertEqual(seq.transposition(3), NoteSeq("Eb G Bb")) self.assertEqual(seq.transposition(5), NoteSeq("F A C''"))
indices = range(1, size*i, i) return self.harmonize_template(scale, indices) Note.harmonize_template = note_harmonize_template Note.harmonize = note_harmonize def noteseq_harmonize_template(self, indices): return [\ NoteSeq(note.harmonize_template(self, indices)) for note in self\ ] NoteSeq.harmonize_template = noteseq_harmonize_template c = Note("C") assert str(c) == '<C>' c_major_scale = NoteSeq("C D E F G A B") assert str(c_major_scale) == '<Seq: [<C>, <D>, <E>, <F>, <G>, <A>, <B>]>' assert str(c.harmonize(c_major_scale)) == '[<C>, <E>, <G>]' assert str(c.harmonize_template(c_major_scale, [1, 3, 5])) == '[<C>, <E>, <G>]' assert str(c.harmonize_template(c_major_scale, [1, 2, 3])) == '[<C>, <D>, <E>]' assert str(c.harmonize_template(c_major_scale, [1, 4, 2])) == '[<C>, <F>, <D>]' assert str(c.harmonize_template(c_major_scale, [5, 7, 9])) == '[<G>, <B>, <D>]' assert str(c.harmonize_template(c_major_scale, [1, 2, 3, 4])) == \ '[<C>, <D>, <E>, <F>]' assert str(c.harmonize_template(c_major_scale, [1, 3, 5, 6, 8])) == \ '[<C>, <E>, <G>, <A>, <C>]' assert str(c_major_scale.harmonize()) == '[' \
def test_retrograde(self): seq1 = NoteSeq("C4 D8 E8") seq2 = NoteSeq("E8 D8 C4") self.assertEqual(seq1.retrograde(), seq2)
def test_intervals(self): seq = NoteSeq("C D E F#") self.assertEqual(seq.intervals(), [2, 2, 2])
def test_transposition_with_rest(self): seq1 = NoteSeq("C8 D R E") self.assertEqual(seq1.transposition(3), NoteSeq("Eb8 F R G"))
def test_stretch_dur(self): seq1 = NoteSeq("C4 D8 E8") seq2 = NoteSeq("C8 D16 E16") seq3 = NoteSeq("C2 D4 E4") self.assertEqual(seq1.stretch_dur(.5), seq2) self.assertEqual(seq1.stretch_dur(2), seq3)
def test_append(self): seq1 = NoteSeq("C# D#") seq1.append(Note("F#")) seq2 = NoteSeq("C# D# F#") self.assertEqual(seq1, seq2)
def test_transposition_startswith(self): seq1 = NoteSeq("E G C#") seq2 = NoteSeq([Note(2, 5), Note(5, 5), Note(11, 4)]) seq3 = NoteSeq([Note(2, 4), Note(5, 4), Note(11, 3)]) self.assertEqual(seq1.transposition_startswith(Note(2, 5)), seq2) self.assertEqual(seq1.transposition_startswith(Note(2, 4)), seq3)
def test_transposition_startswith_string(self): seq1 = NoteSeq("C D E") seq2 = NoteSeq("D E F#") self.assertEqual(seq1.transposition_startswith("D"), seq2)
def test_transposition_startswith_rest(self): seq1 = NoteSeq("E G R C#") seq2 = NoteSeq([Note(2, 5), Note(5, 5), Rest(), Note(11, 4)]) self.assertEqual(seq1.transposition_startswith(Note(2, 5)), seq2)
def test_inversion_startswith(self): seq1 = NoteSeq("C E G") seq2 = NoteSeq([Note(1, 5), Note(9, 4), Note(6, 4)]) self.assertEqual(seq1.inversion_startswith(Note(1, 5)), seq2)
def test_inversion_rest(self): seq1 = NoteSeq("C E R G") seq2 = NoteSeq([Note(0, 5), Note(8, 4), Rest(), Note(5, 4)]) self.assertEqual(seq1.inversion(0), seq2)
def test_inversion_octave(self): seq1 = NoteSeq("G Ab B,") seq2 = NoteSeq("G F# Eb''") self.assertEqual(seq1.inversion(7), seq2)
def test_intervals(self): seq1 = NoteSeq("C D E F#") seq2 = NoteSeq("B' C''") self.assertEqual(seq1.intervals(), [2, 2, 2]) self.assertEqual(seq2.intervals(), [1])
def test_inversion_startswith_octave(self): seq1 = NoteSeq("G Ab B,") seq2 = NoteSeq("E Eb C''") self.assertEqual(seq1.inversion_startswith(Note(4, 5)), seq2)
def test_inversion_startswith_string(self): seq1 = NoteSeq("C E G") seq2 = NoteSeq("C Ab, F,") self.assertEqual(seq1.inversion_startswith("C"), seq2)
def test_harmonize(self): c_major = NoteSeq("C D E F G A B") c_major_harmonized = [NoteSeq("C E G"), NoteSeq("D F A"), NoteSeq("E G B"), NoteSeq("F A C''"), NoteSeq("G B D''"), NoteSeq("A C'' E"), NoteSeq("B D'' F''")] self.assertEqual(c_major.harmonize(), c_major_harmonized)
def test_transposition_startswith_integer(self): seq1 = NoteSeq("C D E") seq2 = NoteSeq("D E F#") self.assertEqual(seq1.transposition_startswith(2), seq2)
def test_insert(self): seq1 = NoteSeq("Ab Bb Eb") seq1.insert(2, Note("C#")) seq2 = NoteSeq("Ab Bb C# Eb") self.assertEqual(seq1, seq2)