Esempio n. 1
0
 def test_determine(self):
     for x in chords.chord_shorthand:
         self.assertEqual(
             True,
             chords.determine(chords.from_shorthand("C" + x)) != [],
             "'C%s' should return a value" % x,
         )
     for x in (x for x in chords.chord_shorthand if x != "5"):
         self.assertEqual(
             "C" + chords.chord_shorthand_meaning[x],
             chords.determine(chords.from_shorthand("C" + x))[0],
             "The proper naming of '%s' is not '%s',expecting '%s'"
             % (
                 "C" + x,
                 chords.determine(chords.from_shorthand("C" + x)),
                 "C" + chords.chord_shorthand_meaning[x],
             ),
         )
     self.chordsTest(
         [
             [["A13"], ["A", "C#", "E", "G", "B", "D", "F#",]],
             [["Am13"], ["A", "C", "E", "G", "B", "D", "F#",]],
             [["AM13"], ["A", "C#", "E", "G#", "B", "D", "F#",]],
         ],
         lambda x: chords.determine(x, True),
         "chord name",
     )
Esempio n. 2
0
 def test_determine(self):
     map(lambda x: self.assertEqual(True,
         chords.determine(chords.from_shorthand('C' + x)) != [],
         "'C%s' should return a value" % x), chords.chord_shorthand.keys())
     map(lambda x: self.assertEqual('C' + chords.chord_shorthand_meaning[x],
         chords.determine(chords.from_shorthand('C' + x))[0],
         "The proper naming of '%s' is not '%s',expecting '%s'" % ('C' + x,
         chords.determine(chords.from_shorthand('C' + x)), 'C'
          + chords.chord_shorthand_meaning[x])), [x for x in
         chords.chord_shorthand.keys() if x != '5'])
     self.chordsTest([[['A13'], [
         'A',
         'C#',
         'E',
         'G',
         'B',
         'D',
         'F#',
         ]], [['Am13'], [
         'A',
         'C',
         'E',
         'G',
         'B',
         'D',
         'F#',
         ]], [['AM13'], [
         'A',
         'C#',
         'E',
         'G#',
         'B',
         'D',
         'F#',
         ]]], lambda x: chords.determine(x, True), 'chord name')
Esempio n. 3
0
def play_basic_chord(chord):
   c = NoteContainer(chord)
   l = Note(c[0].name)
   l.octave_down()
   print ch.determine(chord)[0]
	
   # Play chord and lowered first note
   fluidsynth.play_NoteContainer(c)
   fluidsynth.play_Note(l)
   time.sleep(1.0)
	
   return c
Esempio n. 4
0
def play_basic_chord(chord):
    c = NoteContainer(chord)
    l = Note(c[0].name)
    l.octave_down()
    print ch.determine(chord)[0]

    # Play chord and lowered first note
    fluidsynth.play_NoteContainer(c)
    fluidsynth.play_Note(l)
    time.sleep(1.0)

    return c
Esempio n. 5
0
def playProgression():
    progression = ["I", "vi", "ii", "iii7", "I7", "viidom7", "iii7", "V7"]
    key = "C"

    chords = progressions.to_chords(progression, key)

    if not fluidsynth.init(SF2):
        print "Couldn't load soundfont", SF2
        sys.exit(1)

    while 1:
        i = 0
        for chord in chords:
            c = NoteContainer(chords[i])
            l = Note(c[0].name)
            p = c[1]
            l.octave_down()
            print ch.determine(chords[i])[0]

            # Play chord and lowered first note
            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.5:
                p = Note(c[1].name)
                p.octave_down()
                fluidsynth.play_Note(p)
            time.sleep(0.50)

            # 50% chance on a ninth
            if random() > 0.5:
                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.5:
                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
Esempio n. 6
0
def respell_and_determine(chord):
    named_chords = [chords.determine(chord)]
    if len(named_chords[0]) == 0:
        named_chords = []
    
    candidates = list(set(chord) & set(list(synonyms.keys()) + list(synonyms.values())))
    for i in range(0, len(candidates)):
        combs = combinations(candidates, i+1)
        for comb in combs:
            respelling = chord.copy()
            for to_syn in comb:
                respelling[respelling.index(to_syn)] = synonyms[to_syn]
                if chords.determine(respelling) != []:
                    named_chords.append(chords.determine(respelling))
    return named_chords
Esempio n. 7
0
def chordname(chord, numeral=None):
    s = ""
    if numeral:
        s = numeral + " - "
    s += "  ::  ".join(ch.determine([x.name for x in chord], True))
    s += " -- " + " ".join([x.name for x in chord])
    return s
def play_note(note):
    """play_note determines the coordinates of a note on the keyboard image
    and sends a request to play the note to the fluidsynth server"""

    global text
    octave_offset = (note.octave - LOWEST) * width
    if note.name in WHITE_KEYS:

        # Getting the x coordinate of a white key can be done automatically

        w = WHITE_KEYS.index(note.name) * white_key_width
        w = w + octave_offset

        # Add a list containing the x coordinate, the tick at the current time
        # and of course the note itself to playing_w

        playing_w.append([w, tick, note])
    else:

        # For black keys I hard coded the x coordinates. It's ugly.

        i = BLACK_KEYS.index(note.name)
        if i == 0:
            w = 18
        elif i == 1:
            w = 58
        elif i == 2:
            w = 115
        elif i == 3:
            w = 151
        else:
            w = 187
        w = w + octave_offset
        playing_b.append([w, tick, note])

    # To find out what sort of chord is being played we have to look at both the
    # white and black keys, obviously:

    notes = playing_w + playing_b
    notes.sort()
    notenames = []
    for n in notes:
        notenames.append(n[2].name)

    # Determine the chord

    det = chords.determine(notenames)
    if det != []:
        det = det[0]
    else:
        det = ''

    # And render it onto the text surface

    t = font.render(det, 2, (0, 0, 0))
    text.fill((255, 255, 255))
    text.blit(t, (0, 0))
Esempio n. 9
0
	def test_determine(self):
		map(lambda x: self.assertEqual(True, \
			chords.determine(chords.from_shorthand("C" + x)) != [],\
			"'C%s' should return a value" % x), \
			chords.chord_shorthand.keys())
		map(lambda x: self.assertEqual("C" + \
			chords.chord_shorthand_meaning[x],\
			chords.determine(chords.from_shorthand("C" + x))[0], \
			"The proper naming of '%s' is not '%s',"\
			"expecting '%s'" % ("C" + x, \
				chords.determine(chords.from_shorthand("C" + x)), \
				"C" + chords.chord_shorthand_meaning[x])),\
			[x for x in chords.chord_shorthand.keys() if \
				x != '5'])
		self.chordsTest([ [['A13'], ['A', 'C#', 'E', 'G', 'B', 'D', 'F#']],\
						  [['Am13'], ['A', 'C', 'E', 'G', 'B', 'D', 'F#']],\
						  [['AM13'], ['A', 'C#', 'E', 'G#', 'B', 'D', 'F#']]],\
				lambda x: chords.determine(x, True), "chord name")
Esempio n. 10
0
def play_note(note):
	"""play_note determines the coordinates of a note on the keyboard image
	and sends a request to play the note to the fluidsynth server"""

	global text

	octave_offset = (note.octave - LOWEST) * width

	if note.name in WHITE_KEYS:

		# Getting the x coordinate of a white key can be done automatically
		w = WHITE_KEYS.index(note.name) * white_key_width
		w = w + octave_offset

		# Add a list containing the x coordinate, the tick at the current time and 
		# of course the note itself to playing_w
		playing_w.append([w, tick, note])
	else:
		# For black keys I hard coded the x coordinates. It's ugly.
		i = BLACK_KEYS.index(note.name) 
		if i == 0:
			w = 18
		elif i == 1:
			w = 58
		elif i == 2:
			w = 115
		elif i == 3:
			w = 151
		else:
			w = 187

		w = w + octave_offset
		playing_b.append([w, tick, note])

	# To find out what sort of chord is being played we have to look 
	# at both the white and black keys, obviously:
	notes = playing_w + playing_b
	notes.sort()
	notenames = []
	for n in notes:
		notenames.append(n[2].name)
	
	# Determine the chord
	det = chords.determine(notenames)
	if det != []:
		det = det[0]
	else:
		det = ""

	# And render it onto the text surface
	t = font.render(det, 2, (0,0,0))
	text.fill((255,255,255))
	text.blit(t, (0,0))

	# Play the note
	fluidsynth.play_Note(note, channel, 100)
Esempio n. 11
0
def numerals_list_to_shorthand_list(numerals, key='C'):
    '''
        Convert numerals (e.g. ['IIm7', 'V7', 'IM7']) to shorthand (e.g. ['Dm7', 'Gdom7', 'CM7']) with optional choice of key (default is C)
        '''
    chord_notes = [
        progressions.to_chords(chord, key=key)[0] for chord in numerals
    ]  # chords as individual Notes like [['C','E','G','B'],...]
    return [
        chords.determine(chord, shorthand=True)[0] for chord in chord_notes
    ]  # shorthand e.g. ['CM7',...]
Esempio n. 12
0
 def test_determine(self):
     list(
         map(
             lambda x: self.assertEqual(
                 True,
                 chords.determine(chords.from_shorthand('C' + x)) != [],
                 "'C%s' should return a value" % x),
             list(chords.chord_shorthand.keys())))
     list(
         map(
             lambda x: self.assertEqual(
                 'C' + chords.chord_shorthand_meaning[x],
                 chords.determine(chords.from_shorthand('C' + x))[0],
                 "The proper naming of '%s' is not '%s',expecting '%s'" %
                 ('C' + x, chords.determine(chords.from_shorthand('C' + x)),
                  'C' + chords.chord_shorthand_meaning[x])),
             [x for x in list(chords.chord_shorthand.keys()) if x != '5']))
     self.chordsTest([[['A13'], [
         'A',
         'C#',
         'E',
         'G',
         'B',
         'D',
         'F#',
     ]], [['Am13'], [
         'A',
         'C',
         'E',
         'G',
         'B',
         'D',
         'F#',
     ]], [['AM13'], [
         'A',
         'C#',
         'E',
         'G#',
         'B',
         'D',
         'F#',
     ]]], lambda x: chords.determine(x, True), 'chord name')
Esempio n. 13
0
def play_smart_example():
	progression = ["I", "vi", "ii", "iii7",
	       "I7", "viidom7", "iii7", "V7"]

	key = 'C'

	chord_list = progressions.to_chords(progression, key)
	for i in range(len(chord_list)):
		chord_list[i] = chords.determine(chord_list[i], shorthand=True)[0]
		# print(chord_list[i])
	while True:
		play_smart_solo_over_chords(chord_list)
Esempio n. 14
0
def play_example(key):
	progression = ["I", "vi", "ii", "iii7",
	       "I7", "viidom7", "iii7", "V7"]

	# key = 'C'
	
	chord_list = progressions.to_chords(progression, key)

	fluidsynth.set_instrument(13, 45)
	fluidsynth.set_instrument(10, 24)

	while True:
		for chord in chord_list:
			play_solo_bar_with_chord(chords.determine(chord, shorthand=True)[0])
Esempio n. 15
0
def getChordFromNotes(notes):
    chords = {}
    for notelist in itertools.permutations(notes):
        notelist = list(notelist)
        chord = minguschords.determine(notelist, True)
        if len(chord) == 0:
            continue
        if chord[0] not in chords:
            chords[chord[0]] = 0
        chords[chord[0]] += 1
    sorted_d = sorted(chords.items(), key=operator.itemgetter(1))
    try:
        c = sorted_d[0][0]
        if c == "perfect fourth" or c == "perfect fifth":
            c = notes[0] + c
        return c
    except:
        return "".join(notes)
Esempio n. 16
0
def chord_practice():
    minutes_to_practice = pyip.inputInt(
        prompt="How many minutes do you want to practice? ", min=1)
    seconds_between = pyip.inputFloat(
        prompt="How many rest seconds you want between chords? ", min=1)

    start_time = time()
    while (True):
        chosen_chord = choice(choice(scales_content['scales'])['chords'])
        determined_chord = chords.determine(chosen_chord, True)

        if determined_chord:
            print(f"\t{chosen_chord} - {determined_chord[0]}")
        else:
            print(f"\t{chosen_chord}")

        sleep(seconds_between)
        if (time() - start_time) >= minutes_to_practice * 60:
            break
Esempio n. 17
0
def parse_chord(a_chord):
    """
    PENDING:
    - compute semitones between notes of the chord
    - according to the semitones between the previous note
    and the previous note first name(ex C,D#) 
    choose the current note (ex if C -> E, if B -> D#

    establish some priority:
    1. first I,III,V,VII
    2. then II,IV,VI
    """

    #print(a_chord)

    root = a_chord[0][0]

    foundi = degrees.index(root[0])
    ld = len(degrees)
    the_degrees = [
                    degrees[foundi],
                    degrees[(foundi+2)%ld],
                    degrees[(foundi+4)%ld],
                    degrees[(foundi+6)%ld],
                    ]
    #print(the_degrees)

    parsed_chord = [a_chord[0]]


    for i in range(1,len(a_chord)):
    	#print("match",the_degrees[i]," in",a_chord[i])
    	for synonym in a_chord[i]:
    		if synonym.lower()[0] == the_degrees[i].lower():
    			parsed_chord.append(synonym)
    			break

    return chords.determine(parsed_chord), parsed_chord
Esempio n. 18
0
Created on Jan 6, 2017

@author: stephenkoh
'''

import mingus.core.chords as chords
import mingus.core.keys as keys

#all_triads = []
print('TRIADS')
for i in range(len(keys.keys)):
    for elem in keys.keys[i]:
        print('\n%s' % elem)
        triads = chords.triads(elem)
        for triad in triads:
            typ = chords.determine(triad)
            for each in typ:
                print(each)
'''
all_triads = list(set(all_triads))
all_triads.sort()
print("\nTypes of triads naturally occurring:\n")
for elem in all_triads:
    print(elem)
'''

#all_sevenths = []
print('\nSEVENTHS:')
for i in range(len(keys.keys)):
    for elem in keys.keys[i]:
        print('\n%s' % elem)
Esempio n. 19
0
 def determine(self, shorthand=False):
     """Determine the type of chord or interval currently in the
     container."""
     return chords.determine(self.get_note_names(), shorthand)
Esempio n. 20
0
'''
Created on Jan 6, 2017

@author: stephenkoh
'''

import mingus.core.chords as chords

key = str(input('Please enter a key: '))
triads = chords.triads(key)
print('\nTriads shorthand:')
for elem in triads:
    print(chords.determine(elem, True)[0])
sevenths = chords.sevenths(key)
print('\nSevenths shorthand:')
for elem in sevenths:
    print(chords.determine(elem, True)[0])
Esempio n. 21
0
def determine(chord, key, shorthand=False):
    """Determine the harmonic function of chord in key.

    This function can also deal with lists of chords.

    Examples:
    >>> determine(['C', 'E', 'G'], 'C')
    ['tonic']
    >>> determine(['G', 'B', 'D'], 'C')
    ['dominant']
    >>> determine(['G', 'B', 'D', 'F'], 'C', True)
    ['V7']
    >>> determine([['C', 'E', 'G'], ['G', 'B', 'D']], 'C', True)
    [['I'], ['V']]
    """
    result = []

    # Handle lists of chords
    if type(chord[0]) == list:
        for c in chord:
            result.append(determine(c, key, shorthand))
        return result

    func_dict = {
        'I': 'tonic',
        'ii': 'supertonic',
        'iii': 'mediant',
        'IV': 'subdominant',
        'V': 'dominant',
        'vi': 'submediant',
        'vii': 'subtonic',
        }
    expected_chord = [
        ['I', 'M', 'M7'],
        ['ii', 'm', 'm7'],
        ['iii', 'm', 'm7'],
        ['IV', 'M', 'M7'],
        ['V', 'M', '7'],
        ['vi', 'm', 'm7'],
        ['vii', 'dim', 'm7b5'],
        ]
    type_of_chord = chords.determine(chord, True, False, True)
    for chord in type_of_chord:
        name = chord[0]

        # Get accidentals
        a = 1
        for n in chord[1:]:
            if n == 'b':
                name += 'b'
            elif n == '#':
                name += '#'
            else:
                break
            a += 1
        chord_type = chord[a:]

        # Determine chord function
        (interval_type, interval) = intervals.determine(key, name).split(' ')
        if interval == 'unison':
            func = 'I'
        elif interval == 'second':
            func = 'ii'
        elif interval == 'third':
            func = 'iii'
        elif interval == 'fourth':
            func = 'IV'
        elif interval == 'fifth':
            func = 'V'
        elif interval == 'sixth':
            func = 'vi'
        elif interval == 'seventh':
            func = 'vii'

        # Check whether the chord is altered or not
        for x in expected_chord:
            if x[0] == func:
                # Triads
                if chord_type == x[1]:
                    if not shorthand:
                        func = func_dict[func]
                elif chord_type == x[2]:
                    # Sevenths
                    if shorthand:
                        func += '7'
                    else:
                        func = func_dict[func] + ' seventh'
                else:
                    # Other
                    if shorthand:
                        func += chord_type
                    else:
                        func = func_dict[func]\
                             + chords.chord_shorthand_meaning[chord_type]

        # Handle b's and #'s (for instance Dbm in key C is bII)
        if shorthand:
            if interval_type == 'minor':
                func = 'b' + func
            elif interval_type == 'augmented':
                func = '#' + func
            elif interval_type == 'diminished':
                func = 'bb' + func
        else:
            if interval_type == 'minor':
                func = 'minor ' + func
            elif interval_type == 'augmented':
                func = 'augmented ' + func
            elif interval_type == 'diminished':
                func = 'diminished ' + func

        # Add to results
        result.append(func)
    return result
Esempio n. 22
0
'''
Created on Jan 6, 2017

@author: stephenkoh
'''

import mingus.core.chords as chords

key = input('Please enter a key: ')
song = [lambda x: chords.I(x), lambda x: chords.IV(x), 
        lambda x: chords.V(x), lambda x: chords.I(x)]
for i in range(len(song)):
    print(chords.determine(song[i](key), True)[0])
Esempio n. 23
0
 def determine(self, shorthand=False):
     """Determine the type of chord or interval currently in the
     container."""
     return chords.determine(self.get_note_names(), shorthand)
Esempio n. 24
0
    'iii7',
    'V7',
    ]
key = 'C'
chords = progressions.to_chords(progression, key)
if not fluidsynth.init(SF2):
    print("Couldn't load soundfont", SF2)
    sys.exit(1)
while 1:
    i = 0
    for chord in chords:
        c = NoteContainer(chords[i])
        l = Note(c[0].name)
        p = c[1]
        l.octave_down()
        print(ch.determine(chords[i])[0])

        # Play chord and lowered first note

        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)
Esempio n. 25
0
if not fluidsynth.init(SF2):
    print "Couldn't load soundfont", SF2
    sys.exit(1)
chords = progressions.to_chords(progression, key)
loop = 1
while loop < song_end:
    i = 0
    if random_solo_channel:
        solo_channel = choice(range(5, 8) + [11])
    for chord in chords:
        c = NoteContainer(chords[i])
        l = Note(c[0].name)
        n = Note('C')
        l.octave_down()
        l.octave_down()
        print ch.determine(chords[i])[0]

        if not swing and play_chords and loop > chord_start and loop\
             < chord_end:
            fluidsynth.play_NoteContainer(c, chord_channel, randrange(50, 75))
        if play_chords and loop > chord_start and loop < chord_end:
            if orchestrate_second:
                if loop % 2 == 0:
                    fluidsynth.play_NoteContainer(c, chord_channel2,
                            randrange(50, 75))
            else:
                fluidsynth.play_NoteContainer(c, chord_channel2, randrange(50,
                        75))

        if double_time:
            beats = [random() > 0.5 for x in range((loop % 2 + 1) * 8)]
Esempio n. 26
0
# 3.8 triad pairs (hexatonics)
key = 'D'
scale_choice = 'major'
triad_pair = [1,2] # 1 = I chord, 2 = II chord, etc.

triad_notes = [[1+i,3+i,5+i] for i in range(7)]
# restrict to a 7 note scale by getting note patterns which extend to higher octaves, then mapping back to scale degrees
# equivalently could calculate using [((n-1)%7)+1 for t in triad_notes for n in t]
triad_notes_norm = [note_to_scale_degree(note, 'C', scale_choice) for note in get_scale_patterns(scale_choice, [n for t in triad_notes for n in t])['C'][0]]
triad_notes_norm = [[t[0],t[1],t[2]] for t in [triad_notes_norm[3*i:3*i+3] for i in range(7)]] # unpack to same nested format

from mingus.core.chords import determine
triad1 = get_scale_patterns(scale_choice, p=triad_notes_norm[triad_pair[0]-1], keys=[key])[key][0]
triad2 = get_scale_patterns(scale_choice, p=triad_notes_norm[triad_pair[1]-1], keys=[key])[key][0]
triad1_name = determine([n.name for n in triad1])[0]
triad2_name = determine([n.name for n in triad2])[0]
# print(f'Choices are {triad1_name} and {triad2_name}')

# TODO: generate some triad pair patterns


# 3.9 chromatic cells
scale_choice = 'chromatic'
keys = ['C']#cycle_of_fifths()
p = ['1', '7', 'b7', '7'] 

scale = get_scale(scale_choice, key='C')
chrom_to_pattern = {note_to_scale_degree(note, 'C', 'chromatic'): i for i, note in enumerate(scale)}
exercises[17] = get_scale_patterns(scale_choice, p=[chrom_to_pattern[note]+1 for note in p], keys=keys)
Esempio n. 27
0
def ending(first_track, second_track, subject, key=r""):

    if not bool(key):
        key = 'C'

    canon_subject = shift(subject, 2)

    cadence = [chord.I(key), chord.IV(key), chord.V(key), chord.I(key)]

    notes = []

    for note in canon_subject[-1]:
        if note[-1][0].name not in notes:
            notes.append(note[-1][0].name)

    bar = Bar(key=key)

    # Hitta om det finns ett ackord med de sista noterna i subjektet i, i så fall, komplettera det ackordet
    if len(notes) <= 2 or len(chord.determine(notes, True)) == 0:
        chord_notes = [intervals.fourth(notes[0], key)]
    else:
        subject_chord = chord.determine(notes, True)[0]
        chord_notes = chord.from_shorthand(subject_chord)
        if len(chord_notes) != len(notes):
            for note in notes:
                chord_notes.remove(note)
        else:
            chord_notes = chord_notes[0]

    bar.place_notes(chord_notes[random.randint(0, len(chord_notes) - 1)], 2)

    first_track.add_bar(
        bar)  #Sätt något som passar med andra hälften av subjektet

    while second_track[
            -1].current_beat < 1:  #Placing fitting notes in second to last bar

        #print('test1')
        duration = 2**random.randint(1, 3)
        pitch = cadence[0][random.randint(1, len(cadence[0]) - 1)]

        # If the randomized duration doesn't fit in the bar, make it fit
        if 1 / duration > 1 - second_track[-1].current_beat:
            duration = 1 / (1 - second_track[-1].current_beat)

        # Place the new note in the bar
        second_track[-1].place_notes(pitch, duration)

    first_track[-1].place_notes(cadence[0][0], 2)

    bar = Bar(key=key)
    bar.place_notes(cadence[1][0], 2)
    bar.place_notes(cadence[2][0], 2)
    first_track.add_bar(bar)

    bar = Bar(key=key)
    bar.place_notes(cadence[3][0], 1)
    first_track.add_bar(bar)

    bar = Bar(key=key)
    while bar.current_beat < 0.5:
        #print('test2')
        # Randomize pitch and duration of each note.
        duration = 2**random.randint(1, 3)
        pitch = cadence[1][random.randint(1, len(cadence[1]) - 1)]

        # If the randomized duration doesn't fit in the bar, make it fit
        if 1 / duration > 1 - bar.current_beat:
            duration = 1 / (1 - bar.current_beat)

        # Place the new note in the bar
        bar.place_notes(pitch, duration)
    while bar.current_beat < 1:

        #print('test3')
        duration = 2**random.randint(1, 3)
        pitch = cadence[2][random.randint(1, len(cadence[2]) - 1)]

        # If the randomized duration doesn't fit in the bar, make it fit
        if 1 / duration > 1 - bar.current_beat:
            duration = 1 / (1 - bar.current_beat)

        # Place the new note in the bar
        bar.place_notes(pitch, duration)
    second_track.add_bar(bar)

    bar = Bar(key=key)
    bar.place_notes(cadence[3][2], 1)
    second_track.add_bar(bar)
Esempio n. 28
0
    split_points = [5, 9, 13, 17, 21, 25, 29, 33, 36.5, 40.5, 45, 49,
                    53]  # bar numbers
    shared_tags = ['251', 'major', 'jiminpark']
    individual_tags = [[] for i in range(9)] + 2 * [['pickup']] + [
        [] for i in range(3)
    ]  # i'th lick receives i'th element (tags)

    print(y_comp.tracks[1])
    print(get_chords_from_track(y_comp.tracks[1]))
    licks = licks_from_track(y_comp.tracks[2],
                             get_chords_from_track(y_comp.tracks[1]),
                             split_points, shared_tags, individual_tags)

    print(licks[0].chords)
    # for _, lick in enumerate(licks):
    #     lick.store(db)
    licks[0].store(db)


if __name__ == '__main__':
    # main()
    from sidewinder.lick_library import Bars_from_list, Track_from_list
    tr = Track_from_list(
        Bars_from_list([[[0.0, 2.0, ['G-5', 'A#-5', 'D-6', 'F-6']],
                         [0.5, 2.0, ['F-5', 'G-5', 'A-5', 'C-6']]]]))
    print(get_chords_from_track(tr))

    import mingus.core.chords as chords
    print(chords.determine(['F', 'G', 'A', 'C']))
Esempio n. 29
0
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
Esempio n. 30
0
def determine(chord, key, shorthand=False):
    """Determine the harmonic function of chord in key.

    This function can also deal with lists of chords.

    Examples:
    >>> determine(['C', 'E', 'G'], 'C')
    ['tonic']
    >>> determine(['G', 'B', 'D'], 'C')
    ['dominant']
    >>> determine(['G', 'B', 'D', 'F'], 'C', True)
    ['V7']
    >>> determine([['C', 'E', 'G'], ['G', 'B', 'D']], 'C', True)
    [['I'], ['V']]
    """
    result = []

    # Handle lists of chords
    if type(chord[0]) == list:
        for c in chord:
            result.append(determine(c, key, shorthand))
        return result

    func_dict = {
        'I': 'tonic',
        'ii': 'supertonic',
        'iii': 'mediant',
        'IV': 'subdominant',
        'V': 'dominant',
        'vi': 'submediant',
        'vii': 'subtonic',
    }
    expected_chord = [
        ['I', 'M', 'M7'],
        ['ii', 'm', 'm7'],
        ['iii', 'm', 'm7'],
        ['IV', 'M', 'M7'],
        ['V', 'M', '7'],
        ['vi', 'm', 'm7'],
        ['vii', 'dim', 'm7b5'],
    ]
    type_of_chord = chords.determine(chord, True, False, True)
    for chord in type_of_chord:
        name = chord[0]

        # Get accidentals
        a = 1
        for n in chord[1:]:
            if n == 'b':
                name += 'b'
            elif n == '#':
                name += '#'
            else:
                break
            a += 1
        chord_type = chord[a:]

        # Determine chord function
        (interval_type, interval) = intervals.determine(key, name).split(' ')
        if interval == 'unison':
            func = 'I'
        elif interval == 'second':
            func = 'ii'
        elif interval == 'third':
            func = 'iii'
        elif interval == 'fourth':
            func = 'IV'
        elif interval == 'fifth':
            func = 'V'
        elif interval == 'sixth':
            func = 'vi'
        elif interval == 'seventh':
            func = 'vii'

        # Check whether the chord is altered or not
        for x in expected_chord:
            if x[0] == func:
                # Triads
                if chord_type == x[1]:
                    if not shorthand:
                        func = func_dict[func]
                elif chord_type == x[2]:
                    # Sevenths
                    if shorthand:
                        func += '7'
                    else:
                        func = func_dict[func] + ' seventh'
                else:
                    # Other
                    if shorthand:
                        func += chord_type
                    else:
                        func = func_dict[func]\
                             + chords.chord_shorthand_meaning[chord_type]

        # Handle b's and #'s (for instance Dbm in key C is bII)
        if shorthand:
            if interval_type == 'minor':
                func = 'b' + func
            elif interval_type == 'augmented':
                func = '#' + func
            elif interval_type == 'diminished':
                func = 'bb' + func
        else:
            if interval_type == 'minor':
                func = 'minor ' + func
            elif interval_type == 'augmented':
                func = 'augmented ' + func
            elif interval_type == 'diminished':
                func = 'diminished ' + func

        # Add to results
        result.append(func)
    return result
Esempio n. 31
0
def chord_symbol(chord):
    return chords.determine(chord, shorthand=True)[0]
Esempio n. 32
0
def determine(chord, key, shorthand=False):
    """Determine the harmonic function of chord in key.

    This function can also deal with lists of chords.

    Examples:
    >>> determine(['C', 'E', 'G'], 'C')
    ['tonic']
    >>> determine(['G', 'B', 'D'], 'C')
    ['dominant']
    >>> determine(['G', 'B', 'D', 'F'], 'C', True)
    ['V7']
    >>> determine([['C', 'E', 'G'], ['G', 'B', 'D']], 'C', True)
    [['I'], ['V']]
    """
    result = []

    # Handle lists of chords
    if isinstance(chord[0], list):
        for c in chord:
            result.append(determine(c, key, shorthand))
        return result

    func_dict = {
        "I": "tonic",
        "ii": "supertonic",
        "iii": "mediant",
        "IV": "subdominant",
        "V": "dominant",
        "vi": "submediant",
        "vii": "subtonic",
    }
    expected_chord = [
        ["I", "M", "M7"],
        ["ii", "m", "m7"],
        ["iii", "m", "m7"],
        ["IV", "M", "M7"],
        ["V", "M", "7"],
        ["vi", "m", "m7"],
        ["vii", "dim", "m7b5"],
    ]
    type_of_chord = chords.determine(chord, True, False, True)
    for chord in type_of_chord:
        name = chord[0]

        # Get accidentals
        a = 1
        for n in chord[1:]:
            if n == "b":
                name += "b"
            elif n == "#":
                name += "#"
            else:
                break
            a += 1
        chord_type = chord[a:]

        # Determine chord function
        (interval_type, interval) = intervals.determine(key, name).split(" ")
        if interval == "unison":
            func = "I"
        elif interval == "second":
            func = "ii"
        elif interval == "third":
            func = "iii"
        elif interval == "fourth":
            func = "IV"
        elif interval == "fifth":
            func = "V"
        elif interval == "sixth":
            func = "vi"
        elif interval == "seventh":
            func = "vii"

        # Check whether the chord is altered or not
        for x in expected_chord:
            if x[0] == func:
                # Triads
                if chord_type == x[1]:
                    if not shorthand:
                        func = func_dict[func]
                elif chord_type == x[2]:
                    # Sevenths
                    if shorthand:
                        func += "7"
                    else:
                        func = func_dict[func] + " seventh"
                else:
                    # Other
                    if shorthand:
                        func += chord_type
                    else:
                        func = func_dict[
                            func] + chords.chord_shorthand_meaning[chord_type]

        # Handle b's and #'s (for instance Dbm in key C is bII)
        if shorthand:
            if interval_type == "minor":
                func = "b" + func
            elif interval_type == "augmented":
                func = "#" + func
            elif interval_type == "diminished":
                func = "bb" + func
        else:
            if interval_type == "minor":
                func = "minor " + func
            elif interval_type == "augmented":
                func = "augmented " + func
            elif interval_type == "diminished":
                func = "diminished " + func

        # Add to results
        result.append(func)
    return result
Esempio n. 33
0
def generate_melody(with_chords, repetitions=1):
    use_custom_scale = pyip.inputYesNo(
        prompt="Do you want to use a custom scale? (y/n) ")
    possible_chords = []
    if use_custom_scale == "yes":
        scale_input = input(
            """Insert the notes from the scale separated by a space, do not use flats, only sharps.
        \t\tExample: C D E F# A\n""")
        chosen_scale = scale_input.upper().split()

        for x in range(len(chosen_scale) + 1):
            combinations_object = combinations(chosen_scale, x)
            combinations_list = list(combinations_object)
            possible_chords += combinations_list

        for _ in range(len(chosen_scale) + 1):
            del possible_chords[0]

        get_random_scale = False
        use_custom_scale = True
    else:
        get_random_scale = True
        use_custom_scale = False

    try:
        determined_scale = scales.determine(chosen_scale)[0]
    except:
        determined_scale = ""

    amount_of_notes = pyip.inputInt(
        prompt="How many notes do you want for this melody? ", min=1)
    if with_chords:
        chords_each_x = pyip.inputInt(
            prompt="How many notes you want between chords? ", min=1)
        chord_in_note = [x for x in range(0, amount_of_notes, chords_each_x)]

    for _ in range(repetitions):
        melody_name = generate_random_name()
        melody_path = f"Melodies/{melody_name}"
        os.mkdir(melody_path)

        track = 0
        channel = 0
        time = 0
        duration = 1
        tempo = 120
        volume = 100
        midi_melody = MIDIFile(1)
        midi_melody.addTempo(track, time, tempo)

        if get_random_scale:
            chosen_scale = choice(scales_content["scales"])
            possible_chords = chosen_scale["chords"]
            chosen_scale = chosen_scale["scale"]

        ly_string = r'''\version "2.20.0"
\header{title = "PLACEHOLDER_NAME" subtitle = "PLACEHOLDER_SUBTITLE" tagline = ##f}

\score {        
{
'''
        ly_string = ly_string.replace("PLACEHOLDER_NAME", melody_name)
        ly_string = ly_string.replace(
            "PLACEHOLDER_SUBTITLE",
            f"{str(chosen_scale)} - {determined_scale}")

        print(
            f"\nGenerating melody with scale: {chosen_scale} - {determined_scale}\n"
        )
        print(f"\t****{melody_name}****")

        all_parts = []
        for i in range(amount_of_notes):
            if with_chords:
                if i in chord_in_note:
                    if i != 0:
                        time += duration

                    chosen_chord = choice(possible_chords)
                    chosen_chord = chosen_chord[:3]

                    try:
                        determined_chord = chords.determine(
                            list(chosen_chord))[0]
                    except:
                        determined_chord = ""

                    ly_string += "\n< "
                    for note in chosen_chord:
                        ly_string += f"{note_to_ly(note)}' "
                        note_midi_value = int(Note(note)) + 12
                        midi_melody.addNote(track, channel, note_midi_value,
                                            time, duration, volume)
                    ly_string += ">\n\n"

                    all_parts.append(
                        f"\n\t{chosen_chord} - {determined_chord}\n")

            chosen_note = choice(chosen_scale)

            ly_string += f"{note_to_ly(chosen_note)}4' "

            note_midi_value = int(Note(chosen_note)) + 12
            midi_melody.addNote(track, channel, note_midi_value,
                                time + duration, duration, volume)
            time += duration

            all_parts.append(f"\t{chosen_note}")

        ly_string += """}
\layout { }
\midi { }
}"""

        with open(f"{melody_path}/{melody_name}.txt", "w") as f:
            for part in all_parts:
                f.write(f"{part}\n")
                print(part)

        with open(f"{melody_path}/{melody_name}_pond.ly", "w") as f:
            f.write(ly_string)

        with open(f"{melody_path}/{melody_name}.mid", "wb") as f:
            midi_melody.writeFile(f)