Debian Debian-France Debian-Facile Debian-fr.org Debian-fr.xyz Debian ? Communautés

Debian-facile

Bienvenue sur Debian-Facile, site d'aide pour les nouveaux utilisateurs de Debian.

Vous n'êtes pas identifié(e).

#1 31-03-2019 21:31:34

David5647
Membre
Distrib. : Debian Sid
Noyau : 5.15.0-2-amd64
(G)UI : i3wm + des bouts de kde
Inscription : 27-08-2017

Générateur d'accord de guitare (python3)

Bonjour kholo,

Je me permet d'ouvrir un nouveau sujet,
car la proposition commence à s'écarter grandement de la demande de calixtus06.
pour rappel : message de kholo

La proposition m'interesse, et ça m'amuserai d'y participer,
et je t'invite à partager ton code,
nous pouvons nous servir de ce sujet pour parler de l'avancement du programme,
mais peut-être que l'ouverture d'un projet sur quelque-chose comme github permettrait de partager plus facilement le code, je te laisse voir...

d'abord, votre façon d'aborder la composition des accords est un peu différente de la mienne. je vous propose de commencer par ça :

Oui, j'ai simplement utilisé la base de donnée partagée par calixtus06, j'affiche simplement les notes selon leur coordonnées (x=corde, y=frette)
à vrai dire, j'ai un peu regardé comment générer les accords avec la théorie musicale,
mais je n'ai pas poussé la chose à son terme, étant plutôt néophyte dans le domaine.
Il y a pas mal de programmes qui traînent sur github (pas trouvé un satisfaisant en python),
il y en a un dont la méthode me paraissait assez explicite mais je ne le retrouve plus.
bref, je suis resté avec pas mal questions en suspent...

mon idée était aussi de laisser l'utilisateur pointer un manche et en sortir des possibilités de noms d'accord


Oui l'idée est intéressante, pareil des programmes traînent, ça peut-être intéressant de les décortiquer, mais y a plein de truc à faire smile, et ce n'est peut-être pas le premier module à aborder car il implique la mise en place de l'ensemble de la théorie.

donc mon but ultime est de faire un programme pour les guitaristes avec les grilles d'accords, les positions de doigts, les gammes,... les tablatures (à terme)

Comme je te le disais, je ne suis pas des plus à l'aise avec la théorie; si tu maîtrises, pas de problème smile
le doigté, j'ai un peu de mal à voir comment mettre un tel truc en place, va falloir prendre la guitare et se dire : pourquoi je mets mes doigts comme ça...

je voudrais également pouvoir faire en sorte que tous les modules ouvre, sauve ou importe, exporte depuis des fichiers textes (facilement réutilisables) pour rester dans l'idée de l'open source.

Pas sûr de saisir ce que tu entends par là.

t'en es peu ou prou arrivé au même point que moi,

J'imagine que le projet devra contenir les modules principaux suivants :
1) un module qui met en place la théorie renvoie simplement la liste des notes ([1, 3, ...] par exemple)
2) un module qui cherche à partir de cette liste les possiblités sur le manche et détermine ceux "réalisables" par un être humain
3) un affichage

je vais potasser vos codes plus profondément maintenant...


J'ai essayé de rendre mon code le plus clair possible, j'espère qu'il le sera!

C'est parti?

Hors ligne

#2 01-04-2019 08:03:43

kholo
Membre
Inscription : 15-05-2017

Re : Générateur d'accord de guitare (python3)

salut David5647,
content de trouver quelqu'un avec qui "m'amuser" cool
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 big_smile

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 roll

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 wink

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 !!! lol
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 smile

alors ?

Hors ligne

Pied de page des forums