aRtsy: Generative Art with R and ggplot2

<img src='https://github.com/koenderks/aRtsy/raw/development/man/figures/logo.png' width='149' height='173' alt='logo' align='right' margin-left='20' margin-right='20'/>

"If you laugh at a joke, what difference does it make if subsequently you are told that the joke was created by an algorithm?" - Marcus du Sautoy, The Creative Code

aRtsy aims to make generative art accessible to the general public in a straightforward and standardized manner. The package provides algorithms for creating artworks that incorporate some form of randomness and are dependent on the set seed. Each algorithm is implemented in a separate function with its own set of parameters that can be tweaked.

Good luck hunting for some good seed's!

Artwork of the day

Every 24 hours this repository randomly generates and tweets an artwork from the aRtsy library. The full collection of daily artworks is available on the twitter feed and the mastodon feed. This is today's artwork:

<p align="center"> <img src='https://github.com/koenderks/aRtsy/raw/development/png/daily.png' width='50%'> </p>

Installation

The most recently released version of aRtsy can be downloaded from CRAN by running the following command in R:

install.packages("aRtsy")

Alternatively, you can download the development version from GitHub using:

devtools::install_github("koenderks/aRtsy")

After installation, the aRtsy package can be loaded with:

library(aRtsy)

Note: Render times in RStudio can be quite long for some artworks. It is therefore recommended that you save the artwork to a file (e.g., .png or .jpg) before viewing it. You can save the artwork in an appropriate size and quality using the saveCanvas() function.

artwork <- canvas_strokes(colors = c("black", "white"))
saveCanvas(artwork, filename = "myArtwork.png")

Available artworks

The Iterative collection

• canvas_ant()
• canvas_chladni()
• canvas_cobweb()
• canvas_collatz()
• canvas_flame()
• canvas_flow()
• canvas_lissajous()
• canvas_maze()
• canvas_mesh()
• canvas_petri()
• canvas_phyllotaxis()
• canvas_planet()
• canvas_recaman()
• canvas_smoke()
• canvas_splits()
• canvas_stripes()
• canvas_strokes()
• canvas_swirls()
• canvas_tiles()
• canvas_turmite()
• canvas_watercolors()

The Geometric collection

• canvas_diamonds()
• canvas_function()
• canvas_polylines()
• canvas_ribbons()
• canvas_segments()
• canvas_squares()

The Supervised collection

• canvas_blacklight()
• canvas_forest()
• canvas_gemstone()
• canvas_mosaic()
• canvas_nebula()

The Static collection

• canvas_circlemap()
• canvas_mandelbrot()

The Iterative collection

The Iterative collection implements algorithms whose state depend on the previous state. These algorithms mostly use a grid based canvas to draw on. On this grid, each point represents a pixel of the final image. By assigning a color to these points according to certain rules, one can create the images in this collection.

Langton's ant

According to Wikipedia, Langton's ant is a turmite with a very specific set of rules. In particular, after choosing a starting position the algorithm involves repeating the following three rules:

1. On a non-colored block: turn 90 degrees clockwise, un-color the block, move forward one block,
2. On a colored block: turn 90 degrees counter-clockwise, color the block, move forward one block,
3. If a certain number of iterations has passed, choose a different color which corresponds to a different combination of these rules.

<p align="center"> <img src='https://github.com/koenderks/aRtsy/raw/development/png/ants/2021-03-03.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/ants/2021-03-02.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/ants/2021-03-01.png' width='30%'> </p>

You can use the canvas_ant() function to make your own artwork using this algorithm.

set.seed(1)
canvas_ant(colors = colorPalette("house"))
# see ?canvas_ant for more input parameters of this function

Chladni figures

This function draws Chladni figures on the canvas. It works by generating one or multiple sine waves on a square matrix. You can provide the waves to be added yourself. After generating the waves it is possible to warp them using a domain warping technique. The angles and distances for the warp can be set manually or according to a type of noise.

<p align="center"> <img src='https://github.com/koenderks/aRtsy/raw/development/png/chladnis/2021-11-12.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/chladnis/2021-11-13.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/chladnis/2021-11-14.png' width='30%'> </p>

You can use the canvas_chladni() function to make your own artwork using this algorithm.

set.seed(1)
canvas_chladni(colors = colorPalette("tuscany1"))
# see ?canvas_chladni for more input parameters of this function

Cobwebs

This function draws a lines in a structure that resemble cobwebs. The algorithm creates many Fibonacci spirals shifted by random noise from a normal distribution.

<p align="center"> <img src='https://github.com/koenderks/aRtsy/raw/development/png/cobwebs/2021-11-05.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/cobwebs/2021-11-07.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/cobwebs/2021-11-06.png' width='30%'> </p>

You can use the canvas_cobweb() function to make your own artwork using this algorithm.

set.seed(1)
canvas_cobweb(colors = colorPalette("tuscany1"))
# see ?canvas_cobweb for more input parameters of this function

Collatz conjecture

The Collatz conjecture is also known as the 3x+1 equation. The algorithm draws lines according to a simple rule set:

1. Take a random positive number.
2. If the number is even, divide it by 2.
3. If the number is odd, multiply the number by 3 and add 1.
4. Repeat to get a sequence of numbers.

By visualizing the sequence for each number, overlaying sequences that are the same, and bending the edges differently for even and odd numbers in the sequence, organic looking structures can occur.

<p align="center"> <img src='https://github.com/koenderks/aRtsy/raw/development/png/collatzs/2021-08-09.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/collatzs/2021-08-08.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/collatzs/2021-08-10.png' width='30%'> </p>

You can use the canvas_collatz() function to make your own artwork using this algorithm.

set.seed(1)
canvas_collatz(colors = colorPalette("tuscany3"))
# see ?canvas_collatz for more input parameters of this function

Fractal flames

This function implements the Fractal Flame algorithm described in this article by Scott Draves and Erik Reckase. It iterates a set of randomly determined function systems following one or multiple specific variations to determine a set of points. You can specify which variations from the article to include in the flame, what type of symmetry to include, whether to blend the variations using weights or to pick a single variation for each iteration, whether to apply a post transformation and whether to apply a final transformation (optionally including an additional posttransformation). The final image can either be based on a the origin of the attractors or on the log density of the hit count of each pixel (for a more rigid look).

<p align="center"> <img src='https://github.com/koenderks/aRtsy/raw/development/png/flames/2022-10-06.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/flames/2022-10-05.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/flames/2022-10-04.png' width='30%'> </p>

You can use the canvas_flame() function to make your own artwork using this algorithm.

set.seed(2)
canvas_flame(colors = colorPalette("dark2"))
# see ?canvas_flame for more input parameters of this function

Flow fields

This artwork implements a version of the algorithm described in the blog post Flow Fields by Tyler Hobbs. It works by creating a grid of angles and determining how certain points will flow through this field. The angles in the field can be set manually or according to the predictions of a supervised learning method trained on randomly generated data.

<p align="center"> <img src='https://github.com/koenderks/aRtsy/raw/development/png/flows/2021-09-24.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/flows/2021-09-23.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/flows/2021-09-22.png' width='30%'> </p>

You can use the canvas_flow() function to make your own artwork using this algorithm.

set.seed(1)
canvas_flow(colors = colorPalette("dark2"))
# see ?canvas_flow for more input parameters of this function

Lissajous curves

This function draws Lissajous curves and subsequently connects the points on the curve to its k-nearest neighbors. The function is inspired by the Lissajous curves implemented in Marcus Volz's mathart package but adds colors into the mix.

<p align="center"> <img src='https://github.com/koenderks/aRtsy/raw/development/png/lissajous/2023-08-17.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/lissajous/2023-08-18.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/lissajous/2023-08-19.png' width='30%'> </p>

You can use the canvas_lissajous() function to make your own artwork using this algorithm.

set.seed(1)
canvas_lissajous(colors = colorPalette("blossom"))
# see ?canvas_lissajous for more input parameters of this function

Mazes

This artwork creates mazes. The mazes are created using a random walk algorithm (described in the mazegenerator repository). The mazes can also be displayed with polar coordinates, creating some pretty cool effects.

<p align="center"> <img src='https://github.com/koenderks/aRtsy/raw/development/png/mazes/2021-10-03.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/mazes/2021-10-02.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/mazes/2021-10-04.png' width='30%'> </p>

You can use the canvas_maze() function to make your own artwork using this algorithm.

set.seed(1)
canvas_maze(color = "#fafafa")
# see ?canvas_maze for more input parameters of this function

Meshes

This artwork creates one or more rotating circular morphing meshes on the canvas. The idea behind this artwork is described in this blogpost by Dan Gries with the simple words: "deformed circles move across the canvas, and trace out these shapes". The circle has a three random components at each time step: the center, the radius, and the increase in the radius.

<p align="center"> <img src='https://github.com/koenderks/aRtsy/raw/development/png/meshes/2022-10-03.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/meshes/2022-10-02.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/meshes/2022-10-04.png' width='30%'> </p>

You can use the canvas_mesh() function to make your own artwork using this algorithm.

set.seed(1)
canvas_mesh(color = "#000000")
# see ?canvas_mesh for more input parameters of this function

Petri dishes

This artwork uses a space colonization algorithm (excellently described in this blogpost by Jason Webb) to draw Petri dish colonies. If you add a hole in the middle of the Petri dish, the colony grows around the hole.

<p align="center"> <img src='https://github.com/koenderks/aRtsy/raw/development/png/petris/2022-04-04.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/petris/2022-04-06.png' width='30%'> <img src='https://github.com/koenderks/aRtsy/raw/development/png/petris/2022-04-05.png' width='30%'> </p>

You can use the canvas_petri() function to make your own artwork using this algorithm.

set.seed(1)
canvas_petri(colors = colorPalette("sooph"))
# see ?canvas_petri for