Category: SectionD

Looking Outwards 06 

Randomness 

E

For this I look at art by Christopher Hanusa. Christopher Hanusa is not an artist, but a mathematician. He makes computational art using math and brings it to life with 3D printing. He first makes a model himself and uses computation to make variations. These variations might not be truly random due to the set parameters, but they do occur at random intervals. Personally, I like that although these forms are technically produced with sophisticated tech, he likes fun colors, and this has become one of his signatures. He doesn’t just use randomness because he knows how, but believes it says something beautiful about the nature of life, uniqueness, and chance. Although each is generated with random factors, he goes through many different variations and chooses his favorites. This interaction became an important fingerprint of the artist’s likes and esthetic ideas. I am very curious to know  if his other non-chosen models are just as  “perfect”. 

https://gallery1064.com/collections/christopher-hanusa-solo-show

Project 06

This is my duck clock

the amount of ducks corresponds to the 24 hours and they spin once a minute and blink once a second

sketch
//Evette LaComb 
//elacomb@andrew.cmu.edu
// Section D 
// Project 06 - Duck Clock 

    //Concept: grid of 5 x 5, 24 ducks, every hour a new duck swims onto screen. 
    //each duck rotates once a minute.
    //need a function to draw the ducks
    //need a loop for the ducks- where do they enter from, where do they go each hour
    //need a transformation to roate each duck around its center axis- part of function
// b for bubbles in water:
var b = [];
//angle of roatation:
var angleR = 0;
var direction = 1;
//starting array for x position of ducks; 
var stx = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
//starting array for y position of ducks;
var sty = [200, 280, 200, 120, 280, 200, 120, 120, 280, 200, 120, 360, 40, 280, 40, 200, 360, 40, 280, 360, 360, 120, 40, 360];
//end position array for position of ducks;
var endx = [200, 120, 280, 200, 200, 120, 280, 120, 280, 40, 360, 200, 280, 40, 360, 360, 120, 200, 360, 40, 280, 40, 120, 360];
var speed = 1;

function setup() {
    createCanvas(400, 400);
    // object and Array for water texture: 
    for (i = 0; i < 1000; i ++) {
        b[i] = new Object();
        b[i].c = random(255);
        b[i].x = random(5, width-5);
        b[i].y = random(5, height-5);
        //speed that water moves: 
        b[i].dx = random(-0.1, 0.1);
        b[i].dy = random(-0.1, 0.1);
    }  
    frameRate(60);
}

function draw() {
    background("lightblue");
    var h = hour();
    //loops to create water texture
    for (i = 0; i <= 24; i ++) {
        bubble(b[i]);
        update_bubble(b[i]);
    }
    //loops t ocreate ducks corresponding to arrays 
    for (i = 0; i <= hour() - 1; i ++){
        duck(stx[i], sty[i]);
        stx[i] += speed;
        if(stx[i] >= endx[i]){ stx[i] = endx[i]};
    }
    //beach details:
    push();
    rotate(radians(-45));
    fill(255, 255, 255, 60);
    ellipse(0, 0, 320, 150);
    fill(200, 190, 160)
    ellipse(0, 0, 300, 130)
    pop();
    stroke(0);
    strokeWeight(2);
    //text('Current hour:\n' + h, 5, 50);
}


function duck(stx, sty){
//duck stuff: 
    //draw duck at coordinate x, y
    push();
    translate(stx, sty);
    //rotate the duck; 
    rotate(radians(angleR));
    angleR += 0.007;
    //cosmetics for duck:
    noStroke();
    fill("lightBlue");
    ellipse(0, 0, 80, 70);
    fill(230);
    ellipse(0, 0, 70, 60);
    fill(230);
    triangle(10, 30, 10, -30, 45, 0)
    fill("orange");
    ellipse(-25, 0, 30);
    fill("white");
    //stuff to make ducks blink according to seconds 
    ellipse(-10, 0, 40);
    var s = second();
    if (s % 2 == 0){
        fill("black");
    }else{
        fill("white");
    }
    ellipse(-15, 17, 5);
    ellipse(-15, -17, 5);
    pop();

}

function bubble(b){
//cosmetics of water texture:
    noFill();
    strokeWeight(10);
    stroke(255, 255, 255, 20)
    ellipse(b.x, b.y, 70, 70);
}

function update_bubble(b){
//tecnical stuff for water texture:
    //water movement:
    b.x += b.dx;
    b.y += b.dy;
    //if reach edge of screen change direction: 
    if ( b.x >= width || b.x < 0){
        b.dx = -b.dx;
    }

    if (b.y >= height || b.y < 0){
        b.dy = -b.dy;
    }
}

Looking Outward – 06 – aarnavp

//Aarnav Patel
//aarnavp@andrew.cmu.edu
//Section D
//Looking Outwards

One random computational graphics project that really impressed me is the work of Anders Hoff in the piece A Tangle of Webs. While there is definitely the employment of certain algorithms, the start of the piece is created from scattering random vertices around the canvas. The preceding formula then uses a recursive method to track intersections of lines connecting these vertices, ultimately resulting in the organic web-like structure. The resulting form is also inspired by elastic bands, as they model certain interactions between adjacent nodes to create the elastic materiality effect.

What I especially appreciate about this piece is how natural the integration with technology and graphics was undertaken. The potential for this type of piece is even noted for how it can be applied in a 3D sphere. It really connects with some of the projects we do in class, as we can somehow create this generalized algorithms from a basis of random points, alluding to the mathematical concepts underlying randomness.

https://inconvergent.net/2019/a-tangle-of-webs/

Project-06-aarnavp

For this project, I was inspired by the concept of dendrochronology, which is the study of time depiction through tree rings. Tree rings are indicative not only of the age of the tree, but also the conditions of the climate at the time. I thought this was really interesting, as the from a distance, the time can’t be easily counted, but it depicts more than just time, but place.

The tree ring is comprised of the layered brown/green ring (which denotes 24 layers for 24 hours), and then an underlying minutes and seconds red ring which grows gradually (and doesn’t layer).I also represented days from the moving ellipses in the center of the tree ring, to mimic the idea of celestial bodies.

sketch
//Aarnav Patel
//Section D
//aarnavp@andrew.cmu.edu
//Project 06

//Inspired by dendrochronology (how time is depicted through tree rings)

var radius;
var dayX = [];
var dayY = [];
var degree = [];
var dDegree = []
var diam;

function setup() {
    createCanvas(480, 480);
    let m = month();

    //finding the days per month
	if ( m == 4 || m == 6 || m == 9 || m == 11) {	
		diam = width / 30;
	} else if (m == 1 || m ==3 || m == 5 || m == 7 || m == 8 || m == 10 || m == 12) {		
		diam = width / 31;
	} else {			//february
		diam = width / 28;
	}
    
    radius = width / 60; //for seconds and minutes, they increment evenly 60 times until reach end of canvas
    ringColor = color(random(150, 160), random(105, 155), random(90, 100), 255 / 24);	//opacity is 255/24 so that the center of circle wil eventaully be 100% opacity
    			//random "magic paramters" is for random shade of brown (like tree barks)
    for (var i = 0; i < day(); i++) {
    	append(dayX, diam * i)
    	append(dayY, 0);
    	append(degree, 0);
    	append(dDegree, radians(random(-1, 1)));
    }
}

function draw() {
	background(255);
	translate(width / 2, height / 2);	//set new origin at middle of canvas

	fill(255, 0, 0, 20);	
	drawSecond();
	fill(255, 0, 0, 20);
	drawMinute();
	fill(ringColor);
	drawHour();

	for (var i = 0; i < degree.length; i++) {
		fill(255, 255, 255, 70);		
		ellipse(dayX[i], dayY[i], diam);

		rotate(degree[i]);
		degree[i] = degree[i] + dDegree[i];		//incrementing degree by specific dDegree
	}



}


function drawHour() {					//want the hours rings to be static military time (e.g 24:00) and show circles layered
	for (var i = 0; i < hour(); i++) {	//from 0 to 1 - current hour amount
		noStroke();
		ellipse(0, 0, width / i);		//draws circle proportional to width
	}

}

function drawMinute() {
	ellipse(0, 0, minute() * radius);		//minutes dynamic – increments evenly across canvas

}

function drawSecond() {
	secondR = 8;
	ellipse(0, 0, second() * radius);	//second dynamic – increments evenly across canvas

}

Project 06 – Abstract Clock

For this project, I thought about the growth of plants as a representation of time. However, I decided to combine that concept by creating a method where by looking at the image, one can know in a more literal sense what time of day it is while still being an abstract representation.

The stem grows a little longer each minute and refreshes from the bottom once it reaches 59. This allows the viewer to know what minute of the hour it is. The number o pedals is representative of the hour and the shade change of the pedals represents the seconds. The background also changes from night to day depending on the typical times when the sun and moon are out.

clock sketch
// Sandy Youssef
// syoussef@andrew.cmu.edu
// section D
//Assignment 6
var x; 
var y;
 
function setup() {
    createCanvas(400, 480);

   
}

function draw() {
    x = width/2;
    y = 450;
    

    // draw sun or moon depending on time of day where sun or moon are typically out
    var h = hour(); // current hour of day 0-23
    
    if ( h > 6 & h < 17) {
        background(205,236,255);
        //sun
        fill("yellow");
        ellipse(70, 70, 70);  
    
    } else  {
        background(32,58,131); 
        // draw moon
        fill("white")
        ellipse(330,70,70);
        fill(32,58,131);
        ellipse(310, 70,70);
        
    }
    //clouds 
    var xc = 100; // x cloud
    var xy = 100; // y cloud
    
    fill("white");
    //left cloud
    ellipse(xc + 25, xy +15, 50,25);
    ellipse(xc+ 55, xy + 35, 50,33);
    ellipse( xc, xy + 35, 60, 40);
    ellipse(xc +35, xy + 37, 50, 50);
    //right cloud
    push();
    translate(190,90);
    ellipse(xc + 25, xy +15, 50,25);
    ellipse(xc+ 55, xy + 35, 50,33);
    ellipse( xc, xy + 35, 60, 40);
    ellipse(xc +35, xy + 37, 50, 50);
    pop();
    
    //dirt
    noStroke();
    fill("brown");
    rect(0, 460, width, height);
    
   
    //stem
    var m = minute(); // current minute in hour 0-59
    fill(74,115,69);
    rect(x-10,y-10- (m *5), 5, 300); // every minute the stem will grow and once it reaches 59 it will start over. 
  

   
    var s = second(); // current seconds 0-59
    var h = hour(); // current hour of day 0-23
    for (var i = 0; i < h; i ++) { // loop that creates a new pedal at each hour to count hour
        push();
        translate(x-10 +3, y-10- (m*5)); // translates pedals to the center of flower 
        rotate(radians(360/24)*i);
        stroke("yellow")
        strokeWeight(1);
        // count seconds by changing shade of pedals at each second
        if (s %2) { // if second is odd make light pink
           fill(227,180,242);
        } else {
            fill(225,154,246); // if second is even make dark pink
        }
        ellipse(5 , (-15), 10, 25);
        pop();
        
    }
   

    // center of flower
    fill(243,255,131); // yellow
    ellipse(x-10 + 3 , y-10- (m *5) , 20);
    
     
   

    // grass 
    for (var x = 1; x < width; x = x+ 4) { 
        fill(0,240,0);
        triangle(x,480, x+ 5 , 480, x +2.5, 440);
    }


    

   
}
brainstorming process
messy brainstorming process

Looking Outwards 06: Randomness

Creator’s name: Wenran Zhao
Title of work: Random waLK & particles, vehicles system
Year of Creation: Unknown

This series of artwork uses randomness to create captivating variations of protrusions that resemble squid tentacles. I love the motion depicted in these pieces and the water-like and fluid quality that they have. The computation relies on wavy lines that extrude from a center-horizontal line of the canvas made up of random strings of yellow and blue as well as a circle spread across the canvas. I highly doubt that these works are generated in a “truly” random sense since it is much more likely that a sequence with certain bounds is used to generate these variations. I believe it is so as a result of the loose observable pattern or similar quality from one piece to the other. The artist’s artistic sensibilities portray a very fun and playful essence.

Some artworks from the series

Randomness – TheUnthoughts

Looking outwards 6

For this week I looked at Brian Eno’s use of generative algorithms in music production. I didn’t know that he literally invented generative music and was doing it in the 90’s. This is exciting for me because I’m a fan of him and it makes me more impressed with him as an artist as well as interested in the application of coding. He used a moire pattern, which is two grids of sound layered on top of another and overylaying them into what he calls ambient music. He had a lot of interesting methods using hardware and homemade contraptions to produce and alter his music in really unique ways. This is a link to a talk he gave on his generative music.

https://inmotionmagazine.com/eno1.html

Some of his albums useing genrative production methods are ambient music 1 through 4, and Apollo.

Project 6 abstract clock

I sort of messed around with the changing of these blocks for a while. I had them as notches for a second but I liked how at midnight it’ll turn to a black screen and slowly become red green and blue again. I also liked the layering effect of seconds in front of minutes in front of hours. It would be interesting to try to make it into more of a shifting gradient of red green and blue.

sketchDownload
//felix cooper fcooper D
var secs = {x:200, y:240, w:100, r:0};
var mins = {x:100, y:240, w:100, g:0};
var hours = {x:0, y:240, w:100, b:0}; //initializes each time box as an object

function setup() {
    createCanvas(300, 240);
}

function draw() {
    let s=second(); //sets a variable connected to each set of time
    let m=minute();
    let h=hour();

    background(255);

    fill(0,0,hours.b);
    noStroke();
    rect(hours.x,hours.y-4,300,240); //draws rectangle across canvas
    hours.y=map(hour() + norm(minute(), 0, 60),0,24,0,240); //mapps y value to hours
    hours.b=map(hour() + norm(minute(), 0, 60),0,24,0,255);//same for b value, the norm function makes it move in minute incriments
    if(h == 0){
        hours.y=240; //resets at midnight
    }

    fill(0,mins.g,0);
    noStroke();
    rect(mins.x,mins.y-4,300,240); //does the same stuff just for minutes 
    mins.y=map(minute() + norm(second(), 0, 60),0,60,0,240);
    mins.g=map(minute() + norm(second(), 0, 60),0,60,0,255);
    if(m == 0){
        mins.y=240;
    }

    fill(secs.r,0,0);
    noStroke(); //does the same stuff just for seconds 
    rect(secs.x,secs.y-4,300,240);
    secs.y=map(second(),0,60,0,240);
    secs.r=map(second(),0,60,0,255);
    if(s == 0){
        secs.y=240;
    }

}

Looking Outwards 06

Randomness in generative art

Vera Molnar’s work was amongst the first to be using computation to create art. She would use algorithms that delicately balanced randomness and purpose. This is especially true for her piece titled ‘Dialog Between Emotion and Method’ from 1986 where the idea of computational control is linked to method but the randomness of emotion makes the cube-square-like forms chaotic and unorderly. I suppose a majority of her algorithm revolved around creating the random colorful lines but she used constraints to trap the randomness in squares throughout the canvas– a bit like organized chaos. I think the way she breaks the idea of perfection and order that computationally creating art can quite easily provide and instead leans into disrupting it to create more visually intriguing forms.

https://muda.co/veramolnar/http://dada.compart-bremen.de/item/artwork/127

Looking Outwards 06: Randomness

Karlheinz Stockhauen: KLAVIERSTÜCK XI (1956)

I really liked KLAVIERSTÜCK XI by Karlheinz Stockhauen. Somehow, I felt that there is the usage of randomness in this piece of musical notes. There is a vivid pattern that Karlheinz follows, which I feel integrates randomness within his routine, which is really intriguing. However, there are hints of specific numbers too, such as he stops playing the notes which he has played 3 times. His notes are referred to as ‘pile of leaves’ which is owed due to the randomness of the notes, however, these notes are derived through constant trial and error and manipulated for musical composition means. I also admire the fact that all his notes read as a single piece produce a seriality within, which might come off as a meticulously planned structure. The structure of the notes is such that the other pianists are not able to replicate more than one piece of the whole thing. I do not know much about the approach Karlheinz took to generate these notes, as it seems randomly generated, but it commands attention as it makes complete musical sense when played together. Karlheinz’s intention is unclear in the final piece as no one knows about the origin of its motives, however, I am sure that for Karlheinz it is the manifestation of musical piece that he intended to portray.

Link