Processing: Creative Coding and Computational Art

I call my custom function makeRect(), passing the arrays to the function. makeRect() plots
points based on the coordinate data in the arrays, and then draws lines between the
points. I needed to use the two conditional if statements to ensure that the connecting
lines were drawn to the right points, based on the value of i in the for loop. Remember
that arrays are zero-indexed, meaning that the first position is at [0], not [1]. If you
request an index position in an array that doesn’t exist, you’ll get an error. The first conditional
statement ensures that this doesn’t happen. The second conditional statement
checks when the loop is in its last cycle, and then simply connects the last point back to
the initial point, closing the path. Another way to have done this would be to have eliminated
the last conditional statement and just put a line after the for loop, connecting
the last point back to the first, such as line(pts[0][pts[0].length-1], pts[1][
pts[0].length-1], pts[0][0], pts[1][0]);.
This last code line may look pretty confusing, mostly because of the 2D arrays. These
structures are really not that confusing to conceptually grasp, but they are visually and
procedurally complex to work with. If you really don’t like them, you don’t need to use
them, as you can always substitute two regular one-dimensional arrays in their place.
However, many people use them, so it’s good to be able to recognize and understand how
they work. In truth, there is really no such thing as a multidimensional array structure in
Processing or Java. Since arrays can hold any data type in Processing and Java, they can also
hold other arrays. Multidimensional arrays are just arrays of arrays. In the code example, I
created two coordinate arrays, float[]x and float[]y, and then to be a pest, stuck these
into another 2D array, float[][]xy. I covered arrays in detail in Chapter 3, but a little
review on how to declare/initialize them might be helpful. There are two ways to
declare/initialize arrays in Processing. The first way is as follows:
float[]x = new float[array length];
This creates a new array object and reserves a number of indices in memory. After you
declare and instantiate an array this way, each index will have a default value assigned to
it, based on the data type you’re using; for float arrays, that would be 0.0. You still need
to assign specific values to each index position in the array. For example:
x[0] = .2;
x[1] = .3;
x[2] = .7;
x[3] = .1;
The second way to declare and initialize an array is somewhat of a shortcut:
float[]x = {val 1, val 2, val 3, ...};
This approach works great when you already know the values to put in the array.
Both of these approaches can also be broken into two steps, which you might use if you
needed your array variable to be declared at the top of your program (giving it global
scope), but also wanted to instantiate the array in setup().
float[]x;
x = new float[array length];
LINES
213
6