I already transformed the image into a binary image and am using the OpenCV libary.

I've tried to work with the contour of the object, but didn't find a way to translate it from OpenCV examples like http://www.pyimagesearch.com/2016/02/08/opencv-shape-detection/ .

If anybody has an idea on where to start or just some code as an example, that would be great!

My Code so far :

import gab.opencv.*;
import processing.video.*;

Capture webCam;
OpenCV finalImgcv, cv2;
PImage finalImg,  temp;
boolean foreGExists = false;
ArrayList<Contour> contours;
Contour M;

void setup(){
  size(640, 480);
  String[] cams = Capture.list();


  webCam = new Capture(this, width, height, cams[0], 30); // = name=Vimicro USB2.0 Camrera,size=640x480,fps=30
  webCam.start();


}
void captureEvent(Capture webCam) {
    webCam.read();
    }

void draw(){

  image(webCam, 0, 0);
   if(foreGExists){
     set(0, 0, finalImg);
   }else{
     set(0,0, webCam);
   }
}


void keyPressed(){

  if( key == 'b' ){
    PImage temp = new PImage(640, 480);
    temp.loadPixels();
    temp.pixels = webCam.pixels;
    temp.updatePixels();
    finalImgcv = new OpenCV(this, temp);

  }

  if( key == 'f' ){
    finalImgcv.diff(webCam);
    finalImgcv.threshold(10);
    finalImg = finalImgcv.getSnapshot();
    contours = finalImgcv.findContours();
    println("found " + contours.size() + " contours");
    M = contours.get(0);

    foreGExists = true;
  }
}

I have borrowed this code for a school project. It creates a bouncing ball which you can control with you webcam by movements. Sometimes it works just fine, but there seem to be a bug saying

** (java.exe:9372): WARNING **: gstvideo: failed to get caps of pad nat:sink

And then the webcam won't stream. I stumbled upon a discussion with a similar problem, saying using loadPixels() and updatePixels - yet it did not remove the warning.

Below is the code

BackgroundBouncer.pde:

import processing.video.*;
import gab.opencv.*;
import java.awt.Rectangle;

Capture video;
OpenCV opencv;
Ball b;

void setup() {
    size(640,480, P3D); //setup screen size and uses OpenGL gfx driver
    frameRate(30);
    ellipseMode(RADIUS); //set ellipse mode to radius (center point)
    video = new Capture(this, width/2, height/2);
    opencv = new OpenCV(this, width/2, height/2);
    b = new Ball();

    video.start();
    video.read();

    opencv.startBackgroundSubtraction(50,3,0.5); //detects moving objects

}

void draw() {
    clear();
    scale(2);
    loadPixels();
    opencv.loadImage(video); //
    opencv.flip(OpenCV.HORIZONTAL);
    opencv.updateBackground();
    opencv.calculateOpticalFlow(); //apparent motion between two frames caused by moving object or camera
    opencv.dilate(); //makes the image wider and look at neighbour pixels shape over which minimum is taken
    opencv.erode(); //erodes image and look at neighbour pixels shape over which minimum is taken
    noFill();stroke(255,0,0);
    strokeWeight(1);
    image(opencv.getOutput(), 0, 0);
    for (Contour c : opencv.findContours()) {
        Contour hull = c.getConvexHull();
        Rectangle box = hull.getBoundingBox();
        b.strike(c, opencv);
    }
    b.move();
    reflect(b);
    drawBall(b);
    updatePixels();

}

void keyPressed() {
    b.position = new PVector(120, 120);
    b.momentum = new PVector(0, 0);
}
void captureEvent(Capture c) {
  c.read();
}

And the Ball.pde:

float decayRate = 0.9; //how much decay
float scalingFactor = 7; //how big a ball
PVector gravity = new PVector(0, 0.5); //how heavy
class Ball {
  public Ball() {
    size = 25;
    shade = #FF0000; //red ball
    position = new PVector(120, 120); //start position
    momentum = new PVector(0, 0); //a moment of stillness
  }
  public PVector position;
  public PVector momentum;
  public float size;
  public color shade;
  public void move() {
    position.add(momentum);
    momentum.add(gravity);
    momentum.mult(decayRate);
  }
  public void strike(Contour c, OpenCV opencv) {
    for (PVector p : c.getPoints()) {
        if (p.dist(position) <= size) {
            Rectangle box = c.getBoundingBox();
            PVector flow = opencv.getAverageFlowInRegion(box.x, box.y, box.width, box.height);
            flow.mult(scalingFactor);
            momentum.add(flow);
            return;
        }
    }
  }
}

void drawBall(Ball b) {
    fill(b.shade);
    ellipse(b.position.x, b.position.y,
        b.size, b.size);
}

void reflect(Ball b) {
    if (b.position.x - b.size <= 0) {
        b.position.x = b.size;
        b.momentum.x *= -1;
    } else if (b.position.x + b.size > width/2) {
        b.position.x = width/2 - b.size;
        b.momentum.x *= -1;
    }
    if (b.position.y - b.size <= 0) {
        b.position.y = b.size;
        b.momentum.y *= -1;
    } else if (b.position.y + b.size > height/2) {
        b.position.y = height/2 - b.size;
        b.momentum.y *= -1;
    }
}

Any help or tips is welcomed! Thanks in advance.

// Click the mouse to memorize a current background image
import processing.video.*;
import gab.opencv.*;

// Variable for capture device
Capture video;
OpenCV opencv;

// Saved background
PImage backgroundImage;

// How different must a pixel be to be a foreground pixel
float threshold = 20;

void setup() {
  String[] cameras = Capture.list();
  //printArray(cameras);
  size(1280, 720);
  //video.width = 1280;
  //video.height = 720;
  video = new Capture(this, 1280, 720, cameras[76]);

  video.start();

  opencv = new OpenCV(this, 1280, 720);
  opencv.startBackgroundSubtraction(5, 3, 0.5);

  // Create an empty image the same size as the video
  backgroundImage = createImage(video.width, video.height, RGB);




}

void captureEvent(Capture video) {
  // Read image from the camera
  video.read();
}

void draw() {
  if (video.available() == true) {
    video.read();
  }
  image(video, random(width),random(height));

  opencv.loadImage(video);

  opencv.updateBackground();

  opencv.dilate();
  opencv.erode();

  noFill();
  stroke(255, 0, 0);
  strokeWeight(3);
  for (Contour contour : opencv.findContours()) {
    contour.draw();

}
}

void mousePressed() {

}

** **second code to combine with first one**** **

import processing.video.*;

Capture video;
int signal = 0;

//the buffer for storing video frames
ArrayList frames;

//different program modes for recording and playback
int mode = 0;
int MODE_NEWBUFFER = 0;
int MODE_RECORDING = 1;
int MODE_PLAYBACK = 2;

int currentX = 0;

void setup() {
  size(640, 480);

  // This the default video input, see the GettingStartedCapture 
  // example if it creates an error
  video = new Capture(this, width, height);

  // Start capturing the images from the camera
  video.start();  
}

void captureEvent(Capture c) {
  c.read();

  //create a new buffer in case one is needed
  if (mode == MODE_NEWBUFFER) {
    frames = new ArrayList();
    mode = MODE_RECORDING;
  }

  //record into the buffer until there are enough frames
  if (mode == MODE_RECORDING) {
    //copy the current video frame into an image, so it can be stored in the buffer
    PImage img = createImage(width, height, RGB);
    video.loadPixels();
    arrayCopy(video.pixels, img.pixels);

    frames.add(img);

    //in case enough frames have been recorded, switch to playback mode
    if (frames.size() >= width) {
      mode = MODE_PLAYBACK;
    }
  }
}

void draw() { 
  loadPixels();

  //code for the recording mode 
  if (mode == MODE_RECORDING) {
    //set the image counter to 0
    int currentImage = 0;

    //begin a loop for displaying pixel columns
    for (int x = 0; x < video.width; x++) {
      //go through the frame buffer and pick an image using the image counter
      if (currentImage < frames.size()) {
        PImage img = (PImage)frames.get(currentImage);

        //display a pixel column of the current image
        if (img != null) {
          img.loadPixels();

          for (int y = 0; y < video.height; y++) {
            pixels[x + y * width] = img.pixels[x + y * video.width];
          }  
        }

        currentImage++;

      } 
      else {
        break;
      }
    }
  }

  if (mode == MODE_PLAYBACK) {  

    for (int x = 0; x < video.width; x++) {
      PImage img = (PImage)frames.get(x);

      if (img != null) {
        img.loadPixels();
        for(int y = 0; y < video.height; y++) {
          pixels[x + y * width] = img.pixels[currentX + y * video.width];
        }  
      }
    } 

    currentX++;

    if(currentX >= video.width) {
      mode = MODE_NEWBUFFER;
      //reset the column counter
      currentX = 0;
    }
  }

  updatePixels();
}

So here is the deal : I have a pretty simple code, that basically displays the video from webcam feed, in pixels form. What I am trying to do is REPLACE each pixel by an image. Let's say I have 3 folders called : Blue Folder, Red Folder, Green Folder. In each folder I have 100 pictures. I want my code to randomly grab a picture in the folder in order to replace the pixel. So all red pixels will go grab pictures from the red folder. The results would look like a collage of hundreds of photos.

Do you think that is possible ? I have been on this for over 2 weeks and cannot figure it out :(

HERE IS MY BASIC CODE:

import processing.video.*;

int numPixels;
int blockSize = 10 ;
Capture video;
color collageColors[];

void setup() {
  size(displayWidth, displayHeight);
  noStroke();
  background(0);
  video = new Capture(this, displayWidth, displayHeight);
  numPixels = width / blockSize;
  collageColors = new color[numPixels * numPixels];
  video.start();
}

void captureEvent(Capture v) {
  v.read();
  v.loadPixels();

  for (int j = 0; j < numPixels; j++) {
    for (int i = 0; i < numPixels; i++) {
      collageColors[j*numPixels + i] = v.get(i*blockSize, j*blockSize);
    }
  }
}

void draw()  {

 if (video.available() == true) {
 video.read();
 image(video, 0, 0);
}

  for (int j = 0; j < numPixels; j++) {
    for (int i = 0; i < numPixels; i++) {
      fill(collageColors[j*numPixels + i]);
      rect(i*blockSize, j*blockSize, blockSize-1, blockSize-1);


    }
  }
}

This example was performed with camera(320,240) and its work nice but my canvas size is (1280,720) so the frameRate is getting very low near by 8 to 10fps and if i use camera with (640,480) then the feed is displaying twice seems like it duplicating.

i want to display my live feed in full resolution which is (1280,720) so how can i scale up my camera which is (640,480) to (1280,720) ? (frameRate can be better with that resolution?)

// Learning Processing
// Daniel Shiffman
// http://www.learningprocessing.com

// Example 16-13: Simple motion detection

import processing.video.*;
// Variable for capture device
Capture video;
// Previous Frame
PImage prevFrame;
// How different must a pixel be to be a "motion" pixel
float threshold = 50;

void setup() {
  size(1280, 720, P3D);
  video = new Capture(this, 640,480, 30);
  video.start();
  // Create an empty image the same size as the video
  prevFrame = createImage(video.width, video.height, RGB);
}

void captureEvent(Capture video) {
  // Save previous frame for motion detection!!
  prevFrame.copy(video, 0, 0, video.width, video.height, 0, 0, video.width, video.height); // Before we read the new frame, we always save the previous frame for comparison!
  prevFrame.updatePixels();  // Read image from the camera
  video.read();
}

void draw() {
  background(255);
  //pushMatrix();
  //scale(2.0);

  loadPixels();
  video.loadPixels();
  prevFrame.loadPixels();

  // Begin loop to walk through every pixel
  for (int x = 0; x < video.width; x ++ ) {
  for (int y = 0; y < video.height; y ++ ) {

//  for (int x = 440; x < 840; x ++ ) {
//   for (int y = 0; y < 400; y ++ ) {

      int loc = x + y*video.width;            // Step 1, what is the 1D pixel location
      color current = video.pixels[loc];      // Step 2, what is the current color
      color previous = prevFrame.pixels[loc]; // Step 3, what is the previous color

      // Step 4, compare colors (previous vs. current)
      float r1 = red(current); 
      float g1 = green(current); 
      float b1 = blue(current);
      float r2 = red(previous); 
      float g2 = green(previous); 
      float b2 = blue(previous);
      float diff = dist(r1, g1, b1, r2, g2, b2);

      // Step 5, How different are the colors?
      // If the color at that pixel has changed, then there is motion at that pixel.
      if (diff > threshold) { 
        // If motion, display black 
        
        pixels[loc] = color(0);
      } else {
        // If not, display white
        pixels[loc] = color(255);
      }
    }
  }
  updatePixels();
  
//popMatrix();

  stroke(255, 0, 0);
  rect(440, 0, 400, 400);
  surface.setTitle((int) frameRate + " motion");
}

how can i play alpha transparent video without P3D OR P2D render ?

any help will be good

Thanks.

mycode:

import processing.video.*;
Movie mov;
PImage img;

Capture cam;

void setup() {
  size(640, 480);
  frameRate(30);

  mov = new Movie(this, "../../../files/movie/Final.mov");
  mov.play();

  cam = new Capture(this, 640, 480);
  cam.start();
}

void draw() {

  background(0);
  image(cam, 0, 0);
  image(mov, 0, 0);

}

void movieEvent(Movie m) {
  m.read();
}
void captureEvent(Capture cam) {
  cam.read();
}

Any and all insight/ help would be greatly appreciated!!

` import processing.video.*;

// Variable for capture device
Capture video;

// A variable for the color we are searching for.
color trackColor; 

float threshold = 25;

void setup() {
  size(640, 360);
  String[] cameras = Capture.list();
  printArray(cameras);
  video = new Capture(this, cameras[3]);
  video.start();
  // Start off tracking for red
  trackColor = color(255, 0, 0);
}

void captureEvent(Capture video) {
  // Read image from the camera
  video.read();
}

void draw() {
  video.loadPixels();
  image(video, 0, 0);

  textSize(12);
  text("pick a tool, click the color, draw yourself a friend", 10, 30); 
  stroke(#FFFFFF);

  textSize(12);
  text("press space to save your sketch", 10, 330); 
  fill(#FFFFFF);  

  // XY coordinate of closest color
  float avgX = 0;
  float avgY = 0;

  int count = 0;

  // Begin loop to walk through every pixel
  for (int x = 0; x < video.width; x++ ) {
    for (int y = 0; y < video.height; y++ ) {
      int loc = x + y * video.width;
      // What is current color
      color currentColor = video.pixels[loc];
      float r1 = red(currentColor);
      float g1 = green(currentColor);
      float b1 = blue(currentColor);
      float r2 = red(trackColor);
      float g2 = green(trackColor);
      float b2 = blue(trackColor);

      // Using euclidean distance to compare colors
      float d = dist(r1, g1, b1, r2, g2, b2); // We are using the dist( ) function to compare the current color with the color we are tracking.

      if (d < threshold) {
        avgX += x;
        avgY += y;
        count++;
      }
    }
  }

  // We only consider the color found if its color distance is less than 10. 
  // This threshold of 10 is arbitrary and you can adjust this number depending on how accurate you require the tracking to be.
  if (count > 0) { 
    avgX = avgX / count;
    avgY = avgY / count;

    // Draw a circle at the tracked pixel
    fill(trackColor);
    noStroke();
    ellipse(avgX, avgY, 8, 8);
  }
}

void mousePressed() {
  // Save color where the mouse is clicked in trackColor variable
  int loc = mouseX + mouseY*video.width;
  trackColor = video.pixels[loc];
}

void keyPressed() {
  if (key == ' ') { //space bar
  saveFrame("picture-####.jpg");
  }
}

`

    import processing.video.*;
    import java.awt.Frame;
    import java.awt.Image;
    import java.text.*;

    Capture cam;
    Letter[][] drops;
    int dropsLength;
    PImage prevFrame;
    int sWidth = 1280;
    int sHeight = 720;

    String inputString = "Įsivaizduokime pasaulį, kur visi viską žino tiksliai, ir niekada neklysta. Niekam nekiltų abejoių, koks bus rytoj oras, kaip išsaugoti tirpstačius ledynus, ar koks visatos dydis. Žvelgiant į krentantį kamuoliuką kiekvienas galėtų pasakyti: -  O šito kamuoliuko kritimo greitis 6,325 m/s. -  Tikrai taip - atsakytų kitas. Ir viskas, daugiau nebebūtų jokių diskusijų, ieškojimų, matavimų. Su absoliučiu žinojimu gyvenimas taptų nebeįdomus, monotoniškas, tokiu atveju net progresas neįmanomas. Kai pradedu taip galvoti, džiaugiuosi nežinojimu, diskusijų galimybe, tiesos ieškojimu. Klaida suvokiama kaip neišvengiamas procesas teisybės ieškojime leidžia drąsiai žengti į praktikos sritį, nebijoti suklysti, o neteisingus procesus paversti progresu, žingsneliu link tikslo. Menininkas nebėra tas genijus, kuris turi sukurti kažką naujo, tarsi nežemiško, keičiančio visą mūsų suvokimą. Jo praktikos esmė eksperimentuoti ir klysti, organizuoti jau esamomis reikšmėmis ir kurti nau";
    char[] inputLetters;
    int dupStrings = 3;   //times to dublicate text
    int k = 800;
    float threshold = 50;

    void settings() {
      size(1280, 720);
    }
    void setup() {
      String[] cameras = Capture.list();

      drops = new Letter[dupStrings][inputString.length()];  //[inputString.length()]; 

      int wspace = 50;
      inputLetters = new char[inputString.length()]; 
      splitString();


      // first row hight
      int addLineHeight = 30;                                                       
      for (int i = 0; i < dupStrings; i++) {     
            for (int j = 0; j < inputLetters.length; j++) {   
                 if  (inputLetters[j] < k + wspace ){
                   Letter testLetter = new Letter(inputLetters[j]);
                   testLetter.x = wspace;
                   testLetter.y = addLineHeight;
                   drops[i][j] = testLetter;
                   wspace += 10;   //spaces between letters

                   // new row
                   if (wspace >= sWidth) {   
                                wspace = 10;
                               addLineHeight += 40; } // space between 

                    }
                           else {
                               addLineHeight += 50;
                                }
                                                                  }
                                               }
    // cam conect//

      if (cameras.length == 0) {
        println("There are no cameras available...");
        size(400, 400);
        exit();
      }
      else {
        cam = new Capture(this, sWidth, sHeight);
        cam.start();
        cam.loadPixels();
        prevFrame = createImage(cam.width, cam.height, RGB);

        size(sWidth, sHeight);
      }
      dropsLength = inputString.length();
    }

    void captureEvent(Capture cam) {
      // Save previous frame for motion detection!!
      prevFrame.copy(cam, 0, 0, cam.width, cam.height, 0, 0, cam.width, cam.height); 
      // Before we read the new frame, we always save the previous frame for comparison!```
      prevFrame.updatePixels();  // Read image from the camera
      cam.read();
    }


    void splitString() { 

      for (int i = 0; i < inputString.length() ; i++) {
        inputLetters[i] = inputString.charAt(i);
      }
    }

    void draw() {

        loadPixels();
      cam.loadPixels();
      prevFrame.loadPixels();
        // Begin loop to walk through every pixel
      for (int x = 0; x < cam.width; x ++ ) {
        for (int y = 0; y < cam.height; y ++ ) {

          int loc = x + y*cam.width;            // Step 1, what is the 1D pixel location
          color current = cam.pixels[loc];      // Step 2, what is the current color
          color previous = prevFrame.pixels[loc]; // Step 3, what is the previous color

          // Step 4, compare colors (previous vs. current)
          float r1 = red(current); 
          float g1 = green(current); 
          float b1 = blue(current);
          float r2 = red(previous); 
          float g2 = green(previous); 
          float b2 = blue(previous);
          float diff = dist(r1, g1, b1, r2, g2, b2);

          // Step 5, How different are the colors?
          // If the color at that pixel has changed, then there is motion at that pixel.
          if (diff > threshold) { 
            // If motion, display black
            pixels[loc] = color(0);
          } else {
            // If not, display white
            pixels[loc] = color(255);
          }
        }
      }

       //Responding to the brightness/color of the screen
       for (int i = 0; i < dupStrings; i++) {
        for (int j = 0; j < dropsLength; j++) {

          if (drops[i][j].y < sHeight && drops[i][j].y > 0) {   
           int loc = drops[i][j].x + ((drops[i][j].y)-1)*sWidth;                                           
           float bright = brightness(cam.pixels[loc]);                                                                                                                                                          
            if (bright > threshold) {   
              drops[i][j].dropLetter();
              drops[i][j].upSpeed = 1;
            }
            else {                                                                            
              if (drops[i][j].y > threshold) {
                int aboveLoc = loc = drops[i][j].x + ((drops[i][j].y)-1)*sWidth;
                float aboveBright = brightness(cam.pixels[aboveLoc]);
                if (aboveBright < threshold) {                                              
                  drops[i][j].liftLetter();
                  drops[i][j].upSpeed = drops[i][j].upSpeed * 5;                           
                }
              }
            }
          }
          else {
            drops[i][j].dropLetter(); 
          }

          drops[i][j].drawLetter();
          cam.updatePixels();
        }
      }
    }

    class Letter {
      int x;
      int y; 
      int m;
      char textLetter;
      int upSpeed;
      int alpha = 150;
      Letter(char inputText) {
        x = 100;
        y = 100;
        textLetter = inputText;
        textSize(16);
        upSpeed = 1;
      }
      void drawLetter() {
       // if ( m < 1) {
        fill(150, 150, 150 , alpha);                 
        text(textLetter, x, y);

      }

      void letterFade() {
        alpha -= 5;
        if(alpha <= 0) {
          y = int(random(-350, 0));
          alpha = 255; 
        }
      }


      void dropLetter() {
      //  y++;                         
        if (y > 730) {
          letterFade();
        }
      }

      void liftLetter() {
        int newY = y - upSpeed;       
        if (newY >= 0) {
          y = newY;
        }
        else {
          y = 0;
        }
      }
    }

Essentially, I am trying to take the colour tracking algorithm from Tutorial 11.5, and utilise the avgX variable to control the panning of a sine wave. My code is below...

// Daniel Shiffman
// http://codingtra.in
// http://patreon.com/codingtrain
// Code for: 

import processing.video.*;
import processing.sound.*;

SinOsc sine;
Capture video;

color trackColor; 
float threshold = 25;

void setup() {
  size(640, 360);
  String[] cameras = Capture.list();
  //printArray(cameras);
  video = new Capture(this, cameras[3]);
  video.start();
  trackColor = color(255, 0, 0);
}

void captureEvent(Capture video) {
  video.read();
}

void draw() {
  video.loadPixels();
  image(video, 0, 0);

  //threshold = map(mouseX, 0, width, 0, 100);
  threshold = 20;

  float avgX = 0;
  float avgY = 0;

  int count = 0;

  // Begin loop to walk through every pixel
  for (int x = 0; x < video.width; x++ ) {
    for (int y = 0; y < video.height; y++ ) {
      int loc = x + y * video.width;
      // What is current color
      color currentColor = video.pixels[loc];
      float r1 = red(currentColor);
      float g1 = green(currentColor);
      float b1 = blue(currentColor);
      float r2 = red(trackColor);
      float g2 = green(trackColor);
      float b2 = blue(trackColor);

      float d = distSq(r1, g1, b1, r2, g2, b2); 

      if (d < threshold*threshold) {
        stroke(255);
        strokeWeight(1);
        point(x, y);
        avgX += x;
        avgY += y;
        count++;
      }
    }
  }

  // We only consider the color found if its color distance is less than 10. 
  // This threshold of 10 is arbitrary and you can adjust this number depending on how accurate you require the tracking to be.
  if (count > 0) { 
    avgX = avgX / count;
    avgY = avgY / count;
    // Draw a circle at the tracked pixel
    fill(255);
    strokeWeight(4.0);
    stroke(0);
    ellipse(avgX, avgY, 24, 24);


  }
}

float distSq(float x1, float y1, float z1, float x2, float y2, float z2) {
  float d = (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) +(z2-z1)*(z2-z1);
  return d;

}

void mousePressed() {
  // Save color where the mouse is clicked in trackColor variable
  int loc = mouseX + mouseY*video.width;
  trackColor = video.pixels[loc];
}
  {
      sine = new SinOsc(this);
      sine.pan(map(avgX, 0, width, -1.0, 1.0));
      sine.play();
}  

The problem is that the variable avgX cannot exist outside the draw. It works if I place the Oscillator in Draw, but that causes a crash in a hurry!

Any help greatly appreciated!

Best, Matt

So for this code I'm trying to create a code that will use a live webcam feed and face tracking to put an image on top of the tracked face. After this point, I want to press a key ('n' in the code I posted below) and have it switch to a different picture. Right now as a base code I have processing's "LiveFaceTracking" example in my code. Any help you guys could give me would be greatly appreciated!

    import gab.opencv.*;
    import processing.video.*;
    import java.awt.*;
    PImage WD;
    PImage GJ;

    Capture video;
    OpenCV opencv;

    void setup() {
      size(640, 480);
      video = new Capture(this, 640/2, 480/2);
      opencv = new OpenCV(this, 640/2, 480/2);
      opencv.loadCascade(OpenCV.CASCADE_FRONTALFACE);
      video.start();

      loadImage("WD");
      loadImage("GJ");
    }

    void draw() {
      scale(2);
      opencv.loadImage(video);

      image(video, 0, 0 );

      noFill();
      stroke(0, 255, 0);
      strokeWeight(3);
      Rectangle[] faces = opencv.detect();
      println(faces.length);

      for (int i = 0; i < faces.length; i++) {
        println(faces[i].x + "," + faces[i].y);
        rect(faces[i].x, faces[i].y, faces[i].width, faces[i].height);
      }
    }

    void captureEvent(Capture c) {
      c.read();
    }

    void keyPressed(){
      if(key = 'n'){
        loadImage = WD;

final int kGlitchState=0;
final int kCamState=1;

int state=kCamState;


// ---------------------------------

final int kGlitchTimeLapse=7000;  // 2 secs
final int kCamTimeLapse=5000;    //8 secs
int triggerTime;

// ---------------------------------


import processing.video.*; 
Capture cam; 
Capture video;



void setup() { 
  size(1024, 768); 
  imageMode(CENTER);

  glitches = new ArrayList <GlitchClass>();
  for (int i=0; i<kTotalGlitches; i++)
    glitches.add(new GlitchClass());

  cam = new Capture(this);
  cam.start();
  triggerTime=millis()+kCamTimeLapse;
  img = cam;
  video = new Capture(this, width, height);
  video.start();
} 

void draw() { 

  if (millis()>=triggerTime) {

    if (state==kCamState) {
      state=kGlitchState;
      triggerTime+=kGlitchTimeLapse;
      currGlitch=int(random(kTotalGlitches));  //Select new glitch
    } else {
      state=kCamState;
      triggerTime+=kCamTimeLapse;
    }
  }

  if (state==kCamState)
    image(cam, width/2, height/2);
  else {
    background(0);
    glitches.get(currGlitch).display();
  }
} 


void captureEvent(Capture camera) {
  camera.read();

  img = createImage(width, height, RGB);
  video.loadPixels();
  arrayCopy(video.pixels, img.pixels);
}


//A glitch is just two ellipses overlapping on top of each other with different
//colors and one being rotated by 90 degrees.
class GlitchClass {

  void display() {

    loadPixels();

    int randPos = 0;
    if (frameCount  % 100 == 0)
      randPos = (int)random(0, video.height -4);

    int randPosY = 0;

    // if (frameCount  % 100 == 0)
    randPosY = (int)random(20, 50);

    // Begin a loop for displaying pixel rows of 4 pixels height
    for (int y = 0; y < video.height -57; y++) {
      if (img != null) {
        img.loadPixels();

        // Put 4 rows of pixels on the screen
        if (frameCount % 50 == 0)
          randPosY = (int)random(20, 50);
        for (int x = 0; x < video.width; x++) {
          if (frameCount % 100 == 0)
            randPosY = (int)random(20, 50);
          if (y < video.height -4) {
            pixels[x + (y + 0 + randPosY)* width] = img.pixels[  (y + 0 )* video.width + randPos + x];
            pixels[x + (y + 1 + randPosY) * width] = img.pixels[ (y + 1) * video.width + randPos + 1 + x];
            pixels[x + (y + 2 + randPosY) * width] = img.pixels[ (y + 2) * video.width + randPos + 2 + x];
            pixels[x + (y + 3 + randPosY) * width] = img.pixels[ (y + 3) * video.width + randPos + 3 + x];

            pixels[x + (y + 4 + randPosY)* width] = img.pixels[  (y + 4 )* video.width + randPos + 4 + x];
            pixels[x + (y + 5 + randPosY) * width] = img.pixels[ (y + 5) * video.width + randPos + 5 + x];
            pixels[x + (y + 6 + randPosY) * width] = img.pixels[ (y + 6) * video.width + randPos + 6 + x];
            pixels[x + (y + 7 + randPosY) * width] = img.pixels[ (y + 7) * video.width + randPos + 7 + x];
          }
        }
      } else {
        break;
      }
    }

    updatePixels();
  }
}

Thanks!

I need to use the createGraphics() function in order to hide the result of the captureEvent function and draw my spirals on the top of it, all the previous spirals should be visible. I can't make createGraphics work properly. Do I need two different objects?

Here's my code :

import processing.video.*;

Capture video;
PImage prev;

float threshold = 25;

float motionX = 0;
float motionY = 0;

float lerpX = 0;
float lerpY = 0;

int cnt = 0;

PGraphics p1;

Spiral spi = new Spiral();

void setup(){
  size(640, 480);

  p1 = createGraphics(width, height);
  p1.beginDraw();
  p1.colorMode(HSB, 360, 100, 100);
  p1.background(255);
  p1.noStroke();
  p1.endDraw();

  String[] cameras = Capture.list();
  printArray(cameras);
  video = new Capture(this, cameras[13]);
  video.start();
  prev = createImage(640, 480, RGB);

}

void draw(){
  video.loadPixels();
  prev.loadPixels();

  threshold = 50;
  int count = 0;
  float avgX = 0;
  float avgY = 0;

   loadPixels();
  // Begin loop to walk through every pixel
  for (int x = 0; x < video.width; x++ ) {
    for (int y = 0; y < video.height; y++ ) {
      int loc = x + y * video.width;
      // What is current color
      color currentColor = video.pixels[loc];
      float r1 = red(currentColor);
      float g1 = green(currentColor);
      float b1 = blue(currentColor);
      color prevColor = prev.pixels[loc];
      float r2 = red(prevColor);
      float g2 = green(prevColor);
      float b2 = blue(prevColor);

      float d = distSq(r1, g1, b1, r2, g2, b2); 

      if (d > threshold*threshold) {
        avgX += x;
        avgY += y;
        count++;
        pixels[loc] = color(255);
      } else {
        pixels[loc] = color(0);
      }
    }
  }
  updatePixels();

  if (count > 200) { 
    motionX = avgX / count;
    motionY = avgY / count;
  }

  lerpX = lerp(lerpX, motionX, 0.1); 
  lerpY = lerp(lerpY, motionY, 0.1); 


  spi.update();
  spi.display();

  if (cnt == 50 || cnt == 100) spi.reset();
  cnt += random(5);
  if (cnt >= 200) cnt=0;
}

void captureEvent(Capture video) {
  prev.copy(video, 0, 0, video.width, video.height, 0, 0, prev.width, prev.height);
  prev.updatePixels();
  video.read();
}

float distSq(float x1, float y1, float z1, float x2, float y2, float z2) {
  float d = (x2-x1)*(x2-x1) + (y2-y1)*(y2-y1) +(z2-z1)*(z2-z1);
  return d;
}

and my class :

class Spiral {
  float ang, radians;
  float x;
  float y;
  float size;
  PVector origin;
  float alpha, hue, sat;

  Spiral(){
    ang=0;
    radians=2;
    size = 10;
    origin = new PVector(width/2, height/2);
    alpha = 255.;
    hue = random(330);
    sat = random(30, 100);
 }

 void reset(){
  ang =0;
  radians =2;
  size = 10;
  alpha = 255;
  hue = random(330);
  sat = random(30, 100);
  origin = new PVector(lerpX, lerpY);
}

 void update(){
   x = origin.x + radians *sin(ang);
   y = origin.y + radians *cos(ang);
   ang += .4;
   alpha -= 1.3;
   radians += 0.5;

   size += 0.08;
   hue += 0.2;
}

  void display(){
    p1.beginDraw();
    p1.fill(hue, sat, 255, alpha);  
    p1.ellipse(x,y,size,size); 
    p1.endDraw();
  }
}

I'm trying to stitch images from frames of a webcam. Actually, I want to make a mosaic(or panorama) image, like shown on this videos:

https://youtu.be/aXYnAfZ4bD4?t=15s

https://youtube.com/watch?v=QapSxGnUWtY&t

I don't need to correct lenses, rotation or perspective. I only need to move the image in XY plane, like de first video. Even if I move only on X is ok for now.

So far, I was able to stitch 2 static images. But when I try to make this with a camera, something goes wrong :(

This is my code:

    import boofcv.processing.*;
    import boofcv.struct.image.*;
    import boofcv.struct.feature.*;
    import georegression.struct.point.*;
    import java.util.*;
    import processing.video.*;

    Capture video;

    PImage prevFrame;
    PImage current;

    int leu = 0;
    int c = 1;
    float avgX = 0;
    float avgY = 0;

    List<Point2D_F64> locations0, locations1;      // feature locations
    List<AssociatedIndex> matches;      // which features are matched together

    void setup() {

      size(600, 240);
      video = new Capture(this, 320, 240, 30);
      video.start();

      prevFrame = createImage(video.width, video.height, RGB);
      current = createImage(video.width, video.height, RGB);
    }
    void detectar() {
      SimpleDetectDescribePoint ddp = Boof.detectSurf(true, ImageDataType.F32);  //use SURF
      SimpleAssociateDescription assoc = Boof.associateGreedy(ddp, true);  

      // Find the features
      ddp.process(prevFrame);
      locations0 = ddp.getLocations();
      List<TupleDesc> descs0 = ddp.getDescriptions();

      ddp.process(current);
      locations1 = ddp.getLocations();
      List<TupleDesc> descs1 = ddp.getDescriptions();

      // associar os pontos
      assoc.associate(descs0, descs1);
      matches = assoc.getMatches();
    }

    void draw() {

      loadPixels();
      video.loadPixels();
      prevFrame.loadPixels();

      detectar();
      int count = 0;
      for ( AssociatedIndex i : matches ) {     
        if ( count++ % 20 != 0 )
          continue;
        else if ( count > 100)
        {       
          break;
        }

        Point2D_F64 p0 = locations0.get(i.src); 
        Point2D_F64 p1 = locations1.get(i.dst); 
        float diferencaX = abs((float) p0.x - (float)p1.x);
        float diferencaY = abs((float) p0.y - (float)p1.y);    

        if (leu < 30) {

          if (diferencaY < 15) {
            avgX = avgX + (diferencaX - avgX)/c;
            avgY = avgY + (diferencaY - avgY)/c;
            c++;  
          }
        }

        if ( leu == 29) {
          if (avgX > 300) {    
            translacao();
          }
        }
        leu++;
      }
    }

    void translacao() {
      image( prevFrame, 0, 0 );
      image( current, avgX, -avgY);
      updatePixels();
      println(avgX);
      c = leu = 0;
      avgX = avgY = 0;
    }

    void captureEvent(Capture video) {
      // Save previous frame for motion detection!!
      // Before we read the new frame, we always save the previous frame for comparison!
      if (avgX > 300) {
        prevFrame.copy(video, 0, 0, video.width, video.height, 0, 0, video.width, video.height); 
        prevFrame.updatePixels();  // Read image from the camera
      }
      video.read();
      current.copy(video, 0, 0, video.width, video.height, 0, 0, video.width, video.height); 
      current.updatePixels();
    }

I appreciate any help! Thank you!

How can I do? I have tried with image to resize the output but after how Can i "take" (I'm not english native speaker) the right pixel of the output to use for the color traking (and not the pixel of the low-res camera)?

thx

import processing.video.*; Capture webcam; int w=400; int h=400; int pixn=w*h; int keyhits; PImage img; int i= 0

void setup() { size(w, h); webcam = new Capture(this, 400, 400); webcam.start(); loadPixels(); }

void captureEvent(Capture webcam) { webcam.read(); } void draw() { image(webcam, 0, 0); }

void keyPressed() {

if ( key == '1' ) { save("capture" + ++keyhits + ".jpg"); }

img = loadImage("capture"+keyhits+".jpg"); int x = int(img.width); int y = int(img.height); float r = red(img.pixels[i]); float g = green(img.pixels[i]); float b = blue(img.pixels[i]);

for (int i=0; i<pixn; i++) { float sumar = sumar + red(img.pixels[i]); float sumag = sumag + green(img.pixels[i]); float sumab = sumab + blue(img.pixels[i]); }

float mediar = sumar / pixn); float mediag = sumag / pixn); float mediab = sumab / pixn);

if ( key == '2' ) { fill(mediar, mediag, mediab, 255); rect(0, 0, 400, 400); save("average_color"+ keyhits + ".jpg"); } }

import processing.video.*;

Capture video;



void setup() {
  size(640, 480);
  pixelDensity(1);
  frameRate(60);
  String[] cameras = Capture.list();
  printArray(cameras);
  video = new Capture(this, cameras[1]);
  video.start();
}

void captureEvent(Capture video) {
  video.read();
}



void draw() {

  video.loadPixels();
  image(video, 0, 0);
  grid();
}

void grid() {
  int square = 0;
  int nr = 20;
  int[] avg = new int[width * height];
  background(255, 0, 0);
  loadPixels();
  if (width % nr == 0 & height % nr == 0) {
    for (int s1 = 0; s1 < height; s1 += height/nr) {
      for (int s2 = 0; s2 < width; s2 += width/nr) {

        for (int x = 0; x < width/nr; x++) {
          for (int y = 0; y < height/nr; y++) {
            square = (x + y * width) + s1 * width + s2;
            avg[square] = int(brightness(get(x + s2, y + s1 * width)));
            pixels[square] = color(avg[square]);
          }
        }

      }
    }
    updatePixels();
  }
}

END

when i run this code it only shows me a black screen. I already tried the same code with just slightly changed for() loops

void grid() {
  int[] avg = new int[width*height]; 
  loadPixels();
  for (int x = 0; x < width; x++) {
    for (int y = 0; y < height; y++) {
      avg[x+y*width] = int(brightness(get(x,y)));
      pixels[x+y*width] = color(avg[x+y*width]);
    }
  }
  updatePixels();
}

and it worked 100% correct, so I assume the problem must be in the for() loops or how i used the variables s1 and s2, but I just can not find the mistake. Thanks in advance.

~sLucas

I don't know how to tell the position (x,y) of my image "train" (in draw section) in order to make my background ("fond" ) move .

Thanks in advance.

import processing.sound.*;
import gab.opencv.*;
import processing.video.*;
import java.awt.*;

Capture video;
OpenCV opencv;
int score = 5;
int temps;//la valeur du chronomètre

boolean depart;//commencer le compte à rebours (au clic)

float cx, cy;
boolean alive = true;
float trainX;
float trainY;


Rectangle[] faces;
Capture cam;

float x;
float y;
float easing = 1;


PImage fond;
PImage train;
PImage smiley;

void setup() {
  size(1000, 1000);

 video = new Capture(this, 640, 480);
  opencv = new OpenCV(this, 640, 480);

  opencv.loadCascade(OpenCV.CASCADE_FRONTALFACE);  
  video.start();
  faces = opencv.detect();

  fond = loadImage("Map.bmp");
  train = loadImage("train.gif");  
  smiley = loadImage("train.gif");

}

void draw() {
  scale (0.5);
  image(fond, x, y);
  scale(0.5);
  opencv.loadImage(video);
    imageMode(CENTER);

  // afficher l'image de la webcam 

  Rectangle[] faces = opencv.detect();
  for (int i = 0; i < faces.length; i++) {
   float x = faces[i].x + faces[i].width / 2;
    float y = faces[i].y + faces[i].height / 2;
    image(smiley, x, y, 300, 300);

}

float targetX = xtrain;
  float dx = targetX - x;
  x += dx * easing;

  float targetY = ytrain;
  float dy = targetY - y;
  y += dy * easing;


  //texte compte à rebours

  fill(#585858);
  text("TEMPS RESTANT :", 1170, 30);
  fill(#FF0000);
  text(temps, 1310, 30);
}



void captureEvent(Capture c) {
  c.read();
}

//fonction compte à rebours  
void compte_rebours() {
  if (depart ==true) {
    if (temps == 0 ) {
      temps = 0;
    }
    else {
      temps = 60 - millis()/1000; //compte à rebours à partir de 60
    }
  }
}  

void draw(){
line(pmouseX,pmouseY,mouseX,mouseY)
}

to draw the line however i dont know how i would get the blobs previous position. So far under the blob class in its show() function I am putting line(maxx,maxy) to start the line off in the corner of the blob which works (if you are confused I am following the tutorial in the link above) However I do no know what to do with the last coordinates or if I should try to do this in a different way. Any tips?

import processing.video.*;


Capture video;

color trackColor;
float threshold = 25;
float distThresh = 150;
ArrayList<Blob> blobs = new ArrayList<Blob>();

void setup() {
  size(640, 400);
  video = new Capture (this,640,480,30);
  video.start();
  trackColor = color(0,0,255);
}

 void captureEvent(Capture video){
   video.read();
 }


void draw(){
  video.loadPixels();
  image(video, 0, 0);

blobs.clear();


 for (int x=0; x< video.width; x++){
   for (int y =0; y < video.height; y++){
     int loc = x+y * video.width;

     color currentColor = video.pixels[loc];
     float r1 = red(currentColor);
     float g1 = blue(currentColor);
     float b1 = green(currentColor);
     float r2 = red(trackColor);
     float g2 = blue(trackColor);
     float b2 = green(trackColor);

     float d = dist(r1,b1,g1,r2,b2,g2);

     if (d < threshold){

       boolean found = false;
       for (Blob b : blobs){
         if(b.isNear(x,y)){
           b.add (x,y);
           found = true;
           break;

           }
         }

       if (!found){
        Blob b = new Blob(x,y);
        blobs.add(b);


       }
     }
   }
 }
 int i = 0;
 for (Blob b :blobs){
 if (b.size() > 500){ 
   b.show(i);
   i++;
     }
   }  
 }


 float distSq( float x1, float y1, float x2, float y2) {
 float d = (x2-x1)*(x2-y1) + (y2-y1)*(y2-y1); 
 return d;
}



void mousePressed(){
 int loc = mouseX + mouseY*video.width;
 trackColor = video.pixels[loc];
}

class Blob {

  float minx;
  float miny;
  float maxx;
  float maxy;

Blob(float x , float y) {

minx = x;
miny = y;
maxx = x;
miny = y;
}

void show(int num){
  stroke(0);
  fill(255,255,255,150);
  strokeWeight(2);
  rectMode(CORNERS);
  rect (minx,miny, maxx,maxy);

  textAlign (CENTER);
  textSize(64);
  fill(255);
  text(num, minx + (maxx-minx)*0.5, miny + (maxy-miny)*0.5);

}

void add(float x, float y){
  minx = min(minx,x);
  miny = min(miny,y);
  maxx = max(maxx,x);
  maxy = max(maxy,y);

}

 float size() {
    return (maxx-minx)*(maxy-miny); 
  }

boolean isNear(float x, float y){

  float cx =(minx+maxx)/2;
  float cy = (miny+maxy)/2;


  float d = distSq (cx,cy,x,y); 
  if (d< distThresh*distThresh){
   return true;
  } else{
   return false; 
  }
}

}

I am using my webcam, then I used the face tracker. I copied my face into a rectangle. What I want is my face (rectangle) is getting bigger and bigger within 2/3 minutes.

I hope somebody can help me with that! :)

Below is my code:

import gab.opencv.*;
import processing.video.*;
import java.awt.*;

Capture video;
OpenCV opencv;
PImage cam;

void setup() {
  size(640, 480);
  video = new Capture(this, 640/2, 480/2);
  opencv = new OpenCV(this, 640/2, 480/2);
  opencv.loadCascade(OpenCV.CASCADE_FRONTALFACE);  

  video.start();
}

void draw() {
  scale(2);
  opencv.loadImage(video);

  image(video, 0, 0 );

  noFill();
  stroke(0, 255, 0);
  strokeWeight(3);
  Rectangle[] faces = opencv.detect();
  println(faces.length);


  for (int i = 0; i < faces.length; i++) {
    println(faces[i].x + "," + faces[i].y);
    //rect(faces[i].x, faces[i].y, faces[i].width, faces[i].height);
    copy(cam, faces[i].x, faces[i].y, faces[i].width, faces[i].height, faces[i].x - faces[i].width/2, faces[i].y, faces[i].width * 2,             
faces[i].height);
  }
}

void captureEvent(Capture c) {
  c.read();
  cam = c.get();
}

import processing.video.*;

Capture video;

PImage prevFrame;

float threshold = 50;

void setup() {
  size(600,400);
  video = new Capture(this, 640, 480,30);
  video.start();
  ps = new ParticleSystem(new PVector(width/2, 50));
  prevFrame = createImage(video.width, video.height, RGB);
}

void captureEvent(Capture video) {
  prevFrame.copy(video, 0, 0, video.width, video.height, 0, 0, video.width, video.height);
  prevFrame.updatePixels();
  video.read();
}

void draw() {
  background(0);
  image(video, 0, 0);
  ps.addParticle();
  ps.run();
  loadPixels();
  video.loadPixels();
  prevFrame.loadPixels();

  float sumX = 0;
  float sumY = 0;
  int motionCount = 0;

  for (int x = 0; x < video.width; x++ ) {
    for (int y = 0; y < video.height; y++ ) {
      color current = video.pixels[x+y*video.width];

      color previous = prevFrame.pixels[x+y*video.width];

      float r1 = red(current);
      float g1 = green(current);
      float b1 = blue(current);
      float r2 = red(previous); 
      float g2 = green(previous);
      float b2 = blue(previous);

      float diff = dist(r1, g1, b1, r2, g2, b2);

      if (diff > threshold){
        sumX += x;
        sumY += y;
        motionCount ++;
      }
    }
  }

  float avgX = sumX / motionCount;
  float avgY = sumY / motionCount;


  smooth();
  noStroke();
  fill(0);
  ellipse(avgX, avgY, 16, 16);
}

  ParticleSystem ps;


class ParticleSystem {
  ArrayList<Particle> particles;
  PVector origin;

  ParticleSystem(PVector position) {
    origin = position.copy();
    particles = new ArrayList<Particle>();
  }

  void addParticle() {
    particles.add(new Particle(origin));
  }

  void run() {
    for (int i = particles.size()-1; i >= 0; i--) {
      Particle p = particles.get(i);
      p.run();
      if (p.isDead()) {
        particles.remove(i);
      }
    }
  }
}

class Particle {
  PVector position;
  PVector velocity;
  PVector acceleration;
  float lifespan;

  Particle(PVector l) {
    acceleration = new PVector(0, 0.05);
    velocity = new PVector(random(-1, 1), random(-2, 0));
    position = l.copy();
    lifespan = 255.0;
  }

  void run() {
    update();
    display();
  }

  void update() {
    velocity.add(acceleration);
    position.add(velocity);
    lifespan -= 1.0;
  }

  void display() {
    stroke(255, lifespan);
    fill(255, lifespan);
    ellipse(avgX, avgY, 8, 8);
  }

  boolean isDead() {
    if (lifespan < 0.0) {
      return true;
    } else {
      return false;
    }
  }
}

I have two pieces of code with one being able to detect motion and place a dot where it is detected and the other is a particle system and I am trying to place the particle system where movement is detected but I am unsure as to why it is not working, any help is appreciated!

We're working on our senior project and need help making rollovers stay on the screen once they've been rolled over. We're using basic mouseX and mouseY to define where the rollovers appear. The rollovers appear on top of a live camera feed taken from a webcam. We aren't too advanced and aren't using object oriented programming. We're not sure if the answer is a boolean or maybe a function? We just need a small example to put us in the right direction.

If there's any one who can help we'd greatly appreciate it :)

Here's a look at our code if it helps:

//-----------------------------------------------video stuff

import processing.video.*;
Capture video;

//-----------------------------------------------variables
//Instagram
PImage startscreen;
PImage bellatemp;
PImage celestetemp;
//Ccomments
PImage Ccomment1;
PImage Ccomment2;
PImage Ccomment3;
PImage Ccomment4;
PImage Ccomment5;
PImage Ccomment6;
PImage Ccomment7;
PImage Ccomment8;
PImage Ccomment9;
PImage Ccomment10;
PImage Ccomment11;
PImage Ccomment12;
PImage Ccomment13;


//Bcomments
PImage Bcomment1;
PImage Bcomment2;
PImage Bcomment3;
PImage Bcomment4;
PImage Bcomment5;
PImage Bcomment6;
PImage Bcomment7;
PImage Bcomment8;
//Directions
PImage pressB;
PImage pressC;
boolean clicked = false;//mouse clicked
boolean rPressed = false;//r key
PImage restart;
int rollover = 0;


//-----------------------------------------------setup
void setup() {

  size(1152, 864);
  smooth();
  //Video Camera
  video = new Capture (this, Capture.list()[0]);
  video.start();
  printArray(Capture.list());

  //load ALL images in setup
  startscreen = loadImage ("startscreen.png");
  //Templates
  bellatemp = loadImage ("bellatemp.png");
  celestetemp = loadImage ("celestetemp.png");
  //Ccomments
  Ccomment1 = loadImage ("Ccomment1.png");
  Ccomment2 = loadImage ("Ccomment2.png");
  Ccomment3 = loadImage ("Ccomment3.png");
  Ccomment4 = loadImage ("Ccomment4.png");
  Ccomment5 = loadImage ("Ccomment5.png");
  Ccomment6 = loadImage ("Ccomment6.png");
  Ccomment7 = loadImage ("Ccomment7.png");
  Ccomment8 = loadImage ("Ccomment8.png");
  Ccomment9 = loadImage ("Ccomment9.png");
  // Ccomment10 = loadImage ("Ccomment10.png");
  Ccomment11 = loadImage ("Ccomment11.png");
  Ccomment12 = loadImage ("Ccomment12.png");
  Ccomment13 = loadImage ("Ccomment13.png");

  //Bcommnets
  Bcomment1 = loadImage ("Bcomment1.png");
  Bcomment2 = loadImage ("Bcomment2.png");
  Bcomment3 = loadImage ("Bcomment3.png");
  Bcomment4 = loadImage ("Bcomment4.png");
  Bcomment5 = loadImage ("Bcomment5.png");
  Bcomment6 = loadImage ("Bcomment6.png");
  Bcomment7 = loadImage ("Bcomment7.png");
  Bcomment8 = loadImage ("Bcomment8.png");
  pressC = loadImage ("pressC.png");
  pressB = loadImage ("pressB.png");
  restart = loadImage ("restart.png");
}

void captureEvent(Capture video) {
  video.read();
}


//-----------------------------------------------draw
void draw() {

  image(bellatemp, 0, 0);
  image(celestetemp, 0, 0);
  image(restart, 0, 0);

  //Instagram
  image(pressC, 90, 750);
  image(pressB, 600, 750);
  image(video, 0, 0);
  image(startscreen, 0, 0);

  //boolean



  if (clicked)//bella or celeste
  {
    //background rect
    image(video, 0, 0);
    image(pressC, 90, 750);
    image(pressB, 600, 750);

    //line
    strokeWeight(15);
    stroke(#325d80);
    line(width/2, 0, width/2, height);
  }

  if (rPressed)
  {  
    image(startscreen, 0, 0);
  }
  if (key == 'c') 
  {
    //CAMERA
    image(video, 0, 0);
    image(celestetemp, 0, 0);
    image(restart, 0, 0);

    //ROLLOVERS

    if (mouseY>620 && mouseY<680)
    {
      image(Ccomment2, 0, 0);
    }
    if (mouseY>600 && mouseY<630)
    {
      image(Ccomment1, 0, 0);
    }
    if (mouseY>500 && mouseY<520)
    {
      image(Ccomment4, 0, 0);
    }
    if (mouseY>183 && mouseY<210)
    {
      image(Ccomment6, 0, 0);
    }
    if (mouseY>352 && mouseY<390)
    {
      image(Ccomment7, 0, 0);
    }
    if (mouseY>407 && mouseY<430)
    {
      image(Ccomment8, 0, 0);
    }
    if (mouseY>275 && mouseY<330)
    {
      image(Ccomment9, 0, 0);
    }
    if (mouseY>370 && mouseY<390)
    {
      image(Ccomment11, 0, 0);
    }
  }

  if (key == 'b')
  {
    image(video, 0, 0);
    image(bellatemp, 0, 0);
    image(restart, 0, 0);

    if (mouseY>250 && mouseY<275)

    {
      image(Bcomment1, 0, 0);
    }
    if (mouseY>285 && mouseY<340)
    {
      image(Bcomment2, 0, 0);
    }
    if (mouseY>426 && mouseY<460)
    {
      image(Bcomment4, 0, 0);
    }
    if (mouseY>480 && mouseY<510)
    {
      image(Bcomment5, 0, 0);
    }
    if (mouseY>500 && mouseY<525)
    {
      image(Bcomment6, 0, 0);
    }
    if (mouseY>550 && mouseY<578)
    {
      image(Bcomment7, 0, 0);
    }
    if (mouseY>618 && mouseY<655)
    {
      image(Bcomment8, 0, 0);
    }
  }
}


//-----------------------------------------------mouse pressed
void mousePressed()
{
  if (clicked==false) {
    clicked=true;
  }
  else
  {
    clicked = false;
    rPressed = false;
  }
}
//-----------------------------------------------key pressed

void keyPressed()
{

  if (key=='r') {
    rPressed=true;
  }
}

Thank you very much !

Arduino :

#include <NewPing.h>
#include <Servo.h>


#define TRIGGER_PIN  12  // Arduino pin tied to trigger pin on the ultrasonic sensor.
#define ECHO_PIN     11  // Arduino pin tied to echo pin on the ultrasonic sensor.
#define MAX_DISTANCE 200 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.

int LEDpin = 13;
Servo myservo;
int val;

NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance.

void setup() {
  Serial.begin(9600); // Open serial monitor at 115200 baud to see ping results.
  pinMode(LEDpin, OUTPUT);
  myservo.attach(9);// attaches servo to pin 9

}

void loop() {
  delay(400);                      // Wait 50ms between pings (about 20 pings/sec). 29ms should be the shortest delay between pings.
  unsigned int uS = sonar.ping(); // Send ping, get ping time in microseconds (uS).
  //Serial.print("Ping: ");
  Serial.println(uS / US_ROUNDTRIP_CM); // Convert ping time to distance in cm and print result (0 = outside set distance range)
  //Serial.println("cm");
  //if(uS / US_ROUNDTRIP_CM < 100) {digitalWrite(LEDpin, HIGH);}
  //else if (uS / US_ROUNDTRIP_CM > 100) {digitalWrite(LEDpin, LOW);}
 // else if (uS / US_ROUNDTRIP_CM > 100) {digitalWrite(LEDpin, LOW);}
  //delay (200);

  val = (uS / US_ROUNDTRIP_CM);
  val = map(val, 0, 172, 15, 180);
  myservo.write(val);
  delay (150);


}

PROCESSING

import gab.opencv.*;
import processing.video.*;
import java.awt.*;
//-------------------------------------------------
/*


*/
//-------------------------------------------------
Capture video;
OpenCV opencv;
//---
Movie monSuperFilm;// déclaration du film
float positionDuFilmEnSecondes;//position ds le film
Integer surfaceVisages,surfaceMin,surfaceMax;
//-------------------------------------------------
/*


*/
//-------------------------------------------------
void setup() {
  //----------------
  size(1080, 720);//dimensions de votre film en pixels; mettre la définition de votre film
  //-----------------
  // partie video cam
  //-----------------
  video = new Capture(this, 640/2, 480/2);
  opencv = new OpenCV(this, 640/2, 480/2);
  opencv.loadCascade(OpenCV.CASCADE_FRONTALFACE);  
  video.start();
  //-----------------
  // partie film
  //-----------------
    monSuperFilm = new Movie(this,"pattern1080-6low-1.mov");// chargement du film ; mettre le nom de votre film qui est dans le dossier data
    monSuperFilm.loop();
  //-----------------
  // partie visages
  //-----------------
  // plus la surface du visage est grande dans l'image retournée par la caméra du mac et plus on est près
  // le programme cumule les surfaces de tous les visages capturés par la caméra; à essayer à plusieurs devant le mac !
    surfaceMin=400;// min 0 //surface du visage sur la camera qui correspond au début du film
    surfaceMax=1500;// max 640x480=307200 //surface du visage sur la camera qui correspond à la fin du film
}
//-------------------------------------------------
/*


*/
//-------------------------------------------------
void draw() {
  //background(255);
  //scale(2);
  opencv.loadImage(video);

  //image(video, 0, 0 );

  //noFill();
  stroke(0, 255, 0);
  strokeWeight(3);
  Rectangle[] faces = opencv.detect();
  println(faces.length);
//---------------------------------------------
// calcul de la surface occupée par les visages
//---------------------------------------------
surfaceVisages=0;
  for (int i = 0; i < faces.length; i++) {
    //println(faces[i].x + "," + faces[i].y);
    //rect(faces[i].x, faces[i].y, faces[i].width, faces[i].height);
    surfaceVisages=surfaceVisages+faces[i].width*faces[i].height;
  }
  fill(0);
  text(str(surfaceMin)+" / "+str(surfaceVisages)+" / "+str(surfaceMax),10,50);
   monSuperFilm.read();//on lit l'image du film 
  positionDuFilmEnSecondes=map(surfaceVisages,surfaceMin,surfaceMax,0,monSuperFilm.duration()); 
  monSuperFilm.jump(positionDuFilmEnSecondes);// on se déplace dans le film
  image(monSuperFilm, 0, 0);//on affiche l'image courante du film

}
//-------------------------------------------------
/*


*/
//-------------------------------------------------
void captureEvent(Capture c) {
  c.read();
}

I need the particles to be affected by opticalflow values - i.e. move left and a right with the person in the video.

I can get the variable aveFlow.x each frame but can't run it through to each particle and change the vector x

full code:

import gab.opencv.*;
import processing.video.*;
import java.awt.*;

//Movie video;
Capture video;
OpenCV opencv;

// DECLARE
ArrayList ballCollection;

float numBalls = 2;

void setup() {
  size(640, 480);
  video = new Capture(this, width/4, height/4);
  opencv = new OpenCV(this, width/4, height/4);
  opencv.loadCascade(OpenCV.CASCADE_FRONTALFACE);  

  //INITIALIZE
  ballCollection = new ArrayList();

  video.start();
}

void draw() {
  //background(0);
  //scale(2);
  opencv.loadImage(video);
  opencv.calculateOpticalFlow();

  image(video, 0, 0, width, height);

  //translate(video.width, 0);
  stroke(255, 0, 0);
  //opencv.drawOpticalFlow();

  PVector aveFlow = opencv.getAverageFlow();
  int flowScale = 100;
  //float optX = aveFlow.x;

  stroke(255);
  strokeWeight(2);
  //line(video.width/2, video.height/2, video.width/2 + aveFlow.x*flowScale, video.height/2 + aveFlow.y*flowScale);
  line(width/2, height/2, width/2 + aveFlow.x*flowScale, height/2 + aveFlow.y*flowScale);

  //numberofballs
  if (ballCollection.size()<numBalls) {
    Ball myBall = new Ball(random(width), 0);
    ballCollection.add(myBall);
  }  

  //CALL FUNCTIONALITY
  for (int i = 0; i < ballCollection.size(); i++) {
    Ball mb = (Ball) ballCollection.get(i);
    mb.run();
  }
}

//void movieEvent(Movie m) {
//  m.read();
//}

void captureEvent(Capture c) {
  c.read();
}

class Ball {

  //global variables
  float x=0;
  float y=0;
  //float speedX = random(-2, 2);
  float speedX = 0;

  float speedY = random(-2, 2);

  //float optY = 0;

  //constructor
  Ball(float _x, float _y) {
    x= _x;
    y= _y;
    //optX = _optX*50;
  }

  //functions
  void run() {
    if (y<height) {
      display();
      move();
      //bounce();
      gravity();
      opticalFlow();
    }
  }

  void opticalFlow() {
    //speedX += aveFlow.x*flowScale;
  }

  void gravity() {
    speedY += 0.01;
  }

  void bounce() {
    if (x > width ) {
      speedX *= -1;
    }
    if (x < 0 ) {
      speedX *= -1;
    }
    if (y > height ) {
      speedY *= -1;
    }
    if (y < 0 ) {
      speedY *= -1;
    }
  }

  void move() {
    x += speedX;
    y += speedY;
  }

  void display() {
    ellipse (x, y, 20, 20);
  }
}

void keyPressed() {

if (keyCode == 32) {

try {

  enc.finish();
} 
catch (IOException e) {

  e.printStackTrace();
}

}

}

I'm currently trying to combine two processing sketches (BackgroundRemove and Blobdetection) to do the following with a webcam aimed at a street:

1. Get videocapture and turn the original image fully green
2. Compare every new frame with the original background image

3. Only show the changed pixels (as a result the canvas is fully green but only moving objects are shown).

4. Use blobdetection to draw rectangles around each moving object.

For this I'm trying to combine the two scripts listed at the end of this post. The BackgroundRemove comes from http://learningprocessing.com/examples/chp16/example-16-12-BackgroundRemove The Blobdetection comes from http://www.v3ga.net/processing/BlobDetection/index-page-home.html

Both scripts seperately work fine, but I've been working for days to combine them and I can't seem to get it working. I think the solution would be to replace the video input in the Blob detection with the canvas input, but I can't figure out how to do that (or how to fix this otherwise).

Would anyone be able to help me here? Thanks!

sorry, the Code tags don't seem to work correctly. For a better view, here are the code Gists: https://gist.github.com/Thomvdm/fd4c412b6bb66a264728b1816c9b5a10 https://gist.github.com/Thomvdm/21d6e9d3df86e288cb8e36fd41bcaf29

| | | | | | |

// Example 16-12: Simple background removal

// Click the mouse to memorize a current background image
import processing.video.*;

// Variable for capture device
Capture video;

// Saved background
PImage backgroundImage;

// How different must a pixel be to be a foreground pixel
float threshold = 30;

void setup() {
  size(640, 480);

  video = new Capture(this, width, height);


  video.start();
  // Create an empty image the same size as the video
  backgroundImage = createImage(video.width, video.height, RGB);
}

void captureEvent(Capture video) {
  // Read image from the camera
  video.read();
}

void draw() {
  // We are looking at the video's pixels, the memorized backgroundImage's pixels, as well as accessing the display pixels. 
  // So we must loadPixels() for all!
  loadPixels();
  video.loadPixels(); 
  backgroundImage.loadPixels();

  // Begin loop to walk through every pixel
  for (int x = 0; x < video.width; x ++ ) {
    for (int y = 0; y < video.height; y ++ ) {
      int loc = x + y*video.width; // Step 1, what is the 1D pixel location
      color fgColor = video.pixels[loc]; // Step 2, what is the foreground color

      // Step 3, what is the background color
      color bgColor = backgroundImage.pixels[loc];

      // Step 4, compare the foreground and background color
      float r1 = red(fgColor);
      float g1 = green(fgColor);
      float b1 = blue(fgColor);
      float r2 = red(bgColor);
      float g2 = green(bgColor);
      float b2 = blue(bgColor);
      float diff = dist(r1, g1, b1, r2, g2, b2);

      // Step 5, Is the foreground color different from the background color
      if (diff > threshold) {
        // If so, display the foreground color
        pixels[loc] = fgColor;
      } else {
        // If not, display green
        pixels[loc] = color(0, 255, 0); // We could choose to replace the background pixels with something other than the color green!
      }
    }
  }
  updatePixels();
}

void mousePressed() {
  // Copying the current frame of video into the backgroundImage object
  // Note copy takes 5 arguments:
  // The source image
  // x, y, width, and height of region to be copied from the source
  // x, y, width, and height of copy destination
  backgroundImage.copy(video, 0, 0, video.width, video.height, 0, 0, video.width, video.height);
  backgroundImage.updatePixels();
}














// - Super Fast Blur v1.1 by Mario Klingemann <http://incubator.quasimondo.com>;
// - BlobDetection library

import processing.video.*;
import blobDetection.*;

Capture cam;
BlobDetection theBlobDetection;
PImage img;
boolean newFrame=false;

// ==================================================
// setup()
// ==================================================
void setup()
{
    // Size of applet
    size(640, 480);
    // Capture
    cam = new Capture(this, 640, 480, 30);
        // Comment the following line if you use Processing 1.5
        cam.start();

    // BlobDetection
    // img which will be sent to detection (a smaller copy of the cam frame);
    img = new PImage(80,60); 
    theBlobDetection = new BlobDetection(img.width, img.height);
    theBlobDetection.setPosDiscrimination(true);
    theBlobDetection.setThreshold(0.2f); // will detect bright areas whose luminosity > 0.2f;
}

// ==================================================
// captureEvent()
// ==================================================
void captureEvent(Capture cam)
{
    cam.read();
    newFrame = true;
}

// ==================================================
// draw()
// ==================================================
void draw()
{
    if (newFrame)
    {
        newFrame=false;
        image(cam,0,0,width,height);
        img.copy(cam, 0, 0, cam.width, cam.height, 
                0, 0, img.width, img.height);
        fastblur(img, 2);
        theBlobDetection.computeBlobs(img.pixels);
        drawBlobsAndEdges(true,true);
    }
}

// ==================================================
// drawBlobsAndEdges()
// ==================================================
void drawBlobsAndEdges(boolean drawBlobs, boolean drawEdges)
{
    noFill();
    Blob b;
    EdgeVertex eA,eB;
    for (int n=0 ; n<theBlobDetection.getBlobNb() ; n++)
    {
        b=theBlobDetection.getBlob(n);
        if (b!=null)
        {
    print("Blob #: ");
    println(n);
    print("X Coord of center: ");
    println(b.x);
print("Y Coord of center: ");
println(b.y);
            // Edges
            if (drawEdges)
            {
                strokeWeight(3);
                stroke(0,255,0);
                for (int m=0;m<b.getEdgeNb();m++)
                {
                    eA = b.getEdgeVertexA(m);
                    eB = b.getEdgeVertexB(m);
                    if (eA !=null && eB !=null)
                        line(
                            eA.x*width, eA.y*height, 
                            eB.x*width, eB.y*height
                            );
                }
            }

            // Blobs
            if (drawBlobs)
            {
                strokeWeight(1);
                stroke(255,0,0);
                rect(
                    b.xMin*width,b.yMin*height,
                    b.w*width,b.h*height
                    );

            }

        }

      }
}

// ==================================================
// Super Fast Blur v1.1
// by Mario Klingemann 
// <http://incubator.quasimondo.com>;
// ==================================================
void fastblur(PImage img,int radius)
{
 if (radius<1){
    return;
  }
  int w=img.width;
  int h=img.height;
  int wm=w-1;
  int hm=h-1;
  int wh=w*h;
  int div=radius+radius+1;
  int r[]=new int[wh];
  int g[]=new int[wh];
  int b[]=new int[wh];
  int rsum,gsum,bsum,x,y,i,p,p1,p2,yp,yi,yw;
  int vmin[] = new int[max(w,h)];
  int vmax[] = new int[max(w,h)];
  int[] pix=img.pixels;
  int dv[]=new int[256*div];
  for (i=0;i<256*div;i++){
    dv[i]=(i/div);
  }

  yw=yi=0;

  for (y=0;y<h;y++){
    rsum=gsum=bsum=0;
    for(i=-radius;i<=radius;i++){
      p=pix[yi+min(wm,max(i,0))];
      rsum+=(p & 0xff0000)>>16;
      gsum+=(p & 0x00ff00)>>8;
      bsum+= p & 0x0000ff;
    }
    for (x=0;x<w;x++){

      r[yi]=dv[rsum];
      g[yi]=dv[gsum];
      b[yi]=dv[bsum];

      if(y==0){
        vmin[x]=min(x+radius+1,wm);
        vmax[x]=max(x-radius,0);
      }
      p1=pix[yw+vmin[x]];
      p2=pix[yw+vmax[x]];

      rsum+=((p1 & 0xff0000)-(p2 & 0xff0000))>>16;
      gsum+=((p1 & 0x00ff00)-(p2 & 0x00ff00))>>8;
      bsum+= (p1 & 0x0000ff)-(p2 & 0x0000ff);
      yi++;
    }
    yw+=w;
  }

  for (x=0;x<w;x++){
    rsum=gsum=bsum=0;
    yp=-radius*w;
    for(i=-radius;i<=radius;i++){
      yi=max(0,yp)+x;
      rsum+=r[yi];
      gsum+=g[yi];
      bsum+=b[yi];
      yp+=w;
    }
    yi=x;
    for (y=0;y<h;y++){
      pix[yi]=0xff000000 | (dv[rsum]<<16) | (dv[gsum]<<8) | dv[bsum];
      if(x==0){
        vmin[y]=min(y+radius+1,hm)*w;
        vmax[y]=max(y-radius,0)*w;
      }
      p1=x+vmin[y];
      p2=x+vmax[y];

      rsum+=r[p1]-r[p2];
      gsum+=g[p1]-g[p2];
      bsum+=b[p1]-b[p2];

      yi+=w;
    }
  }

}`

void setup() {
  size(1280, 480, P3D);

  video2 = new Capture(this, 1280/2, 480, "webcam");

  opencv = new OpenCV(this, 1280/2, 480);
  opencv.loadCascade(OpenCV.CASCADE_FRONTALFACE);  

  video2.start();
}

void R()
{
  scale(1);
  opencv.loadImage(video2);
  image(video2, 1280/2, 0);

  noFill();
  stroke(0, 255, 0);
  strokeWeight(1);
  Rectangle[] faces = opencv.detect();

  for (int i = 0; i < faces.length; i++) {
    rect(faces[i].x, faces[i].y, faces[i].width, faces[i].height);
}
}

You will see, I was a bit desperate. I see the mistake, its a big one I know. But I can't see the solution.

import gab.opencv.*;
import processing.video.*;
import java.awt.*;
 int num = 3;
 PImage[] myImageArray = new PImage[num];
 Capture video;
 OpenCV opencv;

 void setup() {

for (int i=0; i<myImageArray.length; i++){             
   myImageArray[i] = loadImage( str(i) + ".png");
 }

  size(800, 600);
   video = new Capture(this, 800/2, 600/2);
   opencv = new OpenCV(this, 800/2, 600/2);
   opencv.loadCascade(OpenCV.CASCADE_FRONTALFACE);  

   video.start();
 }

 void draw() {
   scale(2);
  opencv.loadImage(video);
   image(video, 0, 0 );

  Rectangle[] faces = opencv.detect();
   println(faces.length);                    //print number of faces
   for (int i = 0; i < faces.length; i++) {
     println(faces[i].x + "," + faces[i].y); //print position(x/y) of faces 
  image(myImageArray[(int)random(num)], faces[i].x-70, faces[i].y-60, faces[i].width+80, faces[i].height+80);
 }
}

 void captureEvent(Capture c) {
   c.read();
 }

I realise that the problem currently is that the only way I could find to use the parameters of the face detection rects is to put the playNote in the same brackets as them. Meaning that of course, as the rects are being permanently drawn, so are the notes being permanently created.

How can I have a playNote function that runs on the faces[i] parameters but doesn't have to be in the same 'for' brackets?

All help is greatly appreciated, here is my code currently

import gab.opencv.*;
import processing.video.*;
import java.awt.*;

// audio bits
import ddf.minim.*;
import ddf.minim.ugens.*;
AudioOutput out;

Capture video;
OpenCV opencv;

void setup() {
  size(640, 480);
  video = new Capture(this, 640/2, 480/2);
  opencv = new OpenCV(this, 640/2, 480/2);
  opencv.loadCascade(OpenCV.CASCADE_FRONTALFACE);  

  video.start();

  Minim minim = new Minim(this);
  out = minim.getLineOut();
}

void draw() {
  scale(2);
  opencv.loadImage(video);

  image(video, 0, 0 );

  noFill();
  stroke(0, 255, 0);
  strokeWeight(3);
  Rectangle[] faces = opencv.detect();
  println(faces.length);

  for (int i = 0; i < faces.length; i++) {
    println(faces[i].x + "," + faces[i].y);
    out.playNote(0, 1, (faces[i].width*2));
    rect(faces[i].x, faces[i].y, faces[i].width, faces[i].height);     
  }
}

void captureEvent(Capture c) {
  c.read();
}

Thanks for your help :)

////////////////////////////////////////////
////////////////////////////////// LIBRARIES
////////////////////////////////////////////

import processing.serial.*;
import gab.opencv.*;
import processing.video.*;




/////////////////////////////////////////////////
////////////////////////////////// INITIALIZATION
/////////////////////////////////////////////////

Movie mymovie;
Capture video;
OpenCV opencv;
Contour contour;




////////////////////////////////////////////
////////////////////////////////// VARIABLES
////////////////////////////////////////////

int lf = 10;    // Linefeed in ASCII
String myString = null;
Serial myPort;  // The serial port
int sensorValue = 0;
int x = 300;




/////////////////////////////////////////////
////////////////////////////////// VOID SETUP
/////////////////////////////////////////////


void setup() {
  size(1280, 1024);
  // List all the available serial ports
  printArray(Serial.list());
  // Open the port you are using at the rate you want:
  myPort = new Serial(this, Serial.list()[1], 9600);
  myPort.clear();
  // Throw out the first reading, in case we started reading 
  // in the middle of a string from the sender.
  myString = myPort.readStringUntil(lf);
  myString = null;
  opencv = new OpenCV(this, 720, 480);
  video = new Capture(this, 720, 480);
  mymovie = new Movie(this, "visage.mov");
  opencv.startBackgroundSubtraction(5, 3, 0.5);
  mymovie.loop();
}




////////////////////////////////////////////
////////////////////////////////// VOID DRAW
////////////////////////////////////////////


void draw() { 
  image(mymovie, 0, 0);
  image(video, 20, 20);
  //tint(150, 20);
  noFill();
  stroke(255, 0, 0);
  strokeWeight(1);



  // check if there is something new on the serial port
  while (myPort.available() > 0) {
    // store the data in myString 
    myString = myPort.readStringUntil(lf);
    // check if we really have something
    if (myString != null) {
      myString = myString.trim(); // let's remove whitespace characters
      // if we have at least one character...
      if (myString.length() > 0) {
        println(myString); // print out the data we just received
        // if we received a number (e.g. 123) store it in sensorValue, we sill use this to change the background color. 
        try {
          sensorValue = Integer.parseInt(myString);
        } 
        catch(Exception e) {
        }
      }
    }
  }
  if (x < sensorValue) {
    video.start();
    opencv.loadImage(video);

  }

  if (x > sensorValue) {
    image(mymovie, 0, 0);
  }

  opencv.updateBackground();
  opencv.dilate();
  opencv.erode();

  for (Contour contour : opencv.findContours()) {
    contour.draw();
  }

}




//////////////////////////////////////////////
////////////////////////////////// VOID CUSTOM
//////////////////////////////////////////////


void captureEvent(Capture video) {
  video.read(); // affiche l'image de la webcam
}

void movieEvent(Movie myMovie) {
  myMovie.read();
}