Processing Forum

Screen name:
rinarinarina

rinarinarina's Profile

1 Posts

1 Responses

0 Followers

Activity Trend

Last 30 days

Loading Chart...

Show:

Expanded view
List view

Issues with TargetRegion in frame differencing

[1 Reply]
- 05-Jun-2013 08:00 AM
- Forum: Core Library Questions
Hi all

Im working with sound and spaces and trying to set an installation, based on webcam triggers.

I was wondering if anyone can help.

I have 5 targetRegions to trigger and play a file, however only one is actually being triggered.

If anyone can point out where Im going wrong thats would be awesome.

Many thanks

Rina
2. import processing.video.*;
3. // minim stuff
4. import ddf.minim.*;
6. Minim minim;
7. AudioPlayer player;
8. //
11. // webcam stuff
12. int numPixels;
13. int[] previousFrame;
14. Capture video;
15. //
17. // target regions specified as a rectangle x,y,width,height
18. int[] targetRegion_1 = { 0,0, 50,480 };
19. int[] targetRegion_2 = { 100,0, 50,480 };
20. int [] targetRegion_3 = {200,0, 50, 480};
21. int [] targetRegion_4 = {300,0, 50, 480};
22. int [] targetRegion_5 = {400, 0, 50, 480};
23. //int [] targetRegion_6 = {500, 0, 50, 480};
25. // amount of delay before allowing trigger
26. int totDelay = 5; // just using cycles, not time
27. int delayCounter = 0;
29. // to determine when sound has finished
30. boolean isPlaying=false;
32. String soundFileName = "spotsound1.mp3";
35. // amount of change required before trigger active, not true percentage
36. float thresholdPercentage = 2.0;
38. void setup() {
39. size(640, 480); // Change size to 320 x 240 if too slow at 640 x 480
40. // Uses the default video input, see the reference if this causes an error
41. video = new Capture(this, width, height, 24);
42. numPixels = video.width * video.height;
43. // Create an array to store the previously captured frame
44. previousFrame = new int[numPixels];
45. loadPixels();
46. noFill();
49. // minim stuff
50. minim = new Minim(this);
51. // load a file, give the AudioPlayer buffers that are 2048 samples long
52. player = minim.loadFile(soundFileName, 2046);
53. // play the file
54. // player.play(); // actually, not here, only start after motion
57. }
59. void draw() {
60. if (video.available())
61. {
62. // When using video to manipulate the screen, use video.available() and
63. // video.read() inside the draw() method so that it's safe to draw to the screen
64. video.read(); // Read the new frame from the camera
65. video.loadPixels(); // Make its pixels[] array available
67. float movementAsPercentage_1 = checkMovement(targetRegion_1[0],targetRegion_1[1],targetRegion_1[2],targetRegion_1[3]);
68. float movementAsPercentage_2 = checkMovement(targetRegion_2[0],targetRegion_2[1],targetRegion_2[2],targetRegion_2[3]);
69. float movementAsPercentage_3 = checkMovement(targetRegion_3[0],targetRegion_3[1],targetRegion_3[2],targetRegion_3[3]);
70. float movementAsPercentage_4 = checkMovement(targetRegion_4[0],targetRegion_4[1],targetRegion_4[2],targetRegion_4[3]);
71. float movementAsPercentage_5 = checkMovement(targetRegion_5[0],targetRegion_5[1],targetRegion_5[2],targetRegion_5[3]);
72. //float movementAsPercentage 6 = checkMovement(targetRegion_6[0],targetRegion_6[1],targetRegion_6[2],targetRegion_6[3]);
74. if(!player.isPlaying())
75. {
76. if(isPlaying) // so the sound has just finished
77. {
78. delayCounter=0; // start delay before allowing restart of playing sound
79. isPlaying=false;
80. }
81. }
83. if(movementAsPercentage_1>0 || movementAsPercentage_2>0 || movementAsPercentage_3>0 || movementAsPercentage_4>0 || movementAsPercentage_5>0)
84. {
85. // println(movementAsPercentage); // for debugging...
86. updatePixels();
87. }
89. //
90. // add one to delay counter if in delay period
91. if(delayCounter<totDelay)
92. {
93. delayCounter++;
94. }
96. if(movementAsPercentage_1 > thresholdPercentage || movementAsPercentage_2 > thresholdPercentage || movementAsPercentage_3 > thresholdPercentage || movementAsPercentage_4 > thresholdPercentage || movementAsPercentage_5 > thresholdPercentage) // if movement detected
97. {
98. noFill();
99. stroke(255,0,0); // red box if in delay period
101. // if not in the delay period
102. // check if reached delay before allowing trigger
103. if(delayCounter==totDelay)
104. {
105. stroke(255,255,0); // yellow box=triggered but already playing sound
106. // if the sound is not already playing
107. if(!player.isPlaying())
108. {
109. stroke(0,255,0); // green box = start sound
110. // then play the sound from the beginning (0)
111. isPlaying=true;
112. player.play(0);
113. }
114. }
116. // draw the rectangle around the region
117. rect(targetRegion_1[0],targetRegion_1[1],targetRegion_1[2],targetRegion_1[3]);
118. rect(targetRegion_2[0],targetRegion_2[1],targetRegion_2[2],targetRegion_2[3]);
119. rect(targetRegion_3[0],targetRegion_3[1],targetRegion_3[2],targetRegion_3[3]);
120. rect(targetRegion_4[0],targetRegion_4[1],targetRegion_4[2],targetRegion_4[3]);
121. rect(targetRegion_5[0],targetRegion_5[1],targetRegion_5[2],targetRegion_5[3]);
122. //rect(targetRegion_6[0],targetRegion_6[1],targetRegion_6[2],targetRegion_6[3]);
125. }
126. else
127. {
128. if(player.isPlaying())
129. {
130. noFill();
131. stroke(155,155,155); // grey box = sound is playing
132. rect(targetRegion_1[0],targetRegion_1[1],targetRegion_1[2],targetRegion_1[3]);
133. rect(targetRegion_2[0],targetRegion_2[1],targetRegion_2[2],targetRegion_2[3]);
134. rect(targetRegion_3[0],targetRegion_3[1],targetRegion_3[2],targetRegion_3[3]);
135. rect(targetRegion_4[0],targetRegion_4[1],targetRegion_4[2],targetRegion_4[3]);
136. rect(targetRegion_5[0],targetRegion_5[1],targetRegion_5[2],targetRegion_5[3]);
137. //rect(targetRegion_6[0],targetRegion_6[1],targetRegion_6[2],targetRegion_6[3]);
139. }
140. // player.pause();
141. }
143. }
144. }
147. //=========================
148. // returns the amount of movement in the specified region as a percentage(ish)
149. float checkMovement(int x, int y, int w, int h)
150. {
151. int movementSum = 0; // Amount of movement in the frame
152. for(int ypos = 0;ypos < video.height; ypos ++)
153. {
154. for(int xpos = 0;xpos < video.width; xpos ++)
155. {
156. int index = xpos + (ypos * video.width);
157. color currColor = video.pixels[index];
158. if( xpos >= x && xpos < x+w && ypos >= y && ypos < y+h)
159. {
160. color prevColor = previousFrame[index];
162. int currR = (currColor >> 16) & 0xFF; // Like red(), but faster
163. int currG = (currColor >> 8) & 0xFF;
164. int currB = currColor & 0xFF;
165. // Extract red, green, and blue components from previous pixel
166. int prevR = (prevColor >> 16) & 0xFF;
167. int prevG = (prevColor >> 8) & 0xFF;
168. int prevB = prevColor & 0xFF;
169. // Compute the difference of the red, green, and blue values
170. int diffR = abs(currR - prevR);
171. int diffG = abs(currG - prevG);
172. int diffB = abs(currB - prevB);
174. //
175. movementSum += diffR + diffG + diffB;
176. // Render the difference image to the screen
177. pixels[index] = color(diffR, diffG, diffB);
178. // The following line is much faster, but more confusing to read
179. //pixels[i] = 0xff000000 | (diffR << 16) | (diffG << 8) | diffB;
180. // Save the current color into the 'previous' buffer
181. }
182. else
183. {
184. // if this pixel isnt in our area of interest, just show current video frame colour
185. pixels[index] = currColor;
186. }
188. // keep the current pixel colour for comparison next time
189. previousFrame[index] = currColor;
190. }
191. }
193. int totalPossibleMovement = w*h*255*3; // width * height (of area of interest) * 255 (is the max difference per colour) * 3 (number of colour channels eg:rgb)
194. float percentage = (float)movementSum / (float)totalPossibleMovement;
195. percentage = percentage * 100.0f;
197. return percentage;
198. }
201. void stop()
202. {
203. // always close Minim audio classes when you are done with them
204. player.close();
205. // always stop Minim before exiting
206. minim.stop();
208. super.stop();
209. }

«Prev
Next »