Category: SectionC

Looking outwards 06: Randomness

Work title: Generative Illustrations of the Human Form [Papilarnie II]

Designer: Janusz Jurek

Work Link: https://www.behance.net/januszjurek

Jurek is a Polish designer who focuses on transforming human forms into 3D generative art that is constructed with entangling strings. After creating this series of works, he stated, “Human body has always been the most popular subject in a drawing. Generative art is about motion, and the human body is about motion, even motionless. It has a complicated nervous system and blood vessels, which work all the time like wires. The way it works is the greatest wonder of nature.” In his works, there are no specific rules for how the wires are displayed on canvas. Instead, it is through a more randomized layering of these wires that creates depth and tension. In programming wise, I assume there is a primary path set for the computer to draw over many times (the densest layer), and all other lines are generated randomly on the canvas either by controlling the mouse or not. I also like how the artist is portraying only a partial body on the canvas because this allows the viewer to imagine the narrative of the drawing differently through blank spaces. 

anabelle’s project 06

we always think too much about how time passes by too quickly. don’t be obsessed with aging, and just think about the good that comes with your birthday!

the background indicates to minute (to some extent). at the start of the hour, the background will be pink. it will become increasingly bluer the greater the minute is.

the number of strawberries on the cake indicate the hour of the day in a 12-hour cycle. to distinguish am and pm, the fruit will turn into blueberries in the am and strawberries in the pm.

the number of candles indicates the month and the number of gifts indicates the day.

sketch 

// kayla anabelle lee (kaylalee)
// kaylalee@andrew.cmu.edu
// section c
// project 6

// define variables
let redValue, blueValue, greenValue;
let strawberryFill;
let giftCounter;
let giftDraw;

function setup() {
    createCanvas(480, 480);
    let h = hour(); 
    let m = minute();
    let d = day();
    let mon = month();

    // initialize background color
    redValue = 248;
    blueValue = 226;
    greenValue = 226;

    giftCounter = 0;

}

function draw() {
    // every minute, the background changes by this increment
    let redMinute = 1.25;
    let blueMinute = 0.633;
    let greenMinute = 0.1167;

    // final color will be (173, 188, 219)
    background(redValue - (redMinute*minute()), blueValue - (blueMinute*minute()), greenValue - (greenMinute*minute())); // final color will be (173, 188, 219)

    // set color variables for helper functions
    let cakeColor = color(255, 214, 148);
    let icingColor = color(246, 158, 178);
    let tableColor = color(112, 77, 36);

    let candleColor = color(247, 200, 238);
    let outerFire = color(245, 154, 142);
    let innerFire = color(255, 202, 150);

    let giftColor = color(171, 156, 217);
    let ribbonColor = color(248, 239, 233);

    // draw table and cake
    table(150, height - 105, 275, 190, tableColor); // 4/3 ratio
    cakeBase(150, height - 160, 150, 75, cakeColor);
    cakeBase(150, height - 230, 100, 50, cakeColor);

    // the number of candles = month (12 candles total)
    for (i = 1; i <= month()%12; i++) {
        if (i <= 6) {
            candle(i*15 + 96, 205, 8, 32, candleColor); // (top row)

        } else {
            candle(i*20 - 45, 255, 10, 40, candleColor); // 2/3 ratio (bottom row)
        }
    }

    // the number of gifts = day (31 total)
    giftDraw = true;
    giftCounter = 0;
    for (i = 0; i < 7; i++) {
        for (j = 0; j < 5; j++) {
            if (giftCounter >= day()) {
                giftDraw = false;
            } gift(280 + 30*i, 470 - 30*j, 25, 25, giftColor, ribbonColor, giftDraw);   
            giftCounter += 1;
        }
    }

    print (giftCounter);

    // now working on strawberries
    // for PM, fill is BLUE. for AM, fill is PINK)
    if (hour() <= 12) {
        strawberryFill = color(73, 104, 152);
    } if (hour() > 12) {
        strawberryFill = color(231, 84, 128);
    }

    // the number of strawberries = hour of the day (12 strawberries total)
    for (i = 1; i <= hour()%12; i ++) {
        if (i <= 6) {
            strawberry(i*16 + 92, 220, 15, 25, strawberryFill); // (top row)

        } else {
            strawberry(i*22 - 60, 270, 15, 25, strawberryFill); // 2/3 ratio (bottom row)
        }
    }

    textSize(20);
    textAlign(CENTER);
    text('life is too short to worry about time. eat some cake!', 220, 180, 300, 200);

}

/*my functions*/

function cakeBase(x, y, w, h, color) { // draws the bread part of cake
    var r = (w / 6);
    noStroke();
    fill(color);

    // base rectangle
    rectMode(CENTER);
    rect(x, y, w, h);

    // left arc
    arc(x - w/2 + r/2, y - h/2, r, r, radians(180), radians(270));

    // right arc
    arc(x + w/2 - r/2, y - h/2, r, r, radians(270), radians(360));

    // connect arcs
    line(x - w/2 + r/2, y - 2*r, x + w/2 - r/2, y - 2*r);
    rect(x, y - 7*r/4, w - r, r/2);

}

function table(x, y, w, h, color) { // draws table
    fill(color);
    rectMode(CENTER);
    noStroke();

    // vertical slabs
    rect(x - 3*w/10, y + 3*h/10, w/12, h/2); // left
    rect(x + 3*w/10, y + 3*h/10, w/12, h/2); // right

    // horizontal slabs
    rect(x, y, (3*w)/4, (h/6)); // bottom
    rect(x, y - h/12, w, h/12); // top
}

function gift(x, y, w, h, boxColor, ribbonColor, draw) { // draws one present

    if (!draw) {
        return false;
    }

    rectMode(CENTER);
    noStroke();

    fill(boxColor) // use arrays to create different colors for each gift

    // rectangles
    rect(x, y, 4*w/5, 4*h/5); // bottom
    rect(x, y - 2*h/5, w, h/10); // top

    // bow
    stroke(ribbonColor);
    strokeWeight(w/10);
    noFill();
    circle(x - w/8, y - h/2, w/4);
    circle(x + w/8, y - h/2, w/4);

    // box ribbon
    fill(ribbonColor);
    noStroke();
    rectMode(CENTER);
    rect(x, y, w/5, 8*h/10);
}

function candle(x, y, w, h, color) { // the width to height should be a 1/4 ratio
    rectMode(CENTER);
    fill(color);
    strokeWeight(1);
    stroke(150);
    rect(x, y, w, 4*h/5);

    fill(255, 0, 0, 150); // outer flame
    noStroke();
    ellipse(x, y - 3*h/5, 4*w/5, 3*h/10);

    fill(255, 165, 0, 150);
    ellipse(x, y - 11*h/20, 3*w/5, h/5);
}

function strawberry(x, y, w, h, color) { // draws one strawberry
    fill(color);
    noStroke();

    arc(x, y, w, h, radians(180), radians(0));
    arc(x, y, w, h/10, radians(0), radians(180));

}

function icing(x, y, w, h, color) {
    push();
    translate(x, y);
    fill(color); 
    stroke(color);

    x += cos(radians(x));
    y += sin(radians(y));

    point(x, y);
    pop();
}

anabelle’s blog 06

One work of random art that I enjoy is the infinite biome generation of Minecraft. Minecraft can create infinte, borderless worlds filled with a plethora of biomes, structures, and landforms. In my opinion, Minecraft’s unlimited ability to generate unique world after unique world is what keeps it at the top of the gaming market. From observation, I think Minecraft uses perlin noise/randomness to generate its biomes — none of the scenery changes feel jarring and the game has an overall organic, natural feeling to it. I just find it really cool that Minecraft is able to randomize SO many elements to bring together an organized, cohesive piece. For example, it doesn’t just randomize whether it’ll generate an ocean biome or desert biome; the biomes themselves have randomly generated elements so no two oceans are alike. Furthermore, Minecraft stores each generated “seed” or world so they can be reaccessed for whoever wants to explore a specific world. Minecraft never lets its audience become bored by constantly adding new, consistently creative randomized events that give the joy of open-world exploration with each play.

Some cool minecraft worlds: https://www.youtube.com/watch?v=gFHj4E_1o6E&ab_channel=Minecraft%26Chill

(Like, can you believe these seeds spawned naturally, rather than a player going in and building the biome themself? It’s so cool!)

Project-06-Abstract-Clock

Clock

sketch
//Brody Ploeger
//Section C
//jploeger@andrew.cmu.edu
//Assignment-06



function setup() {
    createCanvas(450, 450);
    background(220);
    //text("p5.js vers 0.9.0 test.", 10, 15);
}

function draw() {
var s = second()
var m = minute()
var h = hour()
background(0)

//hours
for(var n = 0; n<h*height/24; n+=height/24){
    noStroke();
    fill('orange');
    rect(0,0,width,n+20);
}

//hours
for(var n = 0; n<h*height/24; n+=height/24){
    noStroke();
    fill('red');
    circle(width-20,0+n+10,20);
}

//minute counter
for(var j = 0; j<m*7.5; j+=7.5){
    strokeWeight(2)
    stroke(255)
    line(0+j,0,0+j,height)
}

//move origin for second counter
push();
translate(width/2,height/2)
//secondcounter
for(var i = 0; i<s; i++){
    rotate(radians(6));
    secondcounter(0,0)
}
secondcounter(0,0)
pop();
}

//seconds function
function secondcounter(x,y){
stroke('green');
strokeWeight(10);
noFill();
arc(x,y,width/2,width/2,0,radians(6))
}

Looking Outwards-06

Tyler Hobbs: CARELESS AND WELL-INTENTIONED #1

Tyler Hobbs is a visual artist who works with code to create digital drawings which he will also sometimes plot or paint. All of his works use computer algorithms he develops. Within these algorithms, Hobbs programs in an amount of randomness. What I find interesting about Hobbs’s work is the partnership he develops with the computer. When he begins his work, he does not have a final goal in mind, together with the randomness of the program he develops, the artwork becomes a journey. The randomness of the work is not pure randomness, but rather it is refined and becomes more refined as Hobbs works with it.

https://tylerxhobbs.com/process
https://tylerxhobbs.com/works/2022/careless-and-well-intentioned

Looking Outwards 06

Randomly Generated Poetry

Although the world of random visual art is vast, as is the genre of randomly generated music, I found that I was drawn toward the idea of randomly generated poetry. In a recent project from two students at Bard College, an algorithm was written that created randomly generated poetry based on the stylistic choices of a chosen poets such as Dickenson and Shakespear. In terms of their process, they begin by writing an algorithm that reads poetry from the writer and creates a numerical value based on how often the word s used(its usage probability). Next, the bot randomly chooses a word from the list. The choice is truly random but constrained to words used by the writer. The algorithm then goes on to gauge the probability of other words used in conjunction with the first word, and chooses the next word accordingly, and so on. So although it is not truly random, the code is not always choosing the words that are most likely to be used together. I really admire this work because it is created for the public by students like ourselves, and the poetry generated is really beautiful.

Project 06

sleeping earth, suns, moons, and stars!

sketch
// Sowang Kundeling skundeli Section C Project 05

var angle = 0;
var x = 480/2;
var y = 480;
var z = 60; // size

function setup() {
    createCanvas(480, 480);
}

function draw() {
    background('black');
    push();
    frameRate(1);
    translate(240, 480);
    rotate(radians(7) * second());
    galaxy();
    pop();
  
    noStroke();
    fill('black')
    var eyeLX = x + 60
    var eyeRX = x - 60
    ellipse(eyeLX, y-60, z+10, z); // left eye
    ellipse(eyeRX, y-60, z+10, z); // right eye
    fill(9, 130, 13);
    ellipse(eyeLX, y-75, z+15, z); // cut out left eye
    ellipse(eyeRX, y-75, z+15, z) // cut out right eye
  
    push();
    frameRate(1);
    translate(x-120, y-350);
    rotate(radians(5) * second());
    star(0+minute(), 0+minute(), 10, 30, 5); // left star
    pop();
  
    push();
    frameRate(1);
    translate(x+120, y-380);
    rotate(-radians(5) * second());
    star(0+minute(), 0+minute(), 5, 20, 5); // right star
    pop();
}

function galaxy() {
    // earth
    translate(-240, -480);
    fill(9, 130, 13); // green
    noStroke();
    circle(x, y, z*5);
  
    // yellow
    noStroke();
    fill(245, 206, 51); // yellow
    circle(x, y-200, z);
    fill(242, 221, 136); // inner yellow
    circle(x, y-200, z/2)
  
    // orange
    fill(245, 145, 51); // orange
    circle(x+200, y, z);
    fill(242, 188, 138); // inner orange
    circle(x+200, y, z/2);
  
    // dark blue
    fill(74, 51, 245); // dark blue
    circle(x, y+200, z);
    fill(167, 156, 247); // inner dark blue
    circle(x, y+200, z/2);

    // light blue
    fill(150, 198, 250); // light blue
    circle(x-200, y, z);
    fill(211, 227, 245); // inner light blue
    circle(x-200, y, z/2)

}

function star(x, y, radius1, radius2, npoints) { // reference star https://editor.p5js.org/p5/sketches/Form:_Star
    fill(241, 242, 153)
    let angle = TWO_PI / npoints;
    let halfAngle = angle / 2.0;
    beginShape();
    for (let a = 0; a < TWO_PI; a += angle) {
      let sx = x + cos(a) * radius2;
      let sy = y + sin(a) * radius2;
      vertex(sx, sy);
      sx = x + cos(a + halfAngle) * radius1;
      sy = y + sin(a + halfAngle) * radius1;
      vertex(sx, sy);
    }
    endShape(CLOSE);
}

Blog 06

Manolo Gamboa Naon is a creative coder from Argentina with a focus on generative visual aesthetics. Through the combination of image and video, he strives to discover the line between chaos and order. In his piece Manoloide, Last Flowers, he displays selections of different variations of black, red, yellow, white, and blue. The pieces look like acrylic paint lathered onto a canvas, giving the illusion of texture. The shapes are also flower-like and fragmented, with no shape repeating. Naon certainly achieves an organized chaos in his work, with the feeling of a pattern but no exactly repeating imagery. You can also see where the colors ever so slightly blend together to create fine lines.

Looking Outwards-06

I browsed through various articles showcasing beautiful randomized computational art, but the artwork that I found the most unique was Rami Hammour’s “A Text of Random Meanings“.

“A Text of Random Meanings” by Rami Hammour

Hammour is an architectural designer based in Brooklyn, NY and has garnered his artistic attention through his sporadic, yet structured artworks. For this piece in particular, I admire the randomized bars and lines that look like a collection of mazes, or a labyrinth. Hammour creates this effect using a random number generator to visually create 18 lines of a “Registers and Taps” coupled with python scripts. The drawing comparing three different registers of 9, 11, and 13. I can see how Hammour’s artistic sensibilities manifest into this randomly simulated artwork because he aims to create random yet systematic pieces, and blend both the natural randomness of mathematics with artistic mapping.

Blog – 06


The work of Katharina Brunner most inspires me. She is an artist and data scientist from Germany that often uses randomness in her artwork. She also is involved in the fields of technical writing and research. Recently, she created a software package in R called generative art. She publicly posted this package on GitHub so that people can access and experiment with randomly generated art. According to her website, she says that her package allows for the creation of images based on thousands of points. Additionally, the position of every single point in the picture is calculated by a formula that takes in random parameters. Thus, every image looks different due to the built-in randomness. Her work stands out to me because she is creating her own artwork while simultaneously working to inspire others by giving them the initial tools to learn about the field of generative art. Check out her work below!

By: Katie Makarska

https://katharinabrunner.de/generativeart/