Project 06 Abstract Clock – Ellan Suder

For my clock I made a scene at the ocean. The small clock shows the progression of an hour (when it’s near the end of the screen the hour’s about to change) and the big cloud shows the progression of a minute. The water is controlled by a sin function so it makes a whole cycle in a minute. There is a transparent layer on top of the water (called oceanLight) that also expands and contracts sinusoidally. It has the same x,y value (0,2*height/3+yMin) so that it follows the blue water exactly.

There is also a simple function to make the sky more orange during specific hours (6am to 6pm) and more blue otherwise.

clock

/*
Ellan Suder
15104 1 D
esuder@andrew.cmu.edu
Project-06
*/

var skyColor;
var oceanColor;
var oceanColorLight;
var sandColor;
var logColor;
var notchColor;
var orangeSky;
var purpleSky;
var boatColor;

var prevSec;
var millisRolloverTime;
var hr;

function setup() {
    skyColor = color(140,220,240);
    oceanColor = color(60,140,190);
    oceanColorLight = color(219,222,236,150);
    sandColor = color(220,190,110);
    logColor = color(97,54,35);
    notchColor = color(141,94,43);
    orangeSky = color(248,170,66,40);
    purpleSky = color(129,36,229,40);
    boatColor = color(200,50,50);
    createCanvas(480, 480);
    noStroke();

//gets accurate starting time
    hr = hour() + minute()/60 + second()/60/60;
}

function draw() {
    background(skyColor);  
  
//fetch current time
    var H = hour();
    var M = minute();
    var S = second();
    if (prevSec != S) {
        millisRolloverTime = millis();
    }
    prevSec = S;
    var mils = floor(millis() - millisRolloverTime);
//smooth out seconds and minutes
    var secondsWithFraction = S + (mils / 1000.0);
    var minutesWithFraction  = M + (mils / 60000.0);
    var cloudPositionSec = map(secondsWithFraction,  0, 60, -150, width + 50);
    var cloudPositionMin = map(minutesWithFraction,  0, 60, -75, width + 25);
  
  
//ocean - full cycle every minute
    var seconds = hr + (millis() * 0.001) /60;
    var yMin = sin(seconds * TWO_PI) * height/4; //highest value is 2*height/3 + height/4, lowest is 2*height/3 - height/4. one full cycle is a minute
    var yMin2 = sin(seconds * TWO_PI) * height/20;
    fill(oceanColor);
    rect(0,2*height/3+yMin,
         width,height/4-yMin); //2*height/3 is middle value/start of sin wave. goes up and then down
  
  
//sand + log + light water
    fill(logColor);
    rect(height/4,height/2-30,55,height/2-30,5,5);
    fill(notchColor);
    triangle(height/4+55,2*height/3-5, //top
             height/4+35,2*height/3,
             height/4+55,2*height/3+10);
  
    fill(oceanColorLight);
    rect(0,2*height/3+yMin,
         width,height/20+yMin2);//sits on top of blue water/yMin
  
    fill(sandColor);
    ellipse(width/2,height-30,width+500,70);
    ellipse(height/4+55/2,height-53,120,30);
  
  
//cloud that moves across screen in an hour
    fill(225,235,240);
    drawCloud(cloudPositionMin,height/3,50);
//cloud that moves across screen in a minute
    fill(250,250,250);
    drawCloud(cloudPositionSec,height/5);
  
    boatY=2*height/3+yMin+20;
  
    drawBoat(width/2,boatY);

  
//night and day overlay color
    if(H >= 6 & H < 18) {
      fill(orangeSky);
    } else {
      fill(purpleSky);
    }
      rect(0,0,width,height);
}

function drawCloud(x,y,size = 100) {
    push();
    noStroke();
    //fill(230);
    ellipse(x, y, size, size);
    ellipse(x + size*.5, y + size*.05, size, size);
    ellipse(x + size, y, size, size*.8);
    ellipse(x + size*.3, y - size*.2, size*.8, size*.8);
    ellipse(x + size*.7, y - size*.35, size*.8, size*.8);
    pop();
}

function drawBoat(x=width/2,y=height/2) {
  fill("black");
  rect(x+30,y-220,
       12,220);
  fill("white");
  triangle(x+42,y-220,
           x+150,y-103,
           x+42,y-90);
  fill(boatColor);
  beginShape();
  vertex(x-20, y-80);
  vertex(x+220, y-80);
  vertex(x+170, y);
  vertex(x, y);
  endShape(CLOSE);
}

Sarah Choi – Project – 06 – Abstract Clock

My representation of the clock showed three different parts of the clock. I wanted to portray hours, minutes, and seconds in three different manners. By doing this, I was able to code the outside of the circle with an arc, showing the hour. I made an inner loop with the minutes by using stroke lines. And finally, the seconds were done with the squares in the perimeter.

project-06

//Sarah Choi 
//Section D
//sychoi@andrew.cmu.edu
//Project-06

var x = 0;
var y = 0;
var dX = 1;
var dY = 1;

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

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

    background(0);

    //seconds
    //top half right side
    stroke(0);
    strokeWeight(1);
    for (i = 0; i < 8; i++) {
        x1 = 281 - (37.5 / 2) + i * 37.5;
        y1 = 0;
        rects.push([x1, y1, s > i]);
    }

    for (i = 8; i < 25; i++) {
        x1 = 600 - 37.5;
        y1 = (i - 8) * 37.5;
        rects.push([x1, y1, s > i]);
    }

    for (i = 25; i < 39; i++) {
        x1 = 600 - (37.5 * (i - 23));
        y1 = 600 - 37.5;
        rects.push([x1, y1, s > i]);
    }

    for (i = 39; i < 55; i++) {
        x1 = 0;
        y1 = 600 - (37.5 * (i - 38));
        rects.push([x1, y1, s > i]);
    }

    for (i = 55; i < 61; i++) {
        x1 = (i - 54) * 37.5;
        y1 = 0;
        rects.push([x1, y1, s > i]);
    }

    for (i = 0; i < 61; i++) {
        if (rects[i][2]) {
            x1 = rects[i][0];
            y1 = rects[i][1];
            fill(255);
            rect(x1, y1, 37.5, 37.5);
        } 
        else {
            x1 = rects[i][0];
            y1 = rects[i][1];
            fill(255, 153, 0);
            rect(x1, y1, 37.5, 37.5);
        }
    }

    //minute
    for (a = 0; a < m; a++) {
        fill(255);
        circle(300, 300, 300 - (5 * a), 300 - (5 * a));
    }

    //hour
    noFill();
    strokeWeight(20);
    stroke(0, 0, 255);
    arc(300, 300, 360, 360, -HALF_PI, TWO_PI * (h / 12) - HALF_PI);

    //time
    noStroke();
    fill(0);
    textSize(30);
    text(nf(h % 12, 2, 0) + ":" + nf(m, 2, 0) + ":" + nf(s, 2, 0), 240, 285, 300, 300);
}

Cathy Dong-06-Abstract-Clock

sketch

/* Cathy Dong
   Section D
   yinhuid@andrew.cmu.edu
   Project: abstract clock
*/

//color scheme
var wall = '#D6C9C9';
var light = '#DDE1E4';
var dark = '#8C9A9B';
var sunset = '#D2AB99';
var coffee = '#60463E';
var table = '#2F2F2F';
var curtainC = '#CEB5A7';

//time variable
var s; //seconds
var m; //minutes
var h; //hours


//coffee cup
var cupGap = 10;
var cupWidth = 28;
var cupHeight = 60;
var coffeeHeight = 0;
var coffeeX = 10;


//curtain
var curtainHeight = 0;

//deco
var deco1X = 100;
var deco1Y = 100;
var deco1Size = 0;
var deco2X = 150;
var deco2Y = 80;
var deco2Size = 0;
var deco3X = 160;
var deco3Y = 160;
var deco3Size = 0;


function setup() {
    createCanvas(470, 480);
    background(0);


}

function draw() {
    //set time variables
    s = second();
    m = minute();
    h = hour();
    coffeeHeight = s;

    //wall & table setting
    noStroke();
    fill(wall);
    rect(0, 0, width, height);
    fill(table);
    rect(0, height - height / 5, width, height / 5);

    //call functions
    coffeeLevel();
    
    cup();
    skyColor();
    curtain();
    deco();
}

//cup outline don't change
function cup() {
    for (var i = 0; i < 12; i++) {
    stroke(0);
    strokeWeight(2);
    noFill();
    var cupX = cupGap * (i + 1) + cupWidth * i;
    var cupY = height - height / 5 - cupHeight;
    rect(cupX, cupY - 10, cupWidth, cupHeight + 10);
    }
}

// coffee level changes every second
function coffeeLevel() {
    noStroke();
    fill(coffee);
    //coffee level increase per second
    for (var j = 0; j < 12; j++) {
        var coffeeY = height - height / 5 - coffeeHeight;
        var coffeeX = cupGap * (j + 1) + cupWidth * j; 
        rect(coffeeX, coffeeY, cupWidth, coffeeHeight);   
    }
}

// sky changes color based on hours
function skyColor() {
    stroke(255);
    strokeWeight(5);
    if ((h > 6) & (h < 15)) {
        fill(light); //morning
    }
    else if ((h > 14) & (h <17)) {
        fill(sunset); //dawn
    }
    else {
        fill(dark); //night
    }
    rect(width / 5 * 3, height / 4, width / 4, height / 3);
}

//curtain height changes based on hours
function curtain() {
    stroke(0);
    strokeWeight(1);
    fill(curtainC);
    var curtainX = width / 5 * 3;
    var curtainY = height / 4;
    var curtainWidth = width / 4;
    var curtainHeight = h * 5;
    rect(curtainX, curtainY, curtainWidth, curtainHeight);
}

//decoration size changes based on minutes
//color changed based on hours (matching sky color)
function deco() {
    stroke(255);
    strokeWeight(3);
    //morning
    if ((h > 6) & (h < 15)) {
        fill(light);
    }
    //dawn
    else if ((h > 14) & (h <17)) {
        fill(sunset);
    }
    //night
    else {
        fill(dark);
    }   
    deco1Size = m * 2;
    deco2Size = m;
    deco3Size = m * 3 / 2;
    circle(deco1X, deco1Y, deco1Size);
    circle(deco2X, deco2Y, deco2Size);
    circle(deco3X, deco3Y, deco3Size);
}

initial sketch

The abstract clock is an animation changes based on time in the day. There will not be any repetitions anytime in the same day. The coffee levels in the cups change based on seconds. The hour decides color of the sky and decoration elements and height of the curtain, whereas decoration dimensions change based on the minute.

There are three color modes: day time as light blue, evening as dark blue, and sunset as pale orange. 7 AM to 2 PM are considered as day time, 3 PM to 4 PM are sunset, and 5 PM to 6 AM are evening. 

Kristine Kim- Project 06- Abstract-Clock


sketch

//Kristine Kim
//Section D
//younsook@andrew.cmu.edu
//Project -06- Abstract Clock


var prevSec;

//cloud
var dx = 0;
var x = 30
var y = 110;
var db = 120


function setup() {
    createCanvas(480, 380);
    secondRolloverTime = 0;
    noStroke();
}

function draw() {
    background('lightblue'); // sky
    


//grass
    var grassTop = 330;
    var grassBottom = 380;
    var grassTilt = 30;


    for(var g = 0 - 30; g < 530; g = g + 10){
        stroke(3, 168, 50);
        strokeWeight(3);
        line(g + grassTilt, grassTop, g, grassBottom);
        line(g - grassTilt, grassTop + 10, g, grassBottom);
  }
    
   

//clock part

    var H = hour();
    var M = minute();
    var S = second();
    
    // Reckon the current millisecond, 
    // particularly if the second has rolled over.
    // Note that this is more correct than using millis()%1000;

    if (prevSec != S) {
        secondRolloverTime = millis();
    }
    prevSec = S;

    var mils = floor(millis() - secondRolloverTime);

   
    var hourballoonheight   = map(H, 0, 23, 0, height);
    var minuteballoonheight = map(M, 0, 59, 0, height);
    var secondballoonheight = map(S, 0, 59, 0, height);

    
    // // Make a bar which *smoothly* interpolates across 1 minute.
    // // We calculate a version that goes from 0...60, 
    // // but with a fractional remainder:

    var secondsWithFraction   = S + (mils / 1000.0);
    var secondballoonheightSmooth  = map(secondsWithFraction, 0, 60, 0, height);


    
   
    //hour balloon (green)
    stroke(255);
    strokeWeight(5);
    line(80,330 - hourballoonheight, 80, 500 - hourballoonheight)

    noStroke();
    fill(138, 199, 107);
    triangle(80, 330 - hourballoonheight, 50 ,  390 - hourballoonheight , 110,  390 - hourballoonheight);
    
    fill(168, 247, 129);
    stroke(138, 199, 107);
    strokeWeight(5);
    ellipse(80, 300 - hourballoonheight, db, db + 30);


    //minute balloon (pink)
    strokeWeight(5);
    stroke(255);
    line(240,330 - minuteballoonheight, 240, 500 - minuteballoonheight)

    noStroke();
    fill(214, 152, 227);
    triangle(240, 330 - minuteballoonheight, 210 ,  390 - minuteballoonheight , 270,  390 - minuteballoonheight);
    
    fill(247, 209, 255);
    stroke(214, 152, 227);
    strokeWeight(5);
    ellipse(240, 300 - minuteballoonheight, db, db + 30);

    //seconds balloon(yellow)
    stroke(255);
    line(400,330 - secondballoonheightSmooth, 400, 500 - secondballoonheightSmooth)

    noStroke();
    fill(196, 209, 96);
    triangle(400, 330 - secondballoonheightSmooth, 370 ,  390 - secondballoonheightSmooth , 430,  390 - secondballoonheightSmooth);
    
    stroke(196, 209, 96);
    strokeWeight(5);
    fill(246, 255, 176);
    ellipse(400, 300 - secondballoonheightSmooth, db,db + 30);


    translate(dx,0);
    dx ++;

    for(var c = 0; c < 3; c++){
        fill(245);
        noStroke()
        ellipse(c * x *-1, y, 50, 50);
        ellipse(c * x + 160 * -1, y - 80, 50, 50);
        ellipse(c *x + 300 * -1, y + 35, 50, 50);
        //if (dx -50 > width){
            //dx = -100;
        if ( dx - 350 > width){
        dx = -50
        }
    } 
      


    }



When I was brainstorming for this project, I saw a balloon fly outside my window and that sparked an idea in my head; to represent time with balloons flying. I didn’t want just the balloons to be the only things in the canvas so I put them in a setting. I created grass and clouds to make my abstract clock more interesting. I struggled with having the balloons and the triangles move according to the hour/minute/second variables the most. I am very glad I added those elements because it resulted in an animation for my abstract clock . 

Kristine Kim – Looking Outward-06

Path, Casey Reas, 2001

Casey Reas is a generative artist and owns a website that is filled with variety of different types of generative art but the ones that I was most drawn into was Path and Tissues. They are both executed and created in a similar technique and are built around the ideas of neuroanatomist Valentino Braitenberg. They are a series of prints and images that documents the movement of synthetic neural systems. Each line in the image reveals the history of one system’s movement as it navigates its environment. I love these projects because of the textures its creating randomly and also the rapid movement it captures. I think the idea behind the works are executed very well. I personally admire Path a little bit more than Tissues because of its’ color palette. The combination of both cool and warm color makes the piece more livid and interesting. There is no end to observing these prints because there are so many details and “paths” that leads the audience into, but I love that about Path and Tissues. Rea’s website contains many more generative arts and prints that are very admirably and interesting. 

http://reas.com/path_p/

Tissues, Casey Reas, 2002

Raymond Pai-Project 06 – Abstract Clock

sketch

///RAYMOND PAI
///SECTION D
///RPAI@ANDREW.CMU.EDU
///PROJECT 06

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

}

function draw() {
    strokeWeight(0);
    background(255);

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

    //diameter variables
    var sd = 200;
    var md = 400;
    var hd = 550;

    //angles of arcs
    c = 2 * PI;
    var sa = s * c;
    var ma = m * c;
    var ha = h * c;

    //seconds
    angleMode(DEGREES);
    noFill();
    stroke(255, 0, 0);
    strokeWeight(50);
    arc(width/2, height/2, sd, sd, 0, sa);

    //minutes
    angleMode(DEGREES);
    noFill();
    stroke(0, 255, 0);
    strokeWeight(50);
    arc(width/2, height/2, md, md, 0, ma);

    //hours
    angleMode(DEGREES);
    noFill();
    stroke(0, 0, 255);
    strokeWeight(49);
    arc(width/2, height/2, hd, hd, 0, ha);
}

Inspired by Apple Watch rings:

Image result for apple watch rings

Each ring represents a different aspect of time. Red is seconds, Green is minutes, and blue is hours.

Lauren Park-Looking Outwards-06

Nicolas Ménard directed a television commercial for a brand called “Habito”, produced at Nexus Studios. This commercial contains multiples images of different randomized algorithms. This series is a “metaphorical visualization of the brand’s powerful mortgage matching algorithm”. I really admire the audio and the narrative that harmonizes with the series of algorithms. These visuals becomes more like scenes that informs the audience about Habito and what the brand does.

Using variable.io for coding, the artist created instructions that were then translated into versatile Web apps by Marcin Ignac and Nick Nikolov, in order to change and play around with the visuals and speed of algorithms. Additionally, sound was also incorporated in the same way.

By collaborating with David Kamp, the sound designer, and many others to finalize this commercial at the end, I think Nicolas Ménard was very successful in creating those layers of algorithms that build up a storyline for viewers to understand about easy mortgage. Although the algorithms started off randomized in the process, they look to be very orderly and organized in the commercial overall. And with all these random, colored algorithms, along with the narrative, it shows how complex and confusing figuring out mortgage can be in the beginning of the commercial. This is very crucial for Nicolas Ménard’s goal of getting the message across that unlike these generated algorithms, the people at Habito can help simplify the mortgage process. 

Nicolas Ménard (Nexus Studios), “Habito” commercial, 201

Stefanie Suk – Project 06 – Abstract -Clock

sketch

//Stefanie Suk
//15-104 D
//ssuk@andrew.cmu.edu
//Project - 06 - Abstract Clock

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

function draw() {
    background(5, 0, 50); //background color

    fill(50); //color of buildings
    noStroke();
    rect(10, 350, 120, 150);
    rect(30, 280, 30, 150);
    rect(80, 260, 60, 220);
    rect(80, 240, 20, 20);
    rect(360, 380, 110, 130);
    rect(385, 300, 60, 220);
    rect(405, 220, 20, 220); // buildings in background

    fill(238, 232, 37);
    ellipse(400, 60, 70, 70); //moon

    fill(218, 214, 85);
    ellipse(300, 50, 5, 5);
    ellipse(270, 74, 5, 5);
    ellipse(130, 50, 5, 5);
    ellipse(20, 80, 5, 5);
    ellipse(360, 100, 5, 5);
    ellipse(70, 160, 5, 5);
    ellipse(230, 140, 5, 5);
    ellipse(443, 170, 5, 5); //stars 


    var H = hour();
    var M = minute();
    var S = second();

    var buildingH = map(H, 23, 0, 280, 0);
    var buildingM = map(M, 59, 0, 280, 0);
    var buildingS = map(S, 59, 0, 280, 0);
    var change = 150/3;

    fill(230);
    rect(155, 200, change, buildingH);
    fill(230);
    rect(175+change, 200, change, buildingM);
    fill(250);
    rect(195+2*change, 200, change, buildingS); //ticking building that represents time, referenced code given in the instructions 

}

I thought a lot about how I can represent time without making the clock too literal. I personally think the hardest part about this project was to think of how I can represent my clock than actually creating it. As I was thinking about what to create late at night, I looked outside the window and saw buildings across from my dorm. This struck me hard as I realized how much time I spend working at night. Every time I work at night, I tend to look outside the window once in awhile because I get tired as time passes by. I feel like I’m more aware of ‘time’ during the night than the day, which is why I decided to create a visual of a night cityscape I see outside the window and use the tall buildings as an indicator of time (building is forming as time goes).

Stefanie Suk – Looking Outwards – 06

Marbled Panel by Natalie Stopka

Natalie Stopka is an artist who focuses on the creative process from the materials and forces of the natural world. One of the art techniques she likes to use in her work is marbling, which is a method of creating “random” pattern designs using color and water. This method is the result of floating color onto the surface of the water, then transferring the pattern to an absorbent surface, like paper or fabric. Marbling is a perfect definition of randomness because the artist never has full control over the design. Although the artist may be able to create designs using a sharp utensil to form patterns on the color, every single drop of color the artist puts on the water spreads differently throughout the surface. The direction, size, and color changes every time the color is dropped onto the surface of the water, and I think this marbling method effectively uses randomness to create unique patterns. Natalie Stopka’s marbling artwork shows a perfect example of the use of random movements from the natural force of color.

Video of Marbling Method

Sammie Kim – Looking Outwards 06

35 years ago, Ken Perlin won an academic award for discovering a technique now called “Perlin Noise.” It is defined as a type of gradient noise that interpolates random values to create smooth transitions through the noise function. While it is readily controllable, Perlin Noise can also be embedded flexibly into other mathematical expressions to create a wide range of textures that imitate the controlled random appearance of textures in nature. 

Thus, this technique is a powerful algorithm that is used in methodical content generation, particularly popular in visual media from games to movies for adding realistic randomness to CG renderings of smoke, fire, and water. Likewise, the bottom artworks “Perlin Noise Patterns” by the artist Martin Tinram really inspired me, especially with how delicate and sophisticated the texture are rendered. It was astonishing how they were computer generated, as they looked so detailed and realistic, almost like photographs. The effects are mostly present in the 2nd and 3rd dimension, although it could be extended into the 4th dimension as well. With this, I learned how significant randomness can be in computation and design, as it could be both readily controlled for specific aesthetic results, yet unprecedented at the same time. 

Perlin Noise Patterns (Martin Tinram)
Perlin Noise Patterns (Martin Tinram)

https://www.behance.net/stingingeyes