How to Manipulate Video Playback Speed using FrameDifferencing?

bkeum

Hi!

I'm trying to combine the FrameDifferencing library example, which quantifies the amount of movement in a video frame of the webcam, and using numbers in movementSum to manipulate the speed of a video that I import into the program. (Example: if the video that I wanted to play was a scene from the Matrix, I would want it so that when I run the program, the more intense the movement in front of the webcam, the faster the speed of the playback in the Matrix video.) Right now, I'm having trouble figuring out

1) how to get the data from the movement of the webcam (so, turning on the webcam and using that as in input) but not drawing it. (What I want to draw is the Matrix video—where do I put the information for that?) 2) where and/how to use the movementSum numbers, which are integers, to correspond to the video playback speed of the Matrix.

Below is the code for the FrameDifferencing example by Golan Levin:

/** * Frame Differencing * by Golan Levin. * * Quantify the amount of movement in the video frame using frame-differencing. */

import processing.video.*;

int numPixels; int[] previousFrame; Capture video;

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();

numPixels = video.width * video.height; // Create an array to store the previously captured frame previousFrame = new int[numPixels]; loadPixels(); }

void draw() { if (video.available()) { // When using video to manipulate the screen, use video.available() and // video.read() inside the draw() method so that it's safe to draw to the screen 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;
  // Render the difference image to the screen
  pixels[i] = color(diffR, diffG, diffB);
  // The following line is much faster, but more confusing to read
  //pixels[i] = 0xff000000 | (diffR << 16) | (diffG << 8) | diffB;
  // Save the current color into the 'previous' buffer
  previousFrame[i] = currColor;
}
// To prevent flicker from frames that are all black (no movement),
// only update the screen if the image has changed.
if (movementSum > 0) {
  updatePixels();
  println(movementSum); // Print the total amount of movement to the console
}

} }