Some suggestions:

• Store your colors outside the for loop, otherwise there is no efficiency gain.
• Use the actual colors, not just ints (these are not the same in most cases).
• Brightness is costly, just compare the actual colors.
• You need an array to store the positions. The size of the array is the width of the sketch.
  
• Go over the x's and the y's, the first y sets the position for this column, then break to next x.

Code Example

1. color black = color(0);
2. color white = color(255);
3. int[] positions;
4.  
5. void setup() {
6.   size(500, 500);
7.   positions = new int[width];
8. }
9.  
10. void draw() {
11.   // randomize landscape every 60th frame
    
12.   if (frameCount%60==0) { randomize(); }
13.   // find and draw positions every 60th frame (but 20 frames later as the new landscape)
    
14.   if ((frameCount+20)%60==0) { findPositions(); drawPositions(); }
15. }
16.  
17. // generate random black and white mountain scape
    
18. void randomize() {
19.   background(white);
20.   loadPixels();
21.   for (int i=0; i<pixels.length; i++) {
22.     if (i/width>(noise(frameCount+i%width*0.01)+0.5)*height/2) {
23.       pixels[i] = black;
24.     }
25.   }
26.   updatePixels();
27. }
28. 
    
29. // find the first black pixel from the top (y) for each column (x)
    
30. void findPositions() {
31.   loadPixels();
32.   for (int x=0; x<width; x++) {
33.     for (int y=0; y<height; y++) {
34.       if (y==0) { positions[x] = -1; }
35.       int index = x + y * width;
36.       color c = pixels[index];
37.       if (c == black) {
38.         positions[x] = y;
39.         break;
40.       }
41.     }
42.   }
43. }
44. 
    
45. // draw the found positions with a thick red stroke
    
46. void drawPositions() {
47.   strokeWeight(10);
48.   stroke(255, 0, 0);
49.   beginShape(LINES);
50.   for (int x=0; x<width; x++) {
51.     int y = positions[x];
52.     if (y>-1) {
53.       vertex(x, y);
54.     }
55.   }
56.   endShape();
57. }

Hi amnon,

I tried to implement your example in my project as I want to find the very first black pixel of an image. But somehow the programm doesn't draw a red line anymore. Obviously it doesn't recognize the black pixels of an image.

Do you have an idea how to fiy it?

1. PImage test_image;    
2. color black = color(0);
3. color white = color(255);
4. int[] positions;
5. void setup() {
6. size(600,450);
7. positions = new int[width];
8. test_image = loadImage("skyline.jpg"); 
9. }
10. void draw() {
11. // Display the image
12. image(test_image,0,0);
13. } 
14.  
15. /* SECOND STEP
16. find the first black pixel from the top (y) for each column (x)*/ 
17. void findPositions() {
18.       test_image.loadPixels();
19.       for (int x=0; x<width; x++) {
20.         for (int y=0; y<height; y++) {
21.           if (y==0)
22.             { positions[x] = -1; }
23.             int index = x + y * width;
24.             color c = pixels[index];
25.               if (c == black) {
26.               positions[x] = y;
27.               print (positions[x]);
28.               break;
29.               }
30.           }
31.         }
32.     }
33.    
34. /* THIRD STEP
35. draw the found positions with a thick red stroke*/    
36.    
37. void drawPositions() {
38.       strokeWeight(10);
39.       stroke(255, 0, 0);
40.       beginShape(LINES);
41.       for (int x=0; x<width; x++) {
42.         int y = positions[x];
43.         if (y>-1) {
44.           vertex(x, y);
45.         }
46.       }
47.       endShape();
48.     }

  

It might help to call your functions in draw(), after the image() call, too...

Do you mean the for-loops?

1. void draw() {
2. // Display the image
3. image(test_image,0,0);
4. for (int x=0; x<width; x++) {
5.   for (int y=0; y<height; y++) {
6.     }
7.   }
8. for (int x=0; x<width; x++) {
9.         int y = positions[x];
10.       }
11.   }

No, the methods findPositions() and drawPositions(). You copy-pasted them, but you are not using them anywhere in your program, so of course nothing happens. Take a look at my example, I'm calling these functions in my draw() loop. You should do the same, after you display the image.

You changed the first line of the findPositions() method to test_image.loadPixels(); This will probably cause a nullpointer exception, because the rest of that method operates on the main pixel array (which now doesn't get loaded). Either leave the method intact as it was or change the whole method to operate on the pixel array of the image.

Also, you don't need to do all of this continuously. In this case you could add a noLoop() or put the calls in setup(). In a more interactive/dynamic program, you could make sure findPositions() is called once when needed so only the drawing methods (image and positions) are called continuously.

Oh sure. I've recognized my obvious mistake. Now it works basicly.
My new draw function:

1. void draw() {
2. // Display the image
3. image(test_image,0,0);
4. findPositions();
5. drawPositions();
6. }   

Just a further question: the redline doesn't continue at some spots.



How to fix that?

Use:

1. noFill();
2. beginShape();

instead of

1. beginShape(LINES);

Great! Thanks a lot!

The code and the result for anyone who cares:

1. PImage test_image;    
2. color black = color(0);
3. color white = color(255);
4. int[] positions;
5. void setup() {
6.   size(600,450);
7.   noLoop();
8.   positions = new int[width];
9.   test_image = loadImage("skyline.jpg");
10. } 
11. /* FIRST STEP
12. find the first black pixel from the top (y) for each column (x)*/ 
13. void findPositions() {
14.       loadPixels();
15.       for (int x=0; x<width; x++) {
16.         for (int y=0; y<height; y++) {
17.           if (y==0)
18.             { positions[x] = -1; }
19.             int index = x + y * width;
20.             color c = pixels[index];
21.               if (c == black) {
22.               positions[x] = y;
23.               print (positions[x]);
24.               print (" ");
25.               break;
26.               }
27.           }
28.         }
29.     }
30.    
31. /* SECOND STEP
32. draw the found positions with a thick red stroke*/    
33.    
34. void drawPositions() {
35.       strokeWeight(3);
36.       stroke(255, 0, 0);
37.       noFill();
38.       beginShape();
39.       for (int x=0; x<width; x++) {
40.         int y = positions[x];
41.         if (y>-1) {
42.           vertex(x, y);
43.         }
44.       }
45.       endShape();
46.     }
47. void draw() {
48. // Display the image
49. image(test_image,0,0);
50. findPositions();
51. drawPositions();
52. }