|
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 |
// // // // création d'un regard avec l'utilisation de la // courbe de Bezier et la fonction ellipse // // Version de IDE:Processing 3.3.4 // RedOhm // H-Mazelin 12/07/2017 // Déclaration des variables // Une variable est une donnée que l'ordinateur va stocker dans l'espace de sa mémoire // Il existe différents type de variables: // dans notre exemple . // int =>Les nombres entiers peuvent être compris entre 2 147 483 647 à - 2 147 483 648 // float => pour les nombres à virgule flottante " qui posséde un point décimal " // Modification de la valeur du premier rayon de courbure de mes yeux int be1; // Modification de la valeur du deuxième rayon de courbure de mes yeux int be2; // Valeur de déplacement de mes yeux int deplace_x; // Intervalle aléatoire pour le clignotement des yeux float r; // Intervalle aléatoire pour le déplacement des yeux float deplacement_x; // 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,600); } //Le programme principal s’exécute par une boucle infinie appelée draw () void draw () { // ************* clignotement des paupieres **************************** // Fonction random(valeur_mini,valeur_maxi) // Cette fonction génère 1 nombre aléatoire. Chaque fois que cette fonction // est sollicitée dans le programme, le nombre aléatoire sera compris entre // la valeur mini et maxi fixée entre parenthèses r = random(1,20); if (r>5 && r<6 ) { // transfert des valeurs pour le clignotement des paupieres be1=180; be2=170; } else { // transfert des valeurs par defaut be1=160; be2=140; } // ******** fin du teste de clignotement pour les paupieres *********** // ************* deplacement des yeux **************************** // Fonction random(valeur_mini,valeur_maxi) // Cette fonction génère 1 nombre aléatoire. Chaque fois que cette fonction // est sollicitée dans le programme, le nombre aléatoire sera compris entre // la valeur mini et maxi fixée entre parenthèses deplacement_x = random(1,40); // La ligne ci-dessous teste si le nombre aléatoire est compris entre la valeur // 5 et 6 si tel est le cas nous transférons la nouvelle valeur dans la variable // "déplacent_x", ce qui nous permettra de faire bouger l’œil. if (deplacement_x>5 && 6<deplacement_x ) { // force la variable à 8 deplace_x= 8; } else { // force la variable à 0 deplace_x= 0; } // ************* fin deplacement des yeux **************************** // 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 background(0,0,0); // Définit la couleur utilisée pour remplir les formes. // dans notre exemple 255 = noir fill(255); // **************** Oeil gauche ************************* // bezier (ax,ay,c1x,c1y,c2x,c2y,bx,by); // ax,ay => definition du debut de la courbe // c1x,c1y => premier controle de courbure // c2x,c2y => deuxieme controle de courbure // bx,by => definition de la fin de la courbe // bezier(10,100, 50,50, 150,50, 190,100); bezier(300,176,350,be2,400,be1,450,200); bezier(300,176,350,230,400,220,450,200); // **************** Oeil droit ************************* // bezier (ax,ay,c1x,c1y,c2x,c2y,bx,by); // ax,ay => definition du debut de la courbe // c1x,c1y => premier controle de courbure // c2x,c2y => deuxieme controle de courbure // bx,by => definition de la fin de la courbe // bezier(10,100, 50,50, 150,50, 190,100); bezier(550,200,600,be1,650,be2,700,176); bezier(550,200,600,220,650,230,700,176); // Dessine une ellipse (ovale) à l’écran. Une ellipse de // même largeur et hauteur est un cercle. Les 2 premiers // paramètres définissent l’emplacement sur l’écran . // ellipse(a, b, c, d); // a => coordonnée x de l’ellipse // b => coordonnée y de l’ellipse // c => largeur de l’ellipse // d => hauteur de l’ellipse ellipse(380+deplace_x,193,35,35); ellipse(610+deplace_x,193,35,35); // Définit la couleur utilisée pour remplir les formes. // dans notre exemple le gris fill(128,128,128); ellipse(380+deplace_x,193,10,10); ellipse(610+deplace_x,193,10,10); // La fonction println () écrit sur la zone de la console, // le rectangle noir au bas de l'environnement de traitement. // Cette fonction est souvent utile pour regarder les données // générées par un programme. print("Valeur du nombre aleatoire pour le clignotement de yeux => "+ r); println(" Valeur du nombre aleatoire pour le deplacement des yeux => "+ r); // La fonction delay () arrête l'execution du programme pendant un temps spécifié. // Les délais sont spécifiés en millièmes de seconde. Par exemple, // le délai d' exécution (3000) arrête le programme pendant trois // secondes et le délai (500) arrête le programme pendant une demi-seconde. delay(100); } |
programme pour affiche une valeur audio
|
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 |
// // // // 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; AudioInput in; // declaration des variables son à virgule flottante float son; float son1; float son2; float son3; float son4; 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); in = minim.getLineIn(Minim.STEREO, 512); } //Le programme principal s’exécute par une boucle infinie appelée draw () void draw() { // 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); // 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*100; // Mise a l'echelle et augmentation de la valeur son2=son*50; // Mise a l'echelle et augmentation de la valeur son3=son*100; // ******** 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); // ******** Convertion d'une variable flottante en entier *********** // valeur_entier = int(valeur flottante * 1.4); // *********** 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); text("Mise à l'echelle " + son4 ,100,330); text("map (variable son3 , 1 , 40 , 0 , 10) ",400,330 ); // 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); 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); bezier(500,600,550,600-son1,600,600-son1,650,600); bezier(500,600,550,600+son2,600,600+son2,650,600); } void stop() { minim.stop(); super.stop(); } |