Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
214
This other way is less common:
float[]x;
x = new float []{val-1, val-2, val-3...};
Getting back to the 2D array float[][]xy, this array just holds two other arrays. In this
case, both of the internal arrays x[] and y[] are the same size, or length, but they don’t
actually need to be. For example, the following is perfectly legal:
int[]months = new int[12];
int[]weeks = new int[52];
int[]days = new int[365];
int[][]year = {months, weeks, days};
year is still a 2D array, even though it contains three arrays, each with a different length. A
3D array, which I don’t recommend using, would be an array containing 2D arrays (yuck).
To access the first value in the first array in xy[][], you use xy[0][0];. To access the second
value in the first array, you use xy[0][1];. To access the first value in the second
array, you use xy[1][0]; to access the second value in the second array, you use
xy[1][1]. Do you see the pattern? Here’s one more: if you wanted to access the 17th
value in the 26th array, you’d write arrayname[25][16]. One other metaphor that might
help you visualize a 2D array is a multi-drawer filing cabinet. The first set of brackets of a
2D array can be thought of as the drawers of the filing cabinet, and the second set of
brackets represent the files in each drawer. You’ll be using arrays a whole lot throughout
the book, so rest assured—if it didn’t stick this time, it will eventually.
Anti-aliasing using the smooth function
The other new function I used in the plotter example was smooth(), which anti-aliases
the screen output. Anti-aliasing is essentially a blending trick, providing a smooth edge to
screen output. Since the screen is composed of discrete rectangular pixels in a rigid grid,
diagonal and curved edges won’t coincide precisely with the pixel grid, and will thus
appear jagged. Anti-aliasing compensates for this by filling in edge pixels with varying
colors/values, based on an anti-aliasing algorithm. For example, a relatively simple antialiasing
algorithm could be to evaluate the percent a pixel is overlapped by a shape’s ideal
edge (the edge if it weren’t converted to jagged pixels), and then fill those overlapped pixels
with a color value based on the edge color multiplied by the percent of overlap. A popular,
but far more processor-intensive anti-aliasing technique is called supersampling, in
which an image in internally rendered to a pixel buffer (not to the screen) multiple times
larger than it actually is. Thus, numerous pixels now represent each original image pixel.
Color values can then be evaluated at different points on the original pixel (where each of
the extra pixels now represent a part of the original pixel) and averaged. After the averaging
is completed, the image is reduced to its normal size and rendered to the screen.