Hello everybody
I have a little piece of code in Processing but I would like to have the same functionality in oF instead.
The code make and playback some seconds of a webcam mixed with the original image.
The problem is: I don’t know were to start.
I have been looking in the addons to see if there is some example that could be a starting point, but I had no luck so far.
ofxVideoBuffer, ofxVideoUtils and ofxPlaymodes were my bets. But they let me down.
The ofxVideoBuffer basic video grabber example and the multi-tap, which seemed (by their names) good starting points, are missing this header, which I couldn’t find anywhere: ofxVideoFrame.h
ofxVideoUtils I got a …/BufferLoaderEvents.h:29: error: Poco/Exception.h: No such file or directory
and ofxPlaymodes examples complains also about not finding Poco/* like in: …/addons/ofxPlaymodes/src/utils/pmUtils.h:11: error: Poco/Timestamp.h: No such file or directory
#include “Poco/Timestamp.h”
^
I would rather use a vanilla solution, but I don’t know were to start. Any direction either of a solution or something I should learn to figure out how to do it, will be greatly appreciated.
best regards
Here goes the Processing code:
import processing.video.*;
Capture video;
int capW = 640; //match camera resolution here
int capH = 480;
float yoff = 50.0; // 2nd dimension of perlin noise
float delayTime;
int nDelayFrames = 100; // about 3 seconds
int currentFrame = nDelayFrames-1;
int currentFrame2;
int currentFrame3;
int numPixels;
int[] previousFrame;
PImage frames[];
PImage framesHV[];
PImage framesV[];
PImage videoFlipH;
void setup() {
size(640, 480); //set monitor size here
frameRate(200);
video = new Capture(this, capW, capH );
video.start();
frames = new PImage [nDelayFrames];
framesHV = new PImage[nDelayFrames];
framesV = new PImage[nDelayFrames];
videoFlipH = new PImage(video.width, video.height);
for (int i= 0; i<nDelayFrames; i++) {
frames[i] = createImage(capW, capH, ARGB);
framesHV[i] = createImage(capW, capH, ARGB);
framesV[i] = createImage(capW, capH, ARGB);
numPixels = video.width * video.height;
// Create an array to store the previously captured frame
previousFrame = new int[numPixels];
loadPixels();
}
}
void draw() {
float delayTime = constrain(map(noise(yoff)*10, 1, 7, 1, 100), 1, 100); // Option #2: 1D Noise
yoff = (yoff+0.01) % nDelayFrames;
nDelayFrames = int(delayTime);
if (video.available()) {
video.read();
video.loadPixels(); // Make its pixels[] array available
for (int loc = 0; loc < width*height; loc++) {
color currColor = video.pixels[loc];
color prevColor = previousFrame[loc];
int currR = (currColor >> 16) & 0xFF;
int currG = (currColor >> 8) & 0xFF;
int currB = currColor & 0xFF;
// Compute the difference of the red, green, and blue values
// summes and divide the colors to result black and white
// look at the FrameDifferencing example if you want it in colors
int newR = abs(int(currR+(currG+currB)/2)/2);
int newG = abs(int(currG+(currR+currB)/2)/2);
int newB = abs(int(currB+(currG+currR)/2)/2);
// mantain the values of the colors between 0 and 255
newR = newR < 0 ? 0 : newR > 255 ? 255 : newR;
newG = newG < 0 ? 0 : newG > 255 ? 255 : newG;
newB = newB < 0 ? 0 : newB > 255 ? 255 : newB;
// Render the difference image to the screen
video.pixels[loc] = 0xff000000 | (newR << 16) | (newG << 8) | newB;
//previousFrame[loc] = lerpColor (previousFrame[loc], currColor, 0.1);
}
for (int x = 0; x < video.width; x++) {
for (int y = 0; y < video.height; y++) {
framesHV[currentFrame].pixels[y*(video.width) + x] = video.pixels[(video.height - 1 - y)*video.width+(video.width-(x+1))];
framesV[currentFrame].pixels[y*(video.width) + x] = video.pixels[(video.height - 1 - y)*(video.width) + x];
videoFlipH.pixels[y*video.width + x] = video.pixels[y*video.width+(video.width-(x+1))];
}
}
arrayCopy (video.pixels, frames[currentFrame].pixels); //, tempImage[currentFrame].pixels
frames[currentFrame].updatePixels();
framesHV[currentFrame].updatePixels();
framesV[currentFrame].updatePixels();
tint(255, 167);
updatePixels();
videoFlipH.updatePixels();
currentFrame = (currentFrame-1 + nDelayFrames) % nDelayFrames;
currentFrame2 = (currentFrame +30)%nDelayFrames; //+30= delay time. must be less than nDelayFrames
currentFrame3 = (currentFrame +60)%nDelayFrames; //+60= delay time. must be less than nDelayFrames
image (framesHV[currentFrame], 0, 0, width, height);
blend(frames[currentFrame2], 0, 0, width, height, 0, 0, width, height, OVERLAY); //try with ADD, DARKEST etc here. see blend help
blend(framesV[currentFrame3], 0, 0, width, height, 0, 0, width, height, SOFT_LIGHT); //try with ADD, DARKEST etc here. see blend help
blend(videoFlipH, 0, 0, width, height, 0, 0, width, height, LIGHTEST); //try with ADD, DARKEST etc here. see blend help
}
// println(nDelayFrames);
println(int(frameRate));
}