Why do you use a 2D array? It just complicate things. See how the pixels[] array is a 1D array used to hold the values of a 2D object (the image). You can do the same with the brightness, it is just a matter of converting the two coordinates of a surface into a single integer value (see your loc variable).

Thank you PhiLho,

Maybe it's better to explain my whole plan in short:
I need to write a programm that recognises the border
between a landscape (or a skyline) and the sky.
To make it easier I decided to work with greyscale
images so that I can use brightness.

For this I got the advice to work with 2D arrays
and the first step will be to save the brightness
of each pixel in both parts of the 2D array.

Maybe my thinking is wrong?

Here's another try to get the brightness
information. But I don't know how to print it

1. for (int i = 0; i < cols; i++) {
2.   for (int j = 0; j < rows; j++) {
3.     int loc = i + j*width;
4.     float brightness = brightness (img.pixels[loc]);
5.   }
6. }

Well, the last code is then a step in the right direction: you get the brightness of each pixel given its i, j coordinates.
Declare the brightness as:
int[][] brightness_values = new int[cols][rows];
and assign it in your nested loop:
brightness_values[i][j] = brightness;

Hm, strange. Processign complained "expecting DOT, found "brightness_values" ".

1. // Declare 2D arrays
2. int[][] myArray = new int[cols][rows];
3. int[][] brightness_values = new int[cols][rows];
4. 
   
5. for (int i = 0; i < cols; i++) {
6.   for (int j = 0; j < rows; j++) {
7.     int loc = i + j*width;
8.     int[][] brightness_values [j][i] = brightness ();
9.     print (brightness (img.pixels[loc]));
10.   }
11. }

Sorry, I made a copy / paste error in my answer above, I fixed it. Of course, brightness_values must not be re-declared in the loop. And assign brightness, the value, not the function call. Or do:
brightness_values[i][j] = brightness(img.pixels[loc]);
if you prefer.

Thanks again. Now I can read each brightness value.

1. // Declare 2D array
2. int[][] brightness_values = new int[cols][rows];
3. 
   
4. //Find location of each pixel
5. for (int i = 0; i < cols; i++) {
6.   for (int j = 0; j < rows; j++) {
7.     int loc = i + j*width;
8.     print (brightness (img.pixels[loc]));
9.   }
10. }

But how did you mean "brightness_values[i][j] = brightness(img.pixels[loc]);"? Where could I implement this? Just for my deeper understanding of things ...

" how did you mean"
I don't understand...

" Where could I implement this?"
Inside the loop, where you have a print (replacing it).

Sorry for the long delay. The version above prints the brightness values, but someone told me that I have to change my plan a bit.

He suggested me to build first an array that gives each pixel its own number. Together with him I've built the following code. Now the console prints "1, 2, 3, 4, ..." and so on.

The next step is to print the brightness values in the same order but here I feel lost again and will be thankful for any help.

1. PImage source; // Source image
2. PImage destination; // Destination image
3.    
4. int[][] twodimensional_array; // This is a global variable
5. int [] onedimensional_array; // This is a global variable
6.    
7. void setup() {
8.   size(715,500);
9.   int who;
10.   int cols = width;
11.   int rows = height;
12.   int cols_and_rows = width*height;
13.   onedimensional_array = new int[cols_and_rows];
14.   source = loadImage("frankfurt_skyline_02.jpg");
15.   destination = createImage(source.width, source.height, RGB);
16. 
    
17.   // Declare 2D array
18.   twodimensional_array = new int[cols][rows];
19. 
    
20. }
21. void draw() {
22. 
    
23. source.loadPixels();
24. destination.loadPixels();
25. int to = 0;
26. int who = 0;
27. for (int x = 0; x < source.width; x++ ) {
28.   who = who + to;
29.     for (int y = 0; y < source.height; y++ ) {
30.     who = who + 1;
31.     onedimensional_array[who] = who; // at position "1" now there's really a "1"
32.     print (onedimensional_array[who]);
33.     print(" ");
34.   }
35.  
36.   // makes a continuous numeration. Each Pixel now has an own number.
37.   to = who;
38.  
39.   // the variable "who" will be emptied again
40.   who = 0;
41.   }
42.   updatePixels();
43.   image(destination, 0,0);
44. }

Actually, I fail to see the point of this array building... An array with values identical to the index is rather pointless.

Hi PhiLho,

My aim was to convert a two-dimensional array into a one-dimensional array so that the console prints the pixel order like "1, 2, 3, ..." So, yes you're right that I didn't change any pixel values so far. I just re-ordered the way how they gonna be read.

My friend told that this is necessary for the next step: To read brightness values of each pixel in an order that is useful for my purpose.

Did I express myself clearly?

Hm, probably my first try in this thread was more clever ...

Maybe you can give me a suggestion in which direction I should go for the whole task:
I have to save the pixels of the border between the sky and the landscape. In the next
step I want to create sound based on this borderline.

Indeed, the formula
int loc = i + j*width;
you used above is all what you need to " convert a two-dimensional array into a one-dimensional array" indexes.

Ok, a new try.

With this code I've made a black and white image to make a maximum contrast between sky and foreground.

Now I want to create an array that scans in direction Y. When it reaches the first black pixel it should save the position and go on to the next pixel row. (That means it shouldn't go on scanning further pixels below the first black pixel.
I hope in this way I can re-create the line on the horizon.

Does this idea make sense?

1. PImage source;       // Source image
2. PImage destination;  // Destination image
3. void setup() {
4. size(600,450);
5. int cols = width;
6. int rows = height;
7. source = loadImage("skyline.jpg"); 
8.  
9. // The destination image is created as a blank image the same size as the source.
10. destination = createImage(source.width, source.height, RGB);
11. }
12. void draw()
13. { 
14.   int brightness_value = 190;
15.   // Load both images
16.   source.loadPixels();
17.   destination.loadPixels();
18.  
19. /* First Loop:  The threshold value increase to draw a black and white image*/ 
20.   for (int x = 0; x < source.width; x++)
21.   {
22.     for (int y = 0; y < source.height; y++ )
23.     {
24.      
25.       // Calculate the 1D pixel location
26.       int loc = x + y*source.width;
27.      
28.       // Compare brightness with "brightness_value"
29.       if (brightness(source.pixels[loc]) > brightness_value)
30.       {
31.         destination.pixels[loc]  = color(255);  // White
32.       } 
33.      
34.       else {
35.         destination.pixels[loc]  = color(0);    // Black
36.       }
37.     }
38.   }
39.   // Refresh all pixels
40.   destination.updatePixels();
41.  
42.   // Display the destination
43.   image(destination,0,0);
44.  
45. /* Second Loop:  The threshold value increases to draw a black and white image*/
46.  for (int x = 0; x < source.width; x++) {
47.     for (int y = 0; y < source.height; y++ ) {
48.      
49.     // Calculate the 1D pixel location
50.     int loc = x + y*source.width;
51.     print (brightness (destination.pixels[loc]));
52.     print(" "); 
53.     } 
54.    }   
55. }

Here's my basic idea for coding in the second loop. But how to express this in real code?

1. if (color (destination.pixels[loc]) = black; {
2.         save the position;
3.         go the next pixel row;
4.         }