It will have 3 zones, an Enter space (< 800), a Middle space (> 800 && < 960), and a Back space (> 960).

What's wrong with this code?
(It's an adaptation from Daniel Shiffman's average point tracking example that comes with the library.)

2. import org.openkinect.*;
3. import org.openkinect.processing.*;
4. 
   
5. // Showing how we can farm all the kinect stuff out to a separate class
6. KinectTracker tracker;
7. // Kinect Library object
8. Kinect kinect;
9. 
   
10. int kw  = 640;
11. int kh = 480;
12. 
    
13. PImage depthImg;
14. int minDepth =  800;
15. int maxDepth = 990;
16. 
    
17. int minimumPresence = 100;
18. int presenceFront = 0;
19. int presenceMiddle = 0;
20. int presenceBack = 0;
21. 
    
22. 
    
23. final int NOTHING = 0;
24. final int ENTER   = 1;
25. final int RECORDING = 2;
26. final int SOUND_PLAYBACK  = 3;
27. int currentPos = -1;
28. int whereIsViewer = NOTHING;
29. 
    
30. int by = 0;
31. 
    
32. //frame differencing stuff
33. int numPixels;
34. int[] averagePixels;
35. int[] toScreenPixels;
36. color white = color(255);
37. color black = color(0);
38. 
    
39. boolean firstTime = true;
40. boolean showBackgroundSubtraction = false;
41. boolean showThresholded = false;
42. 
    
43. void setup() {
44.   size(640, 520);
45.   numPixels = kw * kh;
46. 
    
47.   averagePixels = new int[numPixels];
48.   toScreenPixels = new int[numPixels];
49. 
    
50.   // Make the pixels[] array available for direct manipulation
51.   loadPixels();
52. 
    
53.   kinect = new Kinect(this);
54.   tracker = new KinectTracker();
55.   //frameRate(1);
56. }
57. 
    
58. void draw() {
59.   background(255);
60. 
    
61.   float a = map(kw, 0, width, 0, 1);//I'm not sure what to put instead of mouseX or Y
62.   float thresh = map(kh, 0, height, 0, 255);
63. 
    
64.   kinect.getVideoImage(); // Read a new video frame
65.   //kinect.getVideoPix(); //I'm not sure where to go with this portion
66. 
    
67.   for (int i = 0; i < numPixels; i++) {       
68.     int currColor = loadPixels(i);// it tells me that the method loadPixels() in the type PApplet is not applicable for the arguments (int)
69.     int bkgdColor = averagePixels[i];       
70.     int currR = (currColor >> 16) & 0xFF;
71.     int currG = (currColor >> 8) & 0xFF;
72.     int currB = currColor & 0xFF;
73. 
    
74.     int bkgdR = (bkgdColor >> 16) & 0xFF;
75.     int bkgdG = (bkgdColor >> 8) & 0xFF;
76.     int bkgdB = bkgdColor & 0xFF;
77. 
    
78.     int redAvg = int(a * currR + (1 - a) * bkgdR);
79.     int greenAvg = int(a * currG + (1 - a) * bkgdG);
80.     int blueAvg = int(a * currB + (1 - a) * bkgdB);
81. 
    
82.     // equiv to color(redAvg, greenAvg, blueAvg); , but perhaps slightly faster
83.     averagePixels[i] = 0xFF000000 | (redAvg << 16) | (greenAvg << 8) | blueAvg; // equiv to color(redAvg, greenAvg, blueAvg);
84. 
    
85.     if (showBackgroundSubtraction) {
86.       int bgSubR = abs(bkgdR - currR);
87.       int bgSubG = abs(bkgdG - currG);
88.       int bgSubB = abs(bkgdB - currB);
89. 
    
90.       toScreenPixels[i] = 0xFF000000 | (bgSubR << 16) | (bgSubG << 8) | bgSubB;
91.     }        
92.     else {         
93.       toScreenPixels[i] = averagePixels[i];
94.     }       
95.     if (showThresholded) {
96.       toScreenPixels[i] = brightness(toScreenPixels[i]) > thresh ? 1 : 0;
97.     }
98.   }
99.   fill(255);
100. 
     
101. 
     
102.   // Run the tracking analysis
103.   tracker.track();
104.   // Show the image
105. 
     
106. 
     
107.   // Let's draw the raw location
108.   PVector v1 = tracker.getPos();
109. 
     
110.   // Let's draw the "lerped" location
111.   PVector v2 = tracker.getLerpedPos();
112. 
     
113. 
     
114.   // Display some info
115.   int t = tracker.getThreshold();
116. }
117. 
     
118. 
     
119. void stop() {
120.   tracker.quit();
121.   super.stop();
122. }

and

2. class KinectTracker {
3. 
   
4.   // Size of kinect image
5.   int kw = 640;
6.   int kh = 480;
7.   int threshold = 900;
8. 
   
9.   // Raw location
10.   PVector loc;
11. 
    
12.   // Interpolated location
13.   PVector lerpedLoc;
14. 
    
15.   // Depth data
16.   int[] depth;
17.   int[] depthBg = new int[kw*kh];
18. 
    
19. 
    
20.   PImage display;
21.   PImage display2;
22. 
    
23.   KinectTracker() {
24.     kinect.start();
25.     kinect.enableDepth(true);
26. 
    
27.     // We could skip processing the grayscale image for efficiency
28.     // but this example is just demonstrating everything
29.     kinect.processDepthImage(true);
30. 
    
31.     display = createImage(kw, kh, PConstants.RGB);
32.     display2 = createImage(kw, kh, PConstants.RGB);
33. 
    
34.     loc = new PVector(0, 0);
35.     lerpedLoc = new PVector(0, 0);
36.   }
37. 
    
38.   void track() {
39. 
    
40.     // Get the raw depth as array of integers
41.     depth = kinect.getRawDepth();
42. 
    
43.     // Being overly cautious here
44.     if (depth == null) return;
45. 
    
46.     float sumX = 0;
47.     float sumY = 0;
48.     float count = 0;
49. 
    
50.     presenceFront = 0;
51.     presenceMiddle = 0;
52.     presenceBack = 0;
53. 
    
54.     display2.loadPixels();
55. 
    
56.     for (int x = 0; x < kw; x++) {
57.       for (int y = 0; y < kh; y++) {
58. 
    
59.         // Mirroring the image
60.         int offset = kw-x-1+y*kw;
61. 
    
62.         int bgDepth = depthBg[offset];
63.         // Grabbing the raw depth
64.         int rawDepth = depth[offset];
65. 
    
66. 
    
67.         int correctedBg = rawDepth - bgDepth;
68. 
    
69.         int bgAvg = int(a * rawDepth + (1 - a) * bgDepth);
70.         depthBg[offset] = bgAvg;
71. 
    
72.         display2.pixels[offset] = (color(rawDepth - depthBg[offset]));
73. 
    
74.         // Testing against threshold
75.         if (correctedBg < threshold) {
76.           sumX += x;
77.           sumY += y;
78.           count++;
79.         }
80. 
    
81.         if (correctedBg < minDepth) {
82.           presenceFront++;
83.         } 
84.         else if (correctedBg >= minDepth && correctedBg < maxDepth) {
85.           presenceMiddle++;
86.         } 
87.         else {
88.           presenceBack++;
89.         }
90.       }
91.     }
92. 
    
93.     display2.updatePixels();
94. 
    
95.     int currentPos = -1;
96. 
    
97.     int [] list = {
98.       presenceFront, presenceMiddle, presenceBack
99.     };
100. 
     
101.     println(list);
102. 
     
103.     int maxPresence = max(list);
104. 
     
105.     // do we have a minimal amount of presence to proceed?
106.     if (maxPresence > minimumPresence) { // 1000 is the minimum
107.       if (maxPresence == presenceFront) {
108.         currentPos = ENTER;
109.       } 
110.       else if (maxPresence == presenceMiddle) {
111.         currentPos = RECORDING;
112.       } 
113.       else if (maxPresence == presenceBack) {
114.         currentPos = SOUND_PLAYBACK;
115.       }
116.     } 
117.     else {
118.       currentPos = NOTHING;
119.     }
120. 
     
121.     if (currentPos != whereIsViewer) {
122.       // then do checks cause something changed
123.       if (whereIsViewer == NOTHING && currentPos == ENTER) {
124.         whereIsViewer = ENTER;
125.       }
126.       if (whereIsViewer == ENTER && currentPos == RECORDING) {
127.         whereIsViewer = RECORDING;
128.       }
129.       else if (whereIsViewer == RECORDING && currentPos == SOUND_PLAYBACK) {
130.         whereIsViewer = SOUND_PLAYBACK;
131.       }
132.       if (whereIsViewer == SOUND_PLAYBACK && currentPos == RECORDING) {
133.         whereIsViewer = NOTHING;
134.         reset();
135.       }
136.       if (whereIsViewer == RECORDING && currentPos == ENTER) {
137.         whereIsViewer = NOTHING;
138.         reset();
139.       }
140.       if (whereIsViewer == ENTER && currentPos == NOTHING) {
141.         whereIsViewer = NOTHING;
142.         reset();
143.       }
144.     }
145.     else {
146.       // nothing changed, so nothing to do
147.     }
148.     println(whereIsViewer);
149.     //println(currentPos);
150. 
     
151.     // As long as we found something
152.     if (count != 0) {
153.       loc = new PVector(sumX/count, sumY/count);
154.     }
155. 
     
156.     // Interpolating the location, doing it arbitrarily for now
157.     lerpedLoc.x = PApplet.lerp(lerpedLoc.x, loc.x, 0.3f);
158.     lerpedLoc.y = PApplet.lerp(lerpedLoc.y, loc.y, 0.3f);
159.   }
160. 
     
161.   //PVector getLerpedPos() {
162.   //return lerpedLoc;
163.   //}
164. 
     
165.   //PVector getPos() {
166.   //return loc;
167.   //}
168. }
169. void display() {
170.   PImage img = kinect.getDepthImage();
171. 
     
172.   // Being overly cautious here
173.   if (depth == null || img == null) return;
174. 
     
175.   // Going to rewrite the depth image to show which pixels are in threshold
176.   // A lot of this is redundant, but this is just for demonstration purposes
177.   display.loadPixels();
178.   for (int x = 0; x < kw; x++) {
179.     for (int y = 0; y < kh; y++) {
180.       // mirroring image
181.       int offset = kw-x-1+y*kw;
182.       // Raw depth
183.       int rawDepth = depth[offset];
184. 
     
185.       int pix = x+y*display.width;
186. 
     
187. 
     
188.       if (rawDepth < threshold) {
189.         // A red color instead
190.         display.pixels[pix] = color(150, 50, 50);
191.       } 
192.       else {
193.         display.pixels[pix] = img.pixels[offset];
194.       }
195.     }
196.   }
197.   display.updatePixels();
198. 
     
199. 
     
200. 
     
201.   //  the image
202.   ///    image(display, 0, 0);
203.   image(display2, 0, 0);
204. }
205. 
     
206. void reset() {
207.   currentPos = -1;
208. }
209. 
     
210. void quit() {
211.   kinect.quit();
212. }
213. 
     
214. int getThreshold() {
215.   return threshold;
216. }
217. 
     
218. void setThreshold(int t) {
219.   threshold =  t;
220. }