I'm trying to update and run an old code I played around with, and when I try to run it, the camera turns on, and then off, leaving me with a blank screen instead of the result.

Here's the code:

2. 
   
3. // Game of life parameters
4. float density = 0.08;
5. int[][][] world;
6. 
   
7. // parameters:
8. int finalX = 640;
9. int finalY = 480;
10. int vidX = 640;
11. int vidY = 480;
12. int vidpix = vidX*vidY;
13. int[] oldpixels = new int [vidpix];
14. int threshold = 170;
15. boolean fromRef= false;
16. 
    
17. int glife_vidX = finalX;
18. int glife_vidY = finalY;
19. 
    
20. // static variables:
21. boolean newFrame;
22. boolean once= false;
23. int targets;
24. float scal = finalX/vidX;
25. 
    
26. //particle variables
27. int num=35000;
28. int counter=0;
29. int flow=1;
30. int life=10;
31. int speed=128;
32. int nodes=2;
33. 
    
34. particle[] parts=new particle[num];
35. particle[] glife_parts=new particle[num];
36. 
    
37. int glife_counter = 0;
38. 
    
39. int counter3 = 0;
40. 
    
41. float alpha;
42. import processing.video.*;
43. Capture video;
44. //////////////////////////////////
45. 
    
46. void setup() {
47.   size(finalX, finalY);
48.   video = new Capture(this,vidX, vidY, 30); 
49.   //smooth();
50.   alpha = 0;
51.   for (int i=0; i<num; i++){
52.     parts[i]=new particle(num, 1000, 1000, 0, 0, 0, speed, nodes, 255);
53.   }
54. 
    
55.   for (int i=0; i<num; i++){
56.     glife_parts[i]=new particle(num, 1000, 1000, 0, 0, 0, speed, nodes, 255);
57.   }
58. 
    
59. 
    
60.     //background(0);
61. 
    
62.   frameRate(16);
63.   glife_vidX = width;
64.   glife_vidY = height;
65.   world = new int[glife_vidX+1][glife_vidY+1][2];
66.   //stroke(255, 50, 0);
67. 
    
68.   // Set random cells to 'on'
69.   for (int i = 0; i < (glife_vidX * glife_vidY * density * threshold); i++) {
70.       world[(int)random(glife_vidX)][(int)random(glife_vidY)][1] = 1;
71.   }
72. 
    
73. }
74. 
    
75. void captureEvent(Capture video){
76.  video.read();
77. }
78. 
    
79. void loop() {
80.   background(0);
81.   if (!once || keyPressed){  // if a key is pressed, get a reference frame
82.     for(int i=0; i<vidpix; i++){
83.       oldpixels[i]=video.pixels[i];
84.     }
85.     once= true;
86.   }
87.   
88.   //if (counter3 % 10 == 0)
89.   //{
90.   if (newFrame){
91. 
    
92.     analyzeChangeVideo();
93. }
94. //}
95.     counter3++;
96.   if (!fromRef){     // if reference mode = every frame
97.     for(int i=0; i<vidpix; i++){
98.       oldpixels[i]=video.pixels[i];  // after processing, new pixels are copied as "old" if fromRef=true
99.     }
100.     // if the altering func is class-style, update it here.
101.   }
102. 
     
103. 
     
104. 
     
105.   playGameOfLife();
106.   
107.   for (int x = 0; x < glife_vidX ; x++) {
108.     for (int y = 0; y < glife_vidY ; y++) {
109.       if (world[x][y][1] == 1)
110.       {
111.         glife_parts[glife_counter].positionX[0]= x; 
112.         glife_parts[glife_counter].positionY[0]= y;
113.         glife_parts[glife_counter].alpha= 255; 
114.         if (glife_counter<num-1){
115.           glife_counter++;
116.         } else {
117.           glife_counter=0;
118.         }
119.       }
120.     }
121.   }
122. 
     
123.   for (int i=0; i<num; i++){
124.     //parts[i].update();
125.     //parts[i].render();
126.     glife_parts[i].render();
127.   }
128. 
     
129. 
     
130. }
131. 
     
132. void videoEvent(){
133.   if (!newFrame){
134.     newFrame = true;
135.   }
136. }
137. 
     
138. void analyzeChangeVideo(){
139. 
     
140.   targets = 0;
141.   int x;
142.   int y;
143.   for(int i=0; i<vidpix; i++){
144.     float r = int(red(video.pixels[i]));
145.     float g = int(green(video.pixels[i]));
146.     float b = int(blue(video.pixels[i]));
147.     float rc = abs(r-red(oldpixels[i]));
148.     float gc = abs(g-green(oldpixels[i]));
149.     float bc = abs(b-blue(oldpixels[i]));
150.     float change = rc+gc+bc;
151.     x=int(i%vidX*scal);   //the x location of the pixel that changed
152.     y=int(i/vidX*scal);   //the y location of the pixel that changed
153.     //inverter - for tv displays
154.     x=(finalX-x);
155. 
     
156.     if (change>threshold){      // this is where you decide what to do with the pixels
157.       //do something here. you have x, y.
158.       for (int k=0; k<flow; k++){
159.         parts[counter].life=life;
160.         parts[counter].alpha= 255;
161.         for (int l=0; l<parts[counter].nodes; l++){
162. 
     
163. //          parts[counter].positionX[l]= x;
164. //          parts[counter].positionY[l]= y;
165. 
     
166.           glife_parts[glife_counter].positionX[0]= x; 
167.          glife_parts[glife_counter].positionY[0]= y;
168. 
     
169.         }
170. 
     
171.         // Set changed cells to 'on'
172.         //for (int z = 0; z < glife_vidX * glife_vidY * density; z++) {
173.         //}
174. 
     
175.         if (counter<num-1){
176.           counter++;
177.         } else {
178.           counter=0;
179.         }
180.         
181.                 if (glife_counter<num-1){
182.           glife_counter++;
183.         } else {
184.           glife_counter=0;
185.         }
186. 
     
187. 
     
188. 
     
189.       }
190. 
     
191.           world[x][y][1] = 1;
192. //print("X: " + x);
193.       //rectMode(CENTER_DIAMETER);
194.       //rect(x,y,1,1);
195. 
     
196.     }
197.   }
198. }
199. 
     
200. class particle{
201.   float x, y, px, py;
202.   float xspeed, yspeed, xForce, yForce;
203.   int xSpeedLimit=30;
204.   int ySpeedLimit=30;
205.   int life;
206.   int origLife;
207.   float radCount=random(6.27);
208.   float factor;
209.   int nodes;
210.   float[] positionX;
211.   float[] positionY;
212.   float radSpeed= 50f;
213.   int dir1, dir2;
214.   float alpha;
215. 
     
216.   particle(int numpart, float xin, float yin, int lif, float xp, float yp, int sp, int nds, float ap){
217.     nodes= nds;
218.     positionX= new float[nodes];
219.     positionY= new float[nodes];
220.     for (int i=0; i<nodes; i++){
221.       positionX[i]= xin;
222.       positionY[i]= yin;
223.     }
224.     x=positionX[0];
225.     y=positionY[0];
226.     speed=sp;
227.     alpha=ap;
228.     xForce=random(speed)-speed/2;
229.     yForce=random(speed)-speed/2;
230.     life=lif-int(random(100));
231.     origLife=lif;
232.     factor=random(speed*2)-speed;
233.     factor= 3;
234.     if (random(2)>1){
235.       dir1= 1;
236.     }else{
237.       dir1= -1;
238.     }
239.     if (random(2)>1){
240.       dir2= 1;
241.     }else{
242.       dir2= -1;
243.     }
244.   }
245. 
     
246.   void update(){
247. 
     
248.     if (alpha>0){
249.       x= positionX[0];
250.       y= positionY[0];
251.       float xDif, yDif;
252.       float r2, rot, grav;
253. 
     
254.       xspeed= xForce+int(factor*(cos(radCount)));
255.       yspeed= yForce-int(factor*(sin(radCount)));
256. 
     
257.       //move the points according to the speeds
258.       x+=xspeed;//+random(3);
259.       y+=yspeed;//+random(3);
260.       positionX[0]= x;
261.       positionY[0]= y;
262.       radCount+=radSpeed;
263.       life--;
264.       alpha-=5;
265.     }else{
266.       for (int i=0; i<nodes; i++){
267.         positionX[i]= 1000;
268.         positionY[i]= 1000;
269.       }
270.       xForce=random(speed)-speed/2;
271.       yForce=random(speed)-speed/2;
272.       life=origLife;
273.       alpha=255;
274.     }
275. 
     
276.   }
277. 
     
278.   void render(){
279.     if(alpha>0){
280.       for (int i=0; i<nodes-1; i++){
281.         //stroke(255, 50, 0);
282.         //point(positionX[i], positionY[i]);
283.         rect(positionX[i], positionY[i],1,1);
284.         stroke(255, 50, 0);
285.       }
286.       for (int i=0; i<nodes-1; i++){
287.         positionX[i+1]= positionX[i];
288.         positionY[i+1]= positionY[i];
289.       }
290.     }
291.   }
292. }
293. 
     
294. // Count the number of adjacent cells 'on'
295. int neighbors(int x, int y)
296. {
297.   return world[(x + 1) % glife_vidX][y][0] +
298.   world[x][(y + 1) % glife_vidY][0] +
299.   world[(x + glife_vidX - 1) % glife_vidX][y][0] +
300.   world[x][(y + glife_vidY - 1) % glife_vidY][0] +
301.   world[(x + 1) % glife_vidX][(y + 1) % glife_vidY][0] +
302.   world[(x + glife_vidX - 1) % glife_vidX][(y + 1) % glife_vidY][0] +
303.   world[(x + glife_vidX - 1) % glife_vidX][(y + glife_vidY - 1) % glife_vidY][0] +
304.   world[(x + 1) % glife_vidX][(y + glife_vidY - 1) % glife_vidY][0];
305. }
306. 
     
307.   void playGameOfLife()
308.   {
309.   
310.           // Drawing and update cycle
311.   for (int x = 0; x < glife_vidX; x=x+1) {
312.     for (int y = 0; y < glife_vidY; y=y+1) {
313.       if (world[x][y][1] == 1)
314.       {
315.         world[x][y][0] = 1;
316.         //rectMode(CENTER_DIAMETER);
317.         //rect(x,y,1,1);
318.       }
319.       if (world[x][y][1] == -1)
320.       {
321.         world[x][y][0] = 0;
322.       }
323.       world[x][y][1] = 0;
324.     }
325.   }
326.   
327.   
328. 
     
329.   // Birth and death cycle
330.   for (int x = 0; x < glife_vidX; x=x+1) {
331.     for (int y = 0; y < glife_vidY; y=y+1) {
332.       int count = neighbors(x, y);
333.       if (count == 3 && world[x][y][0] == 0)
334.       {
335.         world[x][y][1] = 1;
336.       }
337.       if ((count < 2 || count > 3) && world[x][y][0] == 1)
338.       {
339.         world[x][y][1] = -1;
340.       }
341. 
     
342.     }
343.   }
344.   }

This code is a bit of a mashup between 2 other bits of code. It was originally "written" in processing 068, but i'm trying to get it working again. My quicktime is updated and my camera works with the basic video capture example.

Any help would be very much appreciated.

Thanks in advance.

Paulo Azevedo