public class MultiGenZooextends processing.core.PApplet
MultiGenZoo: a small sketch showing different ways to create MultiGens, copied and condensed from
ArgosyMixer.
MultiGen composed of row-wise connected HilbertGen objects.
The display framework borrows the useful parts of MultiGenLookupTables: each
MultiGen is drawn as a colored signal path, with optional path lines, so the
orientation of the component PixelMapGens is easy to inspect.
NAMING CONVENTIONS
As all the methods that follow below, hilbertLoop3x2() creates a MultiGen instance
from a list of PixelMapGen objects (genList) and coordinate points (offsetList)
where they will be displayed. MultiGen creates a single signal path over all
the PixelMapGen objects. The path may be *continuous*, which is to say that
the path through each PixelMapGen object ("gen" for short) only has to step
one pixel up, down, left, or right to connect to the next gen. It may even
create a loop, where the last pixel in the path is one step away from the
first pixel. This is reflected in the naming conventions.
In the method names, "ortho" refers to gens that are aligned in rows (or
columns) where each new row begins one unit down from the previous row,
always adding new gens in the same direction. In the "bou" methods
(named for boustrophodon, a method of writing text in alternating directions),
each successive row or column goes in the opposite direction from the previous
one. The bou methods may provide continuous paths, the ortho methods are
inherently discontinous, like row major bitmaps or video scanlines.
Looping methods are are almost always more complex than bou and necessarily
more complex than ortho methods. Like the Hilbert curve, they involve
changes in direction reminiscent of folding. Looping methods often have
constraints on the numbers of rows and columns that can produce a loop.
The constraints arise from the connectivity offered by the different
PixelMapGen child classes: Hilbert gens have connections at two adjacent
corners, DiagonalZigzag gens have connections at opposite corners.
Moore gens are loops to begin with, and have no connections, but are
good for very symmetrical pattern-making.
KEY COMMANDS
Press 'g' or RIGHT to show the next MultiGen.
Press 'G' or LEFT to show the previous MultiGen.
Press 'a' to toggle animation along the signal path.
Press 'A' to step animation backward.
Press 'n' to hide or show numbers.
Press 'l' to hide or show path lines.
Press 'o' to hide or show outlines around the component gens.
Press 't' to hide or show the title text.
Press 'd' to print a description of the current MultiGen.
Press 'h' to show this help text.
hilbertLoop3x2() returns a looping fractal signal path consisting of
6 Hilbert gens, 3 wide by 2 tall, to fit a 3 * genW by 2 * genH image.
This method is available as a static method of HilbertGen.
Note that genH must equal genW and both must be powers of 2.
Parameters:
genW - width of each HilbertGen
genH - height of each HilbertGen
Returns:
a MultiGen consisting of 6 HilbertGens linked together by one signal path
Generates a MultiGen with 6 * 4 HilbertGen components and a continuous signal path.
Parameters:
genW - width of a single PixelMapGen
Returns:
a MultiGen with 6 * 4 HilbertGen components
hilbertZigzagLoop6x4
publicMultiGenhilbertZigzagLoop6x4(int genW,
int genH)
This method creates a MultiGen consisting of a mix of zigzag and Hilbert curves
in 6 columns and 4 rows arranged to provide a continuous loop.
Parameters:
genW - width of a single PixelMapGen composing the MultiGen
genH - height of a single PixelMapGen composing the MultiGen
Returns:
a MultiGen with a signal path composed of HilbertGens and DiagonalZigzagGens.
hilbertStackOrtho
publicMultiGenhilbertStackOrtho(int stacks,
int rows,
int units,
int genW,
int genH)
This method creates a vertical stacks of rows of HilbertGens. Each row
begins genH pixels down from the previous row, back at the beginning
of the previous row (i.e., in "row major" order, like a bitmap). This
method pairs nicely with an image with 3 columns of with 8 rows of words,
using the image as a control surface for sampling an audio file with
words recorded at the appropriate locations to match the screen order.
The signal path jumps from the end of the last gen in each row to the
beginning of the first gen in the next row. The path in each row is
continuous, which provides some interesting optical effects.
Parameters:
stacks - the number of stacks
rows - the number of rows in each stack
units - the number of gens in each row
genW - the width of each gen, a power of 2
genH - the height of each gen, equal to genW
Returns:
a MultiGen consisting of stacks * rows * units PixelMapGens
hilbertStackBou
publicMultiGenhilbertStackBou(int stacks,
int rows,
int units,
int genW,
int genH)
This method creates a vertical stacks of rows of HilbertGens. Each row
begins genH pixels down from the previous row. Alternating rows add units
in opposite directions. This means path continuity is possible in each
stack by changing the orientation of the gens; however, it isn't fully
implemented in this example. Hint: choosing the right orientation for
each gen will assure path continuity.
Parameters:
stacks - the number of stacks
rows - the number of rows in each stack
units - the number of gens in each row
genW - the width of each gen, a power of 2
genH - the height of each gen, equal to genW
Returns:
a MultiGen consisting of stacks * rows * units PixelMapGens
hilbertRowOrtho
publicMultiGenhilbertRowOrtho(int cols,
int rows,
int genW,
int genH)
This method creates rows of HilbertGens, starting each row from the left
and adding gens. The odd rows are flipped vertically and the even rows are
unchanged. The unchanged HilbertGen starts at upper left corner and ends at
upper right corner, so this provides some possibilities of symmetry between rows.
The path is not continuous.
Parameters:
cols - number of columns of gens wide
rows - number of rows of gens high
genW - width of each gen (same as genH and a power of 2)
genH - height of each gen
Returns:
a MultiGen composed of cols * rows PixelMapGens
hilbertColumnOrtho
publicMultiGenhilbertColumnOrtho(int cols,
int rows,
int genW,
int genH)
This variation on hilbertRowOrtho arranges the gens vertically, in columns.
Parameters:
cols - number of columns of gens wide
rows - number of rows of gens high
genW - width of each gen (same as genH and a power of 2)
a looping MultiGen with 6 rows x 4 columns of DiagonalZigzagGen instances
zigzagRowOrtho
publicMultiGenzigzagRowOrtho(int cols,
int rows,
int genW,
int genH)
Creates a MultiGen with rows * cols DiagonalZigzagGens.
Note that you should set values for such that:
(rows * genW) == width and (cols * genH) == height.
"Ortho" implies that each row starts at the left edge.
The orientation of the the diagonals changes for alternate rows.
Parameters:
cols - number of vertical columns
rows - number of horizontal rows
genW - width of an individual PixelMapGen
genH - height of an individual PixelMapGen
Returns:
a MultiGen created from rows * cols PixelMapGens
zigzagRowAltOrtho
publicMultiGenzigzagRowAltOrtho(int cols,
int rows,
int genW,
int genH)
Creates a MultiGen with rows * cols DiagonalZigzagGens.
Note that you should set values for such that:
(rows * genW) == width and (cols * genH) == height.
"Ortho" implies that each row starts at the left edge.
The orientation of the the diagonals is more complex than
zigzagRowOrtho(), hence the "Alt" in the method name.
Parameters:
cols - number of vertical columns
rows - number of horizontal rows
genW - width of an individual PixelMapGen
genH - height of an individual PixelMapGen
Returns:
a MultiGen created from rows * cols PixelMapGens
zigzagColumnOrtho
publicMultiGenzigzagColumnOrtho(int cols,
int rows,
int genW,
int genH)
Creates a MultiGen with rows * cols DiagonalZigzagGens.
Note that you should set values for such that:
(rows * genW) == width and (cols * genH) == height.
The MultiGen steps along columns rather than rows.
"Ortho" implies that each column starts at the top edge.
The orientation of the diagonals alternates one column to the next.
Parameters:
cols - number of vertical columns
rows - number of horizontal rows
genW - width of an individual PixelMapGen
genH - height of an individual PixelMapGen
Returns:
a MultiGen created from rows * cols PixelMapGens
zigzagColumnAltOrtho
publicMultiGenzigzagColumnAltOrtho(int cols,
int rows,
int genW,
int genH)
Creates a MultiGen with rows * cols DiagonalZigzagGens.
Note that you should set values for such that:
(rows * genW) == width and (cols * genH) == height.
The MultiGen steps along columns rather than rows.
"Ortho" implies that each column starts at the top edge.
The orientation of the diagonals is more complex than zigzagColumnOrtho(),
hence "Alt" in the method name.
Parameters:
cols - number of vertical columns wide
rows - number of horizontal rows high
genW - width of an individual PixelMapGen
genH - height of an individual PixelMapGen
Returns:
a MultiGen created from rows * cols PixelMapGens
zigzagRowRandomFlip
publicMultiGenzigzagRowRandomFlip(int cols,
int rows,
int genW,
int genH)
Creates a MultiGen with rows * cols DiagonalZigzagGens.
Note that you should set values for such that:
(rows * genW) == width and (cols * genH) == height.
The MultiGen steps along rows.
"Ortho" implies that each row starts at the left edge.
The orientation of the diagonals is randomized.
Parameters:
cols - number of vertical columns
rows - number of horizontal rows
genW - width of an individual PixelMapGen
genH - height of an individual PixelMapGen
Returns:
a MultiGen created from rows * cols PixelMapGens
boustrophRowRandom
publicMultiGenboustrophRowRandom(int cols,
int rows,
int genW,
int genH)
Creates a MultiGen with rows * cols BoustropheGens.
Note that you should set values for such that:
(rows * genW) == width and (cols * genH) == height.
Parameters:
cols - number of vertical columns wide
rows - number of horizontal rows high
genW - width of an individual PixelMapGen
genH - height of an individual PixelMapGen
Returns:
a MultiGen created from rows * cols PixelMapGens
hilbertRowRandomFlip
publicMultiGenhilbertRowRandomFlip(int cols,
int rows,
int genW,
int genH)
Creates a MultiGen with rows * cols HilbertGens.
Note that you should set values for such that:
(rows * genW) == width and (cols * genH) == height
and that genH == genW and both are powers of 2.
The orientation of the HilbertGens is randomized.
