IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Python Discussion :

Remonter pour démontrer les gammes musicales


Sujet :

Python

  1. #1
    Invité
    Invité(e)
    Par défaut Remonter pour démontrer les gammes musicales
    Bonjour à tous, vous allez avoir la joie de voir les gammes musicales défiler à vitesse cursive...

    C'est à ce moment, qui est encore fort simple à déchiffrer. Un instant à saisir primordial, puisqu'il définit la principale valeur algorithmique du "mécanisme" des tonalités diatoniques. Ainsi, que d'être enchanté de retrouver les notes cursives dans l'ordre chronologique préconfiguré par mes soins...

    Débutant moi-même, et en ayant une connaissance du problème informatique devenu une suite d'instructions avec un jeu de tables.

    Aux Bons Lecteurs : (codes, gammes)

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
     
    #!/usr/bin/env python3 
    # -*- coding: utf-8 -*-
    # *
    # Application gammique évolutive
    # Version 1 : Calculer les gammes
    #
    from tkinter import *
    import winsound
     
    class Gammique(Tk):
        """ Ramification Gammique """
        def __init__(self):
            Tk.__init__(self)
            "Tableau de bord"
            self.title('Entité Gammique :')
    # Fenêtre écran_résultat
            self.can=Canvas(self,bg='white', height=500,width=750)
            self.can.pack(side=RIGHT)
            self.cad=Frame(self,width=200,height=600)
            self.cad.pack(side=LEFT)
            self.can.delete(ALL)
            # Tracé d'encadrement
            # Données de l'encadré : Axes(x,y)=365(x),220(y)
            self.can.create_line(10, 0, 10, 450, fill ='black')
            self.can.create_line(740, 10, 0, 10, fill ='blue')
            self.can.create_line(740, 450, 740, 10, fill ='black')
            self.can.create_line(10, 450, 740, 450, fill ='blue')
            # Bouton gamme_audio
            #winsound.Beep(frequency, duration)
            Button(self.cad,text ='Radio_inactive',width=15,bg='light yellow').pack()
            # Bouton choix chromatique
            Button(self.cad,text ='Chrome_inactif',width=15,bg='light yellow').pack()
            # Bouton tableaux instruments
            Button(self.cad,text ='Tabla_inactif',width=15,bg='light yellow').pack()
            # Bouton accords1357
            Button(self.cad,text ='A1357_inactif',width=15,bg='light yellow').pack()
    # Les notes cursives scalpha : Graduations gérées.
            self.sca1=Scale(self,length =250,orient = HORIZONTAL,label ='C',
                  troughcolor ='black',sliderlength =20,showvalue =1,
                  from_ =0,to =5,tickinterval =1,command=self.scanote1)
            self.sca1.pack()
            self.sca2=Scale(self,length =250,orient = HORIZONTAL,label ='D',
                  troughcolor ='green',sliderlength =20,showvalue =1,
                  from_ =-1,to =4,tickinterval =1,command=self.scanote2)
            self.sca2.pack()
            self.sca3=Scale(self,length =250,orient = HORIZONTAL,label ='E',
                  troughcolor ='blue',sliderlength =20,showvalue =1,
                  from_ =-2,to =3,tickinterval =1,command=self.scanote3)
            self.sca3.pack()
            self.sca4=Scale(self,length =250,orient = HORIZONTAL,label ='F',
                  troughcolor ='grey',sliderlength =20,showvalue =1,
                  from_ =-2,to =3,tickinterval =1,command=self.scanote4)
            self.sca4.pack()
            self.sca5=Scale(self,length =250,orient = HORIZONTAL,label ='G',
                  troughcolor ='red',sliderlength =20,showvalue =1,
                  from_ =-3,to =2,tickinterval =1,command=self.scanote5)
            self.sca5.pack()
            self.sca6=Scale(self,length =250,orient = HORIZONTAL,label ='A',
                  troughcolor ='orange',sliderlength =20,showvalue =1,
                  from_ =-4,to =1,tickinterval =1,command=self.scanote6)
            self.sca6.pack()
            self.sca7=Scale(self,length =250,orient = HORIZONTAL,label ='B',
                  troughcolor ='yellow',sliderlength =20,showvalue =1,
                  from_ =-5,to =0,tickinterval =1,command=self.scanote7)
            self.sca7.pack()
    # Concerne les notes scahuit : Graduations gérées.
            self.sca8=Scale(self,length =250,orient = HORIZONTAL,label ='CDEFGAB',
                  troughcolor ='ivory',sliderlength =20,showvalue =1,
                  from_ =-5,to =5,tickinterval =1,command=self.scanote8)
            self.sca8.pack()
            # Bouton gamme_naturelle
            Button(self,text ='Zéro',width=25,command=self.zero).pack()
            # Bouton gamme_calculée
            self.btgama=Button(self,width=0,command=self.gama)
            self.btgama.pack()
    # Définition des curseurs
        def scanote1(self,xc):
            do=int(xc)
            # Initialise sca8(from_)
            fromdo=do-(do*2)
            self.sca8.configure(from_ = fromdo)
            xsi=self.sca7.get()
            xre=self.sca2.get()
            if do<xsi:self.sca7.set(do)
            if do>xre+1 :self.sca2.set(do-1)
            self.btgama.invoke()
        def scanote2(self,xd):
            re=int(xd)
            xdo=self.sca1.get()
            xmi=self.sca3.get()
            if re<xdo-1:self.sca1.set(re+1)
            if re>xmi+1 :self.sca3.set(re-1)
            self.btgama.invoke()
        def scanote3(self,xe):
            mi=int(xe)
            xre=self.sca2.get()
            xfa=self.sca4.get()
            if mi<xre-1:self.sca2.set(mi+1)
            if mi>xfa:self.sca4.set(mi)
            self.btgama.invoke()
        def scanote4(self,xf):
            fa=int(xf)
            xmi=self.sca3.get()
            xsol=self.sca5.get()
            if fa<xmi:self.sca3.set(fa)
            if fa>xsol+1:self.sca5.set(fa-1)
            self.btgama.invoke()
        def scanote5(self,xg):
            sol=int(xg)
            xfa=self.sca4.get()
            xla=self.sca6.get()
            if sol<xfa-1:self.sca4.set(sol+1)
            if sol>xla+1:self.sca6.set(sol-1)
            self.btgama.invoke()
        def scanote6(self,xa):
            la=int(xa)
            xsol=self.sca5.get()
            xsi=self.sca7.get()
            if la<xsol-1:self.sca5.set(la+1)
            if la>xsi+1:self.sca7.set(la-1)
            self.btgama.invoke()
        def scanote7(self,xb):
            si=int(xb)
            # Initialise sca8(to)
            tosi=si-(si*2)
            self.sca8.configure(to = tosi)
            xla=self.sca6.get()
            xdo=self.sca1.get()
            if si<xla-1:self.sca6.set(si+1)
            if si>xdo:self.sca1.set(si)
            self.btgama.invoke()
        def scanote8(self,xh):
            sch=int(xh)
            xdo=self.sca1.get()
            xre=self.sca2.get()
            xmi=self.sca3.get()
            xfa=self.sca4.get()
            xsol=self.sca5.get()
            xla=self.sca6.get()
            xsi=self.sca7.get()
            self.sca1.set(xdo+sch)
            self.sca2.set(xre+sch)
            self.sca3.set(xmi+sch)
            self.sca4.set(xfa+sch)
            self.sca5.set(xsol+sch)
            self.sca6.set(xla+sch)
            self.sca7.set(xsi+sch)
            self.btgama.invoke()
        def zero(self):
            self.can.delete(ALL)
            # Tracé d'encadrement
            # Données de l'encadré : Axes(x,y)=365(x),220(y)
            self.can.create_line(10, 0, 10, 450, fill ='black')
            self.can.create_line(740, 10, 0, 10, fill ='blue')
            self.can.create_line(740, 450, 740, 10, fill ='black')
            self.can.create_line(10, 450, 740, 450, fill ='blue')
            self.can.create_line(360, 450, 360, 10, fill ='olive')
            self.can.create_line(10, 220, 740, 220, fill ='olive')
            self.sca1.set(0)
            self.can.create_oval(300-5,220-5,300+5,220+5,fill='black')
            self.sca2.set(0)
            self.can.create_oval(320-5,220-5,320+5,220+5,fill='green')
            self.sca3.set(0)
            self.can.create_oval(340-5,220-5,340+5,220+5,fill='blue')
            self.sca4.set(0)
            self.can.create_oval(350-5,220-5,350+5,220+5,fill='grey')
            self.sca5.set(0)
            self.can.create_oval(370-5,220-5,370+5,220+5,fill='red')
            self.sca6.set(0)
            self.can.create_oval(390-5,220-5,390+5,220+5,fill='orange')
            self.sca7.set(0)
            self.can.create_oval(410-5,220-5,410+5,220+5,fill='yellow')
            self.btgama.invoke()
        def gama(self):
            self.can.delete(ALL)
            # Tracé d'encadrement
            # Données de l'encadré : Axes(x,y)=365(x),220(y)
            self.can.create_line(10, 0, 10, 450, fill ='black')
            self.can.create_line(740, 10, 0, 10, fill ='blue')
            self.can.create_line(740, 450, 740, 10, fill ='black')
            self.can.create_line(10, 450, 740, 450, fill ='blue')
            self.can.create_line(360, 450, 360, 110, fill ='olive')
            self.can.create_line(220, 220, 740, 220, fill ='olive')
    # De la table gammique aux tables diatoniques surnommées
            gammes =[[1,1,0,1,1,1,0],[0,2,0,1,1,1,0],[2,0,0,1,1,1,0],[4,0,0,0,0,1,0],[1,0,1,1,1,1,0],[0,1,1,1,1,1,0],
                     [1,0,3,0,0,1,0],[1,2,1,0,0,1,0],[2,2,0,0,0,1,0],[0,0,1,2,1,1,0],[1,3,0,0,0,1,0],[0,0,2,1,1,1,0],
                     [1,2,2,0,0,0,0],[0,0,4,0,0,1,0],[1,4,0,0,0,0,0],[1,0,0,2,1,1,0],[0,1,0,2,1,1,0],[1,1,3,0,0,0,0],
                     [0,0,0,3,1,1,0],[1,1,0,0,2,1,0],[0,2,0,0,2,1,0],[0,2,0,2,0,1,0],[2,0,0,0,2,1,0],[1,0,1,0,2,1,0],
                     [1,0,1,2,0,1,0],[1,1,1,2,0,0,0],[2,0,0,3,0,0,0],[0,0,2,0,2,1,0],[1,2,0,2,0,0,0],[1,0,0,3,0,1,0],
                     [1,0,0,1,2,1,0],[1,1,0,3,0,0,0],[1,1,2,1,0,0,0],[0,1,0,0,3,1,0],[0,0,1,0,3,1,0],[0,0,0,1,3,1,0],
                     [0,0,0,2,2,1,0],[1,0,0,0,3,1,0],[0,0,2,2,0,1,0],[0,0,0,0,4,1,0],[0,0,2,3,0,0,0],[1,0,0,4,0,0,0],
                     [0,0,0,5,0,0,0],[1,1,0,1,0,2,0],[1,1,0,1,2,0,0],[0,2,0,1,0,2,0],[0,2,0,1,2,0,0],[2,0,0,1,0,2,0],
                     [2,0,0,1,2,0,0],[1,0,1,1,0,2,0],[1,0,1,1,2,0,0],[1,1,0,0,1,2,0],[1,1,0,0,3,0,0],[1,1,0,2,1,0,0],
                     [1,1,2,0,1,0,0],[0,2,0,0,0,3,0],[1,0,0,2,2,0,0],[1,0,0,1,0,3,0],[1,3,0,0,1,0,0],[1,0,0,0,1,3,0],
                     [0,0,0,3,0,2,0],[0,0,2,1,2,0,0],[1,0,0,0,0,4,0],[0,0,0,3,2,0,0],[1,1,0,0,0,3,0],[3,0,0,0,0,2,0]]
            gamnoms =['0','-2','+2','^2','-3','-23','-34x','+34','+23x','-34','x3','°3','+34x','°34x','^3',
                      '-4','-24','^4','°4','-5','-25','-25+','+25-','-35','-35+','+45x','+25x','°35-','+35x',
                      '-45+','-45','x5','x45+','-25°','-35°','-45°','°45-','°5','°35+','*5','°35x','-45x',
                      '°45x','-6','+6','-26','-26+','+26-','+26','-36','-36+','-56','-56+','+56','x46+',
                      '-26°','-46+','-46°','x36+','-56°','°46-','°36+','*6','°46+','°6','x26-']
    # Récupération des notes cursives
            ydo=self.sca1.get()
            xcpos_=300
            ycpos_=220
            xc_=xcpos_+(ydo*10)
            yc_=ycpos_-(ydo*10)
            rc_=5
            self.can.create_oval(xc_-rc_,yc_-rc_,xc_+rc_,yc_+rc_,fill='black')
            yre=self.sca2.get()
            xcpos_=320
            ycpos_=220
            xd_=xcpos_+(yre*10)
            yd_=ycpos_-(yre*10)
            rd_=5
            self.can.create_oval(xd_-rd_,yd_-rd_,xd_+rd_,yd_+rd_,fill='green')
            ymi=self.sca3.get()
            xcpos_=340
            ycpos_=220
            xe_=xcpos_+(ymi*10)
            ye_=ycpos_-(ymi*10)
            re_=5
            self.can.create_oval(xe_-re_,ye_-re_,xe_+re_,ye_+re_,fill='blue')
            yfa=self.sca4.get()
            xcpos_=350
            ycpos_=220
            xf_=xcpos_+(yfa*10)
            yf_=ycpos_-(yfa*10)
            rf_=5
            self.can.create_oval(xf_-rf_,yf_-rf_,xf_+rf_,yf_+rf_,fill='grey')
            ysol=self.sca5.get()
            xcpos_=370
            ycpos_=220
            xg_=xcpos_+(ysol*10)
            yg_=ycpos_-(ysol*10)
            rg_=5
            self.can.create_oval(xg_-rg_,yg_-rg_,xg_+rg_,yg_+rg_,fill='red')
            yla=self.sca6.get()
            xcpos_=390
            ycpos_=220
            xa_=xcpos_+(yla*10)
            ya_=ycpos_-(yla*10)
            ra_=5
            self.can.create_oval(xa_-ra_,ya_-ra_,xa_+ra_,ya_+ra_,fill='orange')
            ysi=self.sca7.get()
            xcpos_=410
            ycpos_=220
            xb_=xcpos_+(ysi*10)
            yb_=ycpos_-(ysi*10)
            rb_=5
            self.can.create_oval(xb_-rb_,yb_-rb_,xb_+rb_,yb_+rb_,fill='yellow')
    # Mesure de l'intervalle tempéré
            c1=(yre+1)-ydo
            d2=(ymi+1)-yre
            e3=yfa-ymi
            f4=(ysol+1)-yfa
            g5=(yla+1)-ysol
            a6=(ysi+1)-yla
            b7=i=cum_diat=ok=x=0
            diata=[c1,d2,e3,f4,g5,a6,b7]
            while i < 6:
                cum_diat += diata[i]
                i+=1        
            diata[i]=5-cum_diat
    # Recherche diatonique par l'itération
            cc1=dd2=ee3=ff4=gg5=aa6=bb7=0
            diata2=[cc1,dd2,ee3,ff4,gg5,aa6,bb7]
            while x < 7:
                m=x
                y=0
                while y < 7:
                    diata2[y]=diata[m]
                    y+=1
                    m+=1
                    if m > 6:
                        m=0            
                myx=myx2=0
                for my in gammes:
                    if diata2 == my:
                        degre=x
                        myx2=myx
                        x=7
                    myx+=1
                x+=1
    # Ici : diata(original cursif).degre(tonique).my(gamme)
    # Définition diatonique
            # GMAJ= gammes[0]
            gmaj = [1,1,0,1,1,1,0]      # Forme majeure simplifiée
            # GNAT= Ordre cursif comme diata[]
            gnat = ['C','D','E','F','G','A','B']        # Forme alphabétique
            cnat = ['','','','','','','']
            # Niveaux d'altérations
            nordiese = ['','+','x','^','+^','x^','^^','+^^','x^^','^^^','+^^^','x^^^','^^^^']
            subemol = ['','****','°***','-***','***','°**','-**','**','°*','-*','*','°','-']
            # Configuration modale
            gdeg = ['I','II','III','IV','V','VI','VII']
            # Définition des notes cursives
            cursifs=[ydo,yre,ymi,yfa,ysol,yla,ysi]
            ynat=ymod=0
            for ycurs in cursifs:
                if ycurs > 0 :
                    ymod=nordiese[ycurs]
                if ycurs < 0 :
                    ymod=subemol[ycurs]
                if ycurs == 0 :
                    ymod=subemol[ycurs]
                cnat[ynat]=ymod
                ynat+=1
    # Une tournée produit une tonalité modale de 7 notes
            nat2=degre
            deg = nom = 0
            ynote = xgdeg = 30
            ytone = 50
            while deg < 7 :
                nat = deg               # Degré tonal en question
                cri = gimj = gmod = maj = 0
                xdeg = 60
                text0 = gdeg[deg]
                self.can.create_text(xgdeg,ynote+10,text=text0,
                                     font='bold',fill='black')
                while maj < 7 :         # Tonalité modale du degré
                    gmj = gmaj[maj]     # Forme majeure (1101110)
                    imaj = diata2[nat]  # Forme modale (DIATA[DEGRE])
                    ynt = cnat[nat2]    # Forme altérative des notes
                    gnt = gnat[nat2]    # Forme tonale (CDEFGAB)
                    ideg = gdeg[deg]
                    cri = cri + gimj    # Tonalité cumulée
                    gimj = imaj - gmj   # Calcul tonal PAS/PAS
                    cmod = gmod = cri
                    if gmod > 0 :       # Forme altérative des tonalités
                        imod = nordiese[cmod]
                    if gmod < 0 :
                        imod = subemol[cmod]
                    if gmod == 0 :
                        imod = subemol[cmod]
                    gmod = gmod + cri   # Transition tonale
                    # Construction du nom de la gamme
                    if nom == 0 :
                        ynom = ynt
                        gnom = gnt
                        tnom=ynom,gnom,gamnoms[myx2]
                        self.can.create_text(xdeg+250,ynote,text=tnom,
                                             font='bold',fill='black')
                    nat+=1
                    nat2+=1
                    if nat > 6 :
                        nat = 0
                    if nat2 > 6 :
                        nat2 = 0
                    maj = maj + 1
                    text1=[ynt,gnt]
                    text2=[imod,maj]
                    self.can.create_text(xdeg,ynote,text=text1)
                    self.can.create_text(xdeg,ytone,text=text2,fill='blue')
                    xdeg+=30
                    nom=1
                    #
                ynote+=60
                ytone+=60
                nat2+=1
                if nat2 > 6 :
                        nat2 = 0
                deg = deg + 1
                #
    Gammique().mainloop()

  2. #2
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 631
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 631
    Points : 30 865
    Points
    30 865
    Billets dans le blog
    1
    Par défaut
    Bonjour

    La couleur "olive" n'existe pas chez-moi (mais je suis sous Python 2 alors peut-être que ça joue). J'ai remplacé par "green"'. De plus, pourquoi tu fais 8 scales individuels ??? Les tableaux c'est aussi un truc utile parfois...

    Mais sinon je ne vois pas trop ce que tu veux démontrer dans les gammes...
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  3. #3
    Membre chevronné
    Homme Profil pro
    Enseignant
    Inscrit en
    Juin 2013
    Messages
    1 604
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Enseignant
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2013
    Messages : 1 604
    Points : 2 070
    Points
    2 070
    Par défaut
    le module winsound n'existe pas sous linux...
    Pas d'aide par mp.

  4. #4
    Invité
    Invité(e)
    Par défaut
    21/06/2015, 19h16
    marco056

    le module winsound n'existe pas sous linux...
    Peut-être qu'il y a un module pythonesque voire compatible.
    Pour vous faire entendre vous savez quoi
    @urémail

  5. #5
    Invité
    Invité(e)
    Par défaut
    21/06/2015, 18h58
    Sve@r

    Bonjour

    La couleur "olive" n'existe pas chez-moi (mais je suis sous Python 2 alors peut-être que ça joue). J'ai remplacé par "green"'. De plus, pourquoi tu fais 8 scales individuels ??? Les tableaux c'est aussi un truc utile parfois...

    Mais sinon je ne vois pas trop ce que tu veux démontrer dans les gammes...
    Bon, j'ai moi aussi une question : Expliques comment tu calcules les gammes avec les trucs utiles que sont les tableaux ?
    Bon, j'ai moi aussi une question : La gamme est visible pour ceux qui veulent la voir, sinon une démonstration de code quantum de la gamme

    PS : Si vous n'arrivez pas à dessiner le ciel, pourquoi brûlez vous cette feuille ?

  6. #6
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 631
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 631
    Points : 30 865
    Points
    30 865
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par toumus Voir le message
    Bon, j'ai moi aussi une question : Expliques comment tu calcules les gammes avec les trucs utiles que sont les tableaux ?
    Exactement de la même façon que tu la calcules avec tes sca1, sca2, sca3 => tu écris à la place sca[1], sca[2], sca[3] (bon en réalité faut décaler car sca1 deviendra sca[0] mais c'était pour l'analogie).
    Ca ne rend pas les choses plus compliquées quand elles ne sont pas simplifiables (faudra bien créer les 8 sca[X] de façon individuelle comme tu le fais déjà) mais ça aide quand tu utilises des instructions répétitives (tous tes scaX.pack() pourront être regroupés dans une boucle).
    Et tu peux même utiliser des dictionnaire ce qui te permet de les nommer sca["C"]=..., sca["D"]=..., sca["E"]=... en gardant quand-même la possibilité de les itérer quand tu en as besoin.

    Un exemple tout simple pour remplacer tes 8 créations de sca
    Code python : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    # Les notes cursives scalpha : Graduations gérées.
    self.sca=[
    	Scale(
    		self,
    		length=250,
    		orient=HORIZONTAL,
    		label=label,
    		troughcolor=color,
    		sliderlength=20,
    		showvalue=1,
    		from_=f,
    		to=t,
    		tickinterval=1,
    		command=command,
    	) for (label, color, f, t, command) in (
    		("C", "black", 0, 5, self.scanote1),
    		("D", "green", -1, 4, self.scanote2),
    		("E", "blue", -2, 3, self.scanote3),
    		("F", "grey", -2, 3, self.scanote4),
    		("G", "red", -3, 2, self.scanote5),
    		("A", "orange", -4, 1, self.scanote6),
    		("B", "yellow", -5, 0, self.scanote7),
    		("CDEFGAB", "ivory", -5, 5, self.scanote8),
    	)
    ]
    for x in self.sca: x.pack()

    Je me suis juste contenté de reprérer ce qui était immuable et de mettre ce qui était variable dans un itérateur. Simplifiant non ???

    Mais là encore je ne vois pas ce que tu entends par "calculer". Est-ce que tu veux parler des décalage de tétracordes qui donnent dans un sens la suite Do, Sol, Re, La, Mi, Si, #Fa, #Do et dans l'autre la suite Do, Fa, bSi, bMi, bLa, bRe, bSol, bDo ? C'est ce que j'ai essayé de voir quand j'ai lancé le prog...

    Citation Envoyé par toumus Voir le message
    Bon, j'ai moi aussi une question : La gamme est visible pour ceux qui veulent la voir, sinon une démonstration de code quantum de la gamme
    Ca ce n'est pas une question. Il n'y a ni point d'interrogation ni forme interrogative du sujet-verbe. Et quand à la réponse que tu attends...

    Citation Envoyé par toumus Voir le message
    PS : Si vous n'arrivez pas à dessiner le ciel, pourquoi brûlez vous cette feuille ?
    J'ai rien brûlé, je demandais juste qu'est-ce que j'avais dessiné...
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  7. #7
    Invité
    Invité(e)
    Par défaut
    il y a des réponses...
    (faudra bien créer les 8 sca[X] de façon individuelle comme tu le fais déjà)
    Je rappelle que la gamme naturelle a 7 notes, aussi le huitième curseur déplace toutes les notes cursives (CDEFGAB)
    (tous tes scaX.pack() pourront être regroupés dans une boucle)
    Si çà marche oui, il faut savoir que le fait de mouvoir une note cursive peut avoir à déplacer d'autres notes voisines...
    Un exemple tout simple pour remplacer tes 8 créations de sca
    C'est à tester, vas-y !
    Mais là encore je ne vois pas ce que tu entends par "calculer". Est-ce que tu veux parler des décalage de tétracordes qui donnent dans un sens la suite Do, Sol, Re, La, Mi, Si, #Fa, #Do et dans l'autre la suite Do, Fa, bSi, bMi, bLa, bRe, bSol, bDo ? C'est ce que j'ai essayé de voir quand j'ai lancé le prog...
    Les tétracordes sont occultés dans l'algorithme
    Voici un calcul diatonique de la gamme naturelle, façon pythonx3 sans les curseurs (sans les mains non plus)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    #!/usr/bin/env python3 
    # -*- coding: utf-8 -*-
    # Développement diatonique élémentaire
    # Version 1 : Calculer les modulations majeures
    # pr0diat zéro
     
    gnat = ['C','D','E','F','G','A','B']    # Notes diatoniques
    gmaj = [1,1,0,1,1,1,0]                  # Formule majeure
    gdeg = [0,1,2,3,4,5,6]                  # Degrés modal
    nordiese = [' ','+','x','^','+^','x^']      # Altérations augmentées
    subemol = [' ','°*','-*','*','°','-']       # Altérations diminuées
    deg = 0
    while deg < 7 :             # Lecture diatonique tonale de "gdeg"
        # Une tournée produit une tonalité modale de 7 notes
        nat = gdeg[deg]         # Degré tonal en question
        cri = gimj = gmod = maj = 0
        #
        while maj < 7 :   # Tonalité modale du degré
            #
            gmj = gmaj[maj]     # Forme majeure
            imaj = gmaj[nat]    # Forme modale
            gnt = gnat[nat]     # Forme tonale
            #print ("gmj,imaj,gnt ",gmj,imaj,gnt)
            cri = cri + gimj    # Tonalité cumulée
            gimj = imaj - gmj   # Calcul tonal PAS/PAS
            #print ("gimj,cri,gnt ",gimj,cri,gnt)
            cmod = gmod = cri
            #print ("gmod ",gmod,gnt)
            if gmod > 0 :
                imod = nordiese[cmod]
                #print ("imod+cmod",imod,cmod,gnt)
            if gmod < 0 :
                imod = subemol[cmod]
                #print ("imod-cmod",imod,cmod,gnt)
            if gmod == 0 :
                imod = subemol[cmod]
                #print ("imod,cmod ",imod,cmod,gnt)
            gmod = gmod + cri   # Transition tonale
            nat = nat + 1
            if nat > 6 : nat = 0
            maj = maj + 1 
            print ("imod,maj,gnt ",imod,maj,gnt)
            #
        print ("___",deg)
        deg = deg + 1
        #

  8. #8
    Invité
    Invité(e)
    Par défaut
    Il vous faut savoir, que les opérations réunies dan l'application progamV1alpha (auto ou pas). Ne se sont pas créées en même temps, car le sens donné aux curseurs reprend l'exercice altéractif relatif à la poussée altérative de la note. La position de notes sur les curseurs correspond à l'état des intervalles, si 2 notes sont superposées c'est qu'il y a 1/2 ton d'intervalle entre elles. Une fois les notes situées sur les curseurs, il faut exercer cette force altéractive. Autrement, on sort du domaine classique de la gamme naturelle.
    Il y a plusieurs opérations nécessaires à la représentation des gammes façon "public", même si la gamme est retrouvée parmi les tables. Il en reste pas moins vrai de présenter une formule adaptée, ici on a la note tonique de la gamme précédée de son signe altératif accompagnée de sa nomination mnémonique.
    Exemple de gamme : -E x2 | "-"=bémol(b) |"E"=Mi |"x"=deux dièses(##) |"2"=seconde diatonique de Mi(Fa)

    La gamme de Mi bémol ayant sa seconde augmentée deux fois, en passant par la gamme de Mi bémol majeure
    a)_ la gamme majeure de Mi bémol : -E_F_G-A_-B_C_D. Elle configure l'état des intervalles, comme 1 2 3 4 5 6 7
    b)_ la gamme #2 de Mi bémol : -E__+FG-A_-B_C_D. L'altération portée sur la note Fa, et son côté avoisinant. Comme 1 +2 3 4 5 6 7
    c)_ la gamme x2 de Mi bémol : -E___xF+GA_-B_C_D. La force altéractive en action Comme 1 x2 +3 +4 5 6 7
    d,e)_ fin épique

    Une pause s'impose
    Mais avant de quitter
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
     
    #!/usr/bin/env python3 
    # -*- coding: utf-8 -*-
    # *
    # Application gammique évolutive
    # Version 1 : Calculer les gammes
    # Ouverture niveau DOMAINE PUBLIC
    # L'intérêt culturel des gammes
    ###############################
    # NOM progam_V1alphauto
    # DATE 21 juin 2015 11:11:11
    # ###                    ###
    from tkinter import *
    import winsound
     
    class Gammique(Tk):
        """ Ramification Gammique """
        def __init__(self):
            Tk.__init__(self)
            "Tableau de bord"
            self.title('Entité Gammique :')
    # Fenêtre écran_résultat
            self.can=Canvas(self,bg='white', height=500,width=750)
            self.can.pack(side=RIGHT)
            self.cad=Frame(self,width=200,height=600)
            self.cad.pack(side=LEFT)
            self.can.delete(ALL)
            # Tracé d'encadrement
            # Données de l'encadré : Axes(x,y)=365(x),220(y)
            self.can.create_line(10, 0, 10, 450, fill ='black')
            self.can.create_line(740, 10, 0, 10, fill ='blue')
            self.can.create_line(740, 450, 740, 10, fill ='black')
            self.can.create_line(10, 450, 740, 450, fill ='blue')
            # Bouton gamme_audio
            #winsound.Beep(frequency, duration)
            Button(self.cad,text ='Radio_inactive',width=15,bg='light yellow').pack()
            # Bouton choix chromatique
            Button(self.cad,text ='Chrome_inactif',width=15,bg='light yellow').pack()
            # Bouton tableaux instruments
            Button(self.cad,text ='Tabla_inactif',width=15,bg='light yellow').pack()
            # Bouton accords1357
            Button(self.cad,text ='A1357_inactif',width=15,bg='light yellow').pack()
    # Les notes cursives scalpha : Graduations gérées.
            self.sca1=Scale(self,length =250,orient = HORIZONTAL,label ='C',
                  troughcolor ='black',sliderlength =20,showvalue =1,
                  from_ =0,to =5,tickinterval =1,command=self.scanote1)
            self.sca1.pack()
            self.sca2=Scale(self,length =250,orient = HORIZONTAL,label ='D',
                  troughcolor ='green',sliderlength =20,showvalue =1,
                  from_ =-1,to =4,tickinterval =1,command=self.scanote2)
            self.sca2.pack()
            self.sca3=Scale(self,length =250,orient = HORIZONTAL,label ='E',
                  troughcolor ='blue',sliderlength =20,showvalue =1,
                  from_ =-2,to =3,tickinterval =1,command=self.scanote3)
            self.sca3.pack()
            self.sca4=Scale(self,length =250,orient = HORIZONTAL,label ='F',
                  troughcolor ='grey',sliderlength =20,showvalue =1,
                  from_ =-2,to =3,tickinterval =1,command=self.scanote4)
            self.sca4.pack()
            self.sca5=Scale(self,length =250,orient = HORIZONTAL,label ='G',
                  troughcolor ='red',sliderlength =20,showvalue =1,
                  from_ =-3,to =2,tickinterval =1,command=self.scanote5)
            self.sca5.pack()
            self.sca6=Scale(self,length =250,orient = HORIZONTAL,label ='A',
                  troughcolor ='orange',sliderlength =20,showvalue =1,
                  from_ =-4,to =1,tickinterval =1,command=self.scanote6)
            self.sca6.pack()
            self.sca7=Scale(self,length =250,orient = HORIZONTAL,label ='B',
                  troughcolor ='yellow',sliderlength =20,showvalue =1,
                  from_ =-5,to =0,tickinterval =1,command=self.scanote7)
            self.sca7.pack()
    # Concerne les notes scahuit : Graduations gérées.
            self.sca8=Scale(self,length =250,orient = HORIZONTAL,label ='CDEFGAB',
                  troughcolor ='ivory',sliderlength =20,showvalue =1,
                  from_ =-5,to =5,tickinterval =1,command=self.scanote8)
            self.sca8.pack()
            # Bouton gamme_naturelle
            Button(self,text ='Zéro',width=25,command=self.zero).pack()
            # Bouton gamme_calculée
            self.btgama=Button(self,width=0,command=self.gama)
            self.btgama.pack()
    # Définition des curseurs
        def scanote1(self,xc):
            do=int(xc)
            # Initialise sca8(from_)
            fromdo=do-(do*2)
            self.sca8.configure(from_ = fromdo)
            xsi=self.sca7.get()
            xre=self.sca2.get()
            if do<xsi:self.sca7.set(do)
            if do>xre+1 :self.sca2.set(do-1)
            self.btgama.invoke()
        def scanote2(self,xd):
            re=int(xd)
            xdo=self.sca1.get()
            xmi=self.sca3.get()
            if re<xdo-1:self.sca1.set(re+1)
            if re>xmi+1 :self.sca3.set(re-1)
            self.btgama.invoke()
        def scanote3(self,xe):
            mi=int(xe)
            xre=self.sca2.get()
            xfa=self.sca4.get()
            if mi<xre-1:self.sca2.set(mi+1)
            if mi>xfa:self.sca4.set(mi)
            self.btgama.invoke()
        def scanote4(self,xf):
            fa=int(xf)
            xmi=self.sca3.get()
            xsol=self.sca5.get()
            if fa<xmi:self.sca3.set(fa)
            if fa>xsol+1:self.sca5.set(fa-1)
            self.btgama.invoke()
        def scanote5(self,xg):
            sol=int(xg)
            xfa=self.sca4.get()
            xla=self.sca6.get()
            if sol<xfa-1:self.sca4.set(sol+1)
            if sol>xla+1:self.sca6.set(sol-1)
            self.btgama.invoke()
        def scanote6(self,xa):
            la=int(xa)
            xsol=self.sca5.get()
            xsi=self.sca7.get()
            if la<xsol-1:self.sca5.set(la+1)
            if la>xsi+1:self.sca7.set(la-1)
            self.btgama.invoke()
        def scanote7(self,xb):
            si=int(xb)
            # Initialise sca8(to)
            tosi=si-(si*2)
            self.sca8.configure(to = tosi)
            xla=self.sca6.get()
            xdo=self.sca1.get()
            if si<xla-1:self.sca6.set(si+1)
            if si>xdo:self.sca1.set(si)
            self.btgama.invoke()
        def scanote8(self,xh):
            sch=int(xh)
            xdo=self.sca1.get()
            xre=self.sca2.get()
            xmi=self.sca3.get()
            xfa=self.sca4.get()
            xsol=self.sca5.get()
            xla=self.sca6.get()
            xsi=self.sca7.get()
            self.sca1.set(xdo+sch)
            self.sca2.set(xre+sch)
            self.sca3.set(xmi+sch)
            self.sca4.set(xfa+sch)
            self.sca5.set(xsol+sch)
            self.sca6.set(xla+sch)
            self.sca7.set(xsi+sch)
            self.btgama.invoke()
        def zero(self):
            self.can.delete(ALL)
            # Tracé d'encadrement
            # Données de l'encadré : Axes(x,y)=365(x),220(y)
            self.can.create_line(10, 0, 10, 450, fill ='black')
            self.can.create_line(740, 10, 0, 10, fill ='blue')
            self.can.create_line(740, 450, 740, 10, fill ='black')
            self.can.create_line(10, 450, 740, 450, fill ='blue')
            self.can.create_line(360, 450, 360, 10, fill ='olive')
            self.can.create_line(10, 220, 740, 220, fill ='olive')
            self.sca1.set(0)
            self.can.create_oval(300-5,220-5,300+5,220+5,fill='black')
            self.sca2.set(0)
            self.can.create_oval(320-5,220-5,320+5,220+5,fill='green')
            self.sca3.set(0)
            self.can.create_oval(340-5,220-5,340+5,220+5,fill='blue')
            self.sca4.set(0)
            self.can.create_oval(350-5,220-5,350+5,220+5,fill='grey')
            self.sca5.set(0)
            self.can.create_oval(370-5,220-5,370+5,220+5,fill='red')
            self.sca6.set(0)
            self.can.create_oval(390-5,220-5,390+5,220+5,fill='orange')
            self.sca7.set(0)
            self.can.create_oval(410-5,220-5,410+5,220+5,fill='yellow')
            self.btgama.invoke()
        def gama(self):
            self.can.delete(ALL)
            # Tracé d'encadrement
            # Données de l'encadré : Axes(x,y)=365(x),220(y)
            self.can.create_line(10, 0, 10, 450, fill ='black')
            self.can.create_line(740, 10, 0, 10, fill ='blue')
            self.can.create_line(740, 450, 740, 10, fill ='black')
            self.can.create_line(10, 450, 740, 450, fill ='blue')
            self.can.create_line(360, 450, 360, 110, fill ='olive')
            self.can.create_line(220, 220, 740, 220, fill ='olive')
    # De la table gammique aux tables diatoniques surnommées
            gammes =[[1,1,0,1,1,1,0],[0,2,0,1,1,1,0],[2,0,0,1,1,1,0],[4,0,0,0,0,1,0],[1,0,1,1,1,1,0],[0,1,1,1,1,1,0],
                     [1,0,3,0,0,1,0],[1,2,1,0,0,1,0],[2,2,0,0,0,1,0],[0,0,1,2,1,1,0],[1,3,0,0,0,1,0],[0,0,2,1,1,1,0],
                     [1,2,2,0,0,0,0],[0,0,4,0,0,1,0],[1,4,0,0,0,0,0],[1,0,0,2,1,1,0],[0,1,0,2,1,1,0],[1,1,3,0,0,0,0],
                     [0,0,0,3,1,1,0],[1,1,0,0,2,1,0],[0,2,0,0,2,1,0],[0,2,0,2,0,1,0],[2,0,0,0,2,1,0],[1,0,1,0,2,1,0],
                     [1,0,1,2,0,1,0],[1,1,1,2,0,0,0],[2,0,0,3,0,0,0],[0,0,2,0,2,1,0],[1,2,0,2,0,0,0],[1,0,0,3,0,1,0],
                     [1,0,0,1,2,1,0],[1,1,0,3,0,0,0],[1,1,2,1,0,0,0],[0,1,0,0,3,1,0],[0,0,1,0,3,1,0],[0,0,0,1,3,1,0],
                     [0,0,0,2,2,1,0],[1,0,0,0,3,1,0],[0,0,2,2,0,1,0],[0,0,0,0,4,1,0],[0,0,2,3,0,0,0],[1,0,0,4,0,0,0],
                     [0,0,0,5,0,0,0],[1,1,0,1,0,2,0],[1,1,0,1,2,0,0],[0,2,0,1,0,2,0],[0,2,0,1,2,0,0],[2,0,0,1,0,2,0],
                     [2,0,0,1,2,0,0],[1,0,1,1,0,2,0],[1,0,1,1,2,0,0],[1,1,0,0,1,2,0],[1,1,0,0,3,0,0],[1,1,0,2,1,0,0],
                     [1,1,2,0,1,0,0],[0,2,0,0,0,3,0],[1,0,0,2,2,0,0],[1,0,0,1,0,3,0],[1,3,0,0,1,0,0],[1,0,0,0,1,3,0],
                     [0,0,0,3,0,2,0],[0,0,2,1,2,0,0],[1,0,0,0,0,4,0],[0,0,0,3,2,0,0],[1,1,0,0,0,3,0],[3,0,0,0,0,2,0]]
            gamnoms =['0','-2','+2','^2','-3','-23','-34x','+34','+23x','-34','x3','°3','+34x','°34x','^3',
                      '-4','-24','^4','°4','-5','-25','-25+','+25-','-35','-35+','+45x','+25x','°35-','+35x',
                      '-45+','-45','x5','x45+','-25°','-35°','-45°','°45-','°5','°35+','*5','°35x','-45x',
                      '°45x','-6','+6','-26','-26+','+26-','+26','-36','-36+','-56','-56+','+56','x46+',
                      '-26°','-46+','-46°','x36+','-56°','°46-','°36+','*6','°46+','°6','x26-']
    # Récupération des notes cursives
            ydo=self.sca1.get()
            xcpos_=300
            ycpos_=220
            xc_=xcpos_+(ydo*10)
            yc_=ycpos_-(ydo*10)
            rc_=5
            self.can.create_oval(xc_-rc_,yc_-rc_,xc_+rc_,yc_+rc_,fill='black')
            yre=self.sca2.get()
            xcpos_=320
            ycpos_=220
            xd_=xcpos_+(yre*10)
            yd_=ycpos_-(yre*10)
            rd_=5
            self.can.create_oval(xd_-rd_,yd_-rd_,xd_+rd_,yd_+rd_,fill='green')
            ymi=self.sca3.get()
            xcpos_=340
            ycpos_=220
            xe_=xcpos_+(ymi*10)
            ye_=ycpos_-(ymi*10)
            re_=5
            self.can.create_oval(xe_-re_,ye_-re_,xe_+re_,ye_+re_,fill='blue')
            yfa=self.sca4.get()
            xcpos_=350
            ycpos_=220
            xf_=xcpos_+(yfa*10)
            yf_=ycpos_-(yfa*10)
            rf_=5
            self.can.create_oval(xf_-rf_,yf_-rf_,xf_+rf_,yf_+rf_,fill='grey')
            ysol=self.sca5.get()
            xcpos_=370
            ycpos_=220
            xg_=xcpos_+(ysol*10)
            yg_=ycpos_-(ysol*10)
            rg_=5
            self.can.create_oval(xg_-rg_,yg_-rg_,xg_+rg_,yg_+rg_,fill='red')
            yla=self.sca6.get()
            xcpos_=390
            ycpos_=220
            xa_=xcpos_+(yla*10)
            ya_=ycpos_-(yla*10)
            ra_=5
            self.can.create_oval(xa_-ra_,ya_-ra_,xa_+ra_,ya_+ra_,fill='orange')
            ysi=self.sca7.get()
            xcpos_=410
            ycpos_=220
            xb_=xcpos_+(ysi*10)
            yb_=ycpos_-(ysi*10)
            rb_=5
            self.can.create_oval(xb_-rb_,yb_-rb_,xb_+rb_,yb_+rb_,fill='yellow')
    # Mesure de l'intervalle tempéré
            c1=(yre+1)-ydo
            d2=(ymi+1)-yre
            e3=yfa-ymi
            f4=(ysol+1)-yfa
            g5=(yla+1)-ysol
            a6=(ysi+1)-yla
            b7=i=cum_diat=ok=x=0
            diata=[c1,d2,e3,f4,g5,a6,b7]
            while i < 6:
                cum_diat += diata[i]
                i+=1        
            diata[i]=5-cum_diat
    # Recherche diatonique par l'itération
            cc1=dd2=ee3=ff4=gg5=aa6=bb7=0
            diata2=[cc1,dd2,ee3,ff4,gg5,aa6,bb7]
            while x < 7:
                m=x
                y=0
                while y < 7:
                    diata2[y]=diata[m]
                    y+=1
                    m+=1
                    if m > 6:
                        m=0            
                myx=myx2=0
                for my in gammes:
                    if diata2 == my:
                        degre=x
                        myx2=myx
                        x=7
                    myx+=1
                x+=1
    # Ici : diata(original cursif).degre(tonique).my(gamme)
    # Définition diatonique
            # GMAJ= gammes[0]
            gmaj = [1,1,0,1,1,1,0]      # Forme majeure simplifiée
            # GNAT= Ordre cursif comme diata[]
            gnat = ['C','D','E','F','G','A','B']        # Forme alphabétique
            cnat = ['','','','','','','']
            # Niveaux d'altérations
            nordiese = ['','+','x','^','+^','x^','^^','+^^','x^^','^^^','+^^^','x^^^','^^^^']
            subemol = ['','****','°***','-***','***','°**','-**','**','°*','-*','*','°','-']
            # Configuration modale
            gdeg = ['I','II','III','IV','V','VI','VII']
            # Définition des notes cursives
            cursifs=[ydo,yre,ymi,yfa,ysol,yla,ysi]
            ynat=ymod=0
            for ycurs in cursifs:
                if ycurs > 0 :
                    ymod=nordiese[ycurs]
                if ycurs < 0 :
                    ymod=subemol[ycurs]
                if ycurs == 0 :
                    ymod=subemol[ycurs]
                cnat[ynat]=ymod
                ynat+=1
    # Une tournée produit une tonalité modale de 7 notes
            nat2=degre
            deg = nom = 0
            ynote = xgdeg = 30
            ytone = 50
            while deg < 7 :
                nat = deg               # Degré tonal en question
                cri = gimj = gmod = maj = 0
                xdeg = 60
                text0 = gdeg[deg]
                self.can.create_text(xgdeg,ynote+10,text=text0,
                                     font='bold',fill='black')
                while maj < 7 :         # Tonalité modale du degré
                    gmj = gmaj[maj]     # Forme majeure (1101110)
                    imaj = diata2[nat]  # Forme modale (DIATA[DEGRE])
                    ynt = cnat[nat2]    # Forme altérative des notes
                    gnt = gnat[nat2]    # Forme tonale (CDEFGAB)
                    ideg = gdeg[deg]
                    cri = cri + gimj    # Tonalité cumulée
                    gimj = imaj - gmj   # Calcul tonal PAS/PAS
                    cmod = gmod = cri
                    if gmod > 0 :       # Forme altérative des tonalités
                        imod = nordiese[cmod]
                    if gmod < 0 :
                        imod = subemol[cmod]
                    if gmod == 0 :
                        imod = subemol[cmod]
                    gmod = gmod + cri   # Transition tonale
                    # Construction du nom de la gamme
                    if nom == 0 :
                        ynom = ynt
                        gnom = gnt
                        tnom=ynom,gnom,gamnoms[myx2]
                        self.can.create_text(xdeg+250,ynote,text=tnom,
                                             font='bold',fill='black')
                    nat+=1
                    nat2+=1
                    if nat > 6 :
                        nat = 0
                    if nat2 > 6 :
                        nat2 = 0
                    maj = maj + 1
                    text1=[ynt,gnt]
                    text2=[imod,maj]
                    self.can.create_text(xdeg,ynote,text=text1)
                    self.can.create_text(xdeg,ytone,text=text2,fill='blue')
                    xdeg+=30
                    nom=1
                    #
                ynote+=60
                ytone+=60
                nat2+=1
                if nat2 > 6 :
                        nat2 = 0
                deg = deg + 1
                #
    Gammique().mainloop()

  9. #9
    Membre chevronné
    Homme Profil pro
    Enseignant
    Inscrit en
    Juin 2013
    Messages
    1 604
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Enseignant
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2013
    Messages : 1 604
    Points : 2 070
    Points
    2 070
    Par défaut
    Une question (très) idiote :
    à quel endroit sert winsound ?
    Pas d'aide par mp.

  10. #10
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 631
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 631
    Points : 30 865
    Points
    30 865
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par toumus Voir le message
    Je rappelle que la gamme naturelle a 7 notes, aussi le huitième curseur déplace toutes les notes cursives (CDEFGAB)
    Dans ma modif, je ne me préoccupe absolument pas de la signification de chaque scaX. Tout ce que j'ai vu, c'est que les 8 sca étaient créés de façon absolument identique ; d'où factorisation possible du code via un itérateur. Ensuite suffit de remplacer sca1 par sca[0], sca2 par sca[1] et ainsi de suite ; ce qui est très facile avec nos éditeurs classiques. Le résultat ne change rien à ton algo...

    Citation Envoyé par toumus Voir le message
    Si çà marche oui, il faut savoir que le fait de mouvoir une note cursive peut avoir à déplacer d'autres notes voisines...
    Ton algo reste inchangé. Avant tu déplaçais sca1 par rapport à sca2, maintenant tu déplaces sca[0] par rapport à sca[1]...

    Citation Envoyé par toumus Voir le message
    C'est à tester, vas-y !
    C'était déjà fait - Code complet
    Code python : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    #!/usr/bin/env python 
    # -*- coding: utf-8 -*-
    # *
    # Application gammique évolutive
    # Version 1 : Calculer les gammes
    #
    from Tkinter import *
    #import winsound
     
    class Gammique(Tk):
    	""" Ramification Gammique """
    	def __init__(self):
    		Tk.__init__(self)
    		"Tableau de bord"
    		self.title('Entité Gammique :')
     
    		# Fenêtre écran_résultat
    		self.can=Canvas(self,bg='white', height=500,width=750)
    		self.can.pack(side=RIGHT)
    		self.cad=Frame(self,width=200,height=600)
    		self.cad.pack(side=LEFT)
    		self.can.delete(ALL)
     
    		# Tracé d'encadrement
    		# Données de l'encadré : Axes(x,y)=365(x),220(y)
    		self.can.create_line(10, 0, 10, 450, fill ='black')
    		self.can.create_line(740, 10, 0, 10, fill ='blue')
    		self.can.create_line(740, 450, 740, 10, fill ='black')
    		self.can.create_line(10, 450, 740, 450, fill ='blue')
    		# Bouton gamme_audio
    		#winsound.Beep(frequency, duration)
    		Button(self.cad,text ='Radio_inactive',width=15,bg='light yellow').pack()
    		# Bouton choix chromatique
    		Button(self.cad,text ='Chrome_inactif',width=15,bg='light yellow').pack()
    		# Bouton tableaux instruments
    		Button(self.cad,text ='Tabla_inactif',width=15,bg='light yellow').pack()
    		# Bouton accords1357
    		Button(self.cad,text ='A1357_inactif',width=15,bg='light yellow').pack()
     
    		# Les notes cursives scalpha : Graduations gérées.
    		self.sca=[
    			Scale(
    				self,
    				length=250,
    				orient=HORIZONTAL,
    				label=label,
    				troughcolor=color,
    				sliderlength=20,
    				showvalue=1,
    				from_=f,
    				to=t,
    				tickinterval=1,
    				command=command,
    			) for (label, color, f, t, command) in (
    				("C", "black", 0, 5, self.scanote1),
    				("D", "green", -1, 4, self.scanote2),
    				("E", "blue", -2, 3, self.scanote3),
    				("F", "grey", -2, 3, self.scanote4),
    				("G", "red", -3, 2, self.scanote5),
    				("A", "orange", -4, 1, self.scanote6),
    				("B", "yellow", -5, 0, self.scanote7),
    				("CDEFGAB", "ivory", -5, 5, self.scanote8),
    			)
    		]
    		for x in self.sca: x.pack()
     
    		# Bouton gamme_naturelle
    		Button(self,text ='Zéro',width=25,command=self.zero).pack()
    		# Bouton gamme_calculée
    		self.btgama=Button(self,width=0,command=self.gama)
    		self.btgama.pack()
    	# __init__()
     
    	# Définition des curseurs
    	def scanote1(self,xc):
    		do=int(xc)
    		# Initialise sca[7](from_)
    		fromdo=do-(do*2)
    		self.sca[7].configure(from_ = fromdo)
    		xsi=self.sca[6].get()
    		xre=self.sca[1].get()
    		if do<xsi:self.sca[6].set(do)
    		if do>xre+1 :self.sca[1].set(do-1)
    		self.btgama.invoke()
    	# scanote1()
     
    	def scanote2(self,xd):
    		re=int(xd)
    		xdo=self.sca[0].get()
    		xmi=self.sca[2].get()
    		if re<xdo-1:self.sca[0].set(re+1)
    		if re>xmi+1 :self.sca[2].set(re-1)
    		self.btgama.invoke()
    	# scanote2()
     
    	def scanote3(self,xe):
    		mi=int(xe)
    		xre=self.sca[1].get()
    		xfa=self.sca[3].get()
    		if mi<xre-1:self.sca[1].set(mi+1)
    		if mi>xfa:self.sca[3].set(mi)
    		self.btgama.invoke()
    	# scanote3()
     
    	def scanote4(self,xf):
    		fa=int(xf)
    		xmi=self.sca[2].get()
    		xsol=self.sca[4].get()
    		if fa<xmi:self.sca[2].set(fa)
    		if fa>xsol+1:self.sca[4].set(fa-1)
    		self.btgama.invoke()
    	# scanote4()
     
    	def scanote5(self,xg):
    		sol=int(xg)
    		xfa=self.sca[3].get()
    		xla=self.sca[5].get()
    		if sol<xfa-1:self.sca[3].set(sol+1)
    		if sol>xla+1:self.sca[5].set(sol-1)
    		self.btgama.invoke()
    	# scanote5()
     
    	def scanote6(self,xa):
    		la=int(xa)
    		xsol=self.sca[4].get()
    		xsi=self.sca[6].get()
    		if la<xsol-1:self.sca[4].set(la+1)
    		if la>xsi+1:self.sca[6].set(la-1)
    		self.btgama.invoke()
    	# scanote6()
     
    	def scanote7(self,xb):
    		si=int(xb)
    		# Initialise sca[7](to)
    		tosi=si-(si*2)
    		self.sca[7].configure(to = tosi)
    		xla=self.sca[5].get()
    		xdo=self.sca[0].get()
    		if si<xla-1:self.sca[5].set(si+1)
    		if si>xdo:self.sca[0].set(si)
    		self.btgama.invoke()
    	# scanote7()
     
    	def scanote8(self,xh):
    		sch=int(xh)
    		xdo=self.sca[0].get()
    		xre=self.sca[1].get()
    		xmi=self.sca[2].get()
    		xfa=self.sca[3].get()
    		xsol=self.sca[4].get()
    		xla=self.sca[5].get()
    		xsi=self.sca[6].get()
    		self.sca[0].set(xdo+sch)
    		self.sca[1].set(xre+sch)
    		self.sca[2].set(xmi+sch)
    		self.sca[3].set(xfa+sch)
    		self.sca[4].set(xsol+sch)
    		self.sca[5].set(xla+sch)
    		self.sca[6].set(xsi+sch)
    		self.btgama.invoke()
    	# scanote8()
     
    	def zero(self):
    		self.can.delete(ALL)
    		# Tracé d'encadrement
    		# Données de l'encadré : Axes(x,y)=365(x),220(y)
    		self.can.create_line(10, 0, 10, 450, fill ='black')
    		self.can.create_line(740, 10, 0, 10, fill ='blue')
    		self.can.create_line(740, 450, 740, 10, fill ='black')
    		self.can.create_line(10, 450, 740, 450, fill ='blue')
    		self.can.create_line(360, 450, 360, 10, fill ='green')
    		self.can.create_line(10, 220, 740, 220, fill ='green')
    		self.sca[0].set(0)
    		self.can.create_oval(300-5,220-5,300+5,220+5,fill='black')
    		self.sca[1].set(0)
    		self.can.create_oval(320-5,220-5,320+5,220+5,fill='green')
    		self.sca[2].set(0)
    		self.can.create_oval(340-5,220-5,340+5,220+5,fill='blue')
    		self.sca[3].set(0)
    		self.can.create_oval(350-5,220-5,350+5,220+5,fill='grey')
    		self.sca[4].set(0)
    		self.can.create_oval(370-5,220-5,370+5,220+5,fill='red')
    		self.sca[5].set(0)
    		self.can.create_oval(390-5,220-5,390+5,220+5,fill='orange')
    		self.sca[6].set(0)
    		self.can.create_oval(410-5,220-5,410+5,220+5,fill='yellow')
    		self.btgama.invoke()
    	# zero()
     
    	def gama(self):
    		self.can.delete(ALL)
    		# Tracé d'encadrement
    		# Données de l'encadré : Axes(x,y)=365(x),220(y)
    		self.can.create_line(10, 0, 10, 450, fill ='black')
    		self.can.create_line(740, 10, 0, 10, fill ='blue')
    		self.can.create_line(740, 450, 740, 10, fill ='black')
    		self.can.create_line(10, 450, 740, 450, fill ='blue')
    		self.can.create_line(360, 450, 360, 110, fill ='green')
    		self.can.create_line(220, 220, 740, 220, fill ='green')
    		# De la table gammique aux tables diatoniques surnommées
    		gammes =[[1,1,0,1,1,1,0],[0,2,0,1,1,1,0],[2,0,0,1,1,1,0],[4,0,0,0,0,1,0],[1,0,1,1,1,1,0],[0,1,1,1,1,1,0],
    				 [1,0,3,0,0,1,0],[1,2,1,0,0,1,0],[2,2,0,0,0,1,0],[0,0,1,2,1,1,0],[1,3,0,0,0,1,0],[0,0,2,1,1,1,0],
    				 [1,2,2,0,0,0,0],[0,0,4,0,0,1,0],[1,4,0,0,0,0,0],[1,0,0,2,1,1,0],[0,1,0,2,1,1,0],[1,1,3,0,0,0,0],
    				 [0,0,0,3,1,1,0],[1,1,0,0,2,1,0],[0,2,0,0,2,1,0],[0,2,0,2,0,1,0],[2,0,0,0,2,1,0],[1,0,1,0,2,1,0],
    				 [1,0,1,2,0,1,0],[1,1,1,2,0,0,0],[2,0,0,3,0,0,0],[0,0,2,0,2,1,0],[1,2,0,2,0,0,0],[1,0,0,3,0,1,0],
    				 [1,0,0,1,2,1,0],[1,1,0,3,0,0,0],[1,1,2,1,0,0,0],[0,1,0,0,3,1,0],[0,0,1,0,3,1,0],[0,0,0,1,3,1,0],
    				 [0,0,0,2,2,1,0],[1,0,0,0,3,1,0],[0,0,2,2,0,1,0],[0,0,0,0,4,1,0],[0,0,2,3,0,0,0],[1,0,0,4,0,0,0],
    				 [0,0,0,5,0,0,0],[1,1,0,1,0,2,0],[1,1,0,1,2,0,0],[0,2,0,1,0,2,0],[0,2,0,1,2,0,0],[2,0,0,1,0,2,0],
    				 [2,0,0,1,2,0,0],[1,0,1,1,0,2,0],[1,0,1,1,2,0,0],[1,1,0,0,1,2,0],[1,1,0,0,3,0,0],[1,1,0,2,1,0,0],
    				 [1,1,2,0,1,0,0],[0,2,0,0,0,3,0],[1,0,0,2,2,0,0],[1,0,0,1,0,3,0],[1,3,0,0,1,0,0],[1,0,0,0,1,3,0],
    				 [0,0,0,3,0,2,0],[0,0,2,1,2,0,0],[1,0,0,0,0,4,0],[0,0,0,3,2,0,0],[1,1,0,0,0,3,0],[3,0,0,0,0,2,0]]
    		gamnoms =['0','-2','+2','^2','-3','-23','-34x','+34','+23x','-34','x3','°3','+34x','°34x','^3',
    				  '-4','-24','^4','°4','-5','-25','-25+','+25-','-35','-35+','+45x','+25x','°35-','+35x',
    				  '-45+','-45','x5','x45+','-25°','-35°','-45°','°45-','°5','°35+','*5','°35x','-45x',
    				  '°45x','-6','+6','-26','-26+','+26-','+26','-36','-36+','-56','-56+','+56','x46+',
    				  '-26°','-46+','-46°','x36+','-56°','°46-','°36+','*6','°46+','°6','x26-']
     
    		# Récupération des notes cursives
    		ydo=self.sca[0].get()
    		xcpos_=300
    		ycpos_=220
    		xc_=xcpos_+(ydo*10)
    		yc_=ycpos_-(ydo*10)
    		rc_=5
    		self.can.create_oval(xc_-rc_,yc_-rc_,xc_+rc_,yc_+rc_,fill='black')
    		yre=self.sca[1].get()
    		xcpos_=320
    		ycpos_=220
    		xd_=xcpos_+(yre*10)
    		yd_=ycpos_-(yre*10)
    		rd_=5
    		self.can.create_oval(xd_-rd_,yd_-rd_,xd_+rd_,yd_+rd_,fill='green')
    		ymi=self.sca[2].get()
    		xcpos_=340
    		ycpos_=220
    		xe_=xcpos_+(ymi*10)
    		ye_=ycpos_-(ymi*10)
    		re_=5
    		self.can.create_oval(xe_-re_,ye_-re_,xe_+re_,ye_+re_,fill='blue')
    		yfa=self.sca[3].get()
    		xcpos_=350
    		ycpos_=220
    		xf_=xcpos_+(yfa*10)
    		yf_=ycpos_-(yfa*10)
    		rf_=5
    		self.can.create_oval(xf_-rf_,yf_-rf_,xf_+rf_,yf_+rf_,fill='grey')
    		ysol=self.sca[4].get()
    		xcpos_=370
    		ycpos_=220
    		xg_=xcpos_+(ysol*10)
    		yg_=ycpos_-(ysol*10)
    		rg_=5
    		self.can.create_oval(xg_-rg_,yg_-rg_,xg_+rg_,yg_+rg_,fill='red')
    		yla=self.sca[5].get()
    		xcpos_=390
    		ycpos_=220
    		xa_=xcpos_+(yla*10)
    		ya_=ycpos_-(yla*10)
    		ra_=5
    		self.can.create_oval(xa_-ra_,ya_-ra_,xa_+ra_,ya_+ra_,fill='orange')
    		ysi=self.sca[6].get()
    		xcpos_=410
    		ycpos_=220
    		xb_=xcpos_+(ysi*10)
    		yb_=ycpos_-(ysi*10)
    		rb_=5
    		self.can.create_oval(xb_-rb_,yb_-rb_,xb_+rb_,yb_+rb_,fill='yellow')
     
    		# Mesure de l'intervalle tempéré
    		c1=(yre+1)-ydo
    		d2=(ymi+1)-yre
    		e3=yfa-ymi
    		f4=(ysol+1)-yfa
    		g5=(yla+1)-ysol
    		a6=(ysi+1)-yla
    		b7=i=cum_diat=ok=x=0
    		diata=[c1,d2,e3,f4,g5,a6,b7]
    		while i < 6:
    			cum_diat += diata[i]
    			i+=1		
    		# while
    		diata[i]=5-cum_diat
     
    		# Recherche diatonique par l'itération
    		cc1=dd2=ee3=ff4=gg5=aa6=bb7=0
    		diata2=[cc1,dd2,ee3,ff4,gg5,aa6,bb7]
    		while x < 7:
    			m=x
    			y=0
    			while y < 7:
    				diata2[y]=diata[m]
    				y+=1
    				m+=1
    				if m > 6: m=0			
    			# while
    			myx=myx2=0
    			for my in gammes:
    				if diata2 == my:
    					degre=x
    					myx2=myx
    					x=7
    				# if
    				myx+=1
    			# for
    			x+=1
    		# while
    		# Ici : diata(original cursif).degre(tonique).my(gamme)
    		# Définition diatonique
    		# GMAJ= gammes[0]
    		gmaj = [1,1,0,1,1,1,0]	  # Forme majeure simplifiée
    		# GNAT= Ordre cursif comme diata[]
    		gnat = ['C','D','E','F','G','A','B']		# Forme alphabétique
    		cnat = ['','','','','','','']
    		# Niveaux d'altérations
    		nordiese = ['','+','x','^','+^','x^','^^','+^^','x^^','^^^','+^^^','x^^^','^^^^']
    		subemol = ['','****','°***','-***','***','°**','-**','**','°*','-*','*','°','-']
    		# Configuration modale
    		gdeg = ['I','II','III','IV','V','VI','VII']
    		# Définition des notes cursives
    		cursifs=[ydo,yre,ymi,yfa,ysol,yla,ysi]
    		ynat=ymod=0
    		for ycurs in cursifs:
    			if ycurs > 0 :
    				ymod=nordiese[ycurs]
    			if ycurs < 0 :
    				ymod=subemol[ycurs]
    			if ycurs == 0 :
    				ymod=subemol[ycurs]
    			cnat[ynat]=ymod
    			ynat+=1
    		# for
     
    		# Une tournée produit une tonalité modale de 7 notes
    		nat2=degre
    		deg = nom = 0
    		ynote = xgdeg = 30
    		ytone = 50
    		while deg < 7 :
    			nat = deg			   # Degré tonal en question
    			cri = gimj = gmod = maj = 0
    			xdeg = 60
    			text0 = gdeg[deg]
    			self.can.create_text(xgdeg,ynote+10,text=text0,
    								 font='bold',fill='black')
    			while maj < 7 :		 # Tonalité modale du degré
    				gmj = gmaj[maj]	 # Forme majeure (1101110)
    				imaj = diata2[nat]  # Forme modale (DIATA[DEGRE])
    				ynt = cnat[nat2]	# Forme altérative des notes
    				gnt = gnat[nat2]	# Forme tonale (CDEFGAB)
    				ideg = gdeg[deg]
    				cri = cri + gimj	# Tonalité cumulée
    				gimj = imaj - gmj   # Calcul tonal PAS/PAS
    				cmod = gmod = cri
    				if gmod > 0 :	   # Forme altérative des tonalités
    					imod = nordiese[cmod]
    				if gmod < 0 :
    					imod = subemol[cmod]
    				if gmod == 0 :
    					imod = subemol[cmod]
    				gmod = gmod + cri   # Transition tonale
    				# Construction du nom de la gamme
    				if nom == 0 :
    					ynom = ynt
    					gnom = gnt
    					tnom=ynom,gnom,gamnoms[myx2]
    					self.can.create_text(xdeg+250,ynote,text=tnom,
    										 font='bold',fill='black')
    				# if
    				nat+=1
    				nat2+=1
    				if nat > 6 :
    					nat = 0
    				if nat2 > 6 :
    					nat2 = 0
    				maj = maj + 1
    				text1=[ynt,gnt]
    				text2=[imod,maj]
    				self.can.create_text(xdeg,ynote,text=text1)
    				self.can.create_text(xdeg,ytone,text=text2,fill='blue')
    				xdeg+=30
    				nom=1
    			# while
    			ynote+=60
    			ytone+=60
    			nat2+=1
    			if nat2 > 6 :
    				nat2 = 0
    			deg = deg + 1
    		# while
    	# gamma()
    # class Gammique
     
    Gammique().mainloop()

    Je l'ai un peu aéré, y ai introduit des commentaires marquant les fins de blocs (je trouve ça plus lisible).

    Je pense qu'on peu aussi factoriser de la même façon tous les create_ova de la fonction gamma() ainsi que les fonctions scanoteX (mais là ça devient plus difficile pour moi...)

    Ceci dit, je commence un peu à mieux comprendre. La première gamme (C) montre ses 7 notes naturelles. La seconde (D) montre aussi les 7 notes avec le #F et le #C qui sont bien les deux dièses associés à cette gamme. Et de même pour les 5 autres avec leurs dièses ou leurs bémols bien représentés. Toutefois pourquoi symboliser les dièses par des "-" et les bémols par des "+" ??? Un dièse monte la note d'un demi-ton et un bémol la descend donc j'aurais mieux vu des "+" pour les dièses et des "-" pour les bémols...?

    Citation Envoyé par marco056 Voir le message
    à quel endroit sert winsound ?
    Dans le __init__, il y a un winsound.beep()...
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  11. #11
    Invité
    Invité(e)
    Par défaut
    Merci sve@r, j'adopte
    Toutefois pourquoi symboliser les dièses par des "-" et les bémols par des "+" ??? Un dièse monte la note d'un demi-ton et un bémol la descend donc j'aurais mieux vu des "+" pour les dièses et des "-" pour les bémols...?
    Où çà ?
    Lorsque j'utilise une combinaison de curseurs, je rencontre des erreurs
    Exception in Tkinter callback
    Traceback (most recent call last):
    File "C:\Python34\lib\tkinter\__init__.py", line 1533, in __call__
    return self.func(*args)
    File "C:\Users\Vincent\Documents\developpez\develHM\versions\progam_V1alphauto.py", line 314, in gama
    nat2=degre
    UnboundLocalError: local variable 'degre' referenced before assignment
    Le fait de paramétrer un nombre de curseurs simultanément, les variables n'ont pas le temps de se familiariser avec tous les nouveaux changements survenus...
    Je pourrais enlever l'invocation au bouton gamme,,,
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
     
    #!/usr/bin/env python 
    # -*- coding: utf-8 -*-
    # *
    # Application gammique évolutive
    # Version 1 : Calculer les gammes
    #
    from tkinter import *
    #import winsound
     
    class Gammique(Tk):
    	""" Ramification Gammique """
    	def __init__(self):
    		Tk.__init__(self)
    		"Tableau de bord"
    		self.title('Entité Gammique :')
     
    		# Fenêtre écran_résultat
    		self.can=Canvas(self,bg='white', height=500,width=750)
    		self.can.pack(side=RIGHT)
    		self.cad=Frame(self,width=200,height=600)
    		self.cad.pack(side=LEFT)
    		self.can.delete(ALL)
     
    		# Tracé d'encadrement
    		# Données de l'encadré : Axes(x,y)=365(x),220(y)
    		self.can.create_line(10, 0, 10, 450, fill ='black')
    		self.can.create_line(740, 10, 0, 10, fill ='blue')
    		self.can.create_line(740, 450, 740, 10, fill ='black')
    		self.can.create_line(10, 450, 740, 450, fill ='blue')
    		# Bouton gamme_audio
    		#winsound.Beep(frequency, duration)
    		Button(self.cad,text ='Radio_inactive',width=15,bg='light yellow').pack()
    		# Bouton choix chromatique
    		Button(self.cad,text ='Chrome_inactif',width=15,bg='light yellow').pack()
    		# Bouton tableaux instruments
    		Button(self.cad,text ='Tabla_inactif',width=15,bg='light yellow').pack()
    		# Bouton accords1357
    		Button(self.cad,text ='A1357_inactif',width=15,bg='light yellow').pack()
     
    		# Les notes cursives scalpha : Graduations gérées.
    		self.sca=[
    			Scale(
    				self,
    				length=250,
    				orient=HORIZONTAL,
    				label=label,
    				troughcolor=color,
    				sliderlength=20,
    				showvalue=1,
    				from_=f,
    				to=t,
    				tickinterval=1,
    				command=command,
    			) for (label, color, f, t, command) in (
    				("C", "black", 0, 5, self.scanote1),
    				("D", "green", -1, 4, self.scanote2),
    				("E", "blue", -2, 3, self.scanote3),
    				("F", "grey", -2, 3, self.scanote4),
    				("G", "red", -3, 2, self.scanote5),
    				("A", "orange", -4, 1, self.scanote6),
    				("B", "yellow", -5, 0, self.scanote7),
    				("CDEFGAB", "ivory", -5, 5, self.scanote8),
    			)
    		]
    		for x in self.sca: x.pack()
     
    		# Bouton gamme_naturelle
    		Button(self,text ='Zéro',width=25,command=self.zero).pack()
    		# Bouton gamme_calculée
    		self.btgama=Button(self,text='gamme',width=25,command=self.gama)
    		self.btgama.pack()
    	# __init__()
     
    	# Définition des curseurs
    	def scanote1(self,xc):
    		do=int(xc)
    		# Initialise sca[7](from_)
    		fromdo=do-(do*2)
    		self.sca[7].configure(from_ = fromdo)
    		xsi=self.sca[6].get()
    		xre=self.sca[1].get()
    		if do<xsi:self.sca[6].set(do)
    		if do>xre+1 :self.sca[1].set(do-1)
    	# scanote1()
     
    	def scanote2(self,xd):
    		re=int(xd)
    		xdo=self.sca[0].get()
    		xmi=self.sca[2].get()
    		if re<xdo-1:self.sca[0].set(re+1)
    		if re>xmi+1 :self.sca[2].set(re-1)
    	# scanote2()
     
    	def scanote3(self,xe):
    		mi=int(xe)
    		xre=self.sca[1].get()
    		xfa=self.sca[3].get()
    		if mi<xre-1:self.sca[1].set(mi+1)
    		if mi>xfa:self.sca[3].set(mi)
    	# scanote3()
     
    	def scanote4(self,xf):
    		fa=int(xf)
    		xmi=self.sca[2].get()
    		xsol=self.sca[4].get()
    		if fa<xmi:self.sca[2].set(fa)
    		if fa>xsol+1:self.sca[4].set(fa-1)
    	# scanote4()
     
    	def scanote5(self,xg):
    		sol=int(xg)
    		xfa=self.sca[3].get()
    		xla=self.sca[5].get()
    		if sol<xfa-1:self.sca[3].set(sol+1)
    		if sol>xla+1:self.sca[5].set(sol-1)
    	# scanote5()
     
    	def scanote6(self,xa):
    		la=int(xa)
    		xsol=self.sca[4].get()
    		xsi=self.sca[6].get()
    		if la<xsol-1:self.sca[4].set(la+1)
    		if la>xsi+1:self.sca[6].set(la-1)
    	# scanote6()
     
    	def scanote7(self,xb):
    		si=int(xb)
    		# Initialise sca[7](to)
    		tosi=si-(si*2)
    		self.sca[7].configure(to = tosi)
    		xla=self.sca[5].get()
    		xdo=self.sca[0].get()
    		if si<xla-1:self.sca[5].set(si+1)
    		if si>xdo:self.sca[0].set(si)
    	# scanote7()
     
    	def scanote8(self,xh):
    		sch=int(xh)
    		xdo=self.sca[0].get()
    		xre=self.sca[1].get()
    		xmi=self.sca[2].get()
    		xfa=self.sca[3].get()
    		xsol=self.sca[4].get()
    		xla=self.sca[5].get()
    		xsi=self.sca[6].get()
    		self.sca[0].set(xdo+sch)
    		self.sca[1].set(xre+sch)
    		self.sca[2].set(xmi+sch)
    		self.sca[3].set(xfa+sch)
    		self.sca[4].set(xsol+sch)
    		self.sca[5].set(xla+sch)
    		self.sca[6].set(xsi+sch)
    		self.btgama.invoke()
    	# scanote8()
     
    	def zero(self):
    		self.can.delete(ALL)
    		# Tracé d'encadrement
    		# Données de l'encadré : Axes(x,y)=365(x),220(y)
    		self.can.create_line(10, 0, 10, 450, fill ='black')
    		self.can.create_line(740, 10, 0, 10, fill ='blue')
    		self.can.create_line(740, 450, 740, 10, fill ='black')
    		self.can.create_line(10, 450, 740, 450, fill ='blue')
    		self.can.create_line(360, 450, 360, 10, fill ='green')
    		self.can.create_line(10, 220, 740, 220, fill ='green')
    		self.sca[0].set(0)
    		self.can.create_oval(300-5,220-5,300+5,220+5,fill='black')
    		self.sca[1].set(0)
    		self.can.create_oval(320-5,220-5,320+5,220+5,fill='green')
    		self.sca[2].set(0)
    		self.can.create_oval(340-5,220-5,340+5,220+5,fill='blue')
    		self.sca[3].set(0)
    		self.can.create_oval(350-5,220-5,350+5,220+5,fill='grey')
    		self.sca[4].set(0)
    		self.can.create_oval(370-5,220-5,370+5,220+5,fill='red')
    		self.sca[5].set(0)
    		self.can.create_oval(390-5,220-5,390+5,220+5,fill='orange')
    		self.sca[6].set(0)
    		self.can.create_oval(410-5,220-5,410+5,220+5,fill='yellow')
    		self.btgama.invoke()
    	# zero()
     
    	def gama(self):
    		self.can.delete(ALL)
    		# Tracé d'encadrement
    		# Données de l'encadré : Axes(x,y)=365(x),220(y)
    		self.can.create_line(10, 0, 10, 450, fill ='black')
    		self.can.create_line(740, 10, 0, 10, fill ='blue')
    		self.can.create_line(740, 450, 740, 10, fill ='black')
    		self.can.create_line(10, 450, 740, 450, fill ='blue')
    		self.can.create_line(360, 450, 360, 110, fill ='green')
    		self.can.create_line(220, 220, 740, 220, fill ='green')
    		# De la table gammique aux tables diatoniques surnommées
    		gammes =[[1,1,0,1,1,1,0],[0,2,0,1,1,1,0],[2,0,0,1,1,1,0],[4,0,0,0,0,1,0],[1,0,1,1,1,1,0],[0,1,1,1,1,1,0],
    				 [1,0,3,0,0,1,0],[1,2,1,0,0,1,0],[2,2,0,0,0,1,0],[0,0,1,2,1,1,0],[1,3,0,0,0,1,0],[0,0,2,1,1,1,0],
    				 [1,2,2,0,0,0,0],[0,0,4,0,0,1,0],[1,4,0,0,0,0,0],[1,0,0,2,1,1,0],[0,1,0,2,1,1,0],[1,1,3,0,0,0,0],
    				 [0,0,0,3,1,1,0],[1,1,0,0,2,1,0],[0,2,0,0,2,1,0],[0,2,0,2,0,1,0],[2,0,0,0,2,1,0],[1,0,1,0,2,1,0],
    				 [1,0,1,2,0,1,0],[1,1,1,2,0,0,0],[2,0,0,3,0,0,0],[0,0,2,0,2,1,0],[1,2,0,2,0,0,0],[1,0,0,3,0,1,0],
    				 [1,0,0,1,2,1,0],[1,1,0,3,0,0,0],[1,1,2,1,0,0,0],[0,1,0,0,3,1,0],[0,0,1,0,3,1,0],[0,0,0,1,3,1,0],
    				 [0,0,0,2,2,1,0],[1,0,0,0,3,1,0],[0,0,2,2,0,1,0],[0,0,0,0,4,1,0],[0,0,2,3,0,0,0],[1,0,0,4,0,0,0],
    				 [0,0,0,5,0,0,0],[1,1,0,1,0,2,0],[1,1,0,1,2,0,0],[0,2,0,1,0,2,0],[0,2,0,1,2,0,0],[2,0,0,1,0,2,0],
    				 [2,0,0,1,2,0,0],[1,0,1,1,0,2,0],[1,0,1,1,2,0,0],[1,1,0,0,1,2,0],[1,1,0,0,3,0,0],[1,1,0,2,1,0,0],
    				 [1,1,2,0,1,0,0],[0,2,0,0,0,3,0],[1,0,0,2,2,0,0],[1,0,0,1,0,3,0],[1,3,0,0,1,0,0],[1,0,0,0,1,3,0],
    				 [0,0,0,3,0,2,0],[0,0,2,1,2,0,0],[1,0,0,0,0,4,0],[0,0,0,3,2,0,0],[1,1,0,0,0,3,0],[3,0,0,0,0,2,0]]
    		gamnoms =['0','-2','+2','^2','-3','-23','-34x','+34','+23x','-34','x3','°3','+34x','°34x','^3',
    				  '-4','-24','^4','°4','-5','-25','-25+','+25-','-35','-35+','+45x','+25x','°35-','+35x',
    				  '-45+','-45','x5','x45+','-25°','-35°','-45°','°45-','°5','°35+','*5','°35x','-45x',
    				  '°45x','-6','+6','-26','-26+','+26-','+26','-36','-36+','-56','-56+','+56','x46+',
    				  '-26°','-46+','-46°','x36+','-56°','°46-','°36+','*6','°46+','°6','x26-']
     
    		# Récupération des notes cursives
    		ydo=self.sca[0].get()
    		xcpos_=300
    		ycpos_=220
    		xc_=xcpos_+(ydo*10)
    		yc_=ycpos_-(ydo*10)
    		rc_=5
    		self.can.create_oval(xc_-rc_,yc_-rc_,xc_+rc_,yc_+rc_,fill='black')
    		yre=self.sca[1].get()
    		xcpos_=320
    		ycpos_=220
    		xd_=xcpos_+(yre*10)
    		yd_=ycpos_-(yre*10)
    		rd_=5
    		self.can.create_oval(xd_-rd_,yd_-rd_,xd_+rd_,yd_+rd_,fill='green')
    		ymi=self.sca[2].get()
    		xcpos_=340
    		ycpos_=220
    		xe_=xcpos_+(ymi*10)
    		ye_=ycpos_-(ymi*10)
    		re_=5
    		self.can.create_oval(xe_-re_,ye_-re_,xe_+re_,ye_+re_,fill='blue')
    		yfa=self.sca[3].get()
    		xcpos_=350
    		ycpos_=220
    		xf_=xcpos_+(yfa*10)
    		yf_=ycpos_-(yfa*10)
    		rf_=5
    		self.can.create_oval(xf_-rf_,yf_-rf_,xf_+rf_,yf_+rf_,fill='grey')
    		ysol=self.sca[4].get()
    		xcpos_=370
    		ycpos_=220
    		xg_=xcpos_+(ysol*10)
    		yg_=ycpos_-(ysol*10)
    		rg_=5
    		self.can.create_oval(xg_-rg_,yg_-rg_,xg_+rg_,yg_+rg_,fill='red')
    		yla=self.sca[5].get()
    		xcpos_=390
    		ycpos_=220
    		xa_=xcpos_+(yla*10)
    		ya_=ycpos_-(yla*10)
    		ra_=5
    		self.can.create_oval(xa_-ra_,ya_-ra_,xa_+ra_,ya_+ra_,fill='orange')
    		ysi=self.sca[6].get()
    		xcpos_=410
    		ycpos_=220
    		xb_=xcpos_+(ysi*10)
    		yb_=ycpos_-(ysi*10)
    		rb_=5
    		self.can.create_oval(xb_-rb_,yb_-rb_,xb_+rb_,yb_+rb_,fill='yellow')
     
    		# Mesure de l'intervalle tempéré
    		c1=(yre+1)-ydo
    		d2=(ymi+1)-yre
    		e3=yfa-ymi
    		f4=(ysol+1)-yfa
    		g5=(yla+1)-ysol
    		a6=(ysi+1)-yla
    		b7=i=cum_diat=ok=x=0
    		diata=[c1,d2,e3,f4,g5,a6,b7]
    		while i < 6:
    			cum_diat += diata[i]
    			i+=1		
    		# while
    		diata[i]=5-cum_diat
     
    		# Recherche diatonique par l'itération
    		cc1=dd2=ee3=ff4=gg5=aa6=bb7=0
    		diata2=[cc1,dd2,ee3,ff4,gg5,aa6,bb7]
    		while x < 7:
    			m=x
    			y=0
    			while y < 7:
    				diata2[y]=diata[m]
    				y+=1
    				m+=1
    				if m > 6: m=0			
    			# while
    			myx=myx2=0
    			for my in gammes:
    				if diata2 == my:
    					degre=x
    					myx2=myx
    					x=7
    				# if
    				myx+=1
    			# for
    			x+=1
    		# while
    		# Ici : diata(original cursif).degre(tonique).my(gamme)
    		# Définition diatonique
    		# GMAJ= gammes[0]
    		gmaj = [1,1,0,1,1,1,0]	  # Forme majeure simplifiée
    		# GNAT= Ordre cursif comme diata[]
    		gnat = ['C','D','E','F','G','A','B']		# Forme alphabétique
    		cnat = ['','','','','','','']
    		# Niveaux d'altérations
    		nordiese = ['','+','x','^','+^','x^','^^','+^^','x^^','^^^','+^^^','x^^^','^^^^']
    		subemol = ['','****','°***','-***','***','°**','-**','**','°*','-*','*','°','-']
    		# Configuration modale
    		gdeg = ['I','II','III','IV','V','VI','VII']
    		# Définition des notes cursives
    		cursifs=[ydo,yre,ymi,yfa,ysol,yla,ysi]
    		ynat=ymod=0
    		for ycurs in cursifs:
    			if ycurs > 0 :
    				ymod=nordiese[ycurs]
    			if ycurs < 0 :
    				ymod=subemol[ycurs]
    			if ycurs == 0 :
    				ymod=subemol[ycurs]
    			cnat[ynat]=ymod
    			ynat+=1
    		# for
     
    		# Une tournée produit une tonalité modale de 7 notes
    		nat2=degre
    		deg = nom = 0
    		ynote = xgdeg = 30
    		ytone = 50
    		while deg < 7 :
    			nat = deg			   # Degré tonal en question
    			cri = gimj = gmod = maj = 0
    			xdeg = 60
    			text0 = gdeg[deg]
    			self.can.create_text(xgdeg,ynote+10,text=text0,
    								 font='bold',fill='black')
    			while maj < 7 :		 # Tonalité modale du degré
    				gmj = gmaj[maj]	 # Forme majeure (1101110)
    				imaj = diata2[nat]  # Forme modale (DIATA[DEGRE])
    				ynt = cnat[nat2]	# Forme altérative des notes
    				gnt = gnat[nat2]	# Forme tonale (CDEFGAB)
    				ideg = gdeg[deg]
    				cri = cri + gimj	# Tonalité cumulée
    				gimj = imaj - gmj   # Calcul tonal PAS/PAS
    				cmod = gmod = cri
    				if gmod > 0 :	   # Forme altérative des tonalités
    					imod = nordiese[cmod]
    				if gmod < 0 :
    					imod = subemol[cmod]
    				if gmod == 0 :
    					imod = subemol[cmod]
    				gmod = gmod + cri   # Transition tonale
    				# Construction du nom de la gamme
    				if nom == 0 :
    					ynom = ynt
    					gnom = gnt
    					tnom=ynom,gnom,gamnoms[myx2]
    					self.can.create_text(xdeg+250,ynote,text=tnom,
    										 font='bold',fill='black')
    				# if
    				nat+=1
    				nat2+=1
    				if nat > 6 :
    					nat = 0
    				if nat2 > 6 :
    					nat2 = 0
    				maj = maj + 1
    				text1=[ynt,gnt]
    				text2=[imod,maj]
    				self.can.create_text(xdeg,ynote,text=text1)
    				self.can.create_text(xdeg,ytone,text=text2,fill='blue')
    				xdeg+=30
    				nom=1
    			# while
    			ynote+=60
    			ytone+=60
    			nat2+=1
    			if nat2 > 6 :
    				nat2 = 0
    			deg = deg + 1
    		# while
    	# gamma()
    # class Gammique
     
    Gammique().mainloop()
    Dernière modification par Invité ; 28/06/2015 à 10h54.

  12. #12
    Invité
    Invité(e)
    Par défaut
    Juste une image qui en ce moment m'aide bien
    Nom : cursus.PNG
Affichages : 136
Taille : 49,2 Ko

  13. #13
    Invité
    Invité(e)
    Par défaut
    Bonjour
    Comme je travaille sur le programme « progamV1alpha.py »,
    Il est probable que le sujet soit intéressant à exprimer
    Alors, je dévie le cours de mon avancée… .

    Au début, il s’agissait de créer les opérations de définition de la gamme recherchée
    L’application donne des résultats, sauf qu’il manque le passage à l’octave
    Particulièrement visible, lorsqu’on cherche à diminuer la note Do d’½ ton
    L’application progamV1alpha serait idéale, en élargissant les limites actuelles

    Note gammologique | Le système gammique naturel se développe sur une seule octave
    L’ensemble des gammes fondamentales est en Do, et la septième est naturellement Si
    Signification logique, l’expression des tonalités diatoniques (relatives fondamentales)
    Les modulations diatoniques définissent les moyens de comparaisons chroniques
    « progamV1alpha.py » est de type premier entier, il est un espace de définitions gammiques
    À savoir, le centre complexe des diatonies transposées en milieu fondamental
    Forme un étalonnage de type premier, simplifiant les multiples transitions modales
    Car au-delà des gammes fondamentales, ce n’est pas la forme qui change mais la hauteur
    Les gammes fondamentales (toutes Do(majeur7)) ont les formes modales possibles
    Ce qui change dans une transposition c’est le signe, et non l’intervalle diatonique
    La transposition amène le déplacement en hors zone de la fondamentale naturelle
    D’une basique logique, on sait que la note Do bémolisée 12 fois devient la note Do à l’octave
    Çà met en évidence l’existence d’une limite située entre son augmentation et sa diminution
    Ceci est bien le sujet de mes recherches actuelles

    Trouver cette limite ?
    Nom : armgamfa.png
Affichages : 117
Taille : 112,1 Ko
    Dernière modification par Invité ; 12/07/2015 à 16h38.

Discussions similaires

  1. [Free Pascal] Impossible de scroller l'écran pour afficher les lignes qui ont remonté
    Par Loupsio dans le forum Free Pascal
    Réponses: 10
    Dernier message: 27/03/2013, 19h30
  2. Réponses: 3
    Dernier message: 25/02/2008, 16h09
  3. Requete select pour récupérer les no match entre 2 tables
    Par Celina dans le forum MS SQL Server
    Réponses: 4
    Dernier message: 16/12/2003, 12h59
  4. [FoxPro]Instruction pour enlever les accents ?
    Par Fab-FoxPro dans le forum Autres SGBD
    Réponses: 2
    Dernier message: 19/08/2003, 16h46
  5. Outils linux pour surveiller les perf d'un serveur ?
    Par MASSAKA dans le forum Applications et environnements graphiques
    Réponses: 2
    Dernier message: 22/10/2002, 11h40

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo