Processing Forum

openKinect question:

[0 Replies]
- 26-Apr-2011 11:10 AM
- Forum: Contributed Library Questions
So let's say that I'm trying to set up a thresholding system with my kinect sensor.
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.*;
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;
10. int kw = 640;
11. int kh = 480;
13. PImage depthImg;
14. int minDepth = 800;
15. int maxDepth = 990;
17. int minimumPresence = 100;
18. int presenceFront = 0;
19. int presenceMiddle = 0;
20. int presenceBack = 0;
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;
30. int by = 0;
32. //frame differencing stuff
33. int numPixels;
34. int[] averagePixels;
35. int[] toScreenPixels;
36. color white = color(255);
37. color black = color(0);
39. boolean firstTime = true;
40. boolean showBackgroundSubtraction = false;
41. boolean showThresholded = false;
43. void setup() {
44. size(640, 520);
45. numPixels = kw * kh;
47. averagePixels = new int[numPixels];
48. toScreenPixels = new int[numPixels];
50. // Make the pixels[] array available for direct manipulation
51. loadPixels();
53. kinect = new Kinect(this);
54. tracker = new KinectTracker();
55. //frameRate(1);
56. }
58. void draw() {
59. background(255);
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);
64. kinect.getVideoImage(); // Read a new video frame
65. //kinect.getVideoPix(); //I'm not sure where to go with this portion
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;
74. int bkgdR = (bkgdColor >> 16) & 0xFF;
75. int bkgdG = (bkgdColor >> 8) & 0xFF;
76. int bkgdB = bkgdColor & 0xFF;
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);
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);
85. if (showBackgroundSubtraction) {
86. int bgSubR = abs(bkgdR - currR);
87. int bgSubG = abs(bkgdG - currG);
88. int bgSubB = abs(bkgdB - currB);
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);
102. // Run the tracking analysis
103. tracker.track();
104. // Show the image
107. // Let's draw the raw location
108. PVector v1 = tracker.getPos();
110. // Let's draw the "lerped" location
111. PVector v2 = tracker.getLerpedPos();
114. // Display some info
115. int t = tracker.getThreshold();
116. }
119. void stop() {
120. tracker.quit();
121. super.stop();
122. }
and
2. class KinectTracker {
4. // Size of kinect image
5. int kw = 640;
6. int kh = 480;
7. int threshold = 900;
9. // Raw location
10. PVector loc;
12. // Interpolated location
13. PVector lerpedLoc;
15. // Depth data
16. int[] depth;
17. int[] depthBg = new int[kw*kh];
20. PImage display;
21. PImage display2;
23. KinectTracker() {
24. kinect.start();
25. kinect.enableDepth(true);
27. // We could skip processing the grayscale image for efficiency
28. // but this example is just demonstrating everything
29. kinect.processDepthImage(true);
31. display = createImage(kw, kh, PConstants.RGB);
32. display2 = createImage(kw, kh, PConstants.RGB);
34. loc = new PVector(0, 0);
35. lerpedLoc = new PVector(0, 0);
36. }
38. void track() {
40. // Get the raw depth as array of integers
41. depth = kinect.getRawDepth();
43. // Being overly cautious here
44. if (depth == null) return;
46. float sumX = 0;
47. float sumY = 0;
48. float count = 0;
50. presenceFront = 0;
51. presenceMiddle = 0;
52. presenceBack = 0;
54. display2.loadPixels();
56. for (int x = 0; x < kw; x++) {
57. for (int y = 0; y < kh; y++) {
59. // Mirroring the image
60. int offset = kw-x-1+y*kw;
62. int bgDepth = depthBg[offset];
63. // Grabbing the raw depth
64. int rawDepth = depth[offset];
67. int correctedBg = rawDepth - bgDepth;
69. int bgAvg = int(a * rawDepth + (1 - a) * bgDepth);
70. depthBg[offset] = bgAvg;
72. display2.pixels[offset] = (color(rawDepth - depthBg[offset]));
74. // Testing against threshold
75. if (correctedBg < threshold) {
76. sumX += x;
77. sumY += y;
78. count++;
79. }
81. if (correctedBg < minDepth) {
82. presenceFront++;
83. }
84. else if (correctedBg >= minDepth && correctedBg < maxDepth) {
85. presenceMiddle++;
86. }
87. else {
88. presenceBack++;
89. }
90. }
91. }
93. display2.updatePixels();
95. int currentPos = -1;
97. int [] list = {
98. presenceFront, presenceMiddle, presenceBack
99. };
101. println(list);
103. int maxPresence = max(list);
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. }
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);
151. // As long as we found something
152. if (count != 0) {
153. loc = new PVector(sumX/count, sumY/count);
154. }
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. }
161. //PVector getLerpedPos() {
162. //return lerpedLoc;
163. //}
165. //PVector getPos() {
166. //return loc;
167. //}
168. }
169. void display() {
170. PImage img = kinect.getDepthImage();
172. // Being overly cautious here
173. if (depth == null || img == null) return;
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];
185. int pix = x+y*display.width;
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();
201. // the image
202. /// image(display, 0, 0);
203. image(display2, 0, 0);
204. }
206. void reset() {
207. currentPos = -1;
208. }
210. void quit() {
211. kinect.quit();
212. }
214. int getThreshold() {
215. return threshold;
216. }
218. void setThreshold(int t) {
219. threshold = t;
220. }

Processing +OSC to Max5/MSP question

[0 Replies]
- 22-Apr-2011 11:08 AM
- Forum: Contributed Library Questions
So, I'm now making a sketch that will send messages to Max5, telling it to open a file and play it.

I can't find anything that tells me what the OSC message needs to be to open the file. I can only seem to find things that are examples using a GUI. I want Processing to take care of all of that.

Anyone have any ideas?

Recording while not putting any sound out.

[0 Replies]
- 17-Apr-2011 11:13 AM
- Forum: Core Library Questions
I'm in the process of working on a sketch that generates loads of data, and that is mapped to a tonal range of a sine wave and is then recorded to a .wav file for future playback.

The program works wonderfully, except for one thing: the sound plays as it is recording. I want the information that would be generated to take tonal characteristics, but not be output until a certain event has occurred.

Has anyone done this before?

I'm currently using the minim library, but would be open to any other library too really, I just want this thing to work.

Thank you.

Minim/recording for future playback

[0 Replies]
- 16-Apr-2011 12:31 PM
- Forum: Core Library Questions
So I am looking to use the minim library to record sounds that I am generating and then play that recording back when a certain event has taken place.

The issue that I am having is that I can't exactly figure out what I need to be doing to not have the audio play as it is being generated, and rather save it for later use.

Any one have any ideas or think that there might be some other audio generation library that may be better suited?

Activity Trend