Bonjour à tous!

Je viens vers vous parce que je cherche à pouvoir lancer plusieurs sons (pour l'instant j'essaie déjà avec 2) en fonction de la quantité de mouvement d'une image capturée par une webcam. J'utilise pour ça le frame differencing. Pour essayer d'être plus claire, j'aimerais qu'en fonction de la différence de pixels entre l'image capturée par la webcam et celle qui la précède, un son se lance. Peu de mouvement capturé, le son 1 se lance. Si plus de mouvement est capturé, le son 2 est lancé, et se superpose au précédent.
J'essaie donc d'attribuer une sorte de seuil via averagemove à mon son 1 et mon son 2, mais c'est là où je bute... Pour l'instant, les deux sons se lancent en même temps.

(J'essaie d'appliquer le même principe pour stopper les sons, mais si ça coince dans un sens forcément ça coince aussi dans l'autre.)

Si quelqu'un a une idée pour me faire avancer...
J'espère ne pas être trop confuse (je débute je débute)

Voici le code :

import processing.video.*;
Capture video;

//Librairie minim
import ddf.minim.*;
AudioPlayer[] player;
Minim minim;
int numberOfsongs;
int currPlayer;

boolean playing=false;

// les premiers frames produisent beaucoup de differencing
// une moyenne négative évite un déclenchement au démarrage
float averagemove=-100000000;
int seuil=100000000; // seuil de déclenchement
int numPixels;
int[] previousFrame;

void setup() {
size(640, 480); // Change size to 320 x 240 if too slow at 640 x 480
// Uses the default video input, see the reference if this causes an error
video = new Capture(this, width, height);
video.start();
numPixels = video.width * video.height;
// Create an array to store the previously captured frame
previousFrame = new int[numPixels];
loadPixels();

minim = new Minim(this);
numberOfsongs = 2;
currPlayer = 0;
player = new AudioPlayer[numberOfsongs];
player[0]= minim.loadFile("son1.mp3");
player[1]= minim.loadFile("son2.mp3");
// play the file
player[currPlayer].pause();
fill(0,0,0); // couleur par defaut - noir
}

void draw() {
if (video.available()) {
   video.read(); // Read the new frame from the camera
   video.loadPixels(); // Make its pixels[] array available

   int movementSum = 0; // Amount of movement in the frame
   for (int i = 0; i < numPixels; i++) { // For each pixel in the video frame...
     color currColor = video.pixels[i];
     color prevColor = previousFrame[i];
     // Extract the red, green, and blue components from current pixel
     int currR = (currColor >> 16) & 0xFF; // Like red(), but faster
     int currG = (currColor >> 8) & 0xFF;
     int currB = currColor & 0xFF;
     // Extract red, green, and blue components from previous pixel
     int prevR = (prevColor >> 16) & 0xFF;
     int prevG = (prevColor >> 8) & 0xFF;
     int prevB = prevColor & 0xFF;
     // Compute the difference of the red, green, and blue values
     int diffR = abs(currR - prevR);
     int diffG = abs(currG - prevG);
     int diffB = abs(currB - prevB);
     // Add these differences to the running tally
     movementSum += diffR + diffG + diffB;

     // Save the current color into the 'previous' buffer
     previousFrame[i] = currColor;
   }

   // calcul d'une moyenne
   averagemove=((averagemove *20) + movementSum)/21;

   if(averagemove > 1500000) {
     player[0].play();
     println("demarre");
     playing=true;
     fill(0,0,0); // noir
   }
   
    if(averagemove > 2000000 && playing==true) {
     player[1].play();
     println("demarre");
     playing=true;
     fill(0,0,0); // noir
   }

     else if (averagemove==0 && playing==true) {
     println("stop");
     player[1].pause();
     averagemove=100;
   }

   rect(0,0,width,height);
}
}