Debian-facile

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

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

#26 25-02-2019 15:32:57

David5647
Membre
Distrib. : Debian Buster
Noyau : 4.17.0-3-amd64
(G)UI : KDE/i3wm
Inscription : 27-08-2017

Re : cadrillage en python

Le meilleur conseil que je peux te donner là, c'est lire un tuto, te repencher sur ce qu'est une boucle, et tu prends du papier un crayon et tu suis ton programme.
Dans une premier temps, essaie de tracer des cordes uniquement.
Tu peux essayer de les tracer d'abord sans faire de boucle, tu écris la création de tes 6 lignes, ça marche aussi, t'es pas obligé de faire de boucle.
Puis, si tu veux faire quelque chose d'un peu mieux, t'essaie de voir la récurrence entre les lignes et tu fabriques une boucle.
tu peux partir de :

cordes = [0, 50, 100, 150, 200, 250]

pour des cordes espacées de 50.

Hors ligne

#27 25-02-2019 17:18:41

calixtus06
Membre
Distrib. : Librazik2
Noyau : Linux version 4.9.0-6-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : cadrillage en python

ok,

j'ai repris depuis le début mais je bloque sur le dessin des cordes . peux tu m'éclairer ?

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tkinter as tk

fen_generale=tk.Tk()

frettes=["1ère frette","2ème frette", "3ème frette", "4ème frette","5ème frette"]
cordes=["1ère corde", "2ème corde", "3ème corde","4ème corde","5ème corde", "6ème corde"]

longueur=400
largeur=200
x=0
y=0
x1=largeur
y1=longueur

manche_nu=tk.Canvas(fen_generale, height=longueur, width=largeur, bg="yellow")

for i in frettes:
  print (manche_nu.create_line (x,y+2,x1,y+2))
  y=y+80
 
for i in cordes:
  print (manche_nu.create_line (x+2,y,x+2, y1))
  x=x+10


manche_nu.pack()
tk.mainloop()


Il n'y a pas de mauvaises questions...

Hors ligne

#28 25-02-2019 18:13:57

David5647
Membre
Distrib. : Debian Buster
Noyau : 4.17.0-3-amd64
(G)UI : KDE/i3wm
Inscription : 27-08-2017

Re : cadrillage en python

Commenté :

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tkinter as tk

fen_generale=tk.Tk()

# Quel est l'interet d'une telle liste?
frettes=["1ère frette","2ème frette", "3ème frette", "4ème frette","5ème frette"]
cordes=["1ère corde", "2ème corde", "3ème corde","4ème corde","5ème corde", "6ème corde"]

longueur=400
largeur=200
x=0
y=0
x1=largeur
y1=longueur

manche_nu=tk.Canvas(fen_generale, height=longueur+200, width=largeur+200, bg="yellow")

for i in frettes: # i ne sert à rien, pourquoi ne pas se servir de for pour ajuster la vakeur de y directement?
  print (manche_nu.create_line(x,y+2,x1,y+2)) # il sert à quoi ce print???
  # tu renommerai x en x0, on comprendrai plus facilement qui varie ou non :
  # un nom pour les variables, un nom pour les constantes : voir la suite...
  y=y+80 # prend un papier et demande toi : quelles valeurs prendra y?

for i in cordes:
  # on commence avec y = 6*80=480 et j'ai l'impression que si y>y1 il ne veut
  # rien tracer, c'est ça mélanger variables et constantes, il faut réinitialiser y
  # avant la boucle.
  print (manche_nu.create_line(x+2,y,x+2, y1))
  x=x+10


manche_nu.pack()
tk.mainloop()
 



Ma version :

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tkinter as tk

case = [0, 80, 160, 240, 320, 400] # si on veut 5 case, il faut faire 6 traits
corde = [0, 40, 80, 120, 160, 200]

longueur = 400
largeur = 200

fen = tk.Tk()

manche_nu = tk.Canvas(fen, height=longueur, width=largeur, bg = "yellow")

y0 = 0
y1 = longueur
for x in corde:
  manche_nu.create_line(x, y0, x, y1, fill="black")

x0 = 0
x1 = largeur
for y in case:
  manche_nu.create_line(x0, y, x1, y, fill="red")

manche_nu.pack()
fen.mainloop()
 

Hors ligne

#29 26-02-2019 12:09:50

calixtus06
Membre
Distrib. : Librazik2
Noyau : Linux version 4.9.0-6-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : cadrillage en python

Ayé , il me semble que là c'est plus clair,
prochaine étape mettre tout ça sous forme de classe ?

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tkinter as tk

fen_generale=tk.Tk()


#Pour moi c'est plus représentatif de ce dont je parle
#la frette est un "trait". La case est un espace. Du coup je préfère
#une liste de noms de frettes et une avec le nom des cordes.
#Peutêtre ai-je mal compris ?
#effectivement x et y resteront des entiers et non des chaînes dans les boucles for

frettes=[2,80,160, 240,320,400]
cordes=[2, 40, 80,120,160,200]

longueur=405
largeur=205
x0=0
x1=largeur
y0=0
y1=longueur


manche_nu=tk.Canvas(fen_generale, height=longueur, width=largeur, bg="yellow")

# x est un compteur et non une variable, c'est ça ?

for x in cordes:
  manche_nu.create_line (x,y0,x,y1)


for y in frettes:
  manche_nu.create_line (x0,y,x1,y)

manche_nu.pack()
tk.mainloop()

Dernière modification par calixtus06 (26-02-2019 13:19:20)


Il n'y a pas de mauvaises questions...

Hors ligne

#30 26-02-2019 15:38:49

David5647
Membre
Distrib. : Debian Buster
Noyau : 4.17.0-3-amd64
(G)UI : KDE/i3wm
Inscription : 27-08-2017

Re : cadrillage en python

calixtus06 a écrit :

#Pour moi c'est plus représentatif de ce dont je parle
#la frette est un "trait". La case est un espace. Du coup je préfère
#une liste de noms de frettes et une avec le nom des cordes.
#Peutêtre ai-je mal compris ?

C'est toi qui persistais à utiliser la variable case pour tracer des traits, c'est un de tes codes que j'ai remodifié... big_smile
Donc, oui, frettes est plus adapté.

calixtus06 a écrit :

#effectivement x et y resteront des entiers et non des chaînes dans les boucles for

A quoi t'attendais tu?

calixtus06 a écrit :

# x est un compteur et non une variable, c'est ça ?


Je ne sais pas ce que tu entends pas compteur exactement,
Je définirai compteur ainsi: variable qui à chaque itération s'incrémente de 1
comme x n'augmente pas de 1 à chaque itération, ce n'est pas un compteur, mais c'est une variable
x énumère les valeurs stockées dans la liste cordes,
x a successivement la nature des éléments stockés dans cordes, peu importe la nature de ceux qui s'y trouvent
La boucle for et while, c'est peu ou prou là même chose. Si tu connais déjà les valeurs de x, c'est juste plus explicite d’utiliser la première.


J'ai noté cordes et la boucle for ainsi pour mettre en évidence le fonctionnement,
mais tu remarquera que si tu veux changer l'espace entre les cordes, il te faudra changer plusieurs valeurs

Tu peux tout mettre dans une classe si tu veux,
tu remarquera que si tu remets tout dans une boucle (et en adaptant un peu), tu peux tracer aussi plusieurs diagrammes.
Une classe apportera de la clarté.
Tu dois aussi créer une fonction pour afficher les notes.
Tu peux commencer par l'un ou par l'autre, cherche des tutos tu en trouvera de nombreux, plus exhaustifs que tout ce que je pourrais t'écrire ici

Dernière modification par David5647 (26-02-2019 16:04:54)

Hors ligne

#31 27-02-2019 23:13:39

calixtus06
Membre
Distrib. : Librazik2
Noyau : Linux version 4.9.0-6-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : cadrillage en python

Un grand merci !

Il n'y a pas de mauvaises questions...

Hors ligne

#32 02-03-2019 16:03:27

David5647
Membre
Distrib. : Debian Buster
Noyau : 4.17.0-3-amd64
(G)UI : KDE/i3wm
Inscription : 27-08-2017

Re : cadrillage en python

Salut,
tu t'en sors avec tes classes?

J'ai un peu développé mon code et recyclé quelques bouts de programmes,
pour voir ce que ça donne, c'est par ici

Je sais pas si  tu arrivera à le lire facilement, j'ai essayé de bien le commenter
mais ça peut te donner une idée de structure, comment et quels objets regrouper dans des classes...

Hors ligne

#33 05-03-2019 08:19:14

calixtus06
Membre
Distrib. : Librazik2
Noyau : Linux version 4.9.0-6-lzk-bl-amd64
(G)UI : mate
Inscription : 25-03-2016

Re : cadrillage en python

Un grand merci pour ce boulot . Je vais m'y pencher aujourd'hui . A priori il faut rassembler plusieurs de tes programmes ?

Il n'y a pas de mauvaises questions...

Hors ligne

#34 05-03-2019 09:10:13

David5647
Membre
Distrib. : Debian Buster
Noyau : 4.17.0-3-amd64
(G)UI : KDE/i3wm
Inscription : 27-08-2017

Re : cadrillage en python

Tu n'as besoin que de 3 fichiers :
   - le plus important : show_guitar_accord.py, qu'il faut exécuter avec python3, tout le code nécessaire est là!
   - listedesaccords.py qui contient la liste des accords que tu avais fourni, juste un peu modifiée pour la lire plus facilement avec python
   - guitare_parameter.py : quelques paramètres (dont géométriques) de la guitare   

Pas besoin de "rassembler", juste les garder dans le même dossier et lancer le premier dans lequel j'importe les accords et les paramètres en début de script.

woodenbackground.py n'est pas utilisé par défaut, il faut mettre à True l'option dans les paramètres si tu veux l'utiliser. Pas besoin de le regarder, c'est un vieux truc que j'avais programmé qui malgré ses 30 lignes est complètement incompréhensible par moi même. Il génère un fond style bois, juste de la cosmétique, juste parceque c'est amusant tongue .

essaie déjà de faire

python3 show_guitar_accords.py

Voir si il fonctionne délà big_smile

Pour l'utiliser, ça un peu changé depuis le screenshot, maintenant il faut juste cliquer sur un manche et un popup devrait apparaitre,
tu choisi l'accordage, l'accord et enfin sa variante et ça devrait s'afficher. (note : il n'y à que le premier et dernier accordage qui fonctionnent, les deux autres étaient vides dans le fichier que tu as fourni)

Dernière modification par David5647 (05-03-2019 09:16:51)

Hors ligne

#35 31-03-2019 13:47:36

kholo
Membre
Inscription : 15-05-2017

Re : cadrillage en python

salut à vous...
je suis intéressé par vos codes car je me suis lancé dans le même type de programme il y a quelque mois et je l'avais mis de côté en attendant de trouver des compères...
et là je suis comblé...
mon but était également de faire des grilles d'accords pour noter des chansons : comme ici :
grille_feuillesmortes.png
mais mettons cela de côté.

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 :
en partant d'un fichier de config basé sur l'écart des notes dans une gamme on peut reconstituer un accord en indiquant la dominante :
voici un extrait de la table que je me suis fait pour recréer les accords :

# 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 |


mon idée était aussi de laisser l'utilisateur pointer un manche et en sortir des possibilités de noms d'accord
par exemple accord de C (donc simple majeur composé par I III majeur et V) sur la gamme chromatique de do... ou pour ma notation : 1, 5, 8
je pense que les guitaristes ont également besoin de voir un manche pointé selon une dominante et une gamme, pour les solos voire pour les bassistes par exemple

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)
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.

du code, du code !!!
on y va ; j'ai commencé par faire 2 manches ;
je commence par le plus simple : le manche complet (vue de dessus et corde de basse en bas)

frm_manche.py

#!/usr/bin/env python3
# -*- coding: UTF8 -*-
"""
module docstring

"""

import tkinter as tk
import tkinter.ttk as ttk

from tkinter import Canvas


__title__ = "Ki Affiche un manche"
__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__)


# from configuration import Configuration

# from guitare import TODO

class MancheGuitare(tk.Canvas):
    """  """
    def __init__(self, parent, *args, **kwargs):
        """  """
        self.parent = parent
        super().__init__(*args, **kwargs)
        self.configure(width=800)
        self.configure(height=200)
        self.configure(bg='grey')
        # self.configure(bg='yellow')

        ## TODO : lier avec guitare
        self.notes = [(1, "C"), (2, "C#"), (3, "D"), (4, "D#"), (5, "E"), (6, "F"), (7, "F#"), (8, "G"), (9, "G#"), (10, "A"), (11, "A#"), (12, "B")]
        self.cordes_a_vide = ["E 3", "A 3", "D 4", "G 4", "B 4", "E 5"]
        # self.notes = [(1, "do"), (2, "do#"), (3, "ré"), (4, "ré#"), (5, "mi"), (6, "fa"), (7, "fa#"), (8, "sol"), (9, "sol#"), (10, "la"), (11, "la#"), (12, "si")]
        # self.cordes_a_vide = ["mi 3", "la 3", "ré 4", "sol 4", "si 4", "mi 5"]
        t = [9, 11, 16, 24, 32, 42] # tirant
        # print(self.notes)

        Lg = 700
        Tete = 50
        self.create_line(Tete, 40, Lg, 40, fill="black", width=t[0]/10)
        self.create_line(Tete, 60, Lg, 60, fill="black", width=t[1]/10)
        self.create_line(Tete, 80, Lg, 80, fill="black", width=t[2]/10)
        self.create_line(Tete, 100, Lg, 100, fill="black", width=t[3]/10)
        self.create_line(Tete, 120, Lg, 120, fill="black", width=t[4]/10)
        self.create_line(Tete, 140, Lg, 140, fill="black", width=t[5]/10)
        ## sillet de tête
        self.create_line(Tete - t[0]/10/2, 40, Tete, 140 + t[5]/10/2, fill="black", width=2)
        self.create_line(45, 40, 45, 140, fill="black", width=5)
        ## frets
        self.frets = self.calculs_position_frets()
        for num_f in self.frets:
            x = self.frets[num_f]
            self.create_line(x, 40, x, 140, fill="black", width=3)

        # departx = 25
        departy = 25
        le_fill = "darkblue"
        la_font = "Times 11 italic bold"
        les_textes = ["III", "V", "VII", "IX", "XII"]
        coordsX = self.calcul_placement_num_case()
        for i in range(5):
            self.create_text(coordsX[i], departy, fill=le_fill, font=la_font, text=les_textes[i])

        ## tous les points
        self.points = {} # point: [[coord_x, coord_y], [corde, fret]]
        self.afficher_tous_les_points()

        # self.allumer(4, 1)
        # self.allumer(3, 2)
        # self.allumer(4, 2)
        # self.allumer(5, 2)

    def afficher_tous_les_points(self):
        """  """
        les_y = [140, 120, 100, 80, 60, 40]
        a_vide = 50 - 7 ## place des points à vide
        les_x = [a_vide]
        cf = self.calculs_position_frets()
        les_x.extend([cf[x] - a_vide / 2 for x in cf])
        t = 7 ## t est rayon des points

        corde = 1
        m = 0
        for y in les_y:
            fret = 0
            n = 0
            for x in les_x:
                le_tag = '"' + str(m) + "," + str(n) + '"'
                point = self.create_oval(x-t, y-t, x+t, y+t, fill="yellow", tags=(le_tag))
                self.points[point] = ([x, y], [corde, fret])
                self.tag_bind(point, '<ButtonPress-1>', self.click_point)
                n += 1
                fret += 1
            m += 1
            corde += 1
    def allumer(self, corde, fret):
        """ sélectionne un point, l'allume et retourne le nom de la note """
        le_point = [x for x in self.points if self.points[x][1] == [corde, fret]][0]
        # print(le_point)
        self.inverser_couleur(le_point)
        """ retourne le nom de la note """
        # la_note = self.coords_vers_note(le_point)
        # print(la_note)
        return self.coords_vers_note(le_point)
    def calcul_placement_num_case(self):
        """  """
        retour = []
        frets = self.calculs_position_frets()
        for num_f in [s for s in self.frets if s < len(self.frets)]:
            if num_f in [u - 1 for u in [3, 5, 7, 9, 12]]:
                x1 = self.frets[num_f]
                x2 = self.frets[num_f + 1]
                x = ((x2 - x1) / 2) + x1
                retour.append(x)
        # print(retour)
        return retour
    def calculs_position_frets(self):
        """  """
        frets = {}
        debut = 50
        fin = 700
        LG = (fin - debut)
        nbreFrets = 15
        x_frets = [debut]
        for i in range(1, nbreFrets):
            x = (int(LG / nbreFrets) * (i))
            x_frets.append(x)
            frets[i] = (debut + x)
        #print(x_frets)
        #print(frets)
        return frets
    def click_point(self, event):
        """  """
        x = self.canvasx(event.x)
        y = self.canvasy(event.y)
        # print(self.find_closest(x, y))
        celui_la = self.find_closest(x, y)[0]
        # print(celui_la)

        # self.itemconfigure(celui_la, fill="blue")
        # self.itemconfigure(celui_la, state="disabled")
        # self.changer_couleur(celui_la, "blue")
        self.inverser_couleur(celui_la)

        la_note = self.coords_vers_note(celui_la)
        print(la_note)
    def coords_vers_note(self, coords):
        """  """
        #print(self.gettags(coords)[0])
        corde, case = self.gettags(coords)[0].split(",")
        corde = int(corde)
        case = int(case)
        #print("corde", corde, "case", case)
        a_vide = self.cordes_a_vide[corde].split(' ')[0]
        l_octave = int(self.cordes_a_vide[corde].split(' ')[1])
        #print("à vide", a_vide)
        num_note = [x for x in self.notes if x[1] == a_vide][0][0]
        #print("num_note", num_note)
        temp = num_note -1 + case
        octave = 0
        while temp >= 12:
            temp -= 12
            octave += 1
        la_note = self.notes[temp][1]
        l_octave = l_octave + octave
        #print("la_note", la_note, l_octave)
        retour = la_note + " " + str(l_octave)
        return retour
    def changer_couleur(self, celui_la, couleur):
        self.itemconfigure(celui_la, fill=couleur)
    def inverser_couleur(self, celui_la):
        # print(dir(self))
        # print(self.bbox(celui_la))
        couleur = self.itemcget(celui_la, 'fill')
        if couleur == "yellow":
            # self.changer_couleur(celui_la, 'blue')
            self.itemconfigure(celui_la, fill='blue')
            retour = True
        else:
            # self.changer_couleur(celui_la, 'yellow')
            self.itemconfigure(celui_la, fill='yellow')
            retour = False
        return retour


class Fenetre(tk.Tk):
    """  """
    def __init__(self, parent, *args, **kwargs):
        """  """
        self.parent = parent
        super().__init__(*args, **kwargs)
        # self.configuration = Configuration()
        # c = self.configuration

        self.title("Fenetre")
        self.geometry("+200+300")
        #********************************************
        self.guitare = Guitare(self)
        un_manche = MancheGuitare(self)
        un_manche.grid()

        #********************************************
        """ pour fermer la fenetre avec le bouton escape """
        self.bind('<Escape>', lambda event: self.quit())
        """ la boucle de GUI """
        self.mainloop()

if __name__ == "__main__":
    from guitare import Guitare
    Fenetre(None)

 


et ma class Guitare de mon module guitare.py :

class Guitare(object):
    """  """
    def __init__(self, parent, *args, **kwargs):
        """  """
        self.parent = parent
        super().__init__(*args, **kwargs)
        # self.configuration = Configuration()
        # c = self.configuration

        self.cordes_a_vide = ["E 3", "A 3", "D 4", "G 4", "B 4", "E 5"]
        # self.cordes_a_vide = ["mi 3", "la 3", "ré 4", "sol 4", "si 4", "mi 5"]
        self.t = [9, 11, 16, 24, 32, 42] # tirant
 


NB : 2/3 choses : j'ai un pote guitariste qui ne s'est jamais fait à la notation internationale donc tout devrait fonctionner en européen (do à si) et en international (C à B)
bien sur, il faut pouvoir s'adapter à l'open tuning (mais ça vous avez déjà commencé à le prendre en considération)
... pour les notes, j'utilise des numéros de gamme.
j'ai également utilisé des tailles de cordes dont je prend les tirants qui me servent à représenter le diamètre des cordes pour bien distinguer les basses des aigus.

voilà, pour commencer... si l'idée vous intéresse je vous ferais parvenir plus de code que je nettoierai à l'occasion

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

Hors ligne

#36 31-03-2019 20:34:17

David5647
Membre
Distrib. : Debian Buster
Noyau : 4.17.0-3-amd64
(G)UI : KDE/i3wm
Inscription : 27-08-2017

Re : cadrillage en python

Bonjour kholo,
le proposition s'écartant de la demande ce calixtus06,
je t'invite à poursuivre la discussion par ici : https://debian-facile.org/viewtopic.php?id=24035

Hors ligne

Pied de page des forums