Jonathan Perez Project 2

sketch

var faceWidth = 250
var faceHeight = 300
var cheekWidth = 13*faceWidth/12
var smile = 10
var smileWidth = 7*faceWidth/12
var smileHeight = 2*faceHeight/32
var blushWidth = 20
var blushHeight = 20
var blushDepth = 0
var dimple = 1
var eyeLX = 240 - faceWidth/4
var eyeRX = 240 + faceWidth/4
var eyeLY = 320 //height/2
var eyeRY = 320
var sunglasses = 0
var glassR = 0
var glassG = 0
var glassB = 0
var hairWidth = 100
var hairHeight = 400

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

function draw() {
    background(164, 230, 239);

    //hair
    fill(0);
    ellipse(width/2, height/2 - hairHeight/4, hairWidth, hairHeight);

    //head
    noStroke();
    fill(255, 220, 200);
    ellipse(width/2, height/2 + faceHeight/4, cheekWidth, faceHeight/2);//cheeks
    ellipse(width/2, height/2, faceWidth, faceHeight); //face

    //mouth
    var mouthHeight = height/2 + faceHeight/4
    noFill()
    stroke(0);
    strokeWeight(2);
    if(smile > 20) {
        arc(width/2, height/2 + faceHeight/4, smileWidth, smileHeight, 0, PI); //smile
    }
    else if(smile < 10) {
        arc(width/2, height/2 + faceHeight/4, smileWidth, smileHeight, PI, 0); //frown
    }
    else {
        line(width/2 - smileWidth/2, mouthHeight, width/2 + smileWidth/2, height/2 + faceHeight/4); //straight mouth
    }

     //dimples
    noFill()
    stroke(0);
    strokeWeight(2);
    if(dimple > .5) {
        arc(width/2 - (smileWidth/2 + 12.5), mouthHeight, 25, 30, 3*PI/2, PI/2); //left dimple
        arc(width/2 + (smileWidth/2 + 12.5), mouthHeight, 25, 30, PI/2, 3*PI/2); //right dimple
    }

    //blush
    noStroke();
    fill(254 + blushDepth, 118 + blushDepth, 145 + blushDepth);
    ellipse(width/2 - 7*faceWidth/16, height/2 + 5*faceHeight/32, blushWidth, blushHeight) //left blush
    ellipse(width/2 + 7*faceWidth/16, height/2 + 5*faceHeight/32, blushWidth, blushHeight) //right blush

    //eyes
    if(sunglasses > .5) {
    stroke(0);
    strokeWeight(2);
    fill(glassR, glassG, glassB);
    ellipse(width/2 - 50, height/2, 70, 70); //left frame
    ellipse(width/2 + 50, height/2, 70, 70); //right frame
    noFill();
    arc(width/2, height/2, 30, 30, PI, 0); //nose bridge frame
    line(width/2 - 85, height/2 - 5, width/2 - faceWidth/2, height/2 - 20); //left ear frame
    line(width/2 + 85, height/2 - 5, width/2 + faceWidth/2, height/2 - 20); //right ear frame
    }
    else {
    noStroke();
    fill(0);
    ellipse(eyeLX, eyeLY, 20, 20); //left eye
    ellipse(eyeRX, eyeRY, 20, 20); //right eye
    }
}


function mouseClicked() {
        faceWidth = random(200, 300);
        faceHeight = random(260, 300);
        cheekWidth = random(2*faceWidth/3, 13*faceWidth/12);
        smile = random(30);
        smileWidth = random(faceWidth/4, 7*faceWidth/12);
        smileHeight = random(faceHeight/16, faceHeight/4);
        blushDepth = random(-40, 50);
        blushWidth = random(20, 40);
        blushHeight = random(20, 40);
        dimple = random(1)
        eyeLX = random(240 - 3*faceWidth/8, 240 - faceWidth/8); //width not declared yet, so used numerical value 240 instead
        eyeRX = random(240 + faceWidth/8, 240 + 3*faceWidth/8);
        eyeLY = random(320 - 2.5, 320 + 2.5); //height not declared yet, so used numerical value 320 instead
        eyeRY = random(320 - 2.5, 320 + 2.5);
        sunglasses = random(1)
        glassR = random(255);
        glassG = random(255);
        glassB = random(255);
        hairWidth = random(100, 400);
        hairHeight = random(200, 400);


}

This project made me skeptical at first… When I first heard that we would be using variables to “randomly” generate faces, I thought that the faces would be just that. Random. Impersonal. Throughout the process — and certainly at the end — I found this not to be true though. Even though when I click the mouse, yes, a bunch of variables are randomly assigned values, I found that every generated face still represented me as the artist and programmer. The style of the artist is evident, and that is something that I did not expect. Each of these faces reflect a bit of my comedic and goofy nature (especially with the colored, circular sunglasses).

 

LookingOutwards-02-sjahania

Roman Verostko created an arm that holds a pen and uses algorithms to draw beautiful images. In one project, appropriately named the “Three Story Drawing Machine,” he projected the eight-hour drawing process on a three-story building.

What amazes me the most about this project is Verostko’s ability to see drawings in algorithms. In order to tell the arm what to draw, he had to think like a computer in addition to thinking like an artist. It looks like in order to make certain parts of the image darker, he has the arm draw over areas more than once.

Another aspect of this project that I admire is the way the artist integrated sound into the presentation. Each direction and speed combination projected a sound for the audience, which must have had an interesting effect. I was unable to find a video of the sounds, so I wonder if they were actually appealing or not.

According to Verostko, the project “marries mind and machine with cyberforms celebrating algorithmic form.”

website link: http://www.verostko.com/shows/n-spark/n-spark.html

keuchuka-lookingoutwards2

064c from dextroorg on Vimeo.

Dextro, an anonymous artist, makes generative video art, and has been working on it since the mid-90s. His work looks like waves in one shot and like glitchy fields in another. I find it interesting because he had begun as a 3D artist working in the architecture field. His work, therefore, were influenced by creating physical landscapes in virtual spaces. Dextro exclusively uses Processing, finding relationships between different parts of his work. As he worked in an architectural setting, he was influenced by creating vast landscapes through algorithmic procedures – some real, some fantasy-like. He finds that experimenting with code introduces interesting art – when the script is unstable, the change can be surprising. He switches between oil painting and Processing, and believes that painting simulates physical algorithm. He also codes straight from his oil paintings, trying to represent all the interesting parts of the oil paint using code.

aboyle-Looking Outwards-02

Above: Growth by Aggregation, by Andy Lomas

For this blog post, I have chosen to discuss a series of works by Andy Lomas titled “Aggregation.” His website can be found here: www.andylomas.com, and this series in particular can be found here: http://www.andylomas.com/aggregationImages.html. I believe the images were created in 2005.

First and foremost, I admire the complexity of the end result. He provides a pixel image at ½ the full resolution on his website and it is still stunning. I think that the math behind the project actually enhances the appeal of the final image, lending it a sense of calculated spontaneity. The second reason I admire the series is its resemblance to plants and coral. It draws on nature as an inspiration, forcing the viewer to think about the incredibly complex processes behind the creation of living things. Ultimately, it is not only pleasing to look at, but also interesting to think about.

Above: Aggregation 6, by Andy Lomas

The images in “Aggregation” are gradually created by “simulating the paths of millions of particles randomly flowing in a field of forces”. By building on top of a simple foundation, the algorithms involved were able to create incredibly complex structures. My knowledge is rudimentary, but I’d imagine the algorithms involved are fairly complicated. However, there are aspects of repetition that aesthetically improve the final images and presumably simplify the algorithms somewhat.

I also did a little research into Lomas, and I discovered that he has a passion for morphogenesis, which is the biological process that causes an organism to develop its shape. This clearly impacts his work, specifically the aggregation series. The process of accretion in his work is similar to those found in the natural world, and as a result the final images resemble plants and coral. Lomas is very upfront about this influence; he quotes D’arcy Wentworth Thompson, a pioneer of mathematical biology, as an inspiration. As I mentioned before, I admire his passion and I believe it resulted in harmonious and thought-provoking work. I hope that artists and mathematicians will continue looking to the natural world for inspiration.

 

ssharada-looking-outwards-02

Notional Field is an interactive installation created by Annica Cuppetelli and Cristobal Mendoza. The work is a wall-mounted sculpture containing vertical and parallel elastic like cords that are projected onto a flat surface. The motion of these lines are determined by an algorithm that forced them to respond to any movement in direction that occurs directly in front of them. What I found really interesting about this project is how it looks so three-dimensional – when the cords move around there is shadow movement that makes the work seem all the more believable. Furthermore, when the cords are pushed towards a corner of two walls, they almost bounce off and project onto the adjacent wall that makes the cords look as though they are actually jumping off of the wall.
According to the artists, the piece revolves around the idea of interface, which is interpreted as the point of contact between two different entities, and is displayed in the work in several ways: between the viewer and the piece (a human/computer interface); between the real and the virtual (the physical structure and its relationship with the projected structure); between the foreground and the background (as the projection interferes with the sculpture).

ljkim – Looking Outwards 02

Vergance – short version by Tina Frank

vergence (short version) from Tina Frank on Vimeo.

This project focuses on the threshold of spatial perception. The artist uses geometric shapes and consistent color scheme to be consistent. I think it works effectively in this case because it captures the audience’s attention. The artist also uses a sound track to accompany the piece which also effectively works to create a wholesome experience. I admire the simplicity of the work but being able to capture someone’s attention for something so basic.

I’m assuming that the project uses set variables and the random function. But majority of the video graphics seems intentional and designed. I can also see the artist using a function that I am unaware of that spreads the squares evenly.

Nayeon-Looking Outwards 02

Quayola is a visual artist based in London. He creates digital sculptures and installation arts that consist of unpredictable collisions.

“Iconographies #20” ‘Tiger Hunt’ after Rubens 2014

I love his work that he create algorithm to form various sculpt with combine old and new, real and artificial, time and space using delaunay triangulation algorithm. Delaunay triangulation which he uses to generate his work is new trend for modern arts and quite many modern artist use computer algorithm to investigate new way of using color and shapes. Here is a image of processing digital work out of classic art piece.

“Topologies” Immacolata Concezione 2010

 

I admire his work as he uses classic arts and old beauty into new born beauty. Top of that, he creates immersive audiovisual installation to intensify his work in exhibitions. He is not only digital media artist, but installation artist using audio and visual to create whole space surrounding the art. The matter of size in a space that he gives to audience have them shock and amaze. He said this is not just media, but the project bridge a communication between people and space.

“Captives” Sculpture Triptych 2013

 

Quayola web site

heeseoc-Project-02-Variable-Face

heeseoc-variation

//Steph Chun
//15-104 section #A
//heeseoc@andrew.cmu.edu
//Project-02

var faceW = 200;
var faceH = faceW - 20;

var eyeW = 60;
var eyeH = 40;
var eyeY = 315;

var pupilW = 15;

var noseW = 50;
var noseH = noseW - 10;
var noseY = 355;

var colorR = 165;
var colorG = 180;
var colorB = 180;

var colorR1 = 255;
var colorG1 = 241;
var colorB1 = 108;
 
function setup() {
    createCanvas(480, 640);
}
 
function draw() {
    background(250);
    noStroke();

    //ears//
    fill(colorR, colorG, colorB);
    triangle(width/2 - faceW/2, height/2, 330 - faceW, 220, width/2 - 20, height/2 - faceH/2 + 10);
    triangle(width/2 + faceW/2, height/2, 150 + faceW, 220, width/2 + 20, height/2 - faceH/2 + 10);

    fill(colorR+40, colorG+40, colorB+40);
    triangle(width/2 - faceW/2 + 20, height/2 + 20, 340 - faceW, 240, width/2 + 10, height/2 - faceH/2 + 30);
    triangle(width/2 + faceW/2 - 20, height/2 - 10, 140 + faceW, 240, width/2 - 10, height/2 - faceH/2 + 30);
    
    //face//
    fill(colorR, colorG, colorB);
    ellipse(width / 2, height / 2, faceW, faceH);

    //eyes//
    fill(colorR1,colorG1,colorB1);
    var eyeLX = width / 2 - faceW * 0.25;
	var eyeRX = width / 2 + faceW * 0.25;
    ellipse(eyeLX, eyeY, eyeW, eyeH);
    ellipse(eyeRX, eyeY, eyeW, eyeH);

    //pupils//
    fill(50);
    ellipse(eyeLX, eyeY, pupilW, eyeH-10);
    ellipse(eyeRX, eyeY, pupilW, eyeH-10);

    //nose //
    fill(colorR+40, colorG+40, colorB+40);
    var noseLX = width / 2 - faceW * 0.09;
    var noseRX = width / 2 + faceW * 0.09;
    ellipse(noseRX, noseY, noseW, noseH);
    ellipse(noseLX, noseY, noseW, noseH);

    fill(0);
    triangle(noseRX, noseY - noseH/2, noseLX, noseY - noseH/2, width/2, noseY-10);

}
 
function mousePressed() {
    faceW = random(150, 200);
    faceH = random(130, 180);

    eyeW = random(40, 70);
    eyeH = random(30, 50);
    eyeY = random (310, 325);

    pupilW = random (5,25);

    noswW = random (40,60);
    noseH = random (30,50);
    noseY = random (350,360);

    colorR = random (165, 240);
    colorG = random (165, 240);
    colorB = random (165, 240);

    colorR1 = random (192, 245);
    colorG1 = random (241, 243);
    colorB1 = random (192, 245);

}

I tried to show how the cats’ pupil dilate depending on the brightness of the light their eyes are capturing. I took a close look at how cats’ eyes are in real life, and noticed how their pupils are vertical. So I kept the height of my cat’s pupil proportional to the height of the eyes, leaving the width change randomly. I also wanted to give changes to the background colors depending on the size of the pupil, but even after many tries, wasn’t able to figure out if the numbers for pixel units that are used for the width of the pupils are also applicable for the color coding for the background.

jamieh-LookingOutwards-02

Subdivided Columns (2010) at the Gwangju Design Biennale

Michael Hansmeyer uses algorithm to generate architecture that is almost impossible to imagine, draft and model by hand. He is inspired by nature and its concept of cell division, which he ties together with architecture. In his TED talk, he talked about how we can fold paper multiple times until we are limited by ourselves and/or the folded material thickness. However, by using the computer to help generate these actions, such actions are possible. His example showed a cube being folded in multiple directions and ways to become a completely different form. He uses code to control the folding, such as ratios, so that he is designing the process instead of the form. This process can then generate an infinite amount of possibilities to the final form. Although the form becomes complex, it can be realized through 3D printing to become a part of architecture. His work Subdivided Columns (2010) was designed with such algorithm to take an abstracted doric column and let it evolve digitally into an elaborate, ornamental column.

What I admire about Hansmeyer is his openmindedness to the many possible end results to an architectural form. I would love to see what other types of rules he can apply to his code (other than folding) that can generate another set of possibilities.

hannajan-LookingOutwards-02

                           Video above depicts demonstration of The Classyfier

I reviewed some of the recommended blogs and websites on generative art and stumbled upon one called The Classifier (2017) by Benedict Hubener, Stephanie Lee, and Kelvyn Marte. It is a table with AI that detects the situation and the sounds of beverages being consumed to choose music that fits the situation accordingly.

The algorithm that generates this art, takes into account the different sound patterns that are characteristic for each drink from pre—trained examples. The creator’s artistic sensibilities are manifest in the algorithm through how well each situation or drink type is detected and the type of music that then ensues to fill the ambiance.

                                               Pictured above: The Classifier

I chose to review this particular art piece because I think it is one that was created for a useful purpose. It can be used to elevate relaxing, improve socializations, and ease events that take place in everyday citizens’ lives. It reminded me that the skills I learned in this class can be used in a similarly useful way. Also, for future projects, I can think more about the usability of my designs and codes for the user and their experiences.