Yiran Xuan – Project 06 – Abstract Clock

I started with the idea of a water dripping, at first wanting to just have a series of pitchers pouring into each other. However, this seemed rather uninteresting, and also the mechanics of the water pouring seemed to complicated. I thought it would be better to display each time unit differently, so I went with a plant growing in front of a changing sky.

sketch


var currentsec = second();
var dropdistance = 200;

var totalminutes = hour()*60 + minute();
var sunlight;

var waterlevel = 0;

function setup() {
    createCanvas(300, 300);
    angleMode(DEGREES);
    
}

function draw(){
	totalminutes = hour()*60 + minute();
	sunlight = round(abs(totalminutes/3 - 240)); //ensures that sunlight value is greatest when totalminutes is half of the midnight value

	background(120 - sunlight/2, 240 - sunlight, 240 - sunlight) //background changes gradually each minute; is darkest in the evening and early morning, lightest during the day
	
	
	if(currentsec != second()){ //if start of a new second, create droplet at top of canvas
		dropdistance = 0;
	}
	else {
		dropdistance += 5; //allow droplet to fall
	}

	currentsec = second();

	waterlevel = second();

	noStroke()
	fill(0, 255, 255);
	ellipse(100, dropdistance, 6, 6); //draw droplet
	rect(0, 300 - (waterlevel/2), 300, waterlevel/2); //draw water at the bottom

	

	stroke('green');
	strokeWeight(7);
	var plantheight = 270 - minute()*4;
	line(120, 300 - (waterlevel/2), 120, plantheight); //draw plant stalk

	noStroke();
	fill('green'); //draw plant leaves
	triangle(120, plantheight, 120 - 15, plantheight - 20, 120 - 40, plantheight - 10);
	triangle(120, plantheight, 120 + 15, plantheight - 20, 120 + 40, plantheight - 10);


}

Austin Treu – Looking Outwards 06

jonathanmccabe.com

Jonathan McCabe’s work is very interesting as he utilizes Alan Turing’s research to create pieces of art from very minuscule levels such as pixels. In these projects, he starts with very small random variations in certain variables of the pixels. Once the project is generated it is filled with a wide variety of different features. His work helps to show that such randomness inherently imitates nature on every scale, particularly on a cellular level. The random projects tend to create shapes and colors that combine to form something reminiscent of nature. This is something that makes the uniqueness of nature seem even more fascinating, as it is all just as random as it may seem from the smallest level up, just like these projects.

project 6

sketch.js

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

//--------------------------
function draw() {
    background(255);
    noStroke();
    
    // current time
    var H = hour();
    var M = minute();
    var S = second();
    
    // widths of the rectangles
    //map(value, start1, stop1, start2, stop2, 

    var mappedH = map(H, -5,23, width,0);
    var mappedM = map(M, -5,59, width,0);
    var mappedS = map(S, -5,59, width,0);
    var rectHeight = width / 3;
    
    // rectangle time bars


//Hour
    fill (0)
    rect(0*rectHeight,0, rectHeight,width);
    fill(255);
    rect(0*rectHeight,0, rectHeight,mappedH);
//minute
    fill(50);
    rect(1*rectHeight,0, rectHeight,width);
    fill(255); //background color
    rect(1*rectHeight,0,rectHeight, mappedM);
  //second  
    fill(100);
    rect(2*rectHeight,0, rectHeight,width);
    fill(255);
    rect(2*rectHeight,0, rectHeight,mappedS); //rectangle that moves


//text
    fill(255);
    textFont('Georgia');
    text("Hour " +H, 0*rectHeight+95, mappedH +15);
    text("Minute " +M, 1*rectHeight + 95,mappedM +15 );
    text("Second " +S, 2*rectHeight +95, mappedS +15);//mapped allows the text to move with the bars
    
}

My clock was inspired by a bar graph. I used the mapped function we learned.

Yoo Jin Shin-Project-06-Abstract-Clock

Project-05

// Yoo Jin Shin
// Section D
// yoojins@andrew.cmu.edu
// Project-06-Abstract-Clock

var prevSec;
var millisRolloverTime;
var x = [50, 61, 83, 69, 71, 50, 29, 31, 17, 39];
var y = [358, 377, 383, 400, 422, 413, 422, 400, 383, 377];

function setup() {
    createCanvas(480, 480);
    millisRolloverTime = 0;
    frameRate(10);
}

function draw() {
    background(0); 
    fill(255);
    noStroke(0);
    
    // Fetch the current time
    var H = hour();
    var M = minute();
    var S = second();
    
    if (prevSec != S) {
        millisRolloverTime = millis();
    }
    prevSec = S;
    var mils = floor(millis() - millisRolloverTime);
   
    var hourW = map(H, 0, 23, 0, width);
    var minuteW = map(M, 0, 59, 0, width);
    
    var secondsWithFraction = S + (mils / 1000.0);
    var secondsWithNoFraction = S;
    var secondBarWChunky = map(secondsWithNoFraction, 0, 60, 0, width);
    var secondBarWSmooth = map(secondsWithFraction, 0, 60, 0, width);

    // Hour yellow ellipse
    noStroke();
    fill(255, 237, 101, 255);
    ellipse(width / 4, height / 4, hourW, hourW);

    // Minute green ellipse
    fill(92, 220, 82, 230);
    ellipse(width - 30, height / 3 + 40, minuteW, minuteW);

    // Second blue ellipse
    fill(171, 213, 255, 200);
    ellipse(width / 2, height / 2, secondBarWChunky, secondBarWChunky);

    // Millisecond red ellipse
    fill(240, 32, 32, 200);
    ellipse(width - 50, height - 50, secondBarWSmooth, secondBarWSmooth);

    // Text of the current time
    fill(255);
    textFont("Futura");
    textSize(12);
    text("HOUR: " + H, 10, 22);
    text("MINUTE: " + M, width - 80, height / 3 + 40);
    text("SECOND: " + S, width / 2 - 30, height / 2 + 3);
    text("MILLISECOND: " + mils, width - 120, height - 50);


    // Big star 
    var nPoints = x.length;
    fill(255);
    
    beginShape();
    for (var i = 0; i < nPoints; i++) {
        var px = x[i] + random(-1, 1);
        var py = y[i] + random(-1, 1);
        vertex(px,py);
    }
    endShape(CLOSE);
    
    // Small star
    beginShape();
    for (var i = 0; i < nPoints; i++) {
        var px = x[i] + random(-1, 1);
        var py = y[i] + random(-1, 1);
        vertex(px,py);
    }
    scale(0.5, 0.5);
    endShape(CLOSE);
}

I tend to associate time with space, probably because they’re both used when describing dimensions. So when I thought of space, I thought of outer space— the sun, stars, moons, and various planets floating about in darkness. For this project, I tried to abstractly visualize time in an outer space setting, with each element of time (hour, min, sec, ms) represented with an element in outer space. My original idea was to animate a story of a comet approaching and causing an explosion, but it was difficult to time the movements that I pictured accordingly.

Rough sketch of design

Project 6 rrandell

sketch

/* Rani Randell
rrandell@andrew.cmu.edu
Section A
Project 6 */


function setup() {
    createCanvas(310, 300);
    background(255, 0, 0); //keep background here so the dragging effect happens
}

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

	fill(255, 0, 0);
	ellipse(h * 5, 75, 30, 30); //hour
	ellipse(m * 5, 150, 30, 30); //minute
	ellipse(s * 5, 225, 30, 30); //second

}

This sculpture by famous minimalist artist Donald Judd, is the inspiration for my clock. Although it is very simple, sometimes the best and most complex art is often extremely simple because it is so thought provoking.

Austin Treu – Project 06

atreu-proj-06

/*Austin Treu
	atreu@andrew.cmu.edu
	Section B
	Project-06*/

var hSize = 80, mSize = 40, sSize = 20
    hourX = 0, hourY = 150, 
    minX = 0, minY = 250,
    secX = 0, secY = 350, 
    wProp = 0, hProp = 0, 
    wPropH = 0, hPropH = 0;

//--------------------------
function setup() {
    createCanvas(480, 480);
    wProp = width/60;
    hProp = height/60;
    wPropH = width/12;
    hPropH = height/24;
}

//--------------------------
function draw() {

    /*TEST CODE - grid for measurement
    line(30*wProp, 0, 30*wProp, height);
    line(0, 30*hProp, width, 30*hProp);
    line(15*wProp, 0, 15*wProp, height);
    line(0, 15*hProp, width, 15*hProp);
    line(45*wProp, 0, 45*wProp, height);
    line(0, 45*hProp, width, 45*hProp);*/
    
    // Fetch the current time
    var H = hour();
    var M = minute();
    var S = second();
 

    //draw background, base upon time
    background((S+1)*2.125,int(255-(S+1)*2.125),255-S, (H+S)/4);

    //set current ellipse locs
    hourX = H*hPropH;
    hourY = ((pow(((hourX-width/2)),2)/16)+7*height)/16;
    minX = M*hProp;
    minY = (abs(pow((minX-height/2)/6,2)-height))/4;
    secX = S*hProp;
    secY = -(abs(pow((secX-height/2)/6,2)-height)-4*height)/4;

    //add trail lines every few seconds (pulsating effect)
    if(S%3 === 0){
		stroke(3*S,200-S, 200-S, 10);
	    strokeWeight(5);
	    for(var i = 0; i<width; i++){
	    	//H
	    	var y = -(abs(pow((i-height/2)/6,2)-height)-4*height)/4;
	    	point(i,y);
	    	//M
	    	y = (abs(pow((i-height/2)/6,2)-height))/4;
	    	point(i,y);
	    	//S
	    	y = ((pow(((i-width/2)),2)/16)+7*height)/16;
	    	point(i,y);
	    }
	    noStroke();
	}

    //draw ellipses for time
    fill('yellow');
    ellipse(hourX, hourY, hSize, hSize);
    fill(0,100,255);
    ellipse(minX, minY, mSize, mSize);
    fill(230);
    ellipse(secX, secY, sSize, sSize);
}

This clock assignment took a few different forms in my head, as I wanted to have a vague space/sky theme and also be as minimalist as possible while still getting the point across. I initially thought about utilizing orbital circles, but I ultimately decided that it would be more interesting to mess around with some other types of functions, with the ‘sun’ (hours) having a simple parabola to portray sunrise and sunset. The ‘planet’ (minutes) and ‘moon’ (seconds) actually mirror each other in their patterns, bouncing off of the bottom of the screen at 1/4 and 3/4 of the way through. This keeps things simple whilst allowing an onlooker to easily see quarter minutes and hours as well as days.

Rjpark – Project 06 – Abstract Clock

rjpark_abstractclock

var H; // current hours
var M; // current minutes
var S; // current seconds
var hr; // hour rgb
var hg;
var hb;
var mr; // minute rgb
var mg;
var mb;
var sr; // second rgb
var sg;
var sb;
var bc; // background color
var lc; // line color

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

function draw() {
	H = hour();
	M = minute();
	S = second();

	var mapH = map(H, 24, 0, height, 0);
	var mapM = map(M, 59, 0, height, 0);
	var mapS = map(S, 59, 0, height, 0);

	// switching colors depending on day or night
	// day = midnight (0:00) to noon (12:00)
	// night = noon (12:00) to midnight (24:00)
	if (H < 12) { // day
		hr = 170;
		hg = 40;
		hb = 250;
		mr = 45;
		mg = 250;
		mb = 45;
		sr = 30;
		sg = 185;
		sb = 250;
		bc = 220;
		lc = 0;
	}
	if (H >= 12) { // night
		hr = 50;
		hg = 5;
		hb = 75;
		mr = 10;
		mg = 60;
		mb = 10;
		sr = 30;
		sg = 35;
		sb = 90;
		bc = 30;
		lc = 255;
	}

	// day or night colored rectangles
    fill(hr, hg, hb);
    noStroke();
    rect(0, 0, width / 3, height);
    fill(mr, mg, mb);
    noStroke();
    rect(width / 3, 0, width / 3, height);
    fill(sr, sg, sb);
	noStroke();
	rect(2 * width / 3, 0, width / 3, height);

	// moving of rectangle for hours
	fill(bc);
	noStroke();
	rect(0, 0, width / 3, mapH);

	// moving of rectangle for minutes
	fill(bc);
	noStroke();
	rect(width / 3, 0, width / 3, mapM);

	// moving of rectangle for seconds
	fill(bc);
	noStroke();
	rect(2 * width / 3, 0, width / 3, mapS);

	// markings for hours, minutes, seconds
	for (var hi = 0; hi < 24; hi ++) {
		stroke(lc);
		strokeWeight(1);
		line(0, (height / 24) * hi, width / 12, (height / 24) * hi);
		if (hi == 3 || hi == 6 || hi == 9 || hi == 12 || hi == 15 || hi == 18 || hi == 21) {
			line(0, (height / 24) * hi, width / 6, (height / 24) * hi);
			line(width / 3, (height / 11.9) * hi, 6 * width / 12, (height / 11.9) * hi);
		}
	}
	for (var mi = 0; mi < mapM; mi ++) {
		stroke(lc);
		strokeWeight(1);
		line(width / 3, (height / 11.9) * mi, 5 * width / 12, (height / 11.9) * mi);
	}
	for (var si = 0; si < mapM; si ++) {
		stroke(lc);
		strokeWeight(1);
		line(2 * width / 3, (height / 5.9) * si, 3 * width / 4, (height / 5.9) * si);
	}
}

I drew my inspiration from candle clocks which was used a long time ago to tell time. You can tell how much time as passed by seeing how much of the candle has melted. Similarly, I created an abstract clock that mimics the candle clock, only mine has tick markings on the side so you can better tell what time it is.

(in regards to longer tick markings) It goes from 12am to 6am to 12pm to 6pm to 12 am again for the hours. It goes from 0 to 15 to 30 to 45 minutes. The seconds go by 10s. Also, when the time hits 12pm, the colors switch from bright (day) to dark (night) colors.

Joanne Lee – Looking Outward 06

James White’s early forge output using flower dingbats and the color palette from a scene in ‘300’ (2007).

James White created a program called Forge, which helps White to create art pieces where many elements are out of his control. I admired that not only did he want to create random art, but he also created a program / tool to help himself and other artists do the same. He stated that, “The program forces me to allow elements to react unto themselves.” I think as an artist, you usually want to be in control of every element and it is interesting that he wanted to help himself let go more.

Although I am not sure how the algorithm runs, I am assuming that he is able to input certain general shapes or patterns he likes and the program is able to iterate them in different sizes, colors, and positions randomly. The artist still has control in the sense that they are able to decide what sorts of shapes and patterns are in the artwork, however, must let go in order to get the full effect of randomness. By using a program to aid him, it is truly random since humans struggle to make random choices. The result is a beautiful piece of art and it seems like White has modified the image afterwards adding fade effects, etc. I admire that he created his own program to aid his work.

Dani Delgado Project 06 – Abstract Clock

sketch

/*Dani Delgado
Section E
ddelgad1@andrew.cmu.edu
Project 06
*/

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

function draw() {
	background(250);

	//set the time variables 
    var h = hour();
    var m = minute();
    var s = second(); 

	//draw the static background / peices 
	//draw the "city"
	//draw the buildings
	noStroke();
	fill(60, 60, 80, 90);
	rect(0, 0, width, height / 2 + 20);

	//draw the building shadows
	noStroke();
	fill(20, 20, 40, 90);
	rect(90, 0, 10, height / 2 + 20, 60, 0, 0, 0);
	rect(350, 0, 10, height / 2 + 20, 0, 60, 0, 0);

	//draw a moving person
	//set the moving variables
	var mapp = map(m, 0, 60, width, 0);
    var personX = mapp;
    var speed = m; 

	//draw the person walking on a minute long loop
    push();
    personX += speed;
	ellipseMode(CORNER);
	noStroke();
	fill(0, 45, 50, 60);
	ellipse(personX, 70, 40, 40);
	rect(personX, 110, 40, 200, 80);
    pop();

	//draw the window 
	fill(230, 247, 255, 40);
	noStroke();
	rect(0, 0, width, height / 2 + 20);

	//draw the window highlights
	stroke(255, 255, 255, 90);
	strokeWeight(50);
	line(300, 0, 480, 200);
	strokeWeight(10);
	line(230, 0, 410, 207);
	strokeWeight(100);
	line(0, 150, 180, 350);

	//draw the window frame shadow
	noStroke();
	fill(80);
	rect(355, 0, 30, height / 2 + 20);
	rect(30, 0, 30, height /2 + 20);

    //window frame
	fill(120);
	rect(355, 0, 25, height / 2 + 17, 0, 0, 50, 0);
	rect(30, 0, 25, height /2 + 17, 0, 0, 50, 0);

	//draw the table
	noStroke();
	fill(157, 115, 70);
	rect(0, height / 2 + 20, width, height);
	fill(137, 95, 50);
	rect(0, 350, width, height);

	//draw the shadow of the mug
	 //make the mug shadow rotate bassed on the hour
    if (h >= 12) {
		h -= 12;
	}
	h = map(h, 0, 11, 0, 360);
	push();
	translate(160, 280);
	rotate(radians(h) - 0.25 * (TWO_PI))
	fill(127, 85, 40, 85);
	rect(0, 0, 100, 80, 60);
	pop();

	//draw the mug
	noStroke();
	fill(204, 255, 212);
	rect(115, 220, 120, 80, 0, 0, 90, 90);
	fill(164, 215, 172);
	ellipse(175, 220, 120, 20);
	fill(77, 51, 0);
	ellipse(175, 225, 100, 10);

	stroke(204, 255, 212);
	strokeWeight(10);
	noFill();
	arc(115, 255, 45, 45, radians(80), radians(300), TWO_PI);

	//draw the steam and make it move 
	//the steam moves up and down with each second 
	//first set the needed variables 
	//and then create an if statement that makes it move up or down every other second
	var steam1Y = 200;
	var steam2Y = 180; 
	if ((s % 2) > 0) {
        steam1Y = 200;
        steam2Y = 180;
	} else if (( s % 2) == 0) {
		steam1Y = 190;
		steam2Y = 170;
	}
	//draw the steam itself 
	//left puff of smoke
	fill(255);
	noStroke();
	ellipse(155, steam1Y + 10, 8, 8);
	ellipse(152, steam1Y + 5, 10, 10);
	ellipse(159, steam1Y - 2, 15, 15);
	ellipse(155, steam1Y - 10, 15, 15);
	ellipse(162, steam1Y - 14, 16, 16);
    //right puff of smoke
	ellipse(195, steam2Y, 10, 10);
	ellipse(200, steam2Y - 6, 12, 12);
	ellipse(198, steam2Y + 5, 8, 8);
	ellipse(197, steam2Y - 10, 15, 15);
    ellipse(202, steam2Y - 14, 18, 18);
    ellipse(198, steam2Y - 20, 12, 12);
	
   
}

This project was a bit challenging for me, especially when coming up with a concept to go with. However, completing the extra credit assignment really helped me to understand the mechanics that goes into making a clock work. I went with a coffee shop idea after looking at how the shadows around my coffee cup collection on my desk change as the day goes on and I thought that it would make a cute clock idea.

There are a few details I wish I could have ironed out but overall I think that this clock is cute and fun.
The steam moves with seconds, the person outside the window moves along with the minutes, and the shadow of the cup rotates with each hour.

An initial sketch of the clock landscape
mug and steam development

 

Lan Wei-Project-06-Abstract Clock

sketch

function setup() {
    createCanvas(450, 450);
    stroke(255, 215, 0);
    background(0);
    frameRate(1);
}

function draw() {
    // Fetch the current time
    var H = hour();
    var M = minute();
    var S = second();

    // HourRect
    var rectHH = height/24; //height of each 'hourfloor'
    var rectMH = rectHH/60; //height of each 'minutefloor'
    var rectW = [100, 140, 120, 130];
    for(var i = 0; i < H; i ++){
        fill(25, 25, 112); //add changefulness to different floors color
        var rectX = width/2 - 0.5 * rectW[i % 4]; //X coordinate of HourRect
        var rectY = height -(i + 1) * rectHH; //Y coordinate of HourRect
        rect(rectX, rectY, rectW[i % 4], rectHH);
    }

    //MinuteRect
    for(var j = 0; j < M; j ++){
        fill(255);
        var rectX = width/2 - 0.5 * rectW[j % 4]; //X coordinate of MinuteRect
        var rectY = height -(j + 1) * rectMH - H * rectHH; //Y coordinate of MinuteRect
        rect(rectX, rectY, rectW[j % 4], rectMH);
        //cover secondRect in every new minute
        push();
        fill(0);
        noStroke();
        rect(width/2 - 140/2, height - M * rectMH - H * rectHH - 17, 150, 17);
        pop();
    }

    //SecondRect
    for(var k = 0; k < S; k ++){
        fill(150);
        var heightRange = [5,14,3,8,17]; //to get random height
        var widthRange = [7,5,2,8,6]; //to get random width
        var gap = rectW[k % 4] / 60; // distribute second rectangles
        var rectX = width/2 - 130/2 + k * gap; //X coordinate of MinuteRect
        var rectY = height - M * rectMH - H * rectHH - heightRange[k % 5]; //Y coordinate of MinuteRect
        rect(rectX, rectY, widthRange[k % 5], heightRange[k % 5]);
    }
}

In the design I try to make the clock look like a building under construction. The ‘second rectangles’ and ‘minute rectangles’ are the parts being built and the ‘hour rectangles’ are floors that are already built.