Author: Elyes T.

Projets

Le jeu du motus en python

MOTUS est à l’origine un jeu télévisé diffusé entre 1990 et 2019 sur France 2. Ce programme d’origine américaine s’inspire du jeu MasterMind, les lettres ayant remplacés les chiffres. Ce jeu a connu depuis de nombreuses variantes dont le célèbre WORDLE qui connait un très grand succès actuellement sur internet.

Introduction

Les règles du jeu sont plutôt simples : l’objectif est de trouver un mot d’un nombre fixé de lettres en au plus 6 essais. La première lettre du mot à découvrir est donnée et après chaque tentative :

  • les lettres communes et bien placées sont signalées par une case rouge
  • les lettres communes mais mal placées sont, quant à elles, signalées par une case jaune

Si le joueur parvient à découvrir le mot avant les 6 essais, il remporte la partie, sinon ce mot lui est dévoilé.

Certaines versions du jeu, dont WORDLE, se jouent à une personne, même si à l’origine le jeu télévisé se joue à deux. Dans la version à 2 joueurs, aux règles précédentes s’ajoutent les suivantes : un joueur perd la main si le mot proposé :

  • n’est pas de la bonne longueur
  • ne commence pas par la lettre proposée
  • est mal épelé
  • n’est pas donné dans les 8 secondes imparties
  • ne figure pas dans le dictionnaire
  • n’a pas été trouvé au terme des 6 essais

Dans chacun de ces cas, le joueur adverse récupère la main et bénéficie d’une lettre bonus : la première lettre non découverte lui est dévoilée. Il dispose alors du nombre d’essais restants (du joueur précédent) pour trouver le mot. Dans le cas ou il ne dispose que d’une tentative pour découvrir le mot, il conserve la main pour la grille suivante même en cas d’échec.

Notre projet est donc de programmer en langage python ce jeu. D’une part parce que nous aimons bien jouer à WORDLE (nous avons découvert le jeu original en visionnant une partie sur Youtube) et d’autre part car la programmation de ce jeu nous semblait accessible (pour notre niveau) sans être trop simple et offrait de nombreuses possibilités d’évolutions et améliorations (mode 2 joueurs, prise en compte de règles supplémentaires, interface graphique).

La première question qui s’est naturellement posée dès le départ concernait le choix de l’interface : en mode console ou plutôt avec une interface graphique ? Après une mure réflexion et avoir consulté plusieurs sites notamment de NSI, nous nous sommes rendus à l’évidence : une interface graphique nécessitait un passage obligé par le module tkinter particulièrement adapté à ce jeu. Et même si ce module semble accessible pour les novices que nous sommes, nous avons jugé plus prudent dans un premier temps, de travailler sur un jeu en mode console.

Après avoir réfléchi à la structure de notre programme, nous avons écrit ensemble les différentes fonctions que devra utiliser le jeu. Puis, comme il nous restait du temps, nous avons décidé de programmer à partir de ces fonctions, deux modes de jeu : un mode 1 joueur et un mode à 2. Nous nous sommes répartis le travail et chacun de nous a développé son propre mode et nous les avons assemblés dans le programme final.

Notre programme

Nous avons essayé de rester les plus fidèles au jeu original même si comme nous le verrons plus tard, nous n’avons pas implémenté toutes les règles présentées précedemment.

Concernant l’affichage, avant que le joueur ne fasse sa proposition, nous affichons en majuscules les lettres (bien placées) qui ont été découvertes jusque là (la première lettre étant donnée dès le départ), les lettres manquantes étant remplacées par un tiret. Puis après la saisie du mot, nous affichons en majuscule les lettres communes avec les mots à découvrir bien placées et en minuscule les lettres communes mal placées.

La partie : notre jeu offre la possibilité de jouer à un ou à deux . Après avoir sélectionner le nombre de joueur, la longueur du mot à deviner est demandé (entre 5 et 10 lettres). Puis dans le cas d’une partie à 2, le nombre de grilles de jeu sur lesquelles les adversaires souhaitent s’affronter est demandé. Dans le mode solo, chaque partie s’effectue sur une seule grille.

Les règles : dans la version 1 joueur pour qu’un essai soit validé, le mot proposé doit figurer dans le dictionnaire (et doit être bien orthographié), il doit commencer par la bonne lettre et doit être de la bonne longueur. Si le mot n’est pas valide, il est redemandé au joueur sans qu’il ne soit pénalisé par la perte d’un essai. Voici un exemple de partie :

Dans la version 2 joueurs, la main passe

  • dans chacun des cas précédents
  • au cas ou le mot n’est pas découvert au terme des 6 essais, auquel cas l’adversaire bénéficie d’une seule tentative pour découvrir le mot, mais conserve la main pour la grille suivante en cas d’échec.

Les fonctions

la fonction dico_n_lettres

def dico_n_lettres(dico):
#fonction qui crée une fois pour toute des dictionnaires
#de mots avec un nombre donné de lettres à partir d un
#fichier texte
   for n in range(1,25):
      path=os.getcwd()+'/'                   # définit le répertoire ou se trouve le ditionnaire
      dico1 = path+dico+".txt"               # fichier contenant le dictionnaire 
      dico2 = path+dico+str(n)+".txt"        # fichier qui contiendra le dictionnaire des mots à n lettres 
      fichier1 = open(dico1, "r")
      fichier2 = open(dico2, "w")
      for mot in fichier1:
          if len(mot) == n+1:                # n+1 car on doit tenir compte du caractère de retour à la ligne
              fichier2.write(mot)     
      fichier1.close()
      fichier2.close()

Nous avons récupéré sur le site https://www.lama.univsavoie.fr/pagesmembres/hyvernat/Enseignement/1415/info113/tp6.html deux dictionnaires sous la forme de fichiers .txt . Le premier contrairement au second contient les formes conjuguées des verbes et les pluriels des noms. La fonction précédente a pour but de créer une seule fois (ils sont installés sur le répertoire courant lors de la première exécution du programme), à partir du dictionnaire choisi, des dictionnaires constitués uniquement des mots de même longueur.

La fonction choisir_un_mot

def choisir_un_mot(dico,n):
#fonction qui va choisir aléatoirement un mot
#de n lettres
    path=os.getcwd()+'/'
    dico = path+dico+str(n)+".txt"
    fichier = open(dico, "r")
    liste_mots = fichier.readlines() # met tous les mots du fichiers dans une liste
    i = randint(1,len(liste_mots))
    mot = liste_mots[i]              # prend au hasard un mot dans la liste
    mot = mot.replace('\n','')       # supprime le caractère de retour à la ligne
    fichier.close()
    return(mot)

Cette fonction va utiliser le dictionnaire créé par la fonction précédente pour sélectionner aléatoirement un mot de n lettres qui servira de mot à deviner dans le jeu.

La fonction lettres_placées

def lettres_placees(liste1,liste2,liste3):
# fonction qui met dans liste1 les lettres 
# communes bien placées des liste2 et liste3
    liste = []
    liste0 = []
    for i in range(len(liste2)):
        if liste2[i]==liste3[i]:
            liste0.append(liste2[i])
        else:
            liste0.append('')
    for i in range(len(liste1)):
        if liste1[i]==liste0[i]:
            liste.append(liste1[i])
        else:
            liste.append(liste1[i]+liste0[i])
    return(liste)

Avec la fonction lettres_communes elles sont le cœur de notre programme. Cette fonction a pour but de mettre à jour la liste des lettres bien placées découvertes depuis le début de la partie. La variable liste1 contient la liste des lettres bien placées à mettre à jour et liste2 et liste3 les listes à comparer (le mot mystère et le dernier mot joué) et dont les lettres communes et bien placées vont être ajoutées à liste1.

La fonction lettres_communes

def lettres_communes(liste1,liste2):
# Retourne une liste avec toutes les lettres
# de la liste1 se trouvant dans la liste2
# les lettres bien placées sont en majuscule
# les autres sont en minuscule.
    liste = []
    liste3 = []
    for i in range(len(liste1)):
       liste.append('')
       liste3.append(liste2[i])
    for i in range(len(liste1)):
        if liste1[i]==liste3[i]:
            liste[i]=liste1[i].upper()
            liste3[i]=''
    for i in range(len(liste1)):
        for j in range(len(liste1)):
            if liste1[i]==liste3[j] and liste[i]=='':
                liste[i]=liste1[i].lower()
                liste3[j]=''
                break     
    return(liste)

Cette fonction est chargée de trouver les lettres communes entre liste1 et liste2, (qui représentent le mot joué et le mot à deviner) retournant ces lettres en majuscule pour les lettres bien placées et en minuscules pour les autres. Une des principales difficulté dans la conception de cette fonction a été la gestion des lettres dont le nombre d’apparition était différente dans les deux mots.

La fonction teste_mot

def teste_mot(liste,lettre,dico,n):
# Teste si le mot proposé par le joueur
# est valide : il doit commencer par 'lettre'
# se trouver dans dico et être de n lettres.
    test=True
    mot=''.join(liste).lower()   #transforme 'liste' en chaine de caractère en minuscule
    path=os.getcwd()+'/'
    dico = path+dico+str(n)+".txt"
    fichier = open(dico, "r")
    liste1 = fichier.readlines() # met tous les mots du dico dans une liste
    liste_mots=[]
    for mot1 in liste1:
        liste_mots.append(mot1.replace('\n',''))
    if  len(liste)!=n:                # teste si le mot est de la bonne longueur
       test=False
       print('Ce mot n est pas de la bonne longueur.')
    elif (mot not in liste_mots):     # teste si le mot est dans le dico
       test=False
       print('Ce mot n est pas dans le dictionnaire.')
    elif liste[0]!=lettre:            # teste si le mot commence par la bonne lettre
       test=False            
       print('Ce mot ne commence pas par la lettre '+lettre)
    fichier.close()
    return(test)

Cette fonction a pour but la validation (ou pas) de chaque mot entré par le joueur. Le mot est validé s’il commence par la bonne lettre, est constitué du bon nombre de lettres et se trouve dans le dictionnaire.

Les difficultés rencontrées

1. Pour la création et la gestion des dictionnaires nous nous sommes aidés du site https://python.sdv.univ-paris-diderot.fr/07_fichiers/ qui explique clairement les manipulations de base des fichiers (ouverture en mode lecture/écriture, fermeture, mise sous forme de liste de chaîne de caractères du contenu,…) et nous avons dû nous familiariser avec le module os pour indiquer le répertoire dans lequel se trouve les dictionnaires. Une des difficulté qui est apparue lors de la création des dictionnaires vient du fait que la longueur des mots ne correspondait pas à celle demandée (par exemple les mots de 5 lettres apparaissaient lorsqu’on en demandait 6. C’est après plusieurs tests que nous avons compris que le décalage venait du caractère ‘saut de ligne’ présent mais qui n’apparaissait pas quand on affichait les mots.

2. Pour la fonction « lettres_communes » la gestion des lettres dont le nombre d’apparition était différente entre les mots à comparer nous a aussi posé quelques problèmes. Pour y remédier, la solution que nous avons trouvé a été d’ « effacer » du mot à deviner une lettre commune une fois qu’elle a été trouvée (pour éviter de la recompter si elle apparaît une nouvelle fois dans le mot joué), en remplaçant la lettre en question par le caractère ‘ ‘. Alors que cette opération d’effacement s’effectuait en local (uniquement à l’intérieur de la fonction), la liste modifiée l’était également dans le programme principal. Pour régler le problème, nous avons décidé d’utiliser une liste intermédiaire, pour éviter de toucher à la liste passée en argument. Mais le résultat fut le même. Après quelques recherches sur internet, nous avons compris que le problème était inhérent aux listes et après plusieurs tentatives , nous sommes parvenus à régler le problème en passant par une liste auxiliaire créée non plus par une simple affectation mais en la remplissant grâce à une boucle et la commande .append().

3. Nous avons tenté de prendre en compte la gestion du temps, c’est-a-dire limiter à 10 s la durée de chaque essai mais la simple utilisation du module time ne donnait pas de résultat satisfaisant. En cherchant sur internet, nous avons vu qu’il était possible de créer un minuteur grâce au module threading mais après quelques essais cela s’est avéré plus compliqué que prévu et nous avons décidé de renoncer à cette fonctionnalité pour cette version mais nous espérons et envisageons de l’ajouter dans le futur.

Le fichier motus.py et les dictionnaires

Conclusion

Ce projet libre nous a permis de réaliser notre premier jeu en python. Après avoir longuement hésité, nous avons finalement opté pour MOTUS qui s’est finalement révélé très intéressant à programmer avec quelques challenges. Bien sûr, il reste encore beaucoup à accomplir pour se rapprocher du jeu original, notamment l’utilisation d’une interface graphique grâce au module tkinter ou encore la gestion du temps. Nous avions également pensé à intégrer des niveaux de difficulté en créant par exemple des dictionnaires adaptés (en associant à chaque mot un coefficient indiquant sa « difficulté » sur le même principe que le Scrabble). Toutes ces améliorations feront peut-être l’objet d’un futur projet.

Tutoriels

Faire du montage audio simplement avec Audacity

Que vous souhaitiez monter une interview, mixer vos réalisations musicales, ajouter une ambiance sonore à un récit ou même créer votre propre sonnerie de téléphone, vous serez amené à utiliser un logiciel de montage audio. Il en existe de très nombreux, payants ou gratuits, avec plus ou moins de fonctionnalités. Le logiciel Audacity que je vais utiliser et vous présenter à travers ce tutoriel est un des outils de montage le plus utilisé car il regroupe de nombreuses qualités : c’est un logiciel gratuit, disponible sur tous les systèmes d’exploitation (Windows, Mac OS, Linux) qui est à la fois simple d’accès et très complet ce qui en fait un outils prisé par les professionnels.

Plutôt que de faire une présentation d’Audacity au travers de toutes ses fonctionnalités ce qui donnerait lieu à un tutoriel aussi long que fastidieux au vu de la richesse du logiciel, j’ai préféré vous présenter les principales fonctionnalités à travers une mise en situation : je vais vous montrer comment réaliser un podcast simple, constitué d’une introduction musicale suivie du contenu du podcast, de la voix qui aura été au préalable enregistrée à l’aide d’Audacity, et qui se conclura par un autre morceau musical.

1. Présentation rapide de l’interface d’Audacity

Voici comment se présente l’interface graphique d’Audacity :

Cette interface se divise en trois parties :

  • un menu constitué des différents onglets donnant accès aux nombreuses fonctionnalités du logiciel par des menus déroulants
  • les barres d’outils (partie encadrée en bleu)
  • le plan de travail ou s’affichent les différentes pistes audio nécessaires au projet (partie encadrée en rouge).

Parmi les nombreuses barres d’outils détaillées ci-dessous, il y a :

  • en rouge : le lecteur avec les commandes classiques de lecture, pause, enregistrement,…
  • en jaune : la selection du nombre de canaux : 1=mono, 2=stéréo. Il est possible de choisir jusqu’à 32 canaux différents pour une même piste
  • en bleu : la barre des commandes de bases telles que « couper », « copier », « coller », « effacer », fonctions de zoom
  • en vert : la boite à outils qui regroupe les outils de sélection (pour sélectionner une portion de la piste), l’outil de retouche, l’outil d’enveloppe sur lequel je reviendrai plus tard
  • en mauve : le variateur de vitesse de lecture
  • les vu-mètres qui montrent (barres horizontales vertes) le niveau des signaux audio d’entrée/sortie
  • le réglage des niveaux sonores d’entrée/sortie (au-dessus du cadre bleu)

Enfin le plan de travail est constitué des différentes pistes audio nécessaires au projet. Voici à quoi ressemble une piste audio (mono).

La piste est elle même divisée en deux parties :

  • une large fenêtre dans laquelle apparaît la courbe (en bleu) du signal sonore (il y a autant de courbes que de canaux)
  • à droite de ce signal, une fenêtre regroupant des informations sur ce signal telles que le nombre de canaux, la fréquence d’échantillonnage (44,1 kHz par défaut ce qui correspond à un signal HiFi), des curseurs permettant de régler le niveau sonore et la balance entre la droite et la gauche c’est-à-dire la répartition entre la sortie droite et la sortie gauche (même si le signal est mono) et des options permettant de rendre la piste muette (« silencer ») ou au contraire de rendre toutes les autres muettes (« solo ») lors de la lecture simultanée de plusieurs pistes.

2. Enregistrement d’une voix avec Audacity

Audacity permet d’enregistrer un signal sonore en mono ou en stéréo. La stéréo est utile lorsque le champ sonore à capter est large, en pleine nature, ou que l’on souhaite capturer l’ambiance d’une salle en même temps que le spectacle qui s’y déroule. Dans le cas de la captation d’une simple voix (mon cas ici) un enregistrement en mono est suffisant. Il faut savoir que lors de l’exportation du projet finalisé celui-ci sera de toute façon automatiquement converti en stéréo. Pour procéder à l’enregistrement rien de plus simple :

  1. on sélectionne le nombre de canaux enregistrement (mono/stéréo) : mono dans mon cas
  2. on clique sur la touche d’enregistrement (le bouton avec un point rouge)
  3. une fois l’enregistrement terminé on clique sur la touche d’arrêt (le bouton avec un carré noir).

Nous obtenons la piste suivante d’une durée d’environ 34 secondes :

a. « Silencer » le début de l’enregistrement

Avant d’utiliser cet enregistrement en l’état, il faut procéder à quelle retouches dans le but d’en améliorer la qualité et de corriger d’éventuelles erreurs de diction.

Pour commencer zoomons sur le début du signal. Pour cela, il suffit de placer le curseur dans la zone que l’on souhaite agrandir (ici à 2 sec.) et de cliquer ce qui fera apparaître un trait noir vertical traversant la piste. En cliquant sur l’icone « zoom avant », le zoom (horizontal) s’effectuera autour de cette zone.

On voit que durant les deux premières secondes bien qu’elles correspondent à du silence, la courbe n’est pas parfaitement plate et que donc un léger bruit de fond subsiste. Cela est d’autant plus visible si l’on effectue un zoom vertical. Pour cela, il suffit de placer le curseur de la souris au niveau du 0.0 à droite de la piste audio. Celui-ci se transformera en loupe et en jouant sur la molette de la souris on pourra zoomer et dézoomer à volonté.

On voit clairement que la portion du signal située au dessus de la flèche verte est bruitée. Nous allons donc la remplacer par du silence. Cette opération se fait en deux temps. Tout d’abord, il faut sélectionner la partie à transformer. Pour cela, on positionne le curseur au début de la portion, puis on clique (pour tout le tutoriel « cliquer = cliquer sur le bouton droit ») et en maintenant le bouton appuyé, on sélectionne en se déplaçant vers la droite le morceau qui nous intéresse qui va alors prendre une teinte bleu clair. Pour terminer la sélection, il suffit de relâcher le clic de la souris. La deuxième étape consiste alors à cliquer sur l’icône « silencer » (encadré ci-dessous) pour transformer la sélection en silence comme on peut le constater sur les deux captures suivantes.

ce qui nous donne, après avoir utiliser la commande « silencer la sélection » (encadrée en rouge) la piste ci-dessous :

b. Corriger une erreur de diction

Lors de cet enregistrement, j’ai (volontairement) commis une erreur de diction en me trompant sur un mot , erreur que j’ai corrigée aussitôt en reprenant correctement cette fois le mot et en poursuivant ma lecture. Il est d’ailleurs conseillé lorsqu’on commet une erreur de ce type de se corriger et de continuer son enregistrement plutôt que de tout arrêter et tout reprendre à zéro ce qui peut être une source de stress d’autant plus importante que l’enregistrement est long. Audacity est un logiciel qui permet de rectifier après coup assez facilement ce type d’erreur comme nous allons le voir.

La première étape consiste à repérer la portion du signal dans laquelle se situe l’erreur. Pour cela, après une première écoute qui va nous permettre de repérer assez vaguement le passage en question, on va pouvoir sélectionner dans la réglette temporelle (barre graduée légèrement bleutée située juste au dessus de la piste) une fenêtre en procédant de la même manière que lorsqu’on a sélectionné un morceau de la piste sauf que cette fois-ci, il faut placer le curseur sur cette réglette. Une fois la fenêtre temporelle sélectionnée, celle-ci sera relue en boucle (il ne sera plus nécessaire de réécouter à chaque fois toute la piste. Ainsi en ajustant les bord de cette fenêtre temporelle, il devient facile d’isoler avec précision le passage qui nous intéresse (partie de la piste encadrée en rouge ci-dessous. Le flèche rouge indique la fenêtre temporelle correspondante.)

Pour supprimer ce passage, il faut commencer par le sélectionner mais il faut éviter d’effectuer un simple « couper » ou un « supprimer et raccorder » car au niveau du raccord il subsistera un petit bruit (il y a peu de chance que le raccord se fasse parfaitement et soit inaudible). Pour cela quelques manipulations sont nécessaires. Dans un premier temps, il faut lancer la commande « supprimer-séparer »

ce qui va avoir pour effet de supprimer le morceau désiré et de créer un espace vide à la place et de couper la piste en deux parties (on parle aussi de clips) distinctes.

L’étape suivante consiste à rapprocher les deux clips sans pour autant les coller. Pour cela, on va déplacer le clip de droite vers la gauche. Ce déplacement temporel aussi appelé ajustement temporel est une opération très commune et très simple qu’il est essentiel de maîtriser. Il suffit de placer le curseur sur la partie supérieur de la piste (zone plus claire que le reste de la piste) ; celui-ci prend alors la forme d’une main qui permet d’un simple double-clic de la souris de saisir la piste et de la déplacer horizontalement à sa guise . Dans notre cas, nous allons faire glisser cette piste pour la placer à 0,2 sec de la piste gauche. Pour les opérations suivantes, il peut-être nécessaire d’effectuer un zoom horizontal (x2 suffit) autour de la fin du clip de gauche et du début du clip de droite afin d’avoir plus de détails et ainsi d’être plus précis dans nos futures manipulations. Pour rendre la transition entre les deux morceaux parfaitement inaudible, on va sélectionner un cours laps de temps (quelques dixièmes de seconde) avant la fin de la piste de gauche puis réaliser un « fondu en fermeture » comme indiqué ci-dessous.

Puis de la même manière, on selectionne un cours pas de temps au début de la piste de droite et on réalise un « fondu en ouverture » :

Le but du fondu en fermeture c’est de diminuer la signal sonore jusqu’au silence (l’inverse pour le fondu en ouverture). Par ces quelques manipulations, nous avons supprimé notre erreur et récupéré une piste audio sans raccord audible.

c. Supprimer le bruit de fond

Un autre problème récurrent lors d’un enregistrement est qui peut entâcher la qualité du signal sonore est la présence de bruit de fond. Celui-ci peut avoir plusieurs origines (qui peuvent s’additionner) : matériel de captation de mauvaise qualité ou défectueux, bruit environnant comme le ventilateur du PC. Ce bruit, même léger, peut-être gênant et altérer la qualité de l’enregistrement surtout pendant les périodes de silence ou il sera le plus perceptible. Heureusement Audacity dispose d’une commande qui permet de réduire significativement ce bruit. La tâche est assez simple. Tout d’abord il faut sélectionner un morceau de la piste ne contenant que ce bruit de fond, c’est à dire une partie « silencieuse » (1 ou 2 sec. suffisent).

Ensuite, il faut cliquer sur l’onglet « Effets » puis dans le menu déroulant sélectionner « réduction de bruit ». La fenêtre suivante s’ouvrira :

cliquer alors sur « Prendre le profil du bruit » ce qui permettra à Audacity de savoir ce qu’il devra supprimer.

Retourner ensuite sur la piste et sélectionner cette fois-ci la totalité de la piste (placer le curseur à l’intérieur de la piste de double-cliquer : la totalité de la piste sera colorée en bleu ciel) puis recommencer l’opération précédente : Effets>Réduction de bruit et la fenêtre précédente s’ouvrira à nouveau. Cette fois-ci il faudra cliquer sur le bouton valider :

La totalité de la piste a été débruitée : même s’il n’a pas complètement disparu, le bruit a été significativement réduit comme on peut le constater sur le signal sonore ci-dessous que l’on peut comparer avec celui avant débruitage affiché plus haut.

3. Mixage de la musique d’introduction et du début du podcast

La plupart de podcasteurs débutent leur création par une brève introduction musicale (aussi appelée « jingle ») qui est en quelque sorte la signature du podcasteur. Pour ne pas déroger à la règle, nous allons ajouter en début de notre enregistrement vocal effectué précédemment, un jingle. La première étape va consister à importer un fichier musical (pour cette illustration, j’ai utilisé une musique libre droit).

a. Importation de la musique d’introduction

Le format du fichier importe peu car Audacity reconnait la plupart des formats audio. L’importation est une opération très simple qui s’effectue en quelques clics de souris comme le montre la capture ci-dessous :

Une fenêtre s’ouvre sur le répertoire dans lequel se trouve le fichier que l’on souhaite importer, dans mon cas le fichier Moon-Wisper.mp3

Une nouvelle piste constituée de deux sous-pistes (car le fichier importé est en stéréo) apparaît sous la piste de notre enregistrement : elle correspond à notre fichier musical.

Il est important de noter qu’il n’y a pas de différence à travailler sur une piste mono ou stéréo puisqu’en stéréo toute opération effectuée sur une des deux sous-pistes se répercutera automatiquement et de manière identique sur l’autre sous-piste.

b. Différentes stratégies de mixage

En présence de plusieurs pistes audio, toutes les pistes sont lues simultanément. Comme je souhaite débuter mon podcast uniquement par une introduction musicale de quelques secondes, je vais décaler la piste vocale (qui correspond à l’enregistrement effectué en première partie) de 10 sec pour que sa lecture ne commence que 10 sec plus tard. Pour cela, j’effectue un ajustement temporel comme expliqué dans la section 2.b.

A ce stade, si je lance la lecture à partir du début, on entend bien uniquement de la musique les dix premières secondes puis au-delà vient s’ajouter la voix ce qui bien sûr n’est pas satisfaisant. Il existe (au moins) trois façons de réussir une bonne transition entre le jingle initial et le début du podcast.

  1. On fait commencer la partie vocale juste après la fin du jingle
  2. La fin du jingle et le début du podcast se superposent quelques secondes avant que la musique ne s’arrête complètement.
  3. la troisième approche est similaire à la précédente sauf que la durée ou les deux pistes vont se superposer est un peu plus longue et que le mixage entre voix et musique est plus travaillé : on diminue le volume de la musique durant les moments de parole pour la remettre à son niveau nominal pendant les périodes de silence.

Dans les trois cas, pour que cette transition soit la plus harmonieuse possible et éviter un arrêt brutal de la partie musicale, on va être amené à utiliser l’outils d’enveloppe. Pour mettre en oeuvre cet outil, il suffit de cliquer sur l’icone encadré ci-dessous

Aussitôt chacune des pistes est encadrée par deux lignes bleues représentant les seuils minimal et maximal du volume sonore de chacune d’elles.

En positionnant le curseur sur la piste qui nous intéresse celui-ci prend la forme d’une paire de petits triangles qui se superposent. En cliquant sur la souris, vont apparaître deux paires de petits carrés blancs (un sur chacune des deux lignes bleues puis deux situés à la jonction des parties grises claires/foncées). Il est possible de déplacer verticalement ces carrés ce qui va avoir pour effet de modifier la courbure des lignes bleues et ainsi de modifier le volume sonore de la piste à partir de la position de ces carrés. Ces carrés jouent le rôle de balises que l’on peut poser à plusieurs endroits de la piste pour moduler sur une portion voire la totalité de la piste le volume sonore comme on peut le voir ci-dessous.

On peut se poser la question du rôle de la paire de carrées intérieurs. On a vu que les carrés extérieurs permettaient en courbant les lignes bleues de modifier le volume sonore qui ne peut dépasser le volume nominal. Le déplacement de ces carrés entraîne celui des carrés intérieurs. Néanmoins, il est possible de déplacer directement ces derniers et de les positionner au dessus de leur position initiale et ainsi d’augmenter le volume qui du coup sera plus élevé que le niveau nominal. On dispose donc de deux leviers nous permettant de diminuer le son (les carrés extérieurs) ou de l’augmenter (les carrés intérieurs).

Les mixages 1. et 2. étant assez proches, je vais directement présenté le second. Sur les 10 sec qui précèdent le début de la piste vocale, je vais conserver le niveau sonore musical durant les 8 premières secondes puis à partir de là diminuer celui-ci progressivement jusqu’à le réduire au silence à la quatorzième seconde soit 4 sec après le début du podcast. Pour cela, en utilisant l’outils d’enveloppe présenté juste avant, j’obtiens un simple fondu en fermeture de la piste musicale qui se termine après 14 sec.

Le mixage 3. toujours réalisé à l’aide de l’outils d’enveloppe permet d’alterner pendant les premières secondes du podcast la partie musicale et la partie vocale.

4. Mixage de la fin du podcast et du jingle final

Dans la dernière partie de ce tutoriel, nous allons voir comment terminer notre podcast grâce à l’ajout d’une musique finale. La démarche étant très similaire à l’ajout d’une introduction musicale présentée en détail dans la section précédente, je ne vais pas refaire un présentation aussi détaillée. Pour commencer, j’importe le fichier contenant le morceau qui va servir de jingle final. Même si, comme pour l’introduction musicale, on peut imaginer plusieurs transitions, je vais ici limiter mon choix à un simple fondu en ouverture (note : Audacity possède une fonction « fondu en ouverture » que nous avons utilisée dans la première section mais qui effectue un fondu très basique et moins poussé que ceux que nous avons et allons effectuer). Tout d’abord, je déplace (par ajustement temporel) le jingle final jusqu’à la fin de la piste vocale. Plus précisément, je place le début du jingle 3 sec avant la fin de l’enregistrement vocal.

Ensuite, à l’aide de l’outil d’enveloppe, en partant de zéro j’augmente progressivement le volume de la partie musicale jusqu’à atteindre le volume nominal 3 sec plus tard puis je laisse à ce niveau pendant 5 sec et enfin pour ne pas arrêter brutalement le jingle, j’effectue un dernier fondu en fermeture, toujours à l’aide de l’outils d’enveloppe et je laisse une période de silence de 2 sec au cas ou l’auditeur enchaîne avec la lecture d’un autre enregistrement.

En mettant bout à bout toutes les parties, voici le podcast dans son intégralité :

Voilà notre podcast terminé ! Il ne reste plus qu’à le convertir en un format reconnu par un lecteur audio comme le MP3. Audacity permet la sauvegarde d’un projet avec un format (.aup3) qui est propre au logiciel et qui permet d’y retravailler ultérieurement. Cependant ce format n’est pas reconnu et ne peut donc être lu par d’autres applications. Pour rendre le projet lisible par un lecteur audio, il faut le convertir (ou l’exporter) dans un format audio standard. Audacity permet l’exportation sous de nombreux formats :

certains garantissent une qualité (au moins) CD mais produisent des fichiers volumineux, d’autres sont des formats compressés avec une qualité audio moindre mais qui vont créer des fichiers de plus petite taille.

5. En conclusion

Audacity est un logiciel que j’ai découvert en cours de musique au collège. Depuis, je l’utilise occasionnellement pour faire du mixage audio. Lorsque j’ai dû me familiariser avec ce logiciel, j’ai trouvé de nombreux tutoriels sur internet mais tous ne faisaient que la description (plus ou moins détaillée) des différentes fonctionnalités, ce qui rendait leur lecture peu agréable. J’ai tenté de réaliser ici le tutoriel que j’aurais aimé lire pour pouvoir utiliser rapidement cet outils sans forcément passer par la lecture de fonctionnalités dont je n’aurais peut-être jamais l’utilité. Une mise en situation simple, juste pour démarrer et se familiariser avec les fonctions de base …

Art

Balles et ballons : les ballons du système solaire

Le premier projet de la classe de 1ère NSI est « Regard de géomètre ». Ce projet consiste en la création d’une image basée sur un ou plusieurs thèmes donnés. Pour notre image, on a choisi les thèmes astronomie et balles et ballons. Nous avons voulu représenter le système solaire mais en remplaçant les planètes et le Soleil par des balles et des ballons de différents sports.

Les étapes de création de notre image

Après avoir choisi nos thèmes et décidé de l’illustration que l’on souhaitait faire, nous avons commencé par le fond de notre illustration. Pour cela, on voulait un fond noir avec des étoiles représentées par des points blancs et de tailles différentes placées aléatoirement sur l’image. Cependant, les grosses étoiles à cause de leur couleur blanche, se voyaient trop par rapport aux plus petites. On a alors ajouté une couleur un peu plus grise pour les grosses étoiles mais on a gardé le blanc pour les petites. Pour faire cela, nous avons utilisé une instruction conditionnelle :

import turtle
import random
turtle.speed(0)
for i in range(150):
    turtle.penup()
  turtle.goto(random.randint(-640,640),random.randint(-350,350)) 
    turtle.pencolor("black")
    turtle.pendown()
    a=random.randint(1,5)
    if a<2:
        turtle.begin_fill()
        turtle.fillcolor("white")
        turtle.circle(a)
        turtle.end_fill()
    else:
        turtle.begin_fill()
        turtle.fillcolor("#e1e1df")
        turtle.circle(a)
        turtle.end_fill()

Ce qui donne avec le fond:

Tracé du ciel étoilé

Dans un second temps, nous avons choisi les balles que l’on voulait représenter puis nous les avons tracées chacune séparément pour avoir le rendu le plus fidèle possible. Les balles choisies sont:

  • la balle de tennis
  • le ballon de basket-ball
  • le ballon de rugby
  • la balle de base-ball

A l’origine, on voulait faire le ballon de football plutôt que la balle de base-ball mais le motif de ce ballon est un peu trop complexe à faire et n’apportait que peu d’intérêt pour notre script.

Script pour le tracé du ballon de basket :

import turtle
turtle.bgcolor("black")
turtle.begin_fill()
turtle.fillcolor("coral")
turtle.goto(0,-3)
turtle.circle(98)
turtle.end_fill()
turtle.penup()
turtle.goto(-97,93)
turtle.left(-73)
turtle.pendown()
turtle.pensize(5)
turtle.pencolor("black")
turtle.circle(100,150)
turtle.penup()
turtle.goto(-97,93)
turtle.left(180)
turtle.pendown()
turtle.circle(100,-150)
turtle.penup()
turtle.goto(-97,93)
turtle.right(107)
turtle.pendown()
turtle.forward(186)

Tracé du ballon de basket

Dans la dernière étape de la création de notre image, nous avons regroupé toutes nos créations (fond, balles et ballons) dans un même script et nous avons rajouté certaines fonctionnalités comme les ellipses ou l’effet d’ombre qui vous seront montrés plus loin. Mais, lors de ce regroupement, nous avons fait face à plusieurs problèmes notamment au positionnement des balles et également à leur proportion (un ballon de basket ne peut pas être plus petit qu’une balle de tennis). Pour cela, on a effectué une suite d’essai-erreur jusqu’à ce que le résultat nous plaise.

Rendu final

Les fonctions utilisées dans le script

La première fonction importante de ce script est la fonction « orbite ». Elle consiste en la création d’une « fausse ellipse » à l’aide de 4 arcs de cercles de rayons différents. Cette fonction est plutôt simple mais extrêmement efficace.

def orbite(rayon):
  turtle.seth(-45) 
  for i in range(2):
      turtle.circle(rayon,90)
      turtle.circle(rayon/2,90)
  return()

La deuxième fonction marquante de ce script est la fonction permettant de créer un effet d’ombre sur les balles et ballons ayant une forme circulaire. Pour cela, il faut créer un dégradé de couleur formé à l’aide de cercles de plus en plus petits dont la couleur varie en même temps que le rayon diminue. Cette fonction s’appelle « surface ».

def surface(couleur,rayon,posx,posy):
    r=couleur[0]
    g=couleur[1]
    b=couleur[2]
    turtle.pensize(5)
    for i in range(51):
        turtle.home()
        turtle.goto(posx,posy)
        turtle.pendown()
        if ((r-i*1.5)>=0) and ((g-i*1.5)>=0) and ((b-i*1.5)>=0):
            r1=r-i*1.5; g1=g-i*1.5; b1=b-i*1.5;
        elif ((r-i*1.5)<0): r1=r
        elif ((g-i*1.5)<0): g1=g
        else: b1=b
        turtle.pencolor((r1/255,g1/255,b1/255))
        turtle.circle((100-2*i)*rayon)
        turtle.penup()

Enfin, la dernière fonction est la fonction étoile, elle permet comme son nom l’indique de tracer des étoiles de taille et avec un nombre de branches variables. Elle a pour paramètres le nombre de branches et la longueur des branches.

def etoiles(branches, longueur):
    turtle.begin_fill()
    turtle.fillcolor("white")
    for i in range(branches):
        turtle.forward(longueur)
        turtle.right(180+180/branches)
        turtle.forward(longueur)
        turtle.left(180-180/branches)
    turtle.end_fill()

Malheureusement, cette fonction a un défaut que l’on n’a pas su régler. Lorsque l’on choisit un nombre pair de branches, le nombre n’est pas respecté.

Exemple: lorsque l’on exécute etoiles(6,100). Le nombre de branches n’est pas correct.

Alors que lorsqu’on veut faire une étoile avec un nombre de branches impair, le nombre de branches est respecté.

Exemple: lorsque l’on exécute etoiles(9,100). Le nombre de branches est correct.

Problèmes rencontrés

Lors de la création de notre script, nous avons rencontré plusieurs problèmes comme le positionnement des balles ou encore la proportion des ballons mais également des problèmes qui survenaient lorsqu’on voulait créer une image. Ce problème venait de la commande bgcolor(). Cette fonction consiste à colorier le fond de la toile par la couleur de son choix. Cependant, sur le script nous permettant de créer nos images, le fond n’apparaissait pas. Pour résoudre ce problème, nous avons rajouté au script une boucle faisant des allers-retours sur la toile à l’aide d’un stylo épais permettant de créer manuellement ce fond.

turtle.goto(-760,400)
turtle.pensize(10)
turtle.right(90)
for i in range(75):
    turtle.forward(420*2)
    turtle.left(90)
    turtle.forward(10)
    turtle.left(90)
    turtle.forward(420*2)
    turtle.right(90)
    turtle.forward(10)
    turtle.right(90)

Conclusion sur notre premier projet en NSI

Ce premier projet nous a permis d’approfondir nos connaissances en turtle et de créer notre premier « gros script » de cette année en python en faisant appel à toutes les fonctions vues en cours. Nous aurions pu essayer d’apporter des améliorations avec un peu plus de temps en ajoutant par exemple d’autres balles plus complexes comme la balle de golf.

Télécharger le .py

L’image finale