Generative or Algorithmic Art goes back to the very earliest days of computer graphics and some of the key pioneers of this movement produced work before computer screens were even a thing. It was necessary for them to come up with a clear logic, program an algorithm, and hope for the best when the plotter spit out the results. Some of these earliest pioneers continue as a source of inspiration to algorithmic art to this day, and their early experiments continue to be useful for those learning to code or design algorithms to this day.
One of these early pioneers is the French-Hungarian artist Vera Molnár. She and other generative artists took important ideas from abstract art and Minimalism, which also flourished in the 1960s when many early experiments were done. For more, her biography on Wikipedia: https://en.wikipedia.org/wiki/Vera_Molnár.
While many of her artworks were generated with algorithms, her piece (Dés) Ordres from 1974 stood out to me as being both very beautiful and relatively easy to code. In this case, less truly is more.
The logic is fairly simple. A regular grid of squares is offset multiple times towards the squares’ centres. Some of the squares are then randomly reduced, after which the four corner vertices are slightly jiggled in the X and Y directions.
Below is a simple script recreating for the most part the logic of the pattern.
Step One: Draw a regular Square Grid and Offset Cells towards Centres
First drop a Square Grid component. This takes a couple of parameters. The first is the ‘cell size’ which is the size of the outermost square in our grid. Secondly, the ‘number of cells’ needs to be inputed for both the x and y directions. In this series, Molnár uses a 17 x 17 grid of cells. While setting up the script we will rely on a 5 x 5 grid for clarity, after which we can expand to 17 x 17 or larger.
Before offsetting the outermost square towards the centre, we need to know the total amount to offset, and then divide that amount by the number of offsets we would like. To do this, the ‘cell size’ is Divided by 2.01 to approximate the distance to the centre of the square without being exactly halved. This is then Divided by the parameter ‘number of offsets.’ The number of offsets in the example above is ‘5’ but actually there are only ‘4’ actual offsets since the first offset amount in our series is ‘0.’ The number 5 goes into the (C)ount input on the Series component, while the result of our Division operation goes into the i(N)terval input on the Series component. Then, I using Cull Index I remove the first item (Index 0) in the series since I don’t want to keep the line which is offset by the amount ‘0’.
Since I want the offsets to go towards the inside of my square cells, I then make the series Negative using the appropriate component. The series is then ‘grafted‘ into the (D)istance input of the Offset component.
Step Two: Randomly Reduce the number of Squares.
After setting up the initial ordered grid of squares, it is time to introduce some randomness. In this case, I simply use the Random Reduce component on the flattened list of squares. To know how many values to remove, use the List Length component to measure this list, and Multiply the list length by a decimal percentage–in the example above this is ‘.35’ removing 35% of squares generated at the end of step one. This result is input into the number of values to (R)educe input on the Random Reduce component, and a random number (S)eed is input as well. Note other components such as culls or dispatches could be used as well.
Step Three: Identify Corner Vertices for Remaining Squares
Here I use the Control Points component on a flattened list of the remaining squares. Note that for a four sided square, five control points are produced. This is because the starting and ending point is duplicated. For our purposes, we only want this point once, so again we use Cull Index to remove everything at index ‘0’ (input into parameter input i) We could also have culled index item 4 (the endpoint) but just choose one.
Step Four: ‘Jiggle’ the Four Vertices
This is a very similar procedure to the one used in Jittery Rectangles – Example 1.3 so I won’t go into detail here. You can either ‘hard’ input the amount of Jitter for each domain, or you can make a domain which scales the amount of jitter as a percentage of the initial ‘cell size’ parameter depending on whether you think you may scale the pattern up or down at a later point. I chose to do that latter in this example.
One key difference to note from example 1.3 is the points need to be jittered independently of which square they are in–that is vertex 1 in square 1 should have a unique jitter independent of vertex 1 in square 5, for example–but later the vertices need to be restructured so as to ‘remember’ which square they originally were in. To do this, you need to Flatten the list of vertices at the beginning of this step, move the vertices randomly in the X and Y directions, and then Unflatten the list using the original list of points as a guide to restore this data structure.
Step 5 – Reconstitute the Squares – Adjust Parameters
If everything is structured correctly up to this point, the squares can be reconstituted by simply inputing the unflattened list of points into the (V)ertices input of the Polyline component. Also important is the Polyline needs to be closed and this will only happen if we input the Boolean ‘True’ into the (C)losed? input. Now is the time to adjust parameters to achieve the desired results. In the image above, the initial Jitter amount was very strong, so I decided to tone this back to get something closer to what Vera Molnár showed in her work. Now is also the time to play with scaling up the number of cells in the grid, trying various percentage values for random reduce, etc. A few examples of results can be seen below.
Below is an image of the completed GH script for reference.
