salut David5647,
content de trouver quelqu'un avec qui "m'amuser"
d'abord, j'ai bien un git-truc qui traine quelque part mais j'y connais encore rien et j'ai pas vraiment cherché... je pense que ce sera une bonne raison pour le remplir un peu
sinon pour attaquer, ce matin même, j'ai commencé du code pour jouer avec les gammes pour ensuite les faire s'afficher sur le manche dont je donne le code sur l'autre post :
je vais continuer et peaufiner mon truc mais c'est déjà assez avancé pour te le montrer ici...
NB : tu remarqueras que je laisse quelques fois traîner des tests en commentaires quelques fois pas fonctionnels
fonctions.py (peut être à renommer en fonctions_solfege.py mais comme je l'utilise avec solfège on reste comme ça pour le moment)
#!/usr/bin/env python3
# -*- coding: UTF8 -*-
"""
ensemble de fonctions pour simplifier l'écriture des méthodes
"""
def distiller(notes):
""" depuis une liste de notes numérotées
virer les numéros d'octave et les notes en double
d'une liste de notes données
p.e. = ["E 3", "C 4", "E 4", "G 4", "C 5", "E 5"]
=> {'G', 'E', 'C'}
"""
return set([x.split(" ")[0] for x in notes if x != None])
def possibilites(liste):
""" donne toutes les possibilités des éléments d'une liste """
retour = []
# liste = list(une_liste)
ma_liste = liste.copy()
l_liste = len(liste)
# la liste de retour
retourA = []
for i in range(len(liste)):
retourA.append([])
# liste temporaire
# prépare le montage de toutes les possibilités
retourB = []
i = len(liste)
while i != 0:
i -= 1
for n in range(i, l_liste):
retourB.append(liste[n])
for n in range(0, i):
retourB.append(liste[n])
# print(retourB)
# déploye la liste temporaire
# et l'injecte dans la liste finale
i = 0
while len(retourB) > 0:
for j in range(l_liste):
note = retourB.pop(0)
# print(note)
retourA[i].append(note)
i += 1
return retourA
def numeroter(liste, debut=0):
""" numétoter les éléments d'une liste depuis un index (debut)
p.e. gamme = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
gamme_numerot = [[1, "C"], [2, "C#"], [3, "D"], [4, "D#"], [5, "E"],
[6, "F"], [7, "F#"], [8, "G"], [9, "G#"], [10, "A"], [11, "A#"], [12, "B"]]
"""
retour = []
num = debut
for element in liste:
retour.append([num, element])
num += 1
return retour
def index_element(element, liste):
""" retourne une liste d'index d'un élément d'une liste numérotée
p.e.
une_liste = [[1, "C"], [2, "C#"], [3, "D"], [4, "D#"], [5, "E"],
[6, "F"], [7, "F#"], [8, "G"], [9, "G#"], [10, "A"], [11, "A#"], [12, "B"]]
un_element = "F#"
une_liste = [(1, "1"), (2, "1#"), (3, "2"), (4, "2#"), (5, "3"),
(6, "4"), (7, "4#"), (8, "5"), (9, "5#"), (10, "6"), (11, "6#"), (12, "7"),
(13, "8"), (14, "8#"), (15, "9"), (16, "9#"), (17, "10"),
(18, "11"), (19, "11#"), (20, "12"), (21, "12#"), (22, "13"), (23, "13#"), (24, "14")]
un_element = "8#"
"""
return [x[0] for x in liste if x[1] == element]
def gamme_chromatique_de(note):
""" retourne la gamme chromatique d'une note """
retour = []
gamme = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
gtl = numeroter(gamme, 0)
note_t = [x for x in gtl if x[1] == note][0]
num = note_t[0]
for x in range(num, len(gtl)):
retour.append(gtl[x][1])
for x in range(num):
retour.append(gtl[x][1])
return retour
def ordonner_liste_sur_liste_index(la_liste, liste_index):
""" ordonne les élements d'une liste
selon un critère donné par une liste de tuples
composés par deux éléments (index, element) """
retour = []
liste_tuple = [x for x in liste_index if x[1] in la_liste]
# return sorted(liste_tuple)
return [x[1] for x in sorted(liste_tuple)]
def liste_num_harmonie(liste):
""" converti une liste de notes
en dominante
et liste de nombres sur l'harmonie
['G', 'C', 'E'] =>
gamme de sol = [[1, 'G'], [2, 'G#'], [3, 'A'], [4, 'A#'], [5, 'B'],
[6, 'C'], [7, 'C#'], [8, 'D'], [9, 'D#'], [10, 'E'], [11, 'F'],
[12, 'F#']]
['G', [1, 6, 10]] """
dominante = liste[0]
num_harmonie = []
gamme = gamme_chromatique_de(dominante)
gamme_numerotee = numeroter(gamme, 1)
# print(gamme_numerotee)
for y in liste:
for x in gamme_numerotee:
if x[1] == y:
# print(x)
num_harmonie.append(x[0])
return [dominante, num_harmonie]
def table_accords():
""" ouvre et parse le fichiers des accords """
accords = []
# f_csv = "table_accords.txt"
f_csv = "table_accords_jazzy.txt"
""" separateurs """
sep = ['\n', "|", ","]
# def importer_csv(self, f_csv):
with open(f_csv,'r') as f:
donnees = f.read()
donnees_sans_entete = donnees.split(sep[0])
entete = donnees_sans_entete.pop(0)
for ligne in donnees_sans_entete:
if len(ligne) == 0 or ligne[0] == "#":
continue
champs = ligne.split(sep[1])
# famille|noms|harmonie|
famille = champs[0].strip(" ")
noms = [x.strip(" ") for x in champs[1].split(sep[2])]
harmonie = [int(x.strip(" ")) for x in champs[2].split(sep[2])]
accords.append([famille, noms, harmonie])
return accords
def donne_nom_accord(notes, ta):
""" depuis une liste composée par
une dominante
une liste d'harmonie
retourne un nom d'accord complet
si ces composantes sont contenues dans un tableau d'accords
p.e. ['G', [1, 6, 10]] => """
# print("notes", type(notes), notes)
dominante = notes[0]
# print("dominante", dominante)
gamme = gamme_chromatique_de(dominante)
gamme_numerotee = numeroter(gamme, 1)
""" ta = table_accords """
trouve = False
harmonie = []
for un_accord in ta:
# print(un_accord[2])
# print(un_accord[1][1])
# print(un_accord[2])
# print(notes[1])
if un_accord[2] == notes[1]:
trouve = True
harmonie.append(un_accord[1][1])
"""harmonie = [un_accord[1][1] for un_accord in ta if un_accord[2] == notes[1]]"""
# print(harmonie)
# ***********************************************************
# BUG !!!!!!!!! pas bon l'harmonie !
# ***********************************************************
if trouve == True and len(harmonie) == 0:
retour = dominante
elif trouve == True:
retour = dominante + harmonie[0]
else:
retour = str(None)
# print("accord de " + retour)
return retour
if __name__ == "__main__":
print("DEMOS")
ligne = 30*'-'
# print("")
# une_liste =
# retour = ()
# print(retour)
# print(ligne)
ta = table_accords()
# '''
# exemple
l = 2
un_accord = ta[l]
print("tout => ", un_accord)
print("type => ", un_accord[0])
print("noms => ", un_accord[1])
print("nom long => ", un_accord[1][0])
print("nom court => ", un_accord[1][1])
print("notes => ", un_accord[2])
print(ligne)
# '''
print("donne_nom_accord selon num_harmonie")
notes = ['G', [1, 6, 10]]
accord = donne_nom_accord(notes, ta)
print(notes, '=>', accord)
notes = ['G', [1, 5, 8, 11]]
accord = donne_nom_accord(notes, ta)
print(notes, '=>', accord)
print(ligne)
# '''
print("num_harmonie")
possibilites = [['G', 'C', 'E'], ['E', 'G', 'C'], ['C', 'E', 'G']]
""" pour chaque possibililté transformer en dominante nombre """
for possibilite in possibilites:
liste_nombre = liste_num_harmonie(possibilite)
print(possibilite, "=>", liste_nombre)
print(ligne)
# '''
# '''
print("ordonner_liste_sur_liste_index A")
une_liste = ["G", "A", "D#", "C", "B"]
une_liste_index = [[1, "C"], [2, "C#"], [3, "D"], [4, "D#"], [5, "E"],
[6, "F"], [7, "F#"], [8, "G"], [9, "G#"], [10, "A"], [11, "A#"], [12, "B"]]
retour = ordonner_liste_sur_liste_index(une_liste, une_liste_index)
print(une_liste, retour)
print(ligne)
print("ordonner_liste_sur_liste_index B")
une_liste = ["G", "A", "D#", "C", "B"]
une_gamme = gamme_chromatique_de(une_liste[4])
une_gamme_numerotee = numeroter(une_gamme, 1)
retour = ordonner_liste_sur_liste_index(une_liste, une_gamme_numerotee)
print(une_liste, retour)
print(ligne)
print("ordonner_liste_sur_liste_index C")
une_liste = ["G", "A", "D#", "C", "B"]
numeroter(gamme_chromatique_de(une_liste[4]), 1)
retour = ordonner_liste_sur_liste_index(une_liste, une_gamme_numerotee)
print(une_liste, retour)
print(ligne)
# '''
# '''
print("gamme_chromatique_de")
une_note = "D"
retour = gamme_chromatique_de(une_note)
print(une_note, retour)
print(ligne)
# '''
# '''
print("index_element")
une_liste = [[1, "C"], [2, "C#"], [3, "D"], [4, "D#"], [5, "E"],
[6, "F"], [7, "F#"], [8, "G"], [9, "G#"], [10, "A"], [11, "A#"], [12, "B"]]
un_element = "F#"
retour = index_element(un_element, une_liste)
print(un_element, '=', retour)
une_liste = [(1, "1"), (2, "1#"), (3, "2"), (4, "2#"), (5, "3"),
(6, "4"), (7, "4#"), (8, "5"), (9, "5#"), (10, "6"), (11, "6#"), (12, "7"),
(13, "1"), (14, "1#"), (15, "2"), (16, "2#"), (17, "3"),
(18, "4"), (19, "4#"), (20, "5"), (21, "5#"), (22, "6"), (23, "6#"), (24, "7")]
un_element = "5#"
retour = index_element(un_element, une_liste)
print(un_element, '=', retour)
print(ligne)
# '''
# '''
print("numeroter")
gamme = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
retour = numeroter(gamme, 1)
print(retour)
print(ligne)
# '''
# '''
print("distiller")
une_liste = ["E 3", "C 4", "E 4", "G 4", "C 5", "E 5"]
retour = distiller(une_liste)
print(retour)
print(ligne)
# '''
ensuite un fichier texte pour des gammes (tirées d'ici : http://www.solfego.fr/toutes-les-gammes.htm et un peu enrichi)
gammes.txt
famille | nom | notes
en ien | Aéolien | 1, 3, 4, 6, 8, 9, 11
en ien | Aéolien b5 | 1, 3, 4, 6, 7, 9, 11
en ien | Altéré superlocrien | 1, 2, 4, 5, 7, 9, 11
exotique | Arabe | 1, 3, 5, 6, 7, 9, 11
divers | Bartock | 1, 3, 5, 7, 8, 10, 11
traditionnel | Blues | 1, 4, 6, 7, 8, 11
traditionnel | Blues (heptatonique) | 1, 4, 6, 7, 8, 11, 12
traditionnel | Chromatique | 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12
traditionnel | Demi-ton tons sans sixte | 1, 2, 4, 5, 7, 8, 11
en ien | Dorien | 1, 3, 4, 6, 8, 10, 11
divers | Enigmatique | 1, 2, 5, 7, 9, 11, 12
exotique | Espagnole (première forme) | 1, 2, 5, 6, 8, 9, 11
exotique | Gitane | 1, 2, 5, 6, 8, 10, 11
exotique | Gypsy | 1, 2, 5, 6, 8, 9, 12
exotique | Hindou | 1, 3, 5, 6, 8, 9, 11
exotique | Hongroise gitane | 1, 3, 4, 7, 8, 9, 11
exotique | Hongroise majeure | 1, 4, 5, 7, 8, 10, 11
exotique | Hongroise mineure | 1, 3, 4, 7, 8, 9, 12
en ien | Ionien | 1, 3, 5, 6, 8, 10, 12
en ien | Ionien #5 | 1, 3, 5, 6, 9, 10, 12
exotique | Javanais | 1, 2, 4, 6, 8, 10, 11
en ien | Locrien | 1, 2, 4, 6, 7, 9, 11
en ien | Locrien bécarre 6 | 1, 2, 4, 6, 7, 10, 11
en ien | Lydien | 1, 3, 5, 7, 8, 10, 12
en ien | Lydien #2 | 1, 4, 5, 7, 8, 10, 12
en ien | Lydien augmenté | 1, 3, 5, 7, 9, 10, 12
traditionnel | Majeure harmonique | 1, 3, 5, 6, 8, 9, 12
traditionnel | Mineure harmonique | 1, 3, 4, 6, 8, 9, 12
traditionnel | Mineure mélodique | 1, 3, 4, 6, 8, 10, 12
en ien | Mixolydien | 1, 3, 5, 6, 8, 10, 11
exotique | Napolitaine majeure | 1, 2, 4, 6, 8, 10, 12
exotique | Napolitaine mineure | 1, 2, 4, 6, 8, 9, 12
exotique | Orientale (deuxième forme) | 1, 2, 5, 6, 7, 9, 10
exotique | Orientale (première forme) | 1, 2, 5, 6, 7, 9, 11
exotique | Orientale (troisième forme) | 1, 4, 5, 6, 9, 10, 12
traditionnel | Pentatonique majeure | 1, 3, 5, 8, 10
traditionnel | Pentatonique mineure | 1, 4, 6, 8, 11
exotique | Persane (deuxième forme) | 1, 2, 5, 6, 7, 9, 12
exotique | Persane (première forme) | 1, 2, 5, 6, 7, 8, 11
en ien | Phrygien | 1, 2, 4, 6, 8, 9, 11
exotique | Roumain mineur | 1, 3, 4, 7, 8, 10, 11
en ien | Superlocrien bb7 | 1, 2, 4, 5, 7, 9, 10
et mon parseur que je bosse actuellement :
gammes.py
#!/usr/bin/env python3
# -*- coding: UTF8 -*-
"""
module docstring
"""
import fonctions as Fn
__title__ = "Ki Affiche l'aide"
__author__ = 'Ury Cyril : kholo'
__license__ = 'cc'
__copyright__ = 'Creative Common 2018-2019'
__ver_major__ = 0
__ver_minor__ = 1
__ver_patch__ = 0
__ver_sub__ = ''
__version__ = "%d.%d.%d%s" % (__ver_major__, __ver_minor__,
__ver_patch__, __ver_sub__)
txt_modes = """en ien, en note, de degré, correspondance
Mode Ionien, Mode de Do , degré I, 1
Mode Dorien, Mode de Ré , degré II, 3
Mode Phrygien, Mode de Mi , degré III, 5
Mode Lydien, Mode de Fa , degré IV, 6
Mode Mixolydien, Mode de Sol , degré V, 8
Mode Eolien, Mode de La , degré VI, 10
Mode Locrien, Mode de Si , degré VII, 12
"""
def parser_modes(tete=False):
""" référence les modes connues par le système et ignore les doublons et vides """
tout = [[y.strip(' ') for y in x.split(',') if len(y) > 0] for x in txt_modes.split('\n') if len(x) > 0]
if not tete:
entete = tout.pop(0)
return tout
def modes_par(num):
""" retourne les noms de modes par un des mode ou par degré """
if num > 2 : num = 0
return [x[num] for x in parser_modes()]
def mode(num):
""" retourne le mode d'une gamme si ça semble possible
num correspond au degré demandé """
modes = parser_modes(tete=True)
# corresp =
def table_gammes():
""" ouvre et parse le fichiers des gammes """
gammes = []
# gammes = {}
# f_csv = "table_accords.txt"
f_csv = "gammes.txt"
""" separateurs """
sep = ['\n', "|", ","]
# def importer_csv(self, f_csv):
with open(f_csv,'r') as f:
donnees = f.read()
donnees_sans_entete = donnees.split(sep[0])
entete = donnees_sans_entete.pop(0)
for ligne in donnees_sans_entete:
if len(ligne) == 0 or ligne[0] == "#":
continue
champs = ligne.split(sep[1])
# famille|noms|harmonie|
famille = champs[0].strip(" ")
noms = [x.strip(" ") for x in champs[1].split(sep[2])]
harmonie = [int(x.strip(" ")) for x in champs[2].split(sep[2])]
gammes.append([famille, noms, harmonie])
# if noms[0] in gammes:
# print("attention", gammes[noms[0]], "existe")
# gammes[noms[0]] = (famille, noms, harmonie)
return gammes
def voir_gammes_connues():
""" référence les gammes connues par le système et ignore les doublons """
# tg = table_gammes()
# return set([nom for famille, nom, harmo in table_gammes()])
return set([nom[0] for famille, nom, harmo in table_gammes()])
def voir_familles_connues():
""" référence les familles connues par le système et ignore les doublons """
# tg = table_gammes()
return set([famille for famille, nom, harmo in table_gammes()])
def voir_harmonies_connues():
""" référence les harmonies connues par le système et ignore les doublons """
# tg = table_gammes()
# return set([tuple(harmo) for famille, nom, harmo in table_gammes()])
return set([tuple(harmo) for famille, nom, harmo in table_gammes()])
def voir_par_familles():
tg = table_gammes()
for famille in voir_familles_connues():
print("famille", famille)
print([x[1][0] for x in tg if x[0] == famille])
print(50*'-')
def gamme_sortir_notes(dominante, harmonie):
""" dans une gamme chromatique sort certaines notes
défini par leur numéro (1 est la dominante) au sein d'une liste """
chromatique = Fn.gamme_chromatique_de(dominante)
retour = []
for num in harmonie:
retour.append(chromatique[num])
return retour
if __name__ == "__main__":
tg = table_gammes()
def DEMO_gammes1():
print("table_gammes")
for gamme in tg:
print(gamme)
print(50*'-')
print("voir_gammes_connues", voir_gammes_connues())
print(50*'-')
print("voir_familles_connues", voir_familles_connues())
print(50*'-')
print("voir_harmonies_connues", voir_harmonies_connues())
print(50*'-')
print("voir_par_familles", )
print(50*'-')
voir_par_familles()
def DEMO_modes():
print(50*'-')
modes = parser_modes()
print("modes", modes)
print(50*'-')
print("modes en ien", modes_par(0))
print(50*'-')
print("modes en note", modes_par(1))
print(50*'-')
print("modes en degré", modes_par(2))
print(50*'-')
print("gamme_chromatique_de")
dominante = "D"
la_gamme = Fn.gamme_chromatique_de(dominante)
print(dominante, la_gamme)
print(50*'-')
print("voyons la gamme de blues qui est la 5")
print(tg[5])
harmonie = tg[5][2]
print("notes à sortir", harmonie)
print("donc la gamme de blues en D est")
print(gamme_sortir_notes(dominante, harmonie))
print(50*'-')
bon, il est un peu fleuri mais j'ai justement le nez dedans
en passant par la lorraine voila le code qui allait à l'origine (et va toujours) avec fonctions.py
solfege.py
#!/usr/bin/env python3
# -*- coding: UTF8 -*-
"""
module docstring
"""
import fonctions as Fn
__title__ = "Ki Affiche l'aide"
__author__ = 'Ury Cyril : kholo'
__license__ = 'cc'
__copyright__ = 'Creative Common 2018-2019'
__ver_major__ = 0
__ver_minor__ = 1
__ver_patch__ = 0
__ver_sub__ = ''
__version__ = "%d.%d.%d%s" % (__ver_major__, __ver_minor__,
__ver_patch__, __ver_sub__)
class AccordListLettres(object):
""" """
def __init__(self, notes=[]):
# self.__notes = notes
# print("notes en entrée", notes)
# self.trouve_nom_accord(notes)
pass
def trouve_nom_accord(self, notes):
""" """
# retour = []
""" Etape1 prendre les notes et virer les num octave """
""" virer les doublons """
essence = Fn.distiller(notes)
# print(essence)
""" ordonner sur la gamme de do """
gamme_do = Fn.gamme_chromatique_de("C")
gamme_do_numerotee = Fn.numeroter(gamme_do, 1)
notes_ordonnees = Fn.ordonner_liste_sur_liste_index(essence, gamme_do_numerotee)
print("notes_ordonnees", notes_ordonnees)
""" créer des possibilités """
les_possibilites = Fn.possibilites(notes_ordonnees)
# print("possible", les_possibilites)
""" pour chaque possibililté transformer en nombre + garder la dominante"""
les_possibilites_num = []
for une_possibilite in les_possibilites:
les_possibilites_num.append(Fn.liste_num_harmonie(une_possibilite))
print("les_possibilites_num", les_possibilites_num)
""" chercher une correspondance pour chaque possibilité
pour chaque possibilité numérique,
chercher une correspondance dans la table des accords """
accords = []
ta = Fn.table_accords()
for une_possibilite_num in les_possibilites_num:
# print(une_possibilite_num)
accords.append(Fn.donne_nom_accord(une_possibilite_num, ta))
#
# retour à mettre ici
#
# return accords
# return [x for x in accords if x != 'None']
#
# ********************************************
# ********************************************
# ********************************************
accords = [x for x in accords if x != 'None']
if len(accords) == 0:
# print("rien trouvé")
retour = "rien trouvé"
if len(accords) == 1:
print("accord de", accords[0])
retour = "accord de " + str(accords[0])
if len(accords) > 1:
print("plusieurs solutions", accords)
retour = "plusieurs solutions " + str(accords)
return retour
if __name__ == "__main__":
# notes = ["C# 5", "A 4", "E 4", "E 5", "A 3", "E 3"]
# notes = ["E 3", "C 4", "E 4", "G 4", "C 5", "E 5"]
# notes = ["E 3", "B 3", "F 4", "A 4", "D 5", "E 5"] # trop con ! c'est bien Bm7/5b... enfin pour moi !
notes = ["B 3", "F 4", "A 4", "D 5"]
possibilites_accords = AccordListLettres(notes=notes)
# possibilites_accords.trouve_nom_accord(notes)
print("possibilites", possibilites_accords.trouve_nom_accord(notes))
et ma table "d'accords" plus complète que dans l'autre post :
table_accords_jazzy.txt (j'ai mis jazzy pour la distinguer de la première bien plus pauvre !)
# famille | noms | harmonie |
majeur | sixième majorée, 6, M6, maj6 | 1, 5, 8, 10 |
majeur | septième majorée, maj7, Δ, Δ7, majeur7, Maj7, 7Maj, M7 | 1, 5, 8, 12 |
# l'espace est normal ;+)
majeur | majeur, , MAJ, Majeur | 1, 5, 8 |
mineur | mineur septième majorée, mΔ, -Δ, -M7, min7Δ, -Maj7 | 1, 4, 8, 12 |
mineur | mineur six bémolée, m♭6, min♭6, -♭6, minor♭6, aeolien | 1, 4, 8, 9 |
mineur | Phrygien, sus♭9, phryg, min♭2, m♭2, minor♭2, phrygien | 1, 2, 4, 8, 9 |
mineur | mineur six, m6, min6, -6 | 1, 4, 8, 10 |
mineur | mineur septième, m7, min7, -7 | 1, 4, 8, 11 |
mineur | mineur, m, - | 1, 4, 8 |
septième | septième sus4, 7sus4, 7sus, suspendu | 1, 6, 8, 11 |
septième | septième quinte bémolée, 7-5, 7 -5, 7♭5, 7 ♭5, 7(♭5), 7(-5) | 1, 5, 7, 11 |
septième | septième quinte augmentée, 7♯5, +7, 7aug | 1, 5, 9, 11 |
septième | septième, 7, dom, dom7 | 1, 5, 8, 11 |
diminué | Septième diminuée, °7, dim7 | 1, 4, 7, 10 |
diminué | Demi-diminué, m7♭5, Ø, m7 5-, -7 ♭5, 7♭5, min7(♭5) | 1, 4, 7, 11 |
diminué | diminué, dim, ♭5, d, °, triade dim. | 1, 4, 7 |
augmenté | augmenté septième quinte bémolée, Δ♯5, Δ ♯5 | 1, 4, 9, 12 |
augmenté | augmenté, Aug, augm., +, triade aug. | 1, 5, 9 |
quarte | sus4, sus4, 4 | 1, 6, 8 |
jazzy | accord de quinte, 5, power chord | 1, 8 |
jazzy | triton, b5 | 1, 7 |
jazzy | majeur, maj | 1, 5, 8 |
jazzy | augmenté, aug, + | 1, 5, 9 |
jazzy | sus2, sus2 | 1, 3, 8 |
jazzy | sus4, sus4 | 1, 6, 8 |
jazzy | mineur, m, min, - | 1, 4, 8 |
jazzy | diminué, dim, o | 1, 4, 7 |
jazzy | sixième, 6 | 1, 5, 8, 10 |
jazzy | mineur 6, m6, min6 | 1, 4, 8, 10 |
jazzy | septième majorée, maj7, majeur7, j7 | 1, 5, 8, 12 |
jazzy | septième majorée quinte augmentée, maj7#5, j7#5 | 1, 5, 9, 12 |
jazzy | septième majorée quinte bémolée, maj7b5, j7b5 | 1, 5, 7, 12 |
jazzy | septième, 7 | 1, 5, 8, 11 |
jazzy | sept sus4, 7sus4, 7 sus4 | 1, 6, 8, 11 |
jazzy | septième quinte diminuée, 7b5 | 1, 5, 7, 11 |
jazzy | septième quinte augmentée, 7#5, +7 | 1, 5, 9, 11 |
jazzy | mineur7, m7, min7 | 1, 4, 8, 11 |
jazzy | mineur septième majorée, m(maj7), min(maj7) | 1, 4, 8, 12 |
jazzy | mineur sept quinte bémolée, min7b5, m7b5, ø | 1, 4, 7, 11 |
jazzy | diminué7, dim7, o7 | 1, 4, 7, 10 |
jazzy | neuvième, add9 | 1, 3, 5, 8 |
jazzy | mineur neuvième, m(add9), min(add9) | 1, 3, 4, 8 |
jazzy | six neuf, 6/9 | 1, 3, 5, 8, 10 |
jazzy | mineur six neuf, m6/9, min6/9 | 1, 3, 4, 8, 10 |
jazzy | septième et neuvième majorée, j7/9, maj9, j9 | 1, 3, 5, 8, 12 |
jazzy | sept neuf, 7/9, 9 | 1, 3, 5, 8, 11 |
jazzy | sept neuvième augmenté, 7#9, #9 | 1, 4, 5, 8, 11 |
jazzy | sept neuvième augmenté quinte augmentée, 7#9#5, #9#5 | 1, 4, 5, 9, 11 |
jazzy | sept neuf diminué, 7b9, b9 | 1, 2, 5, 8, 11 |
jazzy | sept neuf diminué quinte augmentée, 7b9#5, b9#5 | 1, 2, 5, 9, 11 |
jazzy | mineur sept neuf, m7/9, m9, min9 | 1, 3, 4, 8, 11 |
jazzy | nimeur neuf quinte bémolée, m9b5, min9b5 | 1, 3, 4, 7, 11 |
jazzy | mineur 7 neuvième bémolée, m7b9, min7b9 | 1, 2, 4, 8, 11 |
jazzy | mineur neuvième majorée, min(maj9), m(maj9) | 1, 3, 4, 8, 12 |
jazzy | majeur neuf onzième augmentée, maj9#11, j9#11 | 1, 3, 5, 7, 8, 12 |
jazzy | majeur sept onzième augmentée, maj7#11, j7#11 | 1, 5, 7, 8, 12 |
jazzy | septième neuf onzième augmentée, 7/9#11, 9#11 | 1, 3, 5, 7, 8, 11 |
jazzy | neuf sus 4, 9sus4, 11 | 1, 3, 6, 8, 11 |
jazzy | mineur neuvième onzième, min9/11, min11, m11 | 1, 3, 4, 6, 8, 11 |
jazzy | mineur septième onzième, m7/11, min7/11 | 1, 4, 6, 8, 11 |
jazzy | majeur neuf onzième augmenté treize, maj9#11/13, maj13#11 | 1, 3, 5, 7, 8, 10, 12 |
jazzy | septième majorée treize, maj7/13, maj7/6 | 1, 5, 8, 12 |
jazzy | sept treize, 7/13, 7/6 | 1, 5, 8, 10, 11 |
jazzy | sept sus quatre treizième, 7sus4/13, 7sus4/6 | 1, 6, 8, 10, 11 |
jazzy | sept treize onzième augmentée, 7#11/13, 13#11 | 1, 5, 7, 8, 10, 11 |
jazzy | neuvième majorée treize, maj9/13, maj13, j9/6 | 1, 3, 5, 8, 10, 12 |
jazzy | neuf treize, 9/13, 13 | 1, 3, 5, 8, 10, 11 |
jazzy | sept treize neuf bémolé, 7b9/13, 13b9, b9/13 | 1, 2, 5, 8, 10, 11 |
... et j'ai pas encore parlé du GUI !!!
pour ça je ferai un post à part parce que je met vraiment trop de bordel quand j'y met le nez (dans les GUI) à m'y perdre moi même ce qui est preuve qu'il y a du boulot
en tous cas tu as ici la partie moteur du logiciel
NB pour les accords, j'ai pas encore attaqué le coté "basse de" ; par exemple D basse de F# noté D/F#
NB 2 : mon rechercheur d'accords est encore trop con à mon gout ;
par exemple si tu as le malheur de ne pas mettre des croix dans le gui sur le E et A sur un D, il te sort un truc trop con (ya un exemple avec le Bm7/5- dans mon code)
la où ça fonctionne c'est que peut importe que la dominante soit ou pas dans les notes de basses puisqu'il considère toutes les possibilités en fonction de toutes les notes données
Après on a aussi la possibilité que la dominante ne fasse même pas partie de l'accord mais là c'est de l'harmonie et on est encore très loin de commencer à seulement l'envisager
alors ?