Month: October 2022

Project 06 Abstract Clock

For my abstract clock, I was having a creative block and had trouble approaching what to make. I thought since most of my other projects have been pretty literal, I would make this one more abstract with a focus on shapes and how they can change based on hours, minutes, and seconds. I was thinking about how time is focused around growing, until it restarts and how that concept could be reflected into my clock. I decided to have “bubbles” that represent hours, minutes, and seconds organized in columns. I wanted these bubbles to slowly grow based on each of the timings. I also made it so the bubble slowly goes from transparent to opaque as seconds, minutes, and hours increase. Originally, I was thinking I wanted a shape inside the bubbles that would turn based on the time, but decided on a line to draw a better connection to a clock. I gave each bubble a line in the center that rotates based on the timing.

project6
//Rachel Legg / rlegg / section C

var col;

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

function draw() {
    //background color changes every hour
    background(0);
    frameRate(15);

    //variables for time
    var sec = second();
    var min = minute();
    var hr = hour();

    strokeWeight(2);

    //Have Bubbles expand with each increment
    //line on each bubble to mimic a clock based on hr, min, sec
    //Hr Row
    for(col = 0; col <= 3/4 * height; col += 120){
        //have hr be yellow
        fill(255, 255, 0, 30 + hr);                  //have opacity grow with time
        stroke(255, 255, 0);
        ellipse(width/6, height/8 + col, 2 * hr);
        //have line in center that moves with change in hr
        push();
        translate(width/6, height/8 + col);
        rotate(radians(-90 + (hr * 15)));                     // 360/24 = 15
        line(0, 0, 10, 10);
        pop();
    }


    //Min Row
    for(col = 0; col <= 3/4 * height; col += 120){
        //have min be pink
        fill(255, 0, 255, 30 + min);                 //have opacity grow with time
        stroke(255, 0, 255);
        ellipse(width/2, height/8 + col, 2 * min);
        //have line in center that moves with change in min
        push();
        translate(width/2, height/8 + col);
        rotate(radians(-90 + (min * 6)));                    // 360/60 = 6
        line(0, 0, 10, 10);
        pop();
    }

    //Sec Row
    for(col = 0; col <= 3/4 * height; col += 120){
        //have sec be blue
        fill(0, 255, 255, 30 + sec);                 //have opacity grow with time
        stroke(0, 255, 255);
        ellipse(5/6 * width, height/8 + col, 2 * sec);
        //have line in center that moves with change in sec
        push();
        translate(5/6 * width, height/8 + col);
        rotate(radians(-90 + (sec * 6)));                   // 360/60 = 6
        line(0, 0, 10, 10);
        pop();
    }

}

Looking Outward – 06

“Small Scale – Fidenza #545” by Tyler Hobbs

Tyler Hobbs is a visual artist who develops and works with algorithms and plotters. Hobbs’ style represents the stiff structure of a computer and the messy chaos of nature, striking an interesting balance in his work. He created “Fidenza” which is a generative algorithm that creates random, generative art. He describes the algorithm as “highly flexible”, and it continuously produces interesting results. It was so fun to scroll through all the artwork produced by the same algorithm as they all go very different directions, yet hold similar underlying charcteristics. “Fidenza” is a flow field algorithm that creates random, organic curves. With these curves, Hobbs shares that there is variety in scale, turbulence, stroke style, shape segments, sharp edges, sprials, collision, margins, and color which leads to infite possibilties of “Fidenza”. In color palettes alone, there are 14 possible color palettes that each have different probabilities for the colors being used.

Title: Fidenza
Artist: Tyler Hobbs
Link: https://tylerxhobbs.com/fidenza

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

Looking Outwards 06

Kenneth Martin’s Chance and Order incorporates aspects of randomness through a combination of chance events and artistic decisions. In order to create each pair of lines, Martin draws numbers (two at a time), randomly from a bag starting counter-clockwise. I admire the pure simplicity of the piece, along with the concrete repetition of lines across the canvas. Chance and Order offers a new perspective of the scientific and artistic world through incorporating creative elements and those of mathematical probability.

The points of intersection on the art are also written and randomly chosen from small cards, and a line is made between each successful pair of numbers picked out. The title, “Chance and Order” also symbolizes the greater process behind the work, a product of random events and ordering procedures. I admire Martin’s ability to hand-draw so precisely, and create these nearly computer-generated forms of media in the collections.

Hannah Wyatt

Abstract clock

This is my abstract clock, I try to record my schedule in a day. Like during the day, I typed notes, or during the night, I drank coffee. The hour plays a role in changing the background color, the minute plays a role in changing the scene content, and the second plays a role in the flicking of elements.

Abstract Clock 

//Jason Jiang
//Section E


function setup() {
    createCanvas(400, 400);
    colorMode(HSB)
    }
    


function draw() { 
//Setting scenes for different time 
    if(hour()>=0 & hour()<=6){
        sleep() 
    }
    if(hour()>=6 && hour()<=18){
        note()
    }
    if(hour()>=18 && hour()<=24){
        coffee() 
    }
}

//0:00-6:00
function sleep(){
    var secondcount = map(minute(), 0, 60, 0, 3600)+second()
    var c = map(hour(), 0, 6, 0, 100)
    var h = map(secondcount, 0, 3600, 0, 90)

    //Changing background color per hour
    background(80, 100-c, 100)

    //Drawing battery
    noFill();
    strokeWeight(10)
    rect(width/2-25, height/2-50, 50, 100)
    rect(width/2-7.5, height/2-60, 15, 5)
    
    //Changing color and height of battery per second, the battery becomes full per hour
    strokeWeight(0)
    push()
    translate(width/2, height/2)
    rotate(radians(180))
    fill(255-c, c, 0)
    rect(-20, -45, 40, h)
    pop()
    //Drawing lightning
    lightning()
}

//Flickering lightning per second
function lightning(){
    if (second()%2==0){
        push()
        translate(width/2, height/2)
        strokeWeight(8)
        rotate(radians(-10))
        line(10, -25, -10, 0)
        line(-10, 0, 10, 0)
        line(10, 0, -10, 25)
        pop()
    }   
}

//6:00-18:00
function note(x, y, m){
    var secondcount = map(minute(), 0, 60, 0, 3600)+second()
    var m = floor(map(minute(), 0, 60, 0, 10))
    var x = map(secondcount, 0, 3600, 0, 340)
    var y = 10+m*40
    var c = map(hour(), 6, 18, 0, 100)
    //Changing background color per hour
    background(30, c, 100)
    
    //Changing line length per second, a row takes 6 minutes
    fill(50)
    strokeWeight(0)
    rect(25, y, x, 15) 
    strokeWeight(5)

    //Flickering line per second
    if(second()%2==0){
        line(x+30, y-5, x+30, y+20)  
        } 
    //Adding lines for previous minutes
    for(var i=0; i<m; i++){
        strokeWeight(0);
        rect(25, 10+i*40, 340, 15)    
        }
}

//18:00-24:00
function coffee() {
    var secondcount = map(minute(), 0, 60, 0, 3600)+second()
    var c = map(hour(), 18, 24, 0, 100)
    var h = map(secondcount, 0, 3600, 0, 140)
    
    //Changing background color per hour
    background(200, c, 50)

    //Drawing coffee cup
    fill(20, 50, 40);
    strokeWeight(10)
    rect(width/2-50, height/2-50, 100, 150)
    noFill();
    strokeWeight(15)
    rect(width/2-92.5, height/2-10, 40, 60)
    strokeWeight(0)
    fill(255)

    //Changing height of coffee per min
    rect(width/2-45, height/2-45, 90, h)

    //Adding heat
    heat()
}

//Flickering heat per second
function heat(){
    strokeWeight(6)
    noFill()
    var w = width/2 
    var h = height/2
    if (second()%2==0){
        for(i=0; i<3; i++){
            bezier(w-30, h-70, w-20, h-80, w-40, h-100, w-30, h-110)
            w+=30
        }
    }
}

Randomness in Sound

The Click::RAND by Paul Dunham (2019-2020) is fascinating to watch. Dunham used a series of electric relays and random numbers to generate clicking noises that become sonic beats. He used the RAND’s 1955 book “A Million Random Digits with 100,000 Normal Deviates” as a database of random numbers to feed into the electric relays. The book is a giant table of a million random digits that contain small but statistically significant biases. The largest bias the table had while running tests was about 2%. Dunham fed the digits to a computer that converted every number into binary, which told the relays when to open and close. The result is a very fun and cool syncopation of clicks and metallic rings. Sometimes there are patterns that appear in the clicks, but they quickly dissolve into something else. I admire the simplicity of the installation, as well as the results it produces. The clicking pauses, breaks, quickens, slows, just like the rhythms of everyday life do as well. He will sometimes add more than one panel of relays to create even more poly-rhythms. There are no algorithms in his work, only randomness and relays. His artistic vision of giving the book a voice, and having the audience listen to randomness, is a highly effective one that definitely manifested in the final form.

Dunham’s other work is also very interesting and I highly recommend viewing his Click::TWEET project from 2020. In that project, he transcribed tweets into morse code using multiple telegraph machines to highlight how ‘loud’ social media is these days.

Click::RAND from Atticus Finch on Vimeo.

Looking-Outwards 06

Graham Murtha

Section A

The randomly generated computational art that I looked into this week is called the “Gallery of Randomly Generated Flames” by JWidlfire, an independent artist/blogger. This German artist uses T.I.N.A, a electronics design software by DesignSoft, to generate a series of randomly generated images that all include some depiction of a flame. The flames are generated through a series of random sin/cos waves, arrays, string art, and lighting effects, all with a black background. What I find particularly fascinating about this exhibition is the sequential nature of it, since we know that these 64 different images come from one identical code. The differences in each image are drastic, and yet at the sametime there is a strong visual acuity and pattern througout all 64 pieces. Even some of the flames that look almost biomorphic share commonalities with flames that appear gaseuous. By depicting all different variations in this series, JWildfire demonstrates to us how randomness can provide massive variety, while at the same time preserving certain biases or qualities.

Gallery of randomly generated flames

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