Category: SectionB

Looking Outwards: 06

Vera Molnar is a pioneer in computational and generative art work. She began writing computer code that introduced randomness to her art in the mid to late 1960s. Even earlier she was creating manual rules and algorithms to generate computational art by hand. She began writing code in Fortran back at a time when they used punch cards to feed a program into the computer. The randomness, she explained, gives her ideas and allows her to try out endless variations of her work. This enables her to create works that she may never have thought of on her own. She explains that the computer is not taking the place of the artist; it is simply a tool.
For this project I became intrigued with her Variations exposition at the Beall Center at the University of California in Irvine. The art works presented are generative both through computer programming and also from her manual algorithms. The piece that resonated with me most is called Interruptions and is presented below. This work is a series of short random lines. She worked with this program and introduced the removal of lines in the randomness algorithm as well. The gaps give the work its name, Interruptions. I really enjoy that she plays with the removal of what is already there. Each iteration of the program creates a unique image. It is compelling to see what gets left behind in the empty spaces.

Interruptions

Project 06

sketchDownload
// Ilia Urgen
// Section B
// iurgen@andrew.cmu.edu
// Project-06

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

function draw() { 
    // 0:00 to 8:00
    if (hour() >= 0 & hour() <= 8) {
        sleep(); 
    }

    // 8:00 to 20:00
    else if (hour() >= 8 & hour() <= 20) {
        daytime();
    }

    // 20:00 to 24:00
    else if (hour() >= 20 & hour() <= 24) {
        sleep();
    }

}

// 0:00 to 8:00 and 20:00 to 24:00
function sleep() {
    
    var s = map (minute(), 0, 60, 0, 3600) + second();
    var c = map (hour(), 0, 20, 0, 70);
    var h = map (s, 0, 3600, 0, 90);

    
    color_1 = color (120,29,173);
    color_2 = color (0);

    // ombre 
    for (var y = 0; y < height; y++ ) {
        n = map (y,0, height, 0, 1);
        var color_3 = lerpColor (color_1, color_2, n);
        stroke (color_3);
        line (0, y, width, y);
    }

    stroke (0);
    strokeWeight (8);

    // canvas border lines
    line (1,1,1,449);
    line (1,1,449,1);
    line (1,449,449,449);
    line (449,1,449,449); 

    // window
    fill (11,11,10 + c);
    rect (width/2, height/2 - 180, 200, 200);

    // moon
    noStroke();
    fill (230,230,180);
    ellipse (320,120,100,100);
    fill (11,11,10 + c);
    ellipse (375 - h,120,95,110);

    // bed
    fill (152,118,84);
    strokeWeight (0.5);
    rect (width/2 - 200, height/4 + 210, 300, 100);
    rect (width/2 - 200, height/4 + 310, 40, 40);
    rect (width/2 + 60, height/4 + 310, 40, 40);

    // hair on head
    fill (255);
    ellipse (280,315,100,40);

    // pillow
    fill (0);
    ellipse (280,300,70,45);

    //blanket
    strokeWeight (2);
    fill (123,24,26);
    square (width/2 - 200, height/4 + 170, 50);
    square (width/2 - 150, height/4 + 220, 50);
    square (width/2 - 100, height/4 + 170, 50);
    square (width/2 - 50, height/4 + 220, 50);
    square (width/2, height/4 + 170, 50);
    square (width/2 - 200, height/4 + 270, 50);
    square (width/2 - 100, height/4 + 270, 50);
    square (width/2, height/4 + 270, 50);

    fill (0,65,169);
    square (width/2 - 200, height/4 + 220, 50);
    square (width/2 - 150, height/4 + 170, 50);
    square (width/2 - 100, height/4 + 220, 50);
    square (width/2 - 50, height/4 + 170, 50);
    square (width/2, height/4 + 220, 50);
    square (width/2 - 150, height/4 + 270, 50);
    square (width/2 - 50, height/4 + 270, 50);
    
    // Flickering Zzz's
    zzz();
}

function zzz() {
    
    if (second () % 2 == 0) {
        stroke (255);
        strokeWeight (4);
        line (280,270,320,270);
        line (280,230,320,230);
        line (280,270,320,230);

        push();
        translate (40, -20);
        line (280,270,320,270);
        line (280,230,320,230);
        line (280,270,320,230);
        pop();

        push();
        translate (80, -40);
        line (280,270,320,270);
        line (280,230,320,230);
        line (280,270,320,230);
        pop();
    }   
}

// 8:00 to 20:00
function daytime () {
    
    var s = map (minute (), 0, 60, 0, 3600) + second();
    var m = floor (map (minute (), 2, 60, 2, 10));
    var x = map (s, 0, 3600, 0, 340);
    var c = map (hour (), 3, 20, 0, 100);
    
    
    color_1 = color (25,206,255 - m);
    color_2 = color (0,129,150 - m);

    // ombre
    for (var y = 0; y < height; y++ ) {
        n = map (y,0, height, 0, 1);
        var color_3 = lerpColor (color_1, color_2, n);
        stroke (color_3);
        line (0, y, width, y);
    } 
    
    // moving clouds
    noStroke();
    fill (255);
    circle (300 + c,120,50);
    circle (300 + c,90,50);
    circle (340 + c,120,50);
    circle (340 + c,90,50);
    circle (282 + c,105,50);
    circle (358 + c,105,50);
    
    push();
    translate (72,80);
    circle (300 + c,120,50);
    circle (300 + c,90,50);
    circle (340 + c,120,50);
    circle (340 + c,90,50);
    circle (282 + c,105,50);
    circle (358 + c,105,50);
    pop();

    stroke (0);
    strokeWeight (8);
    
    // walls
    noFill();
    rect (width/2, height/2 - 180, 200, 200);
    
    fill (255,127,80);
    noStroke();
    rect (0, height/6 - 80, 221, 260);
    rect (height/2 - 12, 0, 240, 41);
    rect (0, height/2 + 24, width, 202);
    rect (height/2 + 204, 0, 22, 300);

    
    // countertop
    fill (255);
    rect (0,width/2 + 24, width, 30);

    // cabinets
    fill (86,60,40);
    rect (0,width/2 + 48, width, 200);

    stroke (0);
    noFill();
    strokeWeight (2);
    rect (28,width/2 + 72, 80, 140);
    rect (132,width/2 + 72, 80, 140);
    rect (236,width/2 + 72, 80, 140);
    rect (340,width/2 + 72, 80, 140);

    // doorknobs
    noStroke();
    fill (212,175,55);
    circle (90,330,20);
    circle (150,330,20);
    circle (300,330,20);
    circle (360,330,20);

    strokeWeight (8);

    // canvas border lines
    line (1,1,1,449);
    line (1,1,449,1);
    line (1,449,449,449);
    line (449,1,449,449);

    // "GOOD"
    if (second () % 2 == 0) {
        
        push();
        translate (20,40);
        stroke (0);
        strokeWeight (4);
        line (20,20,40,20);
        line (20,20,20,60); 
        line (20,60,40,60);
        line (40,60,40,40); 
        line (40,40,30,40); 

        line (60,20,80,20);
        line (60,20,60,60); 
        line (60,60,80,60);
        line (80,60,80,20);

        push();
        translate (40,0);
        line (60,20,80,20);
        line (60,20,60,60); 
        line (60,60,80,60);
        line (80,60,80,20); 
        pop();

        line (140,20,140,60);
        line (140,20,160,40);
        line (140,60,160,40);
        pop();

    }

    // "DAY!!!"
    if (second () % 2 == 1) {
        
        push();
        translate (20,40);
        stroke (0);
        strokeWeight (4);
        line (20,80,20,120);
        line (20,80,40,100);
        line (20,120,40,100);
        
        line (60,80,80,80);
        line (60,80,60,120); 
        line (60,100,80,100);
        line (80,120,80,80); 

        line (100,80,110,100); 
        line (110,100,120,80); 
        line (110,100,110,120); 

        line (140,80,140,110);
        line (150,80,150,110);
        line (160,80,160,110);

        point (140,120);
        point (150,120);
        point (160,120);
        pop();
    }  
}

Blog 06 – Randomness – srauch

I find Paul Dunham’s installation Click::RAND to be fascinating. It’s based on the book A Million Random Digits with 100,000 Normal Deviates, which was published by the RAND corporation in 1955 to allow computer programmers to have an extensive amount of truly random numbers on hand. (The numbers themselves were generated by a program designed to work as a roulette wheel.) The book was available in standard print, but also as computer punchcards, and it’s the latter version that Dunham was inspired by. He created “instruments” by wiring together a grid of old-fashioned electromagnetic relays that make an audible click when they open and close, then feeding them the random numbers provided by the punchcards as instructions on when to move. The result is an audible experience of randomness, with ephemeral patterns seemingly flashing in and out of the composition.

The listening experience seems to say something about how we as humans tend to try to impose order on our surroundings. Because of the way our neural networks work, we aren’t capable of thinking in a truly random way, and we have an inherent tendency to seek patterns. So, it’s an interesting experience to listen to something random and watch your brain spin itself out looking for patterns that actually aren’t there. 

Here is a video of Click::RAND in action. Scroll to about halfway in to see it in all its glory:

Looking Outward 06 / Electric Sheep

This is probably one of the more obvious examples of randomness in digital art, but I still find the overall concept really interesting.
Electric Sheep (a project founded by Scott Draves) is a collaborative and dynamic body of abstract work that can be downloaded to most devices. The program runs while devices are in “sleep” mode, communicating via the internet with other devices around the world to create and change the animations (or “sheep”) on display. Users can vote for their favorite ‘sheep’ with their keyboard, which generates new sheep via the algorithm. Sheep can also be “mated together” manually by server administrators or by users who download existing parameters and make changes.

The reason I chose this work for the blog this week is because of its focus on interactivity. The fact that this is a collaborative project between thousands of different computers is fascinating. And while there is an underlying element of randomness with the automatic ‘mating’ of sheep through the algorithm, users can also participate in generating/supplying new sheep to the flock.

Blog 06: “e4708”

By Ilia Urgen
Section B

This week, I came across a cool work of late-20th Century digital art. “e4708” was created in 1980 by Mark Wilson, one of the greatest pioneers in digital image making. Since then, his various computer generated art pieces have been widely exhibited across the world, but “e4708” remains his most popular work.

Wilson’s digital artwork is a combination of both a well-thought geometrical layout and aspects randomly generated by the computer’s algorithm. For instance, the rows/columns of the squares and circles are distinctively arranged to form a certain pattern. However, we notice that the background overlay, circle diameter/stroke width, and the square/circle fill are randomly generated.

This delegation of assigned and random elements create a structured, but very unique piece of art.

“e4708” as it appeared in 1980.

LO-05: The Dante Quartet

The Dante Quartet (1987) is an 8-minute experimental short film by Stan Brakhage. Produced over the course of six years, Brakhage hand-painted random but organized images on top of film with the aim of capturing various stages of hell. The Dante Quartet is divided into four sections: Hell Itself, Hell Spit Flexion, Purgation, and existence is song, comprising thousands of paintings – all of which can be characterized as emotive and intentional yet utterly random in their framing and order. As Brakhage splotches thick paint across his film, frames them, orders them, and edits them in a way that subverts the audience’s expectations (namely, the expectation that film must be explicitly narrative & played at consistent frame rates), he creates an experimental masterpiece that transcends both the canvas and the screen. The randomness within The Dante Quartet is visceral; watching the film as a spectator feels like witnessing a sort of organized chaos, taking us through the various stages of descension as Brakhage mapped out. That’s exactly what I admire about Brakhage’s work- through manipulating the random and rearranging them in a harmonious manner, Brakhage conveys emotion in an artful way that cannot be championed.

The Dante Quartet (1987), Stan Brakhage
Across the Universe: Stan Brakhage’s The Dante Quartet

Project-05-Wallpaper

cybergoth dragon recursion!!!

sketch 

// Zoe Lin (ID: youlin)
// Section B

function setup() {
  createCanvas(400, 600);
  noLoop();
  strokeWeight(0.025);
}

function draw() {
  callDragon(5, 5, width/1.5, height/2.5, 40);

function callDragon(x, y, width, height, d){
    background(255);
    d = map(40, 0, 60, 10, 16);

    push(); //dragon1
    drawDragon(x + width/3, y-2, width, height, d);
    pop();

    push(); //dragon2
    drawDragon(x + width/3, y+height+2, width, height, d);
    pop();
  
    push(); //dragon3
    drawDragon(x + width/3, y+height*2+2, width, height, d);
    pop();
  
    //push(); //dragon4
    //drawDragon(x + width/4.5, y+height*2.5, width, height, d);
    //pop();
}

function drawDragon(x, y, width, height, d){
    
    //draw
    triangle(x , y+height/2.5, x+width/2, y, x+width, y+height/2);
    translate(x, y+height/2);
  
    push();
    dragon(width, d);
    pop();
}

function dragon(len, d) {
    if (d <= 0) {
        return;
    }

    fill(255);
    triangle(0, 0, len/2, -(len/2), len/2.5, 0);
    push();

    var newLen = len/1.4;
    rotate(- PI/4);
    fill(0);
    triangle(0, 0, newLen, 0, newLen/2.5, -(newLen/2));
    dragon(newLen, d - 1); //recursion
    pop();

    push();
    translate(len, 1.4);
    rotate(-3 * PI/4);
    fill(0);
    triangle(0, 0, newLen, 0, newLen/2.5, -(newLen/3));
    dragon(newLen, d - 1);
    pop();  
}
}

Project 5: Wallpaper

sketchDownload
//Alicia Kim
//Section B
//yoonbink@andrew.cmu.edu
//Project-05

function setup() {
    createCanvas(420, 420);
    background(175,238,238);
}

function draw() {
    for (r=0;r<8;r++){
        for(c=0;c<8;c++){
            if (r%2==0 & c%2==0){
                drawFlower(r*60,c*60,255,209,193);
            }
            else{
                drawFlower(r*60,c*60,255,250,245);
            }
            
        }
    }
    noLoop();
}


function drawFlower (x,y,fillR,fillG,fillB) {
    
// leaves
    push();
    noStroke();
    translate(x+30,y+25);
    var randomR=floor(random(360));
    for (var j=0;j<3;j++){
        
        fill(144,238,144); //light green
        rotate(radians(randomR));
        ellipse(13,13,10,20);     
    }
    pop();

// stem
    push();
    noStroke();
    translate(x+30,y+25);
    var randomS=floor(random(360));
    fill(60,179,113,191); //sea green
    rotate(radians(randomS));
    rect(13,13,12,4.5);
    print(randomS);
    
    pop();

// flower petals
    push();  
    noStroke();
    translate(x+30,y+25);
    fill(fillR,fillG,fillB); // lavender blush
    var petal = floor(random(3,7));
    for (var i=0 ; i<petal ;i++){    
        ellipse(0,0,25,50);
        rotate(2*PI/petal);    
    }
    pop();
    noLoop();

// circle in the middle
    push();
    noStroke();
    fill(249,139,136); //pink
    circle (x+28,y+28,20);
    fill(255,209,193); //peach
    circle(x+30,y+25,12);
//small circles
    fill(128,128,0); //olive
    circle(x+28,y+23,4);
    circle(x+32,y+25,3);
    circle(x+28,y+28,4.5);
    circle(x+29,y+27,2.5);
    circle(x+23,y+23,3);

    pop();

}

Looking Outwards 05: 3D Computer Graphics

I am inspired by the project, Material studies: Snow by Jarron Hasenjager. This piece of 3d graphic art shows the steps of creating a realistic looking snow on a 3d program. The algorithm has so many layers to it to make a white sphere look like a realistic snowball. The creator not only had to explore what to do to achieve a realistic look on snow but also needed to know which steps to take in a certain order and that needed artistic sensibility as well as technological understanding of 3d graphics. The ability of 3d rendering and how realistic it can be fascinates me and makes me want to study 3d graphics.

https://pin.it/5sruoaT

Looking Outwards 05: 3D Computer Graphics

https://www.behance.net/gallery/151840435/Into-the-forest?tracking_source=curated_galleries_3d-arteativeapplications.net/maxmsp/forms-string-quartet/
David Padilla
Into the Forest
2022

This project is an excellent example of graphics combining 3D computing and nature.

Through algorithms and renderings, it simulates the natural ecosystem and explores the local trees, vegetation, fungus, and many other species and forms, as well as their relationships with each other.

The renderings of plants including moss and wood in this series of works are very realistic. The use of light is also very elegant and appropriate. The ratio of sunlight to shadow is just right, which makes the overall look very attractive — where the sun shines is where our vision focuses on, leading people to the incredible shapes of the fungus. The colors of the presented works are mainly shades of yellow and green to present the plants. The colors of the plants are different but also echo each other with wood in brown. The color collocation is very harmonious.