There's a chance it might be a hardware issue. Post the names of the devices and somone might know of any issues.

I had some excellent speed from a Creative Live Pro web cam, a Logitech Communicator ground the whole system to a halt, and the oh so dodgy Trust Web cam was tricky to set up what with it over writing other drivers but ran really fast once you got it going because it was so light on system resources (and it was the cheapest cam about).

WinVDig has rarely been the main cause of any issues I've had. Plus the guy who maintains it was reasonably approachable.

If you've got some spare cash you might want to nip out and get a cheap-as-chips capture device to check the performance differences.

Hi beachmeat,

your renderDifference method needs some serious optimization. There are several unnecessary calculations that can be replaced:

Code:

PGraphics3 renderDifference(color[] a, color[] b, int sens){  
  /* 
 color trans = color(255,255,255); //the colour of the pixels w/ movement  
 color ch = color(0,0,0); //the colour of the pixels that haven't changed  
 */    

// your version maybe nicer to read, but you can simply replace this by:

int trans = 0xffffffff;
int ch= 0xff000000;
  
// though that will not make much of a difference

// this is where the horrible part starts - two nested
// loops? Why? You are just traversing through the pixels
// array, in order to check every pixel. But the pixels
// array is 1-dimensional, so you adding extra effort here
// because two loops will force you to use multiplication

/*
  for(int i = 0; i < width; i++)  
    for(int j = 0; j < height; j++) 
    {  
     float bA = brightness(a[j*width+i]);  
     float bB = brightness(b[j*width+i]);  
  
     if (sens<abs(bA-bB))   
       tmp.pixels[j*width+i] = ch;  
     else    
       tmp.pixels[j*width+i] = trans;  
    }  
  }  
*/

// this is already smaller:

// use a reference to the pixels array
int[] p = tmp.pixels;

for (int i = width*height; --i>-1;)
{
     float bA = brightness(a[i]);  
     float bB = brightness(b[i]);  
  
     if (sens<abs(bA-bB))   
       p[i] = ch;  
     else    
       p[i] = trans;
}

// it could be further improved, though. The two
// brightness() calls should be at least unrolled. 
// Though maybe you could just compare the red channel. 
// Also the abs() is expensive if you use it 640*480 times
// in a loop.

  tmp.updatePixels(); 
  arraycopy(cam.pixels, oldCam.pixels); 
   
  return tmp;  
} 
 

since performance seems to come up a lot, i've added a note to the faq about it (at the end under "all platforms")
http://processing.org/faq/bugs.html#video

Thanks for your improvements Sensei Quasimondo because they offer a lot learning possibility, but this was just some copy paste from another code from a user here of the forum. I was already checking quite some posts of you here, since you seem to be the master of image bit-calculations

But the thing is that you could as well just display any direct output of camera capture, and it would not be the speed one would dream of. 640/480 @ 30fps are impossible for me here.

I completly understand that Processing is not ment to be used for this kind of video analysis, and its doing a great job for what its good at - but I simply dont know what else to use for making some realtime image analysis with background subtraction and in the end have a processing output on it, because thats the tricky part where the proggs I have looked into failed - I couldnt send stuff to Processing in the required way (like a very big 1bit matrix, or).

But anyway I always guess there is room for improvement, be it hardware or drivers or vdig. But if you, Fry, say that maybe double speed could be reached by pushing the quicktime integration further, then there is room for hope
There are very very many projects that use video input from webcams or whatever, so its really a great idea to extend Processings power there I believe...I hope the right person will come across our way nd be able to spend some time on that, because I definitly suck at this.

@cello I really like your flyingplanes sketch! So simple yet so fun to play around with