Publicité

Annonce

Réduire
Aucune annonce.

Python et la musique

Réduire
X
 
  • Filtre
  • Heure
  • Afficher
Tout nettoyer
nouveaux messages

  • Python et la musique

    Sur des fils voisins, l'usage de Python pour la musique a plusieurs fois été évoqué... je pense qu'il peut être temps d'ouvrir un fil à ce sujet.

    Il s'agit d'un langage de script qui allie une certaine puissance, avec un style très clair. Malgré sa puissance, il est assez facile d'approche (il est d'ailleurs utilisé dans l'enseignement lorsque l'on souhaite passer plus de temps sur l’algorithmie que sur la syntaxe). Par ailleurs, certaines distributions (dont Anaconda que j'utilise), intègre un environnement Spyder qui facilite la saisie (fenêtre déroulante pour choisir les méthodes appelées, colorisation syntaxique), mais aussi un interpréteur qui permet d'afficher les variables de son programme, lancer des fonctions avec divers paramètres.

    Mais ce qui nous intéresse ici, c'est la musique. On a vu dans un fil voisin que la bibliothèque "mido" peut être très utile pour créer des fichiers SysEx d'initialisation. Là, je vous propose une copie d'écran en clin d'oeil à Deb qui je crois appréciera...



    À gauche, le programme (si vous êtes perdu par les forteClass, IntervalVector, etc... un cours de Set-Theory vous sera utile, Python n'est pas en cause !!), à droite, la fenêtre de l'interpréteur après avoir lancé le programme. La commande c.show() saisie à la main montre aussi que l'on peut travailler en interaction commande/réponse... et aussi qu'un résultat peut être affiché de façon graphique.

    NB: music21 s'installe en tapant "pip install music21". Il utilise MusScore pour afficher les partitions. Plus d'info sur music21 ici : http://web.mit.edu/music21/doc/. (Avec le chapitre 25 sur la musique post-tonale avec par exemple un petit programme de quelque lignes qui annote une partition avec l'analyse des accords selon la Set-Theory).
    Dernière modification par floyer, 17 décembre 2016, 16h25.
    http://www.sinerj.org/~loyer/piano/

    It's never too late to learn to play the piano. (tip of the day)

    Côté piano : Yamaha CLP150, pianos VSL Syncron et Vienna Imperial, Garritan CFX, Bechstein Digital Grand, Ivory, Galaxy et beaucoup d’autres pianos virtuels - Côté synthé : Roland A-500 Pro, Native-Instruments Komplete 12 - Arturia V Collection 7, Korg Legacy Collection, Air Music Technology plugins, OP-X Pro II, dexed (émulateur DX7 libre), Yamaha S-YXG50 - DAW : Reaper 6, Cubase Artist 9 - Interface audio : Steinberg UR22 -
    Casque : AKG K-702

  • #2
    Excellente initiative. Et merci pour le lien sur music21 que je vais regarder attentivement.
    Là, je vais faire des courses, mais en revenant, je posterai deux petit programmes utilitaires pour calculer des tempéraments et retrouver un intervalle. Comme je suis débutant, il y aura vraisemblablement une codage plus rationnel et tu pourras commenter. Cela serait intéressant de mettre en rapport, peut-être dans un autre sujet, les différents codes qui permettent d'obtenir les listes des tempéraments : Open Music, Python, Opusmodus.
    Pour le cours Set Theory, je veux bien m'y coller...
    Et merci pour le clin d'oeil, j'apprécie vraiment. En plus, ça correspond vraiment à l'idée que je me faisais de cette rubrique Ressources. Et merci à toi et à Alain pour vos apports très instructifs.
    En fin de compte, en est en train petit à petit de faire un inventaire de systèmes permettant de faire de la musique au-delà des éditeurs de partitions et autres séquenceurs/Daw/STAN.
    PS : le 3-11 n'est pas mon préféré, je préfère de loin le 3-5 qui est typiquement la triade atonale parfaite comme le suggérait le musicologue Célestin Deliège...

    Commentaire


    • #3
      @Floyer,

      Très intéressant ce Python.

      Pourrais tu donner des éléments sur la gestion des microtons (pour tempéraments etc …) par Python …: les limites, la gestion en Pitchbend ou pas … etc ..

      Merci,
      Alain

      PS: tu sais que j'ai la flemme de me farcir des dizaines de langages (même sils sont voisins) …
      Roland RD2000, Nord Piano 2 HP, KORG PA900
      FocusRite Scarlett 6i6, Lucas Nano 300, 2xMonitors CM30,
      MacBookPro + Logic Pro X + divers VSTs (AU), Zoom Q2n, Boss VE-5

      Cheminer ou arriver: quel est mon but ? La musique est un chemin infini...

      Commentaire


      • #4
        Pour la gestion des tempéraments, il n'y a rien de prévu directement. Si tu essayes une note avec partie décimale avec music21 :

        Code:
        music21.chord.Chord([0,3,7.6])
        ... tu auras un message d'erreur.

        Ainsi, le mieux est de travailler directement dans un fichier MIDI en générant toi même tes pitch-bend. Documentation de MIDO ici : https://mido.readthedocs.io/en/latest/.

        Si tu mets dans un programme :

        Code:
        import mido
        cc = mido.Message('pitchwheel')
        cc.channel = 3
        cc.pitch = -67
        time = 12
        Tu crées un événement Pitch-bend qui sera à émettre à t=12 ticks. (Cet événement devra être ajouté à une piste, sinon rien ne se passera).

        Pour créer un fichier MIDI, voir https://mido.readthedocs.io/en/lates...ing-a-new-file Pour caler l'heure de tes événements, tu as le paramètre mid.ticks_per_beat (où mid est la variable crée par MidiFIle()) qui donne la résolution du fichier MIDI et donc la valeur de l'unité "ticks". (L'heure est relative au dernier événement, il faut mettre time = 0 pour avoir un événement synchrone avec le précendent).

        PS: Tu as deux approches pour utiliser une bibliothèque : "import mido", puis "mido.Message(...)" par exemple, ou "from mido import Message", puis "Message(...)". Je préfère en générale la première approche qui précise à chaque fois la bibliothèque que l'on utilise. La seconde approche peut être utile pour travailler en interactif. En revanche, je préfère taper "from math import sin" afin d'utiliser la fonction sinus directement ensuite (savoir que sin() vient de la bibliothèque math n'apporte rien lorsque je relis un programme). À toi de voir.

        HS : Je note que le l'accord 3-5 a sa page Wikipédia : https://en.wikipedia.org/wiki/Viennese_trichord
        Dernière modification par floyer, 17 décembre 2016, 18h02.
        http://www.sinerj.org/~loyer/piano/

        It's never too late to learn to play the piano. (tip of the day)

        Côté piano : Yamaha CLP150, pianos VSL Syncron et Vienna Imperial, Garritan CFX, Bechstein Digital Grand, Ivory, Galaxy et beaucoup d’autres pianos virtuels - Côté synthé : Roland A-500 Pro, Native-Instruments Komplete 12 - Arturia V Collection 7, Korg Legacy Collection, Air Music Technology plugins, OP-X Pro II, dexed (émulateur DX7 libre), Yamaha S-YXG50 - DAW : Reaper 6, Cubase Artist 9 - Interface audio : Steinberg UR22 -
        Casque : AKG K-702

        Commentaire


        • #5
          Merci Floyer,

          Ma question était en fait "est ce que Python gère mieux ou autrement les microtons que OM".

          D'après ce que je comprend Python gère les microtons aussi avec le PB, donc aussi par canal Midi … (donc même limitations)

          Pour l'instant je ne vois pas trop de grosse différence d'approche en Python et OM …
          mais il est très possible que j'aie loupé quelque chose…. !!

          Alain
          Roland RD2000, Nord Piano 2 HP, KORG PA900
          FocusRite Scarlett 6i6, Lucas Nano 300, 2xMonitors CM30,
          MacBookPro + Logic Pro X + divers VSTs (AU), Zoom Q2n, Boss VE-5

          Cheminer ou arriver: quel est mon but ? La musique est un chemin infini...

          Commentaire


          • #6
            Il me semblait qu'en OM, la sélection du canal par un chord-seq était automatique (en fonction des fractions de demi-ton). C'est ce que j'ai retenu du tutoriel 10. Mais la documentation de chord-seq indique :
            CHORD-SEQ is defined with:

            - <lmidic>: a list of list of pitches (midicents: 100 = 1 half-tone - 6000 = C3); e.g. '((6000 6500) (6100 6700 7100)). Each pitch list is considered as a chord in teh sequence. Single-note sequences can be specified with simple list of pitches, e.g. (6000 61000 6800) ; in this case each pitch will be considered as a single-note chord.
            - <lonsets>: a list of onsets in milliseconds (one for each chord). If the list is shorter than the list of pitch, the last interval is repeated.
            - <ldur>: a list or list of lists values (in milliseconds) expressing chords durations or note durations inside each chord.
            - <lvel>: a list or list of lists of values (MIDI velocity from 0 to 127) expressing chords velocities or note durations inside each chord.
            - <loffset>: a list or list of lists of values (milliseconds) expressing note offsets for the notes inside each chord.
            - <lchan>: a list or list of lists of values (1-16) expressing MIDI channels for each chord or notes inside each chord.
            - <legato>: a number between 0 and 100, indicating the duration of chords as a percentage of inter-onsets time intervals. If different from 0 (the default), the ldur and loffset inputs are ignored, and notes in the chords are formatted with regard to the legato value.

            All values (excepted onsets and legato) are returned (in the box outputs) as list of lists (one value for each note, missing values computed from previous notes or chords).
            Tu peux donc utiliser le paramètre <lchan>. Je viens de voir que l'un des exemple du tutoriel 10 utilise ce paramètre. Attention, dans l'exemple de ce tutoriel, la liste des instruments est sous forme de liste : un canal par accord. Si tu veux sélectionner les canaux pour chaque note à l'intérieur des accords, il faudra utiliser une liste de listes.

            Par contre, là où tu seras limité, est si tu souhaites changer le pitch-bend d'un canal entre deux accords : ce n'est pas prévu. C'est ce qui me fait penser à prendre le problème à plus bas niveau.


            À un niveau plus bas, parmi les fonctions MIDI, tu n'as pas un MIDI-NOTE-ON, mais plutôt un MIDI-O générique et tu devras assembler les octets d'un NOTE-ON ou d'un NOTE-OFF à la main. Pas compliqué, mais c'est de plus bas niveau que Python/mido. À ce niveau, tu auras une difficulté : comment séquencer le tout et insérer les temporisations, etc. Je t'avoue que je ne vois pas. Je ne sais pas si on peut faire avec OM. (Je ne prétends pas connaître assez OM pour te donner une réponse définitive).

            SI tu regardes http://www.audiokeys.net/forum/showt...l=1#post663351 tu verras qu'utiliser MIDO est assez simple :

            Code:
            import mido
            
            file = mido.MidiFile()
            track = mido.MidiTrack()
            file.tracks.append(track)
            
            [... calcul du sysex ...]
            
            track.append(mido.Message('sysex', data = sysex))
            
            file.save("cordier.mid")
            La complexité du script est dû au calcul du sysex (inutile si tu utilises des pitch bend). La syntaxe est assez claire.

            NB: On peut faire très concis pour créer un événement Pitch Bend Change : mido.Message('pitchwheel',channel=0,pitch=9). Inutile d'utiliser plusieurs lignes comme dans un message plus haut.
            Dernière modification par floyer, 17 décembre 2016, 22h08.
            http://www.sinerj.org/~loyer/piano/

            It's never too late to learn to play the piano. (tip of the day)

            Côté piano : Yamaha CLP150, pianos VSL Syncron et Vienna Imperial, Garritan CFX, Bechstein Digital Grand, Ivory, Galaxy et beaucoup d’autres pianos virtuels - Côté synthé : Roland A-500 Pro, Native-Instruments Komplete 12 - Arturia V Collection 7, Korg Legacy Collection, Air Music Technology plugins, OP-X Pro II, dexed (émulateur DX7 libre), Yamaha S-YXG50 - DAW : Reaper 6, Cubase Artist 9 - Interface audio : Steinberg UR22 -
            Casque : AKG K-702

            Commentaire


            • #7
              Bonsoir,


              Je poste deux "utilitaires" :
              http://www.deb8076.eu/CAOPDF/TableNovaroPython.pdf
              l'un, le plus court, qui calcule la position d'un intervalle dans les différents tempéraments tempérés. Ce qui peut-être pratique dans le cas du 16e de ton qui suppose une division de l'octave en 96 parties égales.
              Le second qui reprend le premier mais qui ajoute les progressions des tempéraments qu'Augusto Navarro avait calculées et insérées dans son ouvrage "Systema Natural De La Musica" qui avait été publié en 1951 et qui est mis en ligne par la société Augusto Novaro :

              http://www.anaphoria.com/novaro51.pdf

              Bien entendu, il y a très certainement une façon de faire plus concise pour arriver aux même résultats, mais bon, je débute. D'ailleurs, sur le premier concernant la recherche de la position d'un intervalle dans une table, j'aurais bien aimé faire en sorte après chaque résultat de continuer le calcul avec d'autres rapports. J'ai essayé avec la définition d'une fonction (Def "fonction") mais je cale sur les entrées multiples ou d'une entrée comprenant directement la fraction du rapport comme 3/2. Bref, je découvre mais c'est vraiment très intéressant.

              Sinon, j'ai découvert les travaux d'Augusto Novaro grâce à l'ouvrage de Jean-Etienne Marie, spécialiste de la microtonalité, L'Homme Musical, paru chez Arthaud, et dans lequel il présentait les tables de progressions des tempéraments de 2e au 53e d'octave, indice dont il suffit de multiplier avec une fréquence de base pour obtenir une hauteur précise. Pour sa part, outre les calculs avec les différents rapports (pages 27 à 50), ses tables publiées vont du 2e au 65e d'octave (pages 53 à 58). Et malgré l'handicap de la langue - mais qui est assez compréhensible - je ne saurais trop vous conseiller de parcourir cet ouvrage.

              J'ajoute un lien complémentaire, portant sur un tableau présentant les notes, leurs fréquences Hz tempérées et comprenant le quart et le huitième de ton ainsi que la note midi - (tableau) - et qui permet de vérifier les calculs des tempéraments 1/2, 1/4 et 1/8e de ton rapidement.




              Commentaire


              • #8
                Pas mal. Quelques remarques : int(x) arrondi par défaut. Il faut utiliser round pour arrondir le plus proche (puis int si tu veux un entier). Contrairement à math.floor et math.ceil, on écrit directement round.

                Pour la boucle : "for i in range(n):" suffit pour itérer de 0 à n-1. Tu as aussi range(n,m) pour itérer de n à m-1, et range(n,m,step) pour préciser le pas. En python 3, range n'est itéré qu'à l'utilisation. En python 2, range(...) sort une liste, et il vaut mieux - si n est grand - utiliser xrange qui permet la même itération sans allouer la liste en mémoire.

                J'aurais plutôt tendance à laisser Python gérer les types sans convertir, sauf peut-être avant le print. Il y a la division qui en python 2 retourne toujours un entier si l'on prend deux entiers. On peut s'en sortir avec un "from __future__ import division" qui récupère la convention Python 3 au sujet des divisions et retourne un flottant s'il y a une partie décimale. Dans ce cas, la division entière doit être explicitée avec //.

                Pour l'affichage, j'aime bien utiliser "rapport={} freq={} Hz".format(r1,f1) Un avantage est que l'on peut paramétrer la présentation avec des codes dans l'accolade. Sinon, ton approche est tout aussi valable.

                Pour la mise en fonction, tu peux regrouper les inputs, puis écrire :

                def cherche_intervalle(num,den,n):

                suivi de tout le reste indenté.

                La ligne cherche_intervalle(num,den,n) appelera la fonction définie. Et tu pourras aussi l'appeler dans une session interactive.

                NB: tu as une bibliothèque de fractions ("from fractions import Fraction", ensuite tu peux écrire Fraction(3,2)... mais je doute que cela aide ici.


                Il faudra que je retrouve l'algorithme qui trouve les fractions les plus approchantes pour un nombre quelconque. Avec log2(3/2), cela propose vite 7/12 puis 31/53 ce qui justifie le découpage de l'octave en 53.
                Dernière modification par floyer, 20 décembre 2016, 11h14.
                http://www.sinerj.org/~loyer/piano/

                It's never too late to learn to play the piano. (tip of the day)

                Côté piano : Yamaha CLP150, pianos VSL Syncron et Vienna Imperial, Garritan CFX, Bechstein Digital Grand, Ivory, Galaxy et beaucoup d’autres pianos virtuels - Côté synthé : Roland A-500 Pro, Native-Instruments Komplete 12 - Arturia V Collection 7, Korg Legacy Collection, Air Music Technology plugins, OP-X Pro II, dexed (émulateur DX7 libre), Yamaha S-YXG50 - DAW : Reaper 6, Cubase Artist 9 - Interface audio : Steinberg UR22 -
                Casque : AKG K-702

                Commentaire


                • #9
                  Pour trouver rapidement une fraction qui approche un réel, je t'invite à lire http://www.sinerj.org/~loyer/euclide.pdf

                  La programmation Python donne (je choisi log2(3/2)) :

                  Code:
                  import math
                  
                  X = math.log2(3/2)
                  
                  (a, b) = (0, 1)
                  (c, d) = (1, 0)
                  
                  for i in range(10):
                      N = math.floor(X)
                      eps = X-N
                  
                      (a,b) = (b, a+b*N)
                      (c,d) = (d, c+d*N)
                      print ("{:6}/{:6} = {}".format(b,d, b/d))
                  
                      X = 1/eps
                  et le résultat :
                  Code:
                       0/     1 = 0.0
                       1/     1 = 1.0
                       1/     2 = 0.5
                       3/     5 = 0.6
                       7/    12 = 0.5833333333333334
                      24/    41 = 0.5853658536585366
                      31/    53 = 0.5849056603773585
                     179/   306 = 0.5849673202614379
                     389/   665 = 0.5849624060150376
                    9126/ 15601 = 0.5849625024036921
                  Cela converge plus rapidement avec round au lieu de math.floor (on évite le 0/1 et le 24/41, )... mais on a des valeurs négatives. On remarque que pour trouver une quinte sur une octave découpée en n parties égales, 12, 41 et 53 sont adéquats... pour faire plus précis, il faut monter à n= 306 !

                  NB: En python 2, il faut ajouter "from __future__ import division" pour que 3/2 fasse 1.5 et non 1 (ou écrire 3./2.).
                  Dernière modification par floyer, 20 décembre 2016, 13h19.
                  http://www.sinerj.org/~loyer/piano/

                  It's never too late to learn to play the piano. (tip of the day)

                  Côté piano : Yamaha CLP150, pianos VSL Syncron et Vienna Imperial, Garritan CFX, Bechstein Digital Grand, Ivory, Galaxy et beaucoup d’autres pianos virtuels - Côté synthé : Roland A-500 Pro, Native-Instruments Komplete 12 - Arturia V Collection 7, Korg Legacy Collection, Air Music Technology plugins, OP-X Pro II, dexed (émulateur DX7 libre), Yamaha S-YXG50 - DAW : Reaper 6, Cubase Artist 9 - Interface audio : Steinberg UR22 -
                  Casque : AKG K-702

                  Commentaire


                  • #10
                    Bonjour,
                    Merci pour toutes ces précisions. Je vais regarder tout ça attentivement. Pour le résultat sur les fréquences Hz, j'avais testé le round, mais il ne me convient pas. En fait, j'aurais souhaité trouver la syntaxe pour afficher deux, trois ou 4 chiffres après la virgule.
                    Pour les input, j'ai vu dans un exemple hier soir qu'on pouvait insérer plusieurs input, mais ce n'est pas exactement ça que je recherche pour le calcul de l'intervalle après avoir inséré les rapports. Ce que je souhaiterais, c'est entrer un premier rapport, obtenir le résultat, avoir une autre demande de rapport, obtenir le résultat, re-rapport, etc., et sortir quand je le souhaite.

                    Code:
                    #!/usr/bin/env python3
                    # -*- coding: utf-8 -*-
                    """Created on Tue Dec 20 14:38:23 2016
                    @author: debrildidier
                    """
                    # -*- coding: utf-8 -*-
                    import math 
                    t= input ('numerateur ?')
                    d= input ('denominateur ?')
                    n= input ('division octave ?')
                    f= input ('fondamentale Hz ? ')
                    r= float(t)/float(d)
                    
                    
                    interval = math.log10(float(r))*float(n)/math.log10(2)
                    
                    
                    hz= (2.**(1./int(n)))**interval*float(f)
                    print ('Rapport = ', r, '-', 'Intervalle =  ', round(interval), "- ", 'hz = ', (hz))
                    # =========================================================    
                    #x=int(n)
                    while(x!=0):
                        x=interval
                        if (x<0):
                            print("Il faut une valeur positive ou nulle !")
                        else :
                            resultat=x
                            print("f("+repr(x)+ ")="+repr(resultat))
                        print("t", "d", "n", "f")
                    Dans la 1er partie, ça va, j'obtiens le résultat du rapport, la position de l'intervalle dans le tempérament et la fréquence Hz.
                    Par contre, je m'emmêle totalment les pinceaux pour relancer les entrées et sortir quand je le souhaite. J'ai mis le round sur l'intervalle mais ce n'est pas nécessaire, il sort correctement. Et comme je l'écris plus haut, j'aurais bien aimé obtenir la fréquence avec 2, 3 ou 4 chiffres derrières la virgule, pas plus. L'inconvénient avec round, c'est que qu'il n'y a ni décimale ou centième.
                    "Pour l'affichage, j'aime bien utiliser "rapport={} freq={} Hz".format(r1,f1)"
                    Quand tu écris affichage, c'est dans le script, pas pour print ?
                    Sinon, oui, j'aime bien cette présentation (qui est celle souvent utilisée pour les ECH(Ensembles de Classes de Hauteurs).
                    Dernière modification par deb76, 20 décembre 2016, 16h57.

                    Commentaire


                    • #11
                      Sur le forum, tu devrais utiliser la balise code qui préserve les indentations... Là avec quote, c'est difficilement lisible.

                      Pour afficher "pi=3.142", tu peux taper :
                      Code:
                      print ("pi={:.3f}".format(math.pi))
                      Sans le f, le formatage prend 3 chiffres significatifs dont le 3 ! La méthode format peut prendre plusieurs paramètres :
                      Code:
                      print ("pi*e = {:.3f}*{:.3f} = {:.3f}".format(math.pi, math.e, math.pi*math.e))
                      Pour faire une boucle infinie qui s'arrête sur une condition (ici, on valide une ligne vide) :
                      Code:
                      while True:
                          str_v = input("Valeur de v:")
                          if str_v == "":
                              break
                          v = int(str_v)
                          print ("v*v = {}".format(v*v))
                      NB: J'ai été un peu rapide dans ma remarque sur les types... effectivement, comme input retourne une chaîne de caractères, il faut convertir explicitement.Je trouve plus logique de le faire juste après la saisie plutôt qu'à chaque fois que l'on a besoin de cette valeur, mais c'est une histoire de goût. (On peut taper v = int(input("question"))... sauf ici où l'on a besoin de la version non convertie pour la comparer à la chaîne vide)

                      Le round sert à trouver l'intervalle la plus proche. Si par hasard, le résultat est 6.4, le round est optionnel. Par contre si le résultat est 6.6, int(6.6) retournera 6 et non l'intervalle le plus proche, 7. Dans tes exemples, tu avais les résultats : 14.039100017307748 et 7.019550008653874. Par chance, l'entier le plus proche était la partie entière.

                      L'inconvénient avec round, c'est que que ni décimale ou centième.
                      Tu peux essayer round(math.pi,2) pour obtenir 3.14.
                      Dernière modification par floyer, 20 décembre 2016, 16h53.
                      http://www.sinerj.org/~loyer/piano/

                      It's never too late to learn to play the piano. (tip of the day)

                      Côté piano : Yamaha CLP150, pianos VSL Syncron et Vienna Imperial, Garritan CFX, Bechstein Digital Grand, Ivory, Galaxy et beaucoup d’autres pianos virtuels - Côté synthé : Roland A-500 Pro, Native-Instruments Komplete 12 - Arturia V Collection 7, Korg Legacy Collection, Air Music Technology plugins, OP-X Pro II, dexed (émulateur DX7 libre), Yamaha S-YXG50 - DAW : Reaper 6, Cubase Artist 9 - Interface audio : Steinberg UR22 -
                      Casque : AKG K-702

                      Commentaire


                      • #12
                        Pour une sorte de blague:

                        début HS

                        Tu es bon, mon cher Floyer !
                        Conversions de variables et autres tortuosités …
                        Pour beaucoup, ce doit être de l'ésotérisme profond et complètement abscons !! …

                        Il est clair que c'est un "sujet spécialisé",
                        mais autant qu'un sujet sur "les Moog", les "flancs", "pianotek", "les PA"… etc…

                        Donc AK est ouvert aux sujets très divers, et c'est très bien …

                        Fin du HS


                        C'était en mode "sténo", sinon ça ferait 3 pages !!b :shock: :bing:

                        Alain
                        Roland RD2000, Nord Piano 2 HP, KORG PA900
                        FocusRite Scarlett 6i6, Lucas Nano 300, 2xMonitors CM30,
                        MacBookPro + Logic Pro X + divers VSTs (AU), Zoom Q2n, Boss VE-5

                        Cheminer ou arriver: quel est mon but ? La musique est un chemin infini...

                        Commentaire


                        • #13
                          Concrètement, j'utilise surtout Python 3.5 soit avec Idle Python, mais aussi Anaconda que tu m'as fait découvrir.
                          Et j'ai téléchargé "Music21" tant dans sa version Mac que windows. A priori, il est nettement plus simple pour installer Music21 dans un PC que sous Mac sous Sierra. J'ai suivi ton indication, après avoir décompressé le fichier et cliqué sur le windows installer ce qui a pour effet d'installer (pour moi) la distribution dans le répertoire Anaconda3/Lib/site-package, j'ai inscrit dans la console ce que tu avais indiqué dans ton premier message "pip install music 21" et j'ai pu constater qu'a priori l'implémentation était réussie avec "in" et "out":

                          Ensuite, je me suis servi de ta copie d'écran avec les codes "Forte" notamment et ô plaisir ça a fonctionné :

                          En revanche, pour la version Mac, c'est nettement moins évident pour l'installation. J'ai suivi la procédure indiquée mais je me heurte au problème du password de l'ordinateur. Quand je lance l'implémentation via leur installateur, je vois bien s'effectuer une série de commandes dans la console mais au final Music21 n'est pas installée. Et la raison est simple, si pour lancer l'installation il faut indiquer "yes", il n'y a aucune demande pour insérer le password qui permet à l'ordinateur d'inscrire dans le système les changements. Mais comme j'ai vu qu'il y avait un groupe google sur Music21, je vais poser quelques questions.
                          En tout cas merci encore pour nous avoir signalé cet environnement qui tourne avec Anaconda.

                          Commentaire


                          • #14
                            Merci. Je préfère la solution round(x,2) qui fonctionne bien.
                            J'ai trouvé ça dans un tutoriel : http://python.lycee.free.fr/exemples.html
                            >>> round(12.456,1)# arrondi de 12.456 au dixième12.5
                            >>> a = 8.743159
                            >>> round(a, 2) # arrondi de a au centième
                            8.74
                            >>> round(a) # arrondi à l'unité
                            9
                            Ce qui me permet d'obtenir la précision que souhaite soit six chiffres après la virgule pour l'indice de progression et 2 après la virgule pour la fréquence Hz :

                            print ('i', i-1, 'p', round(p1,6), 'Hz =', round(f1,2))
                            i 7 p 1.498307 Hz = 391.99

                            HS : Je note que le l'accord 3-5 a sa page Wikipédia : https://en.wikipedia.org/wiki/Viennese_trichord
                            C'est un classique de la musique atonale, on le trouve quasiment dans toutes pièces de Schoenberg, Berg, Webern mais aussi en gestation chez Beethoven tout comme chez Thelonious Monk ou Dizzy Gillepsie. Ce dernier décline le 3-5 transposé successivement dans son thème "Sealt Penauts".
                            Dernière modification par deb76, 20 décembre 2016, 21h45.

                            Commentaire


                            • #15
                              J'aurais du préciser : taper pip install music21 sans les guillemets dans une fenêtre terminal en mode administrateur. Sur Mac, il faut taper dans la console sudo su pour passer administrateur (et taper son mot de passe). Sur Windows 10, taper cmd dans Cortona, cela affiche l'icône de Cmd en console. Au lieu de valider, clic droit de souris pour choisir de le lancer en mode administrateur. Si la commande pip n'est pas trouvé, la rechercher dans le répertoire d'Anaconda et taper le chemin en entier.

                              Mais comme cela marche chez toi (saisir une chaîne dans la console python ne fait que retourner cette chaîne), je pense que c'était déjà installé avec Anaconda. Ce serait curieux, ce n'est pas dans la liste : https://docs.continuum.io/anaconda/pkg-docs
                              Dernière modification par floyer, 20 décembre 2016, 23h07.
                              http://www.sinerj.org/~loyer/piano/

                              It's never too late to learn to play the piano. (tip of the day)

                              Côté piano : Yamaha CLP150, pianos VSL Syncron et Vienna Imperial, Garritan CFX, Bechstein Digital Grand, Ivory, Galaxy et beaucoup d’autres pianos virtuels - Côté synthé : Roland A-500 Pro, Native-Instruments Komplete 12 - Arturia V Collection 7, Korg Legacy Collection, Air Music Technology plugins, OP-X Pro II, dexed (émulateur DX7 libre), Yamaha S-YXG50 - DAW : Reaper 6, Cubase Artist 9 - Interface audio : Steinberg UR22 -
                              Casque : AKG K-702

                              Commentaire

                              Chargement...
                              X