Well, progress so far, but the logic behind what I wanted to do doesn't really appear to be a "best practice" way of doing it.

Using JMyron, I was able to get the average pixel color of the background and then compare it to that of the current scene, but this way of doing things seem to rely heavily on stable conditions for the background. When, for instance, it gets sunnier in a room the background no longer matches.  This can be solved by increasing the tolerance, but that also seems to be a strange way to go about it.  All together, using the average colour of a pixel to determine change seems to be flawed in cases where there is no control due to the fact that, say, the person passing by could be wearing the same colour as the background and sneak by undetected.

Does anyone have any other ways one might accomplish this task of background subtraction?

My current code is below so you can see.

Pressing < / > increases and decreases the tolerance and hitting the spacebar takes a new snapshot of the background.

Thanks in advance!

2. import JMyron.*;
3. 
   
4. int NUM_SQUARES = 50;
5. color [] gridArray;
6. color [] currFrame;
7. int tolerance = 80;
8. boolean revealing;
9. 
   
10. JMyron theMov;
11. int sampleWidth, sampleHeight;
12. int numSamplePixels;
13. 
    
14. void setup() {
15.   size(320, 240);
16.   frameRate(5);
17.   theMov = new JMyron();
18.   theMov.start(width, height);
19.   theMov.findGlobs(0);
20.   currFrame = new color[10100];
21.   gridArray = new color[10100];
22.   sampleWidth = width/NUM_SQUARES;
23.   sampleHeight = height/NUM_SQUARES;
24.   numSamplePixels = sampleWidth*sampleHeight;
25.   //capture initial background
26.   refreshBackground(theMov);
27. }
28. 
    
29. void draw() {
30.   theMov.update();
31.   // go through all the cells
32.   for (int y=0; y <= NUM_SQUARES; y++) {
33.     for (int x=0; x < NUM_SQUARES; x++) {
34.      
35.       int indexOfGrid = (x+y*NUM_SQUARES);
36.       //println(indexOfGrid);
37.       currFrame[indexOfGrid] = theMov.average(x*sampleWidth,y*sampleHeight,(x*sampleWidth)+sampleWidth,(y*sampleHeight)+sampleWidth);
38.      
39.       if(comparePixels(indexOfGrid)){
40.         fill(255,255,255);
41.         rect(x*sampleWidth, y*sampleHeight, sampleWidth, sampleHeight);
42.       }else{
43.         fill(0,0,0);
44.         rect(x*sampleWidth, y*sampleHeight, sampleWidth, sampleHeight);
45.       }
46.     }
47.   }
48. }
49. 
    
50. boolean comparePixels(int index) {
51.   if ((Math.abs(red(currFrame[index]))-(red(gridArray[index]))) < tolerance ||
52.     (Math.abs(green(currFrame[index]))-(green(gridArray[index]))) < tolerance ||
53.     (Math.abs(blue(currFrame[index]))-(blue(gridArray[index]))) < tolerance){
54.         return !revealing;
55.     }else{
56.   return revealing;
57.     }
58. }
59. 
    
60. void refreshBackground(JMyron movObj){
61.   movObj.update();
62.   for (int y=0; y < NUM_SQUARES; y++) {
63.     for (int x=0; x < NUM_SQUARES; x++) {
64.       int indexOfGrid = (x+y*NUM_SQUARES);
65.       gridArray[indexOfGrid] = movObj.average(x*sampleWidth,y*sampleHeight,(x*sampleWidth)+sampleWidth,(y*sampleHeight)+sampleWidth);
66.     }
67.   } 
68. }
69. 
    
70. void keyReleased() {
71.   if (key == '.' || key == '>') {
72.     // increase tolerance
73.     tolerance += 2;
74.   } else if (key == ',' || key == '<') {
75.     // decrease tolerance
76.     tolerance -= 2;
77. // take a new snapshot
78.   } else if (key == ' ') {
79.     refreshBackground(theMov);
80.   }
81. }
82. 
    
83. 
    
84. public void stop() {
85.   theMov.stop();
86.   super.stop();
87. }

I would guess that taking an average colour would make the response less sensitive and not more because more change needs to occur for something to show.

Perhaps I should sample one pixel in the middle of each of my cells instead?