def test_augment(self):
known = { "C" : "C#",
"C#" : "C##",
"Cb" : "C",
"Cbb" : "Cb"}
map(lambda x: self.assertEqual(known[x], notes.augment(x),\
"The augmented note of %s is not %s, expecting %s" % (x, notes.augment(x), known[x])), known.keys())
def test_augment(self):
known = {'C': 'C#', 'C#': 'C##', 'Cb': 'C', 'Cbb': 'Cb'}
map(
lambda x: self.assertEqual(
known[x], notes.augment(
x), 'The augmented note of %s is not %s, expecting %s' %
(x, notes.augment(x), known[x])), known.keys())
def test_augment(self):
known = {"C": "C#", "C#": "C##", "Cb": "C", "Cbb": "Cb"}
for x in known:
self.assertEqual(
known[x],
notes.augment(x),
"The augmented note of %s is not %s, expecting %s" %
(x, notes.augment(x), known[x]),
)
def test_augment(self):
known = {
'C': 'C#',
'C#': 'C##',
'Cb': 'C',
'Cbb': 'Cb',
}
map(lambda x: self.assertEqual(known[x], notes.augment(x),
'The augmented note of %s is not %s, expecting %s' % (x,
notes.augment(x), known[x])), known.keys())
def from_shorthand(note, interval, up=True):
"""Return the note on interval up or down.
Examples:
>>> from_shorthand('A', 'b3')
'C'
>>> from_shorthand('D', '2')
'E'
>>> from_shorthand('E', '2', False)
'D'
"""
# warning should be a valid note.
if not notes.is_valid_note(note):
return False
# [shorthand, interval function up, interval function down]
shorthand_lookup = [
['1', major_unison, major_unison],
['2', major_second, minor_seventh],
['3', major_third, minor_sixth],
['4', major_fourth, major_fifth],
['5', major_fifth, major_fourth],
['6', major_sixth, minor_third],
['7', major_seventh, minor_second],
]
# Looking up last character in interval in shorthand_lookup and calling that
# function.
val = False
for shorthand in shorthand_lookup:
if shorthand[0] == interval[-1]:
if up:
val = shorthand[1](note)
else:
val = shorthand[2](note)
# warning Last character in interval should be 1-7
if val == False:
return False
# Collect accidentals
for x in interval:
if x == '#':
if up:
val = notes.augment(val)
else:
val = notes.diminish(val)
elif x == 'b':
if up:
val = notes.diminish(val)
else:
val = notes.augment(val)
else:
return val
def from_shorthand(note, interval, up=True):
"""Return the note on interval up or down.
Examples:
>>> from_shorthand('A', 'b3')
'C'
>>> from_shorthand('D', '2')
'E'
>>> from_shorthand('E', '2', False)
'D'
"""
# warning should be a valid note.
if not notes.is_valid_note(note):
return False
# [shorthand, interval function up, interval function down]
shorthand_lookup = [
['1', major_unison, major_unison],
['2', major_second, minor_seventh],
['3', major_third, minor_sixth],
['4', major_fourth, major_fifth],
['5', major_fifth, major_fourth],
['6', major_sixth, minor_third],
['7', major_seventh, minor_second],
]
# Looking up last character in interval in shorthand_lookup and calling that
# function.
val = False
for shorthand in shorthand_lookup:
if shorthand[0] == interval[-1]:
if up:
val = shorthand[1](note)
else:
val = shorthand[2](note)
# warning Last character in interval should be 1-7
if val == False:
return False
# Collect accidentals
for x in interval:
if x == '#':
if up:
val = notes.augment(val)
else:
val = notes.diminish(val)
elif x == 'b':
if up:
val = notes.diminish(val)
else:
val = notes.augment(val)
else:
return val
def generate_note(self, state): wild = state['wild'] if self.last_note == '': n = choice(state["chord"]) else: if self.up: n = notes.augment(self.last_note) else: n = notes.diminish(self.last_note) self.last_note = n if random() < 0.20: self.up = not(self.up) if random() < 0.3 * wild: self.params["let_ring"] = False return [Note(n)] elif random() < 0.15 * wild and state["tick"] % 2 == 0: self.params["let_ring"] = True return [Note(self.last_note)] elif random() < 0.1 * wild: self.params["let_ring"] = True c = choice(state["chord"]) self.last_note = c return [Note(c)] else: if random() > 0.05: self.params['let_ring'] = True else: self.params['let_ring'] = False return None
def to_chords(progression, key="C"):
"""Convert a list of chord functions or a string to a list of chords.
Examples:
>>> to_chords(['I', 'V7'])
[['C', 'E', 'G'], ['G', 'B', 'D', 'F']]
>>> to_chords('I7')
[['C', 'E', 'G', 'B']]
Any number of accidentals can be used as prefix to augment or diminish;
for example: bIV or #I.
All the chord abbreviations in the chord module can be used as suffixes;
for example: Im7, IVdim7, etc.
You can combine prefixes and suffixes to manage complex progressions:
#vii7, #iidim7, iii7, etc.
Using 7 as suffix is ambiguous, since it is classicly used to denote the
seventh chord when talking about progressions instead of just the
dominant seventh chord. We have taken the classic route; I7 will get
you a major seventh chord. If you specifically want a dominanth seventh,
use Idom7.
"""
if isinstance(progression, six.string_types):
progression = [progression]
result = []
for chord in progression:
# strip preceding accidentals from the string
(roman_numeral, acc, suffix) = parse_string(chord)
# There is no roman numeral parsing, just a simple check. Sorry to
# disappoint. warning Should throw exception
if roman_numeral not in numerals:
return []
# These suffixes don't need any post processing
if suffix == "7" or suffix == "":
roman_numeral += suffix
# ahh Python. Everything is a dict.
r = chords.__dict__[roman_numeral](key)
else:
r = chords.__dict__[roman_numeral](key)
r = chords.chord_shorthand[suffix](r[0])
while acc < 0:
r = [notes.diminish(x) for x in r]
acc += 1
while acc > 0:
r = [notes.augment(x) for x in r]
acc -= 1
result.append(r)
return result
def lydian_dominant_seventh(note):
"""Build the lydian dominant seventh (7#11) on note.
Example:
>>> lydian_dominant_seventh('C')
['C', 'E', 'G', 'Bb', 'F#']
"""
return (dominant_seventh(note) +
[notes.augment(intervals.perfect_fourth(note))])
def lydian_dominant_seventh(note):
"""Build the lydian dominant seventh (7#11) on note.
Example:
>>> lydian_dominant_seventh('C')
['C', 'E', 'G', 'Bb', 'F#']
"""
return (dominant_seventh(note) +
[notes.augment(intervals.perfect_fourth(note))])
def augmented_triad(note):
"""Build an augmented triad on note.
Example:
>>> augmented_triad('C')
['C', 'E', 'G#']
"""
return [note, intervals.major_third(note),
notes.augment(intervals.major_fifth(note))]
def ascending(self):
notes = [self.tonic]
for note in get_notes(self.key)[1:] + [self.tonic]:
if intervals.determine(notes[-1], note) == ('major second'):
notes.append(augment(notes[-1]))
notes.append(note)
else:
notes.append(note)
notes.pop()
return notes * self.octaves + [notes[0]]
def dominant_sharp_ninth(note):
"""Build a dominant sharp ninth chord on note.
Example:
>>> dominant_ninth('C')
['C', 'E', 'G', 'Bb', 'D#']
"""
res = dominant_ninth(note)
res[4] = notes.augment(intervals.major_second(note))
return res
def dominant_sharp_ninth(note):
"""Build a dominant sharp ninth chord on note.
Example:
>>> dominant_ninth('C')
['C', 'E', 'G', 'Bb', 'D#']
"""
res = dominant_ninth(note)
res[4] = notes.augment(intervals.major_second(note))
return res
def ascending(self):
notes = [self.tonic]
for note in get_notes(self.key)[1:] + [self.tonic]:
if intervals.determine(notes[-1], note) == ('major second'):
notes.append(augment(notes[-1]))
notes.append(note)
else:
notes.append(note)
notes.pop()
return notes * self.octaves + [notes[0]]
def searchEmpty(self, note, result_map):
dim_candidate = note;
aug_candidate = note;
while(True):
dim_candidate = self.utils.normalizeNote(notes.diminish(dim_candidate));
aug_candidate = self.utils.normalizeNote(notes.augment(aug_candidate));
if dim_candidate in result_map:
return dim_candidate;
if aug_candidate in result_map:
return aug_candidate;
def augment_or_diminish_until_the_interval_is_right(note1, note2, interval):
"""A helper function for the minor and major functions.
You should probably not use this directly.
"""
cur = measure(note1, note2)
while cur != interval:
if cur > interval:
note2 = notes.diminish(note2)
elif cur < interval:
note2 = notes.augment(note2)
cur = measure(note1, note2)
# We are practically done right now, but we need to be able to create the
# minor seventh of Cb and get Bbb instead of B######### as the result
val = 0
for token in note2[1:]:
if token == '#':
val += 1
elif token == 'b':
val -= 1
# These are some checks to see if we have generated too much #'s or too much
# b's. In these cases we need to convert #'s to b's and vice versa.
if val > 6:
val = val % 12
val = -12 + val
elif val < -6:
val = val % -12
val = 12 + val
# Rebuild the note
result = note2[0]
while val > 0:
result = notes.augment(result)
val -= 1
while val < 0:
result = notes.diminish(result)
val += 1
return result
def augment_or_diminish_until_the_interval_is_right(note1, note2, interval):
"""A helper function for the minor and major functions.
You should probably not use this directly.
"""
cur = measure(note1, note2)
while cur != interval:
if cur > interval:
note2 = notes.diminish(note2)
elif cur < interval:
note2 = notes.augment(note2)
cur = measure(note1, note2)
# We are practically done right now, but we need to be able to create the
# minor seventh of Cb and get Bbb instead of B######### as the result
val = 0
for token in note2[1:]:
if token == '#':
val += 1
elif token == 'b':
val -= 1
# These are some checks to see if we have generated too much #'s or too much
# b's. In these cases we need to convert #'s to b's and vice versa.
if val > 6:
val = val % 12
val = -12 + val
elif val < -6:
val = val % -12
val = 12 + val
# Rebuild the note
result = note2[0]
while val > 0:
result = notes.augment(result)
val -= 1
while val < 0:
result = notes.diminish(result)
val += 1
return result
def get_note_pattern(pattern, key):
if pattern[0] == 1 :
note = intervals.unison(key)
elif pattern[0] == 2 :
note = intervals.second(key, key)
elif pattern[0] == 3 :
note = intervals.third(key, key)
elif pattern[0] == 4 :
note = intervals.fourth(key, key)
elif pattern[0] == 5 :
note = intervals.fifth(key, key)
elif pattern[0] == 6 :
note = intervals.sixth(key, key)
elif pattern[0] == 7 :
note = intervals.seventh(key, key)
if pattern[3] == "bemol":
note = notes.diminish(note)
elif pattern[3] == "diese" :
note = notes.augment(note)
return note
def transpose_to_relative_minor(track, original_key, harmonic):
transposed_track = copy.deepcopy(track)
if original_key in keys.major_keys:
old_scale = keys.get_notes(original_key)
new_key = keys.relative_minor(original_key)
new_scale = keys.get_notes(new_key)
if harmonic:
new_scale[6] = notes.augment(new_scale[6])
new_scale[6] = notes.reduce_accidentals(new_scale[6])
input_notes = transposed_track.get_notes()
for bar in input_notes:
#Check if the nc contained in the bar/"note" is a pause, then do nothing
nc = bar[-1]
if nc is None:
continue
#Otherwise
else:
#For every actual note in the note containers (important if there is a chord)
for note in nc:
#old_note = copy.deepcopy(note)
if note.name in old_scale:
index = old_scale.index(note.name)
note.name = new_scale[index]
else:
note.transpose("b3")
note.name = notes.reduce_accidentals(note.name)
# Fix octaves
if note.name[0] == 'A' or note.name[0] == 'B':
note.octave_down()
else:
print("input key is not major key")
return transposed_track
def augmentNote(self, note, augSteps = 1):
result_note = note;
for step in range(0, augSteps):
result_note = self.utils.normalizeNote(notes.augment(result_note));
return result_note;
'''
Created on Jan 6, 2017
@author: stephenkoh
'''
import mingus.core.keys as keys
import mingus.core.notes as notes
while (True):
key = str(input('Please enter a key: '))
keyz = keys.get_notes(key)
#print(keys)
for i in range(len(keyz)):
keyz[i] = notes.augment(keyz[i])
print(keyz)
def augmented_unison(note):
return notes.augment(note)
# -*- coding: utf-8 -*-
#2018/8/26
#python2
import mingus.core.notes as notes
#检查音符合法性
notes.is_valid_note('C') # True
#音符、值互转
notes.note_to_int('C') # 0
notes.int_to_note(1) # C#
#半音升降
notes.augment('C') # C#
notes.diminish('C#') # C
#大小调转化(无方法)
#notes.to_minor('C') # A
#notes.to_major('A') # C
#无模块
#import mingus.core.diatonic as diatonic
#十二音
#diatonic.basic_keys
#E调七音
#diatonic.get_notes('E')
import mingus.core.intervals as interval
#间隔半音数
interval.measure('C', 'D') #2
import mingus.core.scales as scales
#爱奥尼音阶对象
def augment(self):
"""Call notes.augment with this note as argument."""
self.name = notes.augment(self.name)
def lydian_major_seventh(note):
"""Build the lydian major seventh (M7#11) on note.
"""
return (major_seventh(note) +
[notes.augment(intervals.perfect_fourth(note))])
def augment(self):
"""Call notes.augment with this note as argument."""
self.name = notes.augment(self.name)
def ascending(self):
notes = NaturalMinor(self.tonic).ascending()[:-1]
notes[5] = augment(notes[5])
notes[6] = augment(notes[6])
return notes * self.octaves + [notes[0]]
def augment(self):
"""Raises the note by a half step"""
self._mingus_note = _mingus_notes.augment(str(self._mingus_note))
self._pitch.accidentals += '#'
return True
def augmented_unison(note):
return notes.augment(note)
key = dict_musickey[h]
return (key)
#
#
#
#
#
if __name__ == "__main__":
image = "Average-Color.png"
avgcolor_img = cv2.imread(image)
cica = more_average(avgcolor_img)
print(cica)
octave = pick_octave(cica)
print("Octave: " + str(octave))
major = pick_major(avgcolor_img)
print("Major/Minor?: " + major)
#pixel_key = pick_key(avgcolor_img) #Note: Overflow error. do key later
note_list = []
note_list.append(notes.augment("C"))
note_list.append(notes.int_to_note(138 % 12))
print(note_list)
def ascending(self):
notes = NaturalMinor(self.tonic).ascending()[:-1]
notes[5] = augment(notes[5])
notes[6] = augment(notes[6])
return notes * self.octaves + [notes[0]]
'''
Created on Jan 5, 2017
@author: stephenkoh
'''
import mingus.core.notes as notes
note = str(input("Please enter a note: "))
if (notes.is_valid_note(note)):
for i in range(4):
note = notes.augment(note)
note_int = notes.note_to_int(note)
note = notes.int_to_note(note_int)
print(note)
