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.
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.
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
// 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.
/* 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
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.
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.
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
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.
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.