Processing Forum

if (int < 10) { Load next image and decrement integer }

[1 Reply]
- 25-May-2013 05:58 PM
- Forum: Programming Questions
Hi,

I have this code (which is probably not very well writtern, but works). The code is changing the appearance of an image based on a Light Dependant Resistor that has Serial Data coming through from Arduino. The potentiometer is just changing the effect.

I want it so when the LDR value (ldreffect) is less than 10, it moves onto the next image, but continues to decrement the blur that you can see in the if () {} statement below.

The problem that I am having is that when I want to increment the photo integer by 1, it keeps looping. I still want the blur to loop though.

Any suggestions??
2. boolean sketchFullScreen() {
3. return true;
4. }
6. import processing.serial.*;
7. Serial myPort;
8. String sensorReading="";
9. PImage img;
10. int blur = 40;
11. int poster = 40;
12. int effect = 0;
13. int photo = 0;
15. void setup() {
16. myPort = new Serial(this, "/dev/tty.usbmodem1411", 9600);
17. myPort.bufferUntil('\n');
18. size(1024, 768);
19. img = loadImage("image1.jpg"); // Load the original image
20. noLoop();
21. }
23. void serialEvent (Serial myPort){
24. sensorReading = myPort.readStringUntil('\n');
25. if(sensorReading != null){
26. sensorReading=trim(sensorReading);
27. }
29. String rawserial = sensorReading;
30. int[] serialvals = int(split(rawserial, '\t'));
31. int ldr = serialvals[0];
32. int pot = serialvals[1];
33. String sldr = str(ldr);
34. String spot = str(pot);
35. //println(pot);
36. //println(ldr);
37. delay(500);
38. ldreffect(sldr);
39. potchange(spot);
40. }
42. void draw() {
43. image(img, 0, 0);
44. if (blur > 40){
45. blur = 40;
46. } else if(blur < 0){
47. blur = 0;
48. }
50. if (poster < 2){
51. poster = 2;
52. } else if (poster > 40){
53. poster = 40;
54. }
56. if(effect == 0){
57. filter(BLUR, blur);
58. redraw();
59. } else if(effect == 1){
60. //float poster = map(ldrblur, 10, 50, 50, 2);
61. //println(poster);
62. filter(POSTERIZE, poster);
63. redraw();
64. } else if(effect == 2){
65. //float poster = map(ldrblur, 10, 50, 50, 2);
66. //println(poster);
67. filter(INVERT);
68. redraw();
69. } else if(effect == 3){
70. //float poster = map(ldrblur, 10, 50, 50, 2);
71. //println(poster);
72. filter(GRAY);
73. redraw();
74. } else if(effect == 4){
75. //float poster = map(ldrblur, 10, 50, 50, 2);
76. //println(poster);
77. filter(THRESHOLD);
78. redraw();
79. } else if(effect == 5){
80. //float poster = map(ldrblur, 10, 50, 50, 2);
81. //println(poster);
82. filter(BLUR, blur);
83. redraw();
84. }
86. }
88. void potchange(String potval) {
89. int potchange = int(potval);
90. effect = potchange;
91. //println(effect);
92. }
94. void ldreffect(String ldrval) {
95. //println(ldrval);
96. int ldreffect = int(ldrval);
97. //blur = ldrblur;
98. if (ldreffect < 10) {
99. println(photo);
100. blur -= 1;
101. poster += 1;
102. redraw();
103. } else if (ldreffect > 10) {
104. blur += 1;
105. poster -= 1;
106. redraw();
107. }
108. //println(blur);
109. }

How to read out Z co-ordinate?

[3 Replies]
- 25-Apr-2013 04:02 AM
- Forum: Contributed Library Questions
I have the code below that reads out the X and Y location of the dot. I am a complete newbie to Processing and Kinect. How can I read out the Z (depth) location co-ordinate?

Help will be much appreciated!
AveragePointTracking.pde:
3. // Daniel Shiffman
4. // Tracking the average location beyond a given depth threshold
5. // Thanks to Dan O'Sullivan
6. // http://www.shiffman.net
7. // https://github.com/shiffman/libfreenect/tree/master/wrappers/java/processing
9. import org.openkinect.*;
10. import org.openkinect.processing.*;
12. // Showing how we can farm all the kinect stuff out to a separate class
13. KinectTracker tracker;
14. // Kinect Library object
15. Kinect kinect;
17. void setup() {
18. size(640,600);
19. kinect = new Kinect(this);
20. tracker = new KinectTracker();
21. }
23. void draw() {
24. background(255);
26. // Run the tracking analysis
27. tracker.track();
28. // Show the image
29. tracker.display();
31. // Let's draw the raw location
32. PVector v1 = tracker.getPos();
33. fill(50,100,250,200);
34. noStroke();
35. ellipse(v1.x,v1.y,10,10);
37. // Let's draw the "lerped" location
38. //PVector v2 = tracker.getLerpedPos();
39. //fill(100,250,50,200);
40. //noStroke();
41. //ellipse(v2.x,v2.y,20,20);
43. // Display some info
44. int t = tracker.getThreshold();
45. fill(0);
46. text("Location-X: " + v1.x,10,500);
47. text("Location-Y: " + v1.y,10,530);
48. text("Depth: ",10,560);
49. text("threshold: " + t,10,590);
50. }
52. void stop() {
53. tracker.quit();
54. super.stop();
55. }
KinectTracker.pde:
3. class KinectTracker {
5. // Size of kinect image
6. int kw = 640;
7. int kh = 480;
8. int threshold = 500;
10. // Raw location
11. PVector loc;
13. // Interpolated location
14. PVector lerpedLoc;
16. // Depth data
17. int[] depth;
20. PImage display;
22. KinectTracker() {
23. kinect.start();
24. kinect.enableDepth(true);
26. // We could skip processing the grayscale image for efficiency
27. // but this example is just demonstrating everything
28. kinect.processDepthImage(true);
30. display = createImage(kw,kh,PConstants.RGB);
32. loc = new PVector(0,0);
33. lerpedLoc = new PVector(0,0);
34. }
36. void track() {
38. // Get the raw depth as array of integers
39. depth = kinect.getRawDepth();
41. // Being overly cautious here
42. if (depth == null) return;
44. float sumX = 0;
45. float sumY = 0;
46. float count = 0;
48. for(int x = 0; x < kw; x++) {
49. for(int y = 0; y < kh; y++) {
50. // Mirroring the image
51. int offset = kw-x-1+y*kw;
52. // Grabbing the raw depth
53. int rawDepth = depth[offset];
55. // Testing against threshold
56. if (rawDepth < threshold) {
57. sumX += x;
58. sumY += y;
59. count++;
60. }
61. }
62. }
63. // As long as we found something
64. if (count != 0) {
65. loc = new PVector(sumX/count,sumY/count);
66. }
68. // Interpolating the location, doing it arbitrarily for now
69. lerpedLoc.x = PApplet.lerp(lerpedLoc.x, loc.x, 0.3f);
70. lerpedLoc.y = PApplet.lerp(lerpedLoc.y, loc.y, 0.3f);
71. }
73. PVector getLerpedPos() {
74. return lerpedLoc;
75. }
77. PVector getPos() {
78. return loc;
79. }
81. void display() {
82. PImage img = kinect.getDepthImage();
84. // Being overly cautious here
85. if (depth == null || img == null) return;
87. // Going to rewrite the depth image to show which pixels are in threshold
88. // A lot of this is redundant, but this is just for demonstration purposes
89. display.loadPixels();
90. for(int x = 0; x < kw; x++) {
91. for(int y = 0; y < kh; y++) {
92. // mirroring image
93. int offset = kw-x-1+y*kw;
94. // Raw depth
95. int rawDepth = depth[offset];
97. int pix = x+y*display.width;
98. if (rawDepth < threshold) {
99. // A red color instead
100. display.pixels[pix] = color(245,100,100);
101. }
102. else {
103. display.pixels[pix] = img.pixels[offset];
104. }
105. }
106. }
107. display.updatePixels();
109. // Draw the image
110. image(display,0,0);
111. }
113. void quit() {
114. kinect.quit();
115. }
117. int getThreshold() {
118. return threshold;
119. }
121. void setThreshold(int t) {
122. threshold = t;
123. }
124. }

Read out depth (Z position) of tracked point in text()

[2 Replies]
- 24-Apr-2013 10:19 AM
- Forum: Contributed Library Questions
Hi,

The code that I have below reads out the x and y position of a dot. How do I get it to read out the depth of the dot?
AveragePointTracking.pde:
2. // Daniel Shiffman
3. // Tracking the average location beyond a given depth threshold
4. // Thanks to Dan O'Sullivan
5. // http://www.shiffman.net
6. // https://github.com/shiffman/libfreenect/tree/master/wrappers/java/processing
8. import org.openkinect.*;
9. import org.openkinect.processing.*;
11. // Showing how we can farm all the kinect stuff out to a separate class
12. KinectTracker tracker;
13. // Kinect Library object
14. Kinect kinect;
16. void setup() {
17. size(640,600);
18. kinect = new Kinect(this);
19. tracker = new KinectTracker();
20. }
22. void draw() {
23. background(255);
25. // Run the tracking analysis
26. tracker.track();
27. // Show the image
28. tracker.display();
30. // Let's draw the raw location
31. PVector v1 = tracker.getPos();
32. fill(50,100,250,200);
33. noStroke();
34. ellipse(v1.x,v1.y,10,10);
36. // Let's draw the "lerped" location
37. //PVector v2 = tracker.getLerpedPos();
38. //fill(100,250,50,200);
39. //noStroke();
40. //ellipse(v2.x,v2.y,20,20);
42. // Display some info
43. int t = tracker.getThreshold();
44. fill(0);
45. text("Location-X: " + v1.x,10,500);
46. text("Location-Y: " + v1.y,10,530);
47. text("Depth: ",10,560);
48. text("threshold: " + t,10,590);
49. }
51. void stop() {
52. tracker.quit();
53. super.stop();
54. }
KinectTracker.pde:
2. class KinectTracker {
4. // Size of kinect image
5. int kw = 640;
6. int kh = 480;
7. int threshold = 500;
9. // Raw location
10. PVector loc;
12. // Interpolated location
13. PVector lerpedLoc;
15. // Depth data
16. int[] depth;
19. PImage display;
21. KinectTracker() {
22. kinect.start();
23. kinect.enableDepth(true);
25. // We could skip processing the grayscale image for efficiency
26. // but this example is just demonstrating everything
27. kinect.processDepthImage(true);
29. display = createImage(kw,kh,PConstants.RGB);
31. loc = new PVector(0,0);
32. lerpedLoc = new PVector(0,0);
33. }
35. void track() {
37. // Get the raw depth as array of integers
38. depth = kinect.getRawDepth();
40. // Being overly cautious here
41. if (depth == null) return;
43. float sumX = 0;
44. float sumY = 0;
45. float count = 0;
47. for(int x = 0; x < kw; x++) {
48. for(int y = 0; y < kh; y++) {
49. // Mirroring the image
50. int offset = kw-x-1+y*kw;
51. // Grabbing the raw depth
52. int rawDepth = depth[offset];
54. // Testing against threshold
55. if (rawDepth < threshold) {
56. sumX += x;
57. sumY += y;
58. count++;
59. }
60. }
61. }
62. // As long as we found something
63. if (count != 0) {
64. loc = new PVector(sumX/count,sumY/count);
65. }
67. // Interpolating the location, doing it arbitrarily for now
68. lerpedLoc.x = PApplet.lerp(lerpedLoc.x, loc.x, 0.3f);
69. lerpedLoc.y = PApplet.lerp(lerpedLoc.y, loc.y, 0.3f);
70. }
72. PVector getLerpedPos() {
73. return lerpedLoc;
74. }
76. PVector getPos() {
77. return loc;
78. }
80. void display() {
81. PImage img = kinect.getDepthImage();
83. // Being overly cautious here
84. if (depth == null || img == null) return;
86. // Going to rewrite the depth image to show which pixels are in threshold
87. // A lot of this is redundant, but this is just for demonstration purposes
88. display.loadPixels();
89. for(int x = 0; x < kw; x++) {
90. for(int y = 0; y < kh; y++) {
91. // mirroring image
92. int offset = kw-x-1+y*kw;
93. // Raw depth
94. int rawDepth = depth[offset];
96. int pix = x+y*display.width;
97. if (rawDepth < threshold) {
98. // A red color instead
99. display.pixels[pix] = color(245,100,100);
100. }
101. else {
102. display.pixels[pix] = img.pixels[offset];
103. }
104. }
105. }
106. display.updatePixels();
108. // Draw the image
109. image(display,0,0);
110. }
112. void quit() {
113. kinect.quit();
114. }
116. int getThreshold() {
117. return threshold;
118. }
120. void setThreshold(int t) {
121. threshold = t;
122. }
123. }

Activity Trend