访问官网
Github
文档
论文
aRtsy: Generative Art with R and ggplot2
"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:
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
The Static collection
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:
- On a non-colored block: turn 90 degrees clockwise, un-color the block, move forward one block,
- On a colored block: turn 90 degrees counter-clockwise, color the block, move forward one block,
- If a certain number of iterations has passed, choose a different color which corresponds to a different combination of these rules.
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.
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.
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:
- Take a random positive number.
- If the number is even, divide it by 2.
- If the number is odd, multiply the number by 3 and add 1.
- 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.
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).
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.
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.
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.
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.
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.
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
