Each element in the pixel array is a 32 bit integer i.e. 4 bytes each byte having 8 bits.

The bit pattern in the integer is coded so you have 8 bits each for the alpha level (opaqueness), red, green and blue

AAAAAAAARRRRRRRRGGGGGGGGBBBBBBBB
  alpha   red     green   blue

there's a bit here about using bitshifts to extract colour components.

http://processing.org/reference/rightshift.html

println will report a -ve number for anything with the top bit set, which will be pretty much everything given that opacity defaults to 255 (0xFF, 11111111). so printing it in hex will make it easier to see.

To see its hexadecimal representation, use function ->  hex():

OK, so I still want to understand the relationship between #00FF00 and 65280. What exactly does 65280 represent, or how is it derived?

The reason I am asking is I am trying to understand Kim Asedorf's Pixel Sorting sketch. He determines whether a pixel is black or white based on this number.

Am I right in assuming that if we were to organize every colour from 0 to (whatever the maximum is) the colours would be arranged by "whiteness" to "blackness"?

edit: I'm guessing that the max is 16 million.

The hash character # before a hexadecimal value is syntactic sugar for 0xff.

This is great, thanks. It's starting to make more sense to me.

Now, shades of gray happen when all RGB channels have the same value like -> #A5A5A5.

I'm not looking to sort from white to black. I want to know what happens when you change the blackValue or whiteValue in Asendorf's sketch.  Why is white -1300000?

              

               int 
               blackValue 
               = 
               -
               16000000
               ;
              
              

               int 
               brigthnessValue 
               = 
               60
               ;
              
              

               int 
               whiteValue 
               = 
               -
               13000000
               ;
              

First article of the Technical FAQ: What is a color in Processing?

Actually, a full white is -1 or #FFFFFF!

Alright, it's slowly coming together for me.

So the int int doesn't really relate to the colour itself in the same way RGB does. I.e. the digits don't relate to a colour value, but rather the sum of the hex value. I had a read through the Wikipedia article on hexadecimal for this.

So, back to Asendorf. In part of his pixel sorting sketch he looks for the first black value and first not black value by checking if a pixel is > or < -16000000.

Am I right in saying that this is like checking a pixel's lightness (as in HSL)?

//BLACK
int getFirstNotBlackX(int _x, int _y) {
  int x = _x;
  int y = _y;
  color c;
  while ( (c = img.pixels[x + y * img.width]) < blackValue) {
    x++;
    if (x >= width) return -1;
  }
  return x;
}

int getNextBlackX(int _x, int _y) {
  int x = _x+1;
  int y = _y;
  color c;
  while ( (c = img.pixels[x + y * img.width]) > blackValue) {
    x++;
    if (x >= width) return width-1;
  }
  return x-1;
}

By the way, thanks so much for all the helpful responses.

" Am I right in saying that this is like checking a pixel's lightness (as in HSL)?"
Probably not...
Brightness / lightness is computed with a more complex formula.
I think it is just an arbitrary way to divide pixels in two categories.

Thank, PhiLo. I think I understand what's going on in the Asendorf sketch now.