Processing: Creative Coding and Computational Art

PROCESSING: CREATIVE CODING AND COMPUTATIONAL ART
184
variable i in all your non-nested for loops. However, when you nest a loop, the inner loop
sees all of the variables you created in the outer loop; that’s why you’re forced to use a
new name for the loop variable j in the inner loop. If you’ve been following this scope
logic, do you think the outer loop can see the variable declared in the inner loop? The
answer is no because the rules of local scope still apply.
Getting back to the code example, within the inner loop are a few lines that might be
confusing:
rowHop-=rowNudge;
if (j % (1+ (int)(random(randNudge))) == 0){
rowNudge*=-1;
}
The first line is a standard shortcut assignment operation. The variable rowHop moves the
points up and down on the y-axis, and rowNudge is the value that it’s either incremented or
decremented by. I use the term “shortcut” because this operation does both an arithmetic
operation (subtraction) and an assignment operation. The next line uses the modulus
operator, which is usually foreign to non-coders. Modulus returns the remainder of division
between two operands. The reason I used it was to generate a somewhat random
result in the loop. I tested for the modulus expression to evaluate to 0, meaning that the
division would yield no remainder. As i increases, there is a greater possibility that division
will have no remainder. For example, 4 has three factors (1, 2, and 4) that go into it evenly,
but 12 has six (1, 2, 3, 4, 6, and 12). In addition, I used a random number generator for the
right operand to make the process more chaotic. The reason I added 1 to the value of the
random() function before doing the modulus operation was to avoid division by 0, which
is illegal and will cause a compiler error. Since the random() function will generate a random
value between 0 and the argument value, periodically 0 will come up. In addition, I
am converting the float value, evaluated by the random() function, to an integer, so the
modulus expression has a chance of evaluating to 0. When you convert a float to an int
by using the int() function, values are rounded down, so .999 still evaluates to 0. Thus,
the statement (int)(random(randNudge)) can generate a lot of zeros. I used parentheses
around the entire expression (1 + (int)(random(randNudge))) to make sure that the
addition happens before the division. Normally multiplication and division, including modulus,
are evaluated before addition and subtraction, but you can use parentheses to
change the order of precedence, which is discussed at more length in Chapter 3. Finally,
the shortcut assignment operation rowNudge*=-1; switches the direction in which the
statement rowHop-=rowNudge; is pushing the points on the y-axis, giving a razor-tooth pattern
to the line output. Hopefully this description wasn’t too rough on the head. Make
sure you play, tweak, experiment, and bust apart the code to get a better sense of what’s
going on.
There are two more modifications I’ll make to the current sketch, and then I’ll (finally)
move on to using Processing’s “real” line functions. The first modification involves laying a
more regular grid pattern on top of the razor-tooth pattern, and the second modification
involves shifting value.