–
Mise à jour le 09/01/2024 : Ce code Processing est une démonstration de l’intégration de la bibliothèque audio Minim, utilisée pour créer une visualisation interactive basée sur les entrées audio. Ce projet illustre la transformation des signaux sonores en éléments visuels dynamiques dans l’environnement de programmation Processing
Sommaire :
- Présentation de la fonction Minim
- Configuration de la fonction Minim
- Utilisation de la valeur mise à l’échelle dans la gestion des formes
- Tutoriel : Manipulation Audio et Effets Visuels avec Processing
- Retour au menu
Présentation de la fonction |
Le logiciel de création multimédia Processing, permet de dessiner et réaliser des animations en deux et trois dimensions , il peut aussi créer des œuvres sonores et visuelles. Concevoir un programme qui permet d’interagir avec l’environnement devient très intéressant pour les personnes qui travaillent sur la robotique ou la domotique. Incorporez la notion de son dans un programme nous ouvre une autre dimension, une interactivité sans précédent, imaginez parler à votre écran et qu’une image informatique vous réponde en bougeant les lèvres là, ça devient beaucoup plus séduisant et beaucoup plus excitant. Dans cette rubrique nous allons voir comment récupérer le son, utilisez le son pour générer cette interactivité.
Pour ajouter une source sonore à notre programme il nous faut pour cela exploiter l’entrée microphone et ou la sortie sonore, nous allons donc utiliser la librairie Minim qui nous permet de rentrer dans cette nouvelle dimension.
Cette rubrique par ses tutoriels et ses exemples vont, je l’espère briser tous les tabous.
Configuration de la fonction Minim |
Lancer votre programme via le bouton Run ne suffit pas pour jouer un son avec Minim. Avant de pouvoir jouer un son, vous devez activer les fonctionnalités de gestion audio de Minim, son moteur audio. Minim doit demander un accès à la carte son de votre ordinateur pour traiter le son. Heureusement, Minim gère cette configuration interne automatiquement. Il suffit simplement d’initialiser Minim dans votre code pour qu’il soit opérationnel. Cependant, il est important de noter que si vous activez Minim, vous devez aussi prévoir de le désactiver à la fin de votre programme pour libérer les ressources audio et éviter les fuites de mémoire.
.
|
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 |
// // // Version de IDE:Processing 3.3.4 // RedOhm // H-Mazelin 25/12/2019 // instruction minimale pour le bon fonctionnement de la // bibliothéque son // Minim est une bibliothèque audio qui permet la manipulation // du son dans l’environnement Processing. import ddf.minim.*; // Création d'une variable qui contiendra le moteur Minim Minim minim; // La fonction setup () est exécutée une fois, lorsque le programme démarre. // Il sert à définir les propriétés d'environnement initiales telle que la // taille de l'écran et à charger des supports tels que des images et/ou des polices // au démarrage du programme. void setup() { // this entre parenthése dans ce code, sachez qu'il sert à indiquer à Processing // que vos instructions s'appliquent à ce programme. // l'instruction Minim a besoin de connaître l'adresse de votre programme pour le // faire communiquer avec la carte son de notre ordinateur minim = new Minim(this); } //Le programme principal s’exécute par une boucle infinie appelée draw () void draw () { } // ***************Procedure d'arret ************************ // il faut prévoir d'arréter la capture du son ainsi que la librairie // minim a la fin de l'execution du programme void stop() { minim.stop(); super.stop(); } |
.
Retour au sommaire
Utilisation de la valeur dans la gestion des formes |
|
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 |
// Partie du programme traitant des formes // // // ********** utilisation des parametres audio ******************* // pour activer la courbe de bezier // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Affectation de la valeur audio " , 500,500); text("aux paramétres de la courbe de " , 500,520); text(" Bezier " , 500,540); // Pour dessiner une courbe de bézier, il faut définir quatre // points avec chaque fois 2 valeurs (x,y) . La première et la // dernière définiront le début et le fin de la courbe. Les deux // points intermédiaires définiront les contrôles de courbe // // bezier (ax,ay,c1x,c1y,c2x,c2y,bx,by) // ax,ay => définition du début de la courbe // c1x,c1y => premier contrôle de courbure // c2x,c2y => deuxième contrôle de courbure // bx,by => définition de la fin de la courbe bezier(500,600,550,600-son1,600,600-son1,650,600); bezier(500,600,550,600+son2,600,600+son2,650,600); } |
Tutoriel vidéo |
.
Le programme commence par intégrer la bibliothèque Minim, un outil puissant pour la manipulation du son dans Processing. Une fois la bibliothèque importée, le code initialise Minim et configure une connexion d’entrée audio, permettant ainsi au programme de recevoir des données sonores en temps réel.
Le cœur du sketch repose sur la capture des niveaux sonores à travers l’objet AudioInput, représenté par la variable in. Cette entrée sonore est ensuite analysée et transformée en plusieurs variables à virgule flottante (son, son1, son2, son3, son4). Chacune de ces variables subit une série de transformations, comme la mise à l’échelle, pour adapter les données sonores aux besoins visuels du sketch.
Une partie intéressante du programme est la conversion d’une de ces variables flottantes en une valeur entière (son5_entier), illustrant comment les données sonores peuvent être manipulées et préparées pour différentes applications visuelles.
Le sketch utilise ensuite ces données audio traitées pour influencer visuellement deux principaux éléments graphiques : un rectangle et une courbe de Bézier. Le rectangle change de taille en fonction des variations sonores, créant un effet visuel dynamique qui réagit en temps réel au son capté. Les courbes de Bézier, quant à elles, utilisent les valeurs sonores pour ajuster leurs points de contrôle, créant un effet visuel qui représente la fluidité et la dynamique du son.
Le programme est conçu avec un souci du détail, incluant des commentaires utiles pour guider les utilisateurs à travers chaque étape du processus, de l’initialisation de la bibliothèque Minim à la construction des éléments visuels. La section draw() du programme, où se déroule l’animation, est structurée de manière à refléter clairement comment les données sonores sont transformées en visuels.
.
.
|
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 |
// Version de IDE:Processing 3.3.4 // RedOhm // H-Mazelin 26/07/2017 // Au sommaire // // Integration de la bibliothéque // Configuration de la fonction minim // Mise à l'echelle de la valeur sonore // Utilisation de la valeur // Minim est une bibliothèque audio qui permet la manipulation // du son dans l’environnement Processing. import ddf.minim.*; // Création d'une variable qui contiendra le moteur Minim Minim minim; // Un AudioInput est une connexion à la source d'enregistrement // actuelle de l'ordinateur. AudioInput in; // declaration des variables son à virgule flottante float son; float son1; float son2; float son3; float son4; // creation d'une variable son5_entier int son5_entier; // La fonction setup () est exécutée une fois, lorsque le programme démarre. // Il sert à définir les propriétés d'environnement initiales telles que la // taille de l'écran et à charger des supports tels que des images et des polices // au démarrage du programme. void setup() { // definition de la taile de la fenetre // syntaxe : size (Hauteur fenetre,largeur fenetre ) size(1000,800); // definition « this » dans ce programme, sachez qu'il sert à indiquer à Processing // que ces instructions s'appliquent à « ce » programme. Minim a besoin de connaître // l'adresse de « ce » programme pour le faire communiquer avec la carte son de // votre ordinateur. minim = new Minim(this); // requête pour une entrée d'un certain taux d'échantillonnage in = minim.getLineIn(Minim.STEREO, 512); } //Le programme principal s’exécute par une boucle infinie appelée draw () void draw() { // *********** Présentation de l'exercice *************************** // // choix de la couleur du fond de la fenetre // syntaxe : background (rouge,vert,bleu ) // valeur du rouge de 0 à 255 iden pour les autre couleurs // affichage du fond de l'ecran en blanc background(255,255,255); // Fill : Définit la couleur utilisée pour remplir les formes. // fill(r,g,b); // r = pour rouge // g = pour le vert // b = pour le bleu fill(0,0,0); // Choix de la taille de la police // syntaxe => textSize( taille ) // Taille => La taille des caractères est en de pixels. textSize(32); // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Utilisation de l'entrée son " , 300,50); //*********** Récupération du niveau sonore ********************** // // transfert de la valeur du volume du canal audio // vers la variable son son=(in.mix.level()); // Mise a l'echelle et augmentation de la valeur son1=son*200; // Mise a l'echelle et augmentation de la valeur son2=son*100; // Mise a l'echelle et augmentation de la valeur son3=son*100; // *********** Affichage de la valeur de remise à l'echelle ********* // // Choix de la taille de la police // syntaxe => textSize( taille ) // Taille => La taille des caractères est en de pixels. textSize(20); // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Valeur du son brute => "+ son , 100,200); text("Valeur du son avec un coef multiplicateur de 100 => "+ son1 , 100,230); // ******** Mise a l'echelle d'une valeur ********************** // // map(valeur, v_basse_e,v_haut_e,valeur_b_sortie,valeur_h_sortie) // valeur => valeur a etalonner // v_basse_e => limite inférieure de la plage actuelle de la valeur // v_haute_e => limite supérieure de la plage actuelle de la valeur // valeur_b_sortie => limite inférieure de la plage cible de la valeur // valeur_h_sortie => limite supérieure de la plage cible de la valeur son4=map(son3,1,40,0,10); text("Mise à l'echelle " + son4 ,100,330); text("map (variable son3 , 1 , 40 , 0 , 10) ",400,330 ); // ******** Convertion d'une variable flottante en entier *********** // valeur_entier = int(valeur flottante * 1.4); son5_entier = int(son4 * 1.4); // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Conversion d'une variable flottante en entier => "+ son5_entier,100,360 ); // *********** Construction du rectangle *************************** // // Choix de la taille de la police // syntaxe => textSize( taille ) // Taille => La taille des caractères est en de pixels. textSize(16); // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Affectation de la valeur audio " , 100,540); text("aux paramétres du rectangle " , 100,560); // Dessine un rectangle à l’écran avec tous les angles à 90° // rect(a, b, c, d); // a => coordonnée x du rectangle // b => coordonnée y du rectangle // c => largeur du rectangle // d => hauteur du rectangle rect(100,600,20+son1,20+son1); // ********** utilisation des parametres audio ******************* // pour activer la courbe de bezier // Affichage d'un texte à l'écran // text (texte,x,y); // x => coordonnée x du texte // y => coordonnée y du texte text("Affectation de la valeur audio " , 500,500); text("aux paramétres de la courbe de " , 500,520); text(" Bezier " , 500,540); // Pour dessiner une courbe de bézier, il faut définir quatre // points avec chaque fois 2 valeurs (x,y) . La première et la // dernière définiront le début et le fin de la courbe. Les deux // points intermédiaires définiront les contrôles de courbe // // bezier (ax,ay,c1x,c1y,c2x,c2y,bx,by) // ax,ay => définition du début de la courbe // c1x,c1y => premier contrôle de courbure // c2x,c2y => deuxième contrôle de courbure // bx,by => définition de la fin de la courbe bezier(500,600,550,600-son1,600,600-son1,650,600); bezier(500,600,550,600+son2,600,600+son2,650,600); } // ***************Procedure d'arret ************************ // il faut prévoir d'arréter la capture du son ainsi que la librairie // minim a la fin de l'execution du programme void stop() { minim.stop(); super.stop(); } |
.
Retour au sommaire.