Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
766
Let’s now return to the initial expression listed in the Processing reference that sparked
this discussion:
float r = myColor >> 16 & 0xFF;
You’ll remember that this expression is a way of getting just the red component of the
color and a faster alternative to Processing’s red() function. Let’s assume myColor is
#FF00FF (purple) and 100 percent alpha (which you’ll remember is the default). The bit
string of this color integer is as follows:
11111111 11111111 00000000 11111111
(alpha) (red) (green) (blue)
Again, I divided the 32-bit string into 4 bytes, just to show how the packed integer represents
the different color components. As I specified, the four 8-bit groups, from left to
right, represent the alpha, red, green, and blue components, respectively. Remembering
what I discussed a few paragraphs back, can you guess whether this integer would evaluate
to a positive or negative value? The answer is negative, since the signed (leftmost) bit
is a one. To test this, run println(#FF00FF );, which should output -65281. This specific
value is not terribly useful. (I remember being pretty confused the first time I ran a
println() on one of my colors and it came up with this huge negative value.) What is
worth remembering is that the sign of the number is based on the leftmost bit (1 is negative
and 0 is positive).
Next, let’s shift the bits of the original purple color 16 places to the right. Here is the original
bit string:
11111111 11111111 00000000 11111111
Shifting the bits 16 places to the right, it becomes the following:
11111111 11111111 11111111 11111111
The 16 bits on the left side of the number move to the right 16 places. The original 16 bits
on the right side move over as well, but since there are no places to their right, they are
discarded. You may be wondering then why the original 16 places on the left, after the
shifting takes place, remain ones instead of becoming zeros. This is a good question, which
originally confused me as well. The reason for this relates to the signed bit (the leftmost
bit), which you’ll remember was a one in the original purple color. When bits are shifted to
the right in a two’s complement system, any empty positions on the left side, where the
bits were shifted away from, as in this example, are filled with the value of the signed bit.
That’s why in the last example, the left 16 bits were replaced with ones instead of zeros.
Here’s one more example in Processing:
color c1 = color(255, 255, 0, 127);
println("c1 = " + c1);
println("binary(c1) = " + binary(c1));
println("show 32 bits = 0" + binary(c1));
println("binary(c1>>16) = " + binary(c1>>16));
println("show 32 bits = 00000000000000000" + binary(c1>>16));