def major_triad(note): """Get the major triad of a Note :param note: Note :returns: Chord """ mingus_chord = _MingusChord.major_triad(note.letter) return Chord.mingusChord_to_chord(mingus_chord, note)
def getChordOrArpeggio(self, input_bar): notes = input_bar.get_note_names() random.seed() chord = chords.major_triad(notes[random.randint(0,len(notes) - 1)]) new_bar = Bar() #nc = NoteContainer(chord) #new_bar.place_notes(nc, 1) #return new_bar if(len(notes) % 2 != 0): #this will be a chord nc = NoteContainer(chord) new_bar.place_notes(nc, 1) return new_bar else: #this will be an arpeggio duration = 0 print(str(len(chord))) for note in chord: if(duration == 0): duration = 2 else: duration = 4 new_bar.place_notes(note, duration) return new_bar
def test_major_triad(self): self.assertEqual(["C", "E", "G"], chords.major_triad("C")) self.assertEqual(["E", "G#", "B"], chords.major_triad("E")) self.assertEqual(["Eb", "G", "Bb"], chords.major_triad("Eb"))
def generate_accompaniment(net_output_chords): generated_chords = [] chords = [] for chord in net_output_chords: root, key = (chord.split(":")) print(root, key) if key == 'maj': chords.append(ch.major_triad(root)) if key == 'min': chords.append(ch.minor_triad(root)) print(chords) key = chords[0][0] print('key', key) if not fluidsynth.init(SF2): print("Couldn't load soundfont", SF2) sys.exit(1) print(dir(fluidsynth.midi)) # fluidsynth.midi.start_audio_output() fluidsynth.midi.start_recording() phrase = 0 while phrase == 0: i = 0 for chord in chords: print("chord", chord) c = NoteContainer(chords[i]) generated_chords.append([{'note':cc.name.replace("B#","B").replace("E#","E").replace("##","#"), 'octave':cc.octave} for cc in c]) l = Note(c[0].name) p = c[1] l.octave_down() print(ch.determine(chords[i])[0]) # Play chord and lowered first note # fluidsynth.midi.MidiFileOut.write_NoteContainer("test.mid", c) print("NEW CHORD = ", c) if PLAY_ENABLED: fluidsynth.play_NoteContainer(c) fluidsynth.play_Note(l) time.sleep(1.0) # Play highest note in chord fluidsynth.play_Note(c[-1]) # 50% chance on a bass note if random() > 0.50: p = Note(c[1].name) p.octave_down() fluidsynth.play_Note(p) time.sleep(0.50) # 50% chance on a ninth if random() > 0.50: l = Note(intervals.second(c[0].name, key)) l.octave_up() fluidsynth.play_Note(l) time.sleep(0.25) # 50% chance on the second highest note if random() > 0.50: fluidsynth.play_Note(c[-2]) time.sleep(0.25) fluidsynth.stop_NoteContainer(c) fluidsynth.stop_Note(l) fluidsynth.stop_Note(p) i += 1 print("-" * 20) phrase = 1 return generated_chords
def get_diatonic_upper_chord_extension(chord, extension, key=None, mode='major'): ''' params: - chord is a (parsed) shorthand symbol e.g. 'Dm7' - extension is an integer representing the target extension (e.g. 3 to give the 3rd (major or minor)) ''' root, chord_type = chord_note_and_family(chord) extension_index = { 1: 0, 3: 1, 5: 2, 7: 3, 9: 4, 2: 4, 11: 5, 4: 5, 13: 6, 6: 6 } # we consider the thirteenth chords which arise from diatonic chord extensions only, # we then check if our chord is a subchord of any of these diatonic thirteenths; # if it is, then we assume that it plays the role of the chord (roman numeral) which is most likely to generate that thirteenth. # e.g. if we find a G13 then we assume it comes from G7 (V7 in C) # More details: # if key is not specified, then default to the most conventional extensions for a given chord type (https://en.wikipedia.org/wiki/Extended_chord#Chord_structure # Note: Would this be different in a different mode/tonality (e.g. extend me a IV chord while playing a locrian tune...)? Should probably factor this in... (TO-DO) # See also https://www.reddit.com/r/musictheory/comments/8becrf/when_to_apply_which_chord_extension/ # M7 -> M13 (M7, 9, #11*, 13) *by convention # m7 -> m13 (m7, 9, 11, 13) # 7 -> 13 (7, 9, 11, 13) # m7b5 -> m7b5b9b13 (7, b9, 11, b13) (e.g. B D F A -> B D F A C E G) # if key is specified then we can work out the degree of our chord (e.g. an FM7 in C is a IV chord) and be more clever with extensions # IM7 -> M13#11 # IIm7 -> m13 (e.g. DFACEGB) - note that this has a major 13th (https://music.stackexchange.com/questions/16932/why-does-a-cm13-chord-use-a-instead-of-a) # IIIm7 -> m13b9 # IVM7 -> M13#11 # V7 -> 13 # VIm7 -> m7b13 (e.g. ACEGBDF) # VIIm7b5 -> m7b5b9b13 def assume_key(root, chord_type, mode): if mode == 'harmonic_minor': if chord_type in ['7b9']: # assume V (C7b9 implies F harmonic minor, i.e. 7b9 is phyrgian dominant (V mode of HM)) TODO: refactor? return notes.int_to_note(notes.note_to_int(root) - 7) if chord_type in ['M7', 'M9', 'M13', 'M6']: return root elif chord_type in ['m7', 'm9', 'm11', 'm13']: # assume II, e.g. Dm7 -> return C return notes.int_to_note(notes.note_to_int(root) - 2) elif chord_type in ['m7b9', 'm11b9', 'm13b9']: # assume III return notes.int_to_note(notes.note_to_int(root) - 4) elif '#11' in chord_type: # assume IV return notes.int_to_note(notes.note_to_int(root) - 5) elif chord_type in ['7', '9', '11', '13']: # assume V return notes.int_to_note(notes.note_to_int(root) - 7) elif chord_type in ['m7b13']: # assume VI return notes.int_to_note(notes.note_to_int(root) - 9) elif ('b5' in chord_type) or ('dim' in chord_type): # assume VII return notes.int_to_note(notes.note_to_int(root) - 11) elif chord_type in [ '7b9' ]: # TODO: refactor so that this is not an ad hoc exception (given 7b9 is covered below) but instea maybe automatically check all hminor modes etc pass else: print( f'\nWarning: utilities.assume_key() does not know how to handle chord_type {chord_type}' ) pass if key is None: key = assume_key(root, chord_type, mode) # TODO: handle modes / alterations (also see above) # assume_key() is assuming major tonality (more precisely, diatonic_thirteen() is assuming major tonality and assume_key() provides accordingly) if key is None: # if assume_key didn't work e.g. for a 7b9 which does not arise on any 7th chord built from the major scale if chord_type == '7b9': diatonic_extended_chord = chords.dominant_flat_ninth( root) + chords.major_triad( intervals.minor_second(root))[1:] # 1 3 5 b7 b9 11 b13 return diatonic_extended_chord[extension_index[extension]] try: diatonic_extended_chord = diatonic_thirteenth(root, key) except NoteFormatError: try: diatonic_extended_chord = diatonic_thirteenth(root, synonyms[key]) except KeyError: print(f'Problem fetching diatonic_thirteenth({root},{key})') return diatonic_extended_chord[extension_index[extension]]
def test_major_triad(self): self.assertEqual(['C', 'E', 'G'], chords.major_triad('C')) self.assertEqual(['E', 'G#', 'B'], chords.major_triad('E')) self.assertEqual(['Eb', 'G', 'Bb'], chords.major_triad('Eb'))