“genesis4321” belongs to Pedersen’s Generative Art collection.
Generative artist Thomas Lin Pedersen explores the quality and beauty of dynamic systems. He writes about the process of designing a system that is familiar and the positive surprise that unfolds as he uncovers new information in highly complex systems. He believes “the process of generative art is dual,” meaning both system development and visualization method are required.
Pedersen uses R to program his generative art and has even developed his own tools that fit into his process, including ggplot2, ggforce, ambient, particles, tidygraph, and ggraph. Though some generative artists choose to share their code with internet users in order to transparently showcase their workflows, Pedersen believes in keeping his code unrevealed; to him, the code is as important as the resulting visualization, and every artist has their own style and method.
“genesis4653” belongs to Pedersen’s Generative Art collection.“genesis39672” belongs to Pedersen’s Generative Art collection.
E-volver is a site specific work for the Research Labs of the LUMC (Lieden University Medical Centre) in Leiden. The software allows people to interact with the screen by tapping on it. Four images of random genetic patterns are displayed on the screen, and the person interacting with the software can touch the image that interests them the least. Voting out the least exciting animation, devalues those particular genes and also upgrades the genes of the three surviving animations. Thus, the selection process evolves a group of agents that generate the most intriguing animation.
A person interacts with E-volver by touching the least interesting of the four images
I found this project interesting due to the combination of art, genetics and the process of evolution. For this project the artists developed software that generates artificial pixel-sized agents. Each agent is made up of thirteen genes that determine how the agent will behave on the screen. The genes read the properties of their eight surrounding pixels and tell the agent what to do with the pixel on which it stands and to which pixel it should move to next. In this way, each of the agents leaves its individual traces on the screen. This project allows one to understand the process of evolution while providing an aesthetic experience.
Four random genetic patterns displayed by the software
Alexey Kashpersky animated the transaction process different components of our respiratory system. As I was watching this animation, though I knew that this is not a literal representation of how the system works, I was greatly mesmerized. This beautiful abstraction of how our body works allows us to broaden our perspective towards it and remind us the wonders of each of us being some kind of a universe.
I think Alexey Kashpersky did a great job of not visually articulating the system, but also doing it in such way that grabs the viewers and takes them on an immersive tour.
It seems like he used a type of 3D rendering tool such as Cinema 4D, which is a very desirable software that I am really looking forward to learning. It really amazes me how much the software can do.
// Danny Cho
// changjuc
// Section: A
// Project: Wallpaper
var waveHeight = 4/5;
var move = 0;
var speed = 0;
var evenOdd = 0;
var tailSize = 20;
var tailHeight = 20;
var fishSize = 10;
function setup(){
createCanvas(600, 600);
}
//creating waves
function waves(R, G, B, size, y, offset){
fill(R, G, B);
strokeWeight(0);
stroke(255);
//was trying to make the waves move, but not enough time & confusion
for (j = 0; j < (width + 1000) / size; j++){
var cirlceX = j * size * waveHeight + offset;
if (cirlceX > width + 500){
cirlceX = size * waveHeight + offset;
ellipse(cirlceX, y, size, size);
}
else {
ellipse(cirlceX, y, size, size);
}
}
}
//drawing fish out of two triangles
function fish(a){
fill(231, 239, 233);
var v = height / 200;
var h = width / 200;
//tail
var t1x = a * h * 15;
var t1y = a * v * 15 + 10;
var t2x = a * h * 15 + tailSize;
var t2y = a * v * 15 + tailSize;
var t3x = t1x;
var t3y = a * v * 15 + 2 * tailHeight - 10;
print("t1x is" + t1x);
print("t1y is" + t1y);
//head
triangle(t1x, t1y, t2x, t2y, t3x, t3y);
var h1x = t2x;
var h1y = t2y - fishSize;
var h2x = t2x + 3 * fishSize;
var h2y = t2y;
var h3x = t2x;
var h3y = t2y + fishSize;
triangle(h1x, h1y, h2x, h2y, h3x, h3y);
}
function draw(){
for (i = 0; i <= 16; i++) {
var count = (i % 2);
if (count == 0) {
waves(15, 146, 167, 100, 600 - (40 * i), -50);
//every other waves are different color
}
else if (count == 1) {
waves(20, 188, 199, 100, 600 - (40 * i), 0);
}
}
for (row = 0; row <= 10; row ++){
push()
translate(row * 100 - 500, 0);
for (k = 0; k <= 12; k++){
fish(k);
}
pop()
}
noLoop();
}
I originally wanted to make the waves move and have a ship or fish moving in between them, but I realized the way that I created the waves and how they overlap on top of each other didn’t allow it. So I decided to just overlay fish on top of the waves.
This project revolves around a program that writes and draws random comics and cartoon art onscreen endlessly. The program randomly combines words, colors, shapes, figures, objects, and scenes into random text stories, cartoon drawings, and comic books. What I find interesting about this project is how Pound used the program not as a passive tool, but as an active agent in making creative decisions, and the extent how Pound used randomness to create his comics – he didn’t just use it minimally on just a few panels with nonsense word balloons, he used it to create text, scribbles, figures, stories, and page layouts.
What I saw through the one screenshot Pound shared about this project is that it uses basic shapes that resemble figures and shapes, but I would like to see this recreated with modern technology that can now scan already published comics, cartoons, and comic books, and then the program can randomly generate new comics and cartoons from those. What Pound did right was his intent behind using randomness; the point of creating something random is the idea of total nonsense and something beyond our conscious that challenges both the artist and the viewers to think abstractly.
Pound was inspired by previous programs that could make random sentences by combining basic words and other programs that could draw random figures and scenes. He then had the thought of combining these two different types of programs to make nonsense Sunday comics.
The one screenshot Pound shared of “RAN DUM LOOP” that allows us to see a sneak peek as to how the randomly generated comics looked like
This work is an computer artwork done by Aaron Marcus. It was created by random filling in a grid of lines and solid areas. The randomness in filling was done by receiving results from a random-number generator. I believe that these numbers were random, as opposed to pseudo-random. I find this inspiring because the visual complexity and handcrafted artifact quality give it compelling characteristics. It shows a high-tech style, but also a more traditional art style. The straight lines and corners interact within the round circle shape in an interesting way, and the circle feels more defined in some places along the circumference, more blurry in other parts. I think the simplicity of black and white reinforces the effects that the randomness creates.
Evolving Gravity by Aaron Marcus, 1972-4. An early computational work by Marcus
// CJ Walsh
// Section D
// cjwalsh@andrew.cmu.edu
// Project 05 - Wallpaper
function setup() {
createCanvas(500, 500);
background('#83D4F3');
noStroke(); // i dont like the stroke on objects!
}
function draw() {
// loop used to create variety of circles
for (var y = 62.5; y < height + 62.5; y += 125) {
for (var x = 62.5; x < width + 62.5; x += 125) {
fill('#64AEFF');
ellipse(x, y, 125, 125);
fill('#8ACAFF');
ellipse(x, y, 99, 99);
fill('#8BEFA7');
ellipse(x - 25, y - 10, 37, 37);
fill('#609FA0');
ellipse(x - 20, y - 20, 21, 21);
fill('#2D4949');
ellipse(x + 20, y + 15, 43, 43);
fill('#FFC5FE');
ellipse(x + 25, y - 2, 29, 29);
}
}
// background set of rectangles
fill('#7F7FEF');
for (var y = 114; y < height; y += 251) {
for (var x = 30; x < width; x += 250) {
rect(x, y, 190, 19);
}
}
// foreground set of rectangles
fill('#5756A5');
for (var y = 29; y < height; y += 250) {
for (var x = 115; x < width; x += 251) {
rect(x, y, 19, 190);
}
}
}
This is the wallpaper that I created for this week’s assignment. After looking through some examples, I decided that I just wanted to experiment with what I knew about loops and shapes and see what I could make. I drew all of my shapes in Adobe Illustrator first to understand where I wanted everything to be placed, and to also choose colors. I found this project to be really fun, especially when I expand the canvas and get to see the design on a larger scale. I could definitely see myself doing something similar to this project again in the future to make fun patterns and textures.
What I admire about this project is how hyperrealistic it looks. It also has this fantasy vibe that i get when I look at it, The skull is intruging and there are different parts of this project that makes it really intricate asw a whole. There are different vines crossing the screen and the rusty metal look is encorporated all over the skull and the body. I dont know the exact algorithms to create piece like this but it definetly tooks some for loops and some basic adrawings in the draw function of simple shapes that get more and more complicated. This piece was made by an artist named Yokohara in Tokyo, I would like to see more of his/ her pieces because they are pretty facinating and I could possibly draw inspiration
var dx = (500/4);//width divided by # of lilies per row
var dy = (500/4);//height divided by # of lilies per column
function setup(){
createCanvas(500,500);
noLoop();
}
function draw() {
//background(66, 85, 255);
background(35, 57, 252);//blue
noStroke();
//for loops
for(var w = 0; w < 4; w++){ //draws horizontal rows of lilies
for(var h = 0; h < 4; h++){ //draws vertical columns of lilies
//lily pads
fill(101, 224, 150);//green
arc((dx / 2) * (2 * w + 1),(dy / 2) * (2 * h + 1), dx / 1.3, dy / 1.3,
-0.4, 1.4 * PI + QUARTER_PI, PIE);//main lily pads (largest)
fill(58, 201, 168);//bluer green
arc((dx / 2) * (2 * w + 1) + 30,(dy / 2) * (2 * h + 1) + 55, dx / 5, dy / 5,
-0.3, 1.4 * PI + QUARTER_PI, PIE);//lily pads 1 (largest of the side ones)
fill(58, 201, 191);//bluer bluer green
arc((dx / 2) * (2 * w + 1) + 48,(dy / 2) * (2 * h + 1) + 35, dx / 8, dy / 8,
-0.3, 1.4 * PI + QUARTER_PI, PIE);//lily pads 2
fill(58, 196, 201);//light blue
arc((dx / 2) * (2 * w + 1) + 56,(dy / 2) * (2 * h + 1) + 17, dx / 10, dy / 10,
-0.3, 1.4 * PI + QUARTER_PI, PIE);//lily pads 3
fill(58, 175, 201);//blue
arc((dx / 2) * (2 * w + 1) + 57,(dy / 2) * (2 * h + 1) + 0, dx / 12, dy / 12,
-0.3, 1.4 * PI + QUARTER_PI, PIE);//lily pads 4 (smallest)
//lily pad flowers (pink)
fill(255, 199, 217);
ellipse((dx / 2) * (2 * w + 1) + 30,
(dy / 2) * (2 * h + 1) + 55, 25,10);//horizontal lily pads 1
ellipse((dx / 2) * (2 * w + 1) + 30,
(dy / 2) * (2 * h + 1) + 55, 10,25);//vertical lily pads 1
fill(255, 140, 177);
ellipse((dx / 2) * (2 * w + 1) + 48,
(dy / 2) * (2 * h + 1) + 35, 15,7);//horizontal lily pads 2
ellipse((dx / 2) * (2 * w + 1) + 48,
(dy / 2) * (2 * h + 1) + 35, 7,15);//vertical lily pads 2
fill(255, 105, 153);
ellipse((dx / 2) * (2 * w + 1) + 56,
(dy / 2) * (2 * h + 1) + 17, 10,5);//horizontal lily pads 3
ellipse((dx / 2) * (2 * w + 1) + 56,
(dy / 2) * (2 * h + 1) + 17, 5,10);//vertical lily pads 3
fill(255, 66, 127);
ellipse((dx / 2) * (2 * w + 1) + 57,
(dy / 2) * (2 * h + 1) + 0, 8,4);//horizontal lily pads 4
ellipse((dx / 2) * (2 * w + 1) + 57,
(dy / 2) * (2 * h + 1) + 0, 4,8);//vertical lily pads 4
//lily pad flower (white)
fill(255);
ellipse((dx / 2) * (2 * w + 1),
(dy / 2) * (2 * h + 1), 28,13);//horizontal lily pads 1
ellipse((dx / 2) * (2 * w + 1),
(dy / 2) * (2 * h + 1), 13,28);//vertical lily pads 1
}
}
}
I decided to make my designs plant based and chose ferns as one of the plants. I then realized those would be complicated, so I chose lily pads and flowers instead. I decided to vary the sizes of my lilies to make them prettier and give my design variation. I then varied the colors as well. After, I added flowers and also varied the colors and sizes of them. I changed the colors throughout to make them complement each other more and make the piece as a whole more aesthetically pleasing. For example, my background was originally very dark brown.
//Zee Salman
//SECTION E
var red // horizantal
var blue // vertical
var sz = 10;
function setup() {
createCanvas(600, 400);
noStroke();
}
function draw() {
background(0);
drawGrid();
}
function drawGrid() {
for (var y = 5; y < height + 50; y += 100) {
var red = map(y,0,height,0,255);
for (var x = 5; x < width + 50; x += 100) {
//color gradient needs to be implemented
var blue = map(x,0,width,0,255);
noStroke();
fill(red,0,blue);
ellipse(x, y,20, 100);
stroke("white");
line(x /2, y /2, width / 2, height / 2);
line(x *2, y *2, width / 2, height / 2);
}
}
}
I wanted to go for something a bit playful, I really enjoy gradients and I wanted to add them to this wallpaper along with lines that sprouted in different directions, I feel like it has a good contrast especially with the black background. I would like to further expand on this idea and see where I can rreally take the design, and even complicate the shapes a bit more in further explorations.
![[OLD FALL 2019] 15-104 • Introduction to Computing for Creative Practice](https://courses.ideate.cmu.edu/15-104/f2019/wp-content/uploads/2020/08/stop-banner.png)
