Catherine Coyle – Looking Outwards 02

In this week’s Looking Outwards I wanted to talk about the pix2pix project. I had considered writing about this one for last week but I think it fits well with the generative art theme.

Essentially, pix2pix is a program that takes a simple line drawing, interprets what it is meant to look like, and turns it into a computer generated ‘oil painting.’ The entire program works because of artificial intelligence and procedural machine learning of scanning thousands of pictures in order to know how to interpret our drawings.

Here is an amazing example of what the program is capable of. (Click the photo for the source.)

It seems that the more lines and detail that are added to your drawing, the better the result will be. The program doesn’t know as much how to handle a lot of blank space which leads to some funny (or horrifying results). This program started at a Dutch broadcasting company called NPO, but the code is open source and it has expanded greatly. I feel as though this computer generated art can be whatever we make of it, and really shows the amazing power of machine learning.

This video demonstrates in more detail how the program works and provides many interesting examples of the generative art.

There is a free demo that anyone can access from their browser! Feel free to try and make your own generative creations here.

Jonathan Liang – Project 02 – Variable Face

sketch

// Simple beginning template for variable face.
var eyeSize = 30;
var eyeHeight = 2.5 * eyeSize;
var eyeWidth = 2 * eyeSize;
var faceWidth = 300;
var faceHeight = 300;
var canvasWidth = 640;
var canvasHeight = 480;
var pupilWidth = 10;
var pupilHeight = 15;
var mouthStroke = 3;
var llWall = canvasWidth / 2 - eyeSize - pupilWidth;
var lrWall = canvasWidth / 2 - eyeSize + pupilWidth;
var rlWall = canvasWidth / 2 + eyeSize - pupilWidth;
var rrWall = canvasWidth / 2 + eyeSize + pupilWidth;
var tlWall = canvasHeight / 2 - eyeSize * 3 - eyeSize;
var blWall = canvasHeight / 2 - eyeSize * 3 + eyeSize;
var trWall = canvasHeight / 2 - eyeSize * 3 - eyeSize;
var brlWall = canvasHeight / 2 - eyeSize * 3 +  eyeSize;
var mouthStart = 320;
var noseSize = eyeSize
var backgroundColor = 1;
var headColor = 1;




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

function draw() {
    switch(backgroundColor){
    	case 1:
    		background('pink');
    		break;
    	case 2:
    		background('lime');
    		break;
    	case 3:
    		background(71, 170, 215);
    		break;
    	case 4:
    		background('magenta');
    		break;
    	case 5:
    		background('cyan');
    		break;
    	case 6:
    		background('orange')
    		break;
    	case 7:
    		background(237,204, 248);
    		break;
    	case 8:
    		background('yellow');
    		break;
    	}

//head
    noStroke();
    switch(headColor){
    	case 1:
    		fill(71, 170, 215);
    		break;
    	case 2:
    		fill('yellow');
    		break;
    	case 3:
    		fill('lime');
    		break;
    	case 4:
    		fill('red');
    		break;
    	case 5:
    		fill('orange');
    		break;

    }
    strokeWeight(3);
    ellipse(canvasWidth / 2, canvasHeight / 2, faceWidth, faceHeight);
    

//white fills on face 
    noStroke();
    fill('white');
    ellipse(canvasWidth / 2, canvasHeight / 2 + eyeSize, faceWidth/1.25, faceHeight/1.25);

//eyes
    ellipse(canvasWidth / 2 - eyeSize, canvasHeight / 2 - eyeSize * 3, 2 * eyeSize, 2.5 * eyeSize);
    ellipse(canvasWidth / 2 + eyeSize, canvasHeight / 2 - eyeSize * 3, 2 * eyeSize, 2.5 * eyeSize);

//pupils
	var xrL = constrain(mouseX, llWall, lrWall);
	var xrR = constrain(mouseX, rlWall, rrWall);
	var yrL = constrain(mouseY, tlWall, blWall);
	var yrR = constrain(mouseY, trWall, brlWall);

    noStroke();
    fill('black');
    ellipse(xrL, yrL, pupilWidth, pupilHeight);
    ellipse(xrR, yrR, pupilWidth, pupilHeight);


//mouth
	noFill();
	stroke('black');
	strokeWeight(mouthStroke);
	line(canvasWidth / 2, canvasHeight / 2 - eyeSize * 1.6 + pupilHeight, canvasWidth / 2, mouthStart);
	arc(canvasWidth / 2, mouthStart - faceWidth / 4, faceWidth * 0.65, faceWidth * 0.5, 0, PI, OPEN);

	
//left whiskers	
	line(canvasWidth / 2 - 1.75 * eyeWidth, canvasHeight / 2 - eyeSize * 1.6, canvasWidth / 2 - noseSize, canvasHeight / 2 - eyeSize * 1.6 + pupilHeight);
	line(canvasWidth / 2 - 1.75 * eyeWidth, canvasHeight / 2 - eyeSize * 1.6 + pupilHeight * 2, canvasWidth / 2 - noseSize, canvasHeight / 2 - eyeSize * 1.6 + pupilHeight * 2);
	line(canvasWidth / 2 - 1.75 * eyeWidth, canvasHeight / 2 - eyeSize * 1.6 + pupilHeight * 4, canvasWidth / 2 - noseSize, canvasHeight / 2 - eyeSize * 1.6 + pupilHeight * 3);
	
//right whiskers
	line(canvasWidth / 2 + noseSize, canvasHeight / 2 - eyeSize * 1.6 + pupilHeight, canvasWidth / 2 + 1.75 * eyeWidth, canvasHeight / 2 - eyeSize * 1.6);
	line(canvasWidth / 2 + 1.75 * eyeWidth, canvasHeight / 2 - eyeSize * 1.6 + pupilHeight * 2, canvasWidth / 2 + noseSize, canvasHeight / 2 - eyeSize * 1.6 + pupilHeight * 2);
	line(canvasWidth / 2 + 1.75 * eyeWidth, canvasHeight / 2 - eyeSize * 1.6 + pupilHeight * 4, canvasWidth / 2 + noseSize, canvasHeight / 2 - eyeSize * 1.6 + pupilHeight * 3);
	
//nose and highlight
    noStroke();
    fill('red');
    ellipse(canvasWidth / 2, canvasHeight / 2 - eyeSize * 1.6, noseSize, noseSize);

    noStroke();
    fill('white');
    ellipse(canvasWidth / 2 - 1, canvasHeight / 2 - eyeSize * 1.63, pupilWidth, pupilWidth);    
    
}

function mousePressed() {
    // when the user clicks, these variables are reassigned
    // to random values within specified ranges. For example,
    // 'faceWidth' gets a random value between 75 and 150.
    faceWidth = random(10, 250);
    faceHeight = random(150, 250);
    eyeSize = random(10, 40);
    noseSize = random(10, 70);
    backgroundColor = int(random(1,8));
    headColor = int(random(1,5));
   

}

As a child, one of my favorite cartoons was Doraemon. I always wondered if there were more to the Doraemon family and if they were in different colors. I also took inspiration from a scene in Guardians of the Galaxy volume 2, I’m not gonna specify which scene.

Kevin Thies – Variable Face

sketch

//Kevin Thies
//Section C
//kthies@andrew.cmu.edu
//Project-02

// Core Variables
var headHeight = 200; // head height and width
var headWidth = 200;
var noseHeight = headHeight * 2.5; // relates proportion of head to  nose
var noseAngle = -4;

var skinR = 221; // color values for skin and background
var skinG = 203;
var skinB = 161;

var backR = 25; // background color offset from skin color values
var backG = 25; // additionally used to offset eye color
var backB = 25; // so the colors all harmonize

var eyeOffset = 50; // setback from head width
var eyeWidth = headWidth/2 - eyeOffset; // eye position
var eyeHeight = eyeWidth * headHeight / headWidth; // use head proportions for eyes
var eyeTop = 3;
var eyeBottom = 3.5;
var pupilRatio = .8; // ratio of eye white to black
var irisRatio = 1.4; // ratio of eye black to color


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

function draw() {

    // Background that
    background(skinR + backR, skinG + backG, skinB + backB);

    // Head Shape
        // Nose, sometimes it looks more like a nose and that's ok
        noStroke();
        fill(skinR, skinG, skinB);
        arc(width/2, height/3, headWidth, noseHeight, noseAngle, 0, CHORD);

        // Hide the top half of nose generated
        fill(skinR + backR, skinG + backG, skinB + backB);
        rect(0,0, width, height/3);

        // Head's main ellipse
        fill(skinR, skinG, skinB);
        ellipse(width/2, height/3, headWidth, headHeight);

    // Nose

    // Eyes
        // Pupil
        fill(0);
        arc(width/2 - headWidth/2 + eyeOffset, height/3, eyeWidth,
            eyeHeight, eyeTop, eyeBottom, PIE);
        // Iris
        fill(skinR - backR, skinG - backG, skinB - backB);
        arc(width/2 - headWidth/2 + eyeOffset, height/3, eyeWidth * pupilRatio * irisRatio,
            eyeHeight * pupilRatio * irisRatio, eyeTop, eyeBottom, PIE);
        // White
        fill(255);
        arc(width/2 - headWidth/2 + eyeOffset, height/3, eyeWidth * pupilRatio,
            eyeHeight * pupilRatio, eyeTop, eyeBottom, PIE);


}

function mousePressed() {

    //Reshuffle the head dimensions
    headWidth = random(120, 200);
    headHeight = random(100, 160);
    noseHeight = headHeight * random(2, 3);
    noseAngle = -random(3.66, 4); //radian angle of  arc

    //Change eye color and Shape
    eyeOffset = random(45, 60);
    eyeTop = random(2.61, 3.14); // 5/6 Pi to Pi
    eyeBottom = random(3.14, 3.66); //Pi to 7/6 pi
    pupilRatio = random(.75, .5);
    irisRatio = random(1.2, 1.3);

    // Constrain face color to less saturated, darker values
    skinR = random(140, 225);
    skinG = random(143, 225);
    skinB = random(140, 184);

    // Reshuffle background color offset
    backR = random(-50, 25);
    backG = random(-50, 25);
    backB = random(-50, 25);
}

There was a lot of math involved in this one. If I could go back in time, I think bezier curves would’ve been a better fit than arcs simply based on the parameters they use. At the same time, since I used arcs, the end product morphed into what it is now instead of more ‘realistic’ shapes.

Project 02 – Variable Face – Sara Frankel

sketch

var eyeSize = 60;
var faceWidth = 300;
var faceHeight = 350;
var value = 'blue';

 
function setup() {
    createCanvas(640, 480);
}
 
function draw() {
    background(141,209,247);
   if (mouseX < width/2)
      background(51);

    //head
    fill(77,47,23);
    arc(width / 2, height / 3 + 0.75 * faceHeight, faceWidth * 1.5 , faceHeight * 2.3, PI, TWO_PI);
    fill('tan');
    ellipse(width / 2,height / 2,faceWidth,faceHeight);
    fill(77,47,23)
    arc(width / 2, height / 3, faceWidth * 0.9 , faceHeight * 0.6, PI, TWO_PI);
    

    //left eye
    fill('white');
    var eyeLX = width / 2 - faceWidth * 0.25;
    ellipse(eyeLX, height / 2, 1.5 * eyeSize, eyeSize);

    //left eyeball (blue iris, black pupil and white glissen)
    fill(value);
    ellipse(eyeLX + 15, height / 2, 0.5 * eyeSize, 0.5 * eyeSize);
    fill(51);
    ellipse(eyeLX + 15, height / 2, 0.25 * eyeSize, 0.25 * eyeSize);
    fill('white');
    ellipse(eyeLX + 10, height / 2, eyeSize / 8, eyeSize / 8);

     //right eye
    fill('white');
    var eyeRX = width / 2 + faceWidth * 0.25;
    ellipse(eyeRX, height / 2, 1.5 * eyeSize, eyeSize);

    //right eyeball (blue iris, black pupil and white glissen)
    fill(value);
    ellipse(eyeRX + 15, height / 2, eyeSize / 2, eyeSize /2);
    fill(51);
    ellipse(eyeRX + 15, height / 2, eyeSize / 4, eyeSize /4);
    fill('white');
    ellipse(eyeRX + 10, height / 2, eyeSize / 8, eyeSize / 8);

    //eyebrows (left then right)
    fill(77,47,23);
    ellipse(eyeLX, height / 2 - 30 , eyeSize * 1.5, eyeSize / 6);
    ellipse(eyeRX, height / 2 - 30, eyeSize * 1.5, eyeSize / 6);

    //mouth
    noFill();
    arc(width / 2, height * 0.66, faceWidth / 4, faceHeight  / 4, 0, PI);

}

function mouseClicked() {
   if(value === 0) {
        value = 'blue';
    } else {
        value = color(random(0,255), random(0,255), random(0,255));
    } 

}
 
function mousePressed() {
    faceWidth = random(200, 350);
    faceHeight = random(325, 350);
    eyeSize = random(35, 50);
}





I really enjoyed this project as I felt that I now have a better understanding of how to use a lot of the code that was established last week and cool new functions introduced this week. I also enjoyed this project in the sense that it was kind of entertaining to play with and trying to understand the ratio of canvas and face features using established values and ratios.

Julie Choi-Project-02-Variable-Face

juliechoi_project_02

// declare character variables
var faceWidth = 130;
var faceHeight = 150;
var eyeSize = 25;
var pupilSize = 10;
var mouthSize = 25;
var tongueSize = 20;
var bodySize = 160;
var legSize = 20;
var blushSize = 20;

// declare other object variable
var discoSize = 85;

// declare color variables
var r = 0;
var g = 0;
var b = 0; 
var skinColor1 = 249; 
var skinColor2 = 205;
var skinColor3 = 161;
var colorA = 0;
var colorB = 0;
var colorC = 0;


function setup() {
    createCanvas(640,480);
 }
function draw() {
	// draw background
    background(r, g, b);

    // draw face + body + legs
    noStroke();
    fill(skinColor1, skinColor2, skinColor3);
    ellipse(width / 2, height / 2, faceWidth, faceHeight);
    fill(249, 205, 161);
    noStroke();
    fill(skinColor1, skinColor2, skinColor3);
    ellipse(width / 2, height / 2 + 100, bodySize, bodySize);
    fill(249, 205, 161);
    noStroke();
    fill(skinColor1, skinColor2, skinColor3);
    ellipse(width / 1.8, height / 1.15, legSize / 1.9, legSize + 30);
    noStroke();
    ellipse(width / 2.2, height / 1.15, legSize / 1.9, legSize + 30);

    // declare eye variables
    var eyeLeft = width / 2 - faceWidth * 0.25;
    var eyeRight = width / 2 + faceWidth * 0.25;
    var pupilLeft = width / 2 - faceWidth * 0.25;
    var pupilRight = width / 2 + faceWidth * 0.25;

    // draw eyes + pupil
    fill(255);
    ellipse(eyeRight, height / 2.25, eyeSize, eyeSize);
    ellipse(eyeLeft, height / 2.25, eyeSize, eyeSize);

    fill(0);
    ellipse(pupilRight, height / 2.2, pupilSize, pupilSize);
    ellipse(pupilLeft, height / 2.2, pupilSize,pupilSize);

    // draw nose with curveVertex
    strokeWeight(1);
    stroke(255);
    noFill(0);
    beginShape();
    curveVertex(width / 1.95, height / 2.3);
    curveVertex(width / 1.95, height / 2.3);
    curveVertex(width / 1.94, height/ 2.1);
    curveVertex(width / 1.9, height/ 2);
    curveVertex(width / 2, height / 2);
    curveVertex(width / 2, height / 2);
    endShape();

    // draw hair strand with curveVertex
    strokeWeight(3);
    stroke('brown');
    noFill(0); //320, 240
    beginShape();
    curveVertex(323, 170);
    curveVertex(323, 170);
    curveVertex(320, 166);
    curveVertex(325, 159);
    curveVertex(323, 153);
    curveVertex(326, 148);
    curveVertex(322, 142);
    curveVertex(324, 135);
    curveVertex(324, 135);
    endShape();

    // draw mouth
    colorA = 243;
    colorB = 159;
    colorC = 76;

    noStroke();
    fill(colorA, colorB, colorB);
    ellipse(width / 2, height / 2 + 20, mouthSize + 5, mouthSize / 2 + 5);

    fill(colorA, colorC, colorC);
    //strokeWeight(5);
	//fillStroke(243, 159, 159);
    ellipse(width / 2, height / 2 + 20, mouthSize + 2, mouthSize / 1.9);

	// draw tongue
    noStroke();
    fill(colorA, colorC, colorC);
    ellipse(width / 2, height / 2 + 25, tongueSize / 1.8, tongueSize + 3);

    // draw blush
    fill('pink');
    strokeWeight(1);
    stroke(255, 255, 255, 50);
    ellipse(width / 2.4, height / 2 + 10, blushSize * 2, blushSize);

    strokeWeight(1);
    stroke(255, 255, 255, 50);
    ellipse(width / 1.7, height / 2 + 10, blushSize * 2, blushSize);

    //draw disco ball shape
    noStroke();
    fill(150);
    rect(315, 0, 15, 25);
    quad(315, 25, 330, 25, 335, 35, 310, 35);
    ellipse(width / 1.99, height / 6.5, discoSize, discoSize);

    fill(0);
    ellipse(307, 52, 15, 15);
    ellipse(327, 72, 15, 15);

    fill(0);
    ellipse(345, 60, 15, 15);
    ellipse(319, 100, 15, 15);

    fill(0);
    ellipse(298, 78, 15, 15);
    ellipse(343, 88, 15, 15);

    fill(243, 36, 202); //pink
    ellipse(305, 50, 15, 15);
    ellipse(325, 70, 15, 15);

    fill(24, 138, 255); //blue
    ellipse(347, 60, 15, 15);
    ellipse(321, 100, 15, 15);

    fill(255, 255, 24); //yellow
    ellipse(300, 80, 15, 15);
    ellipse(345, 90, 15, 15);
}

function mousePressed() {
    faceWidth = random(150, 250);
    faceHeight = random(150, 200);
    eyeSize = random(10, 40);
    pupilSize = random(5, 10);
	mouthSize = random(20, 28);
	tongueSize = random(15, 18);
	bodySize = random(160,200);
	blushSize = random(15,20)
    colorA = random(0, 255);
    colorB = random(0, 255);
    colorC = random(0, 255);
    skinColor1 = random(0, 255);
    skinColor2 = random(0, 255);
    skinColor3 = random(0, 255);
    r = random(0, 255);
    g = random(0, 255);
    b = random(0, 255);
}


For this project, I personally had so much fun using all the new materials from this week. I ended up creating a character in a rave with randomized expression and color. I was able to figure out that when I randomize the color under the draw function, the background changes extremely quickly since the draw function is in a loop. Although applying that part looks more like a rave, I didn’t apply it to my code for this post because it might hurt some people’s eyes. Instead, if you are curious, download this: real_rave  to see how it looks. I hope you enjoy!

Kyle Leve – Project 02 – Variable Face

sketch

//Kyle Leve
//Section A
//kleve@andrew.cmu.edu
//Project-02-Variable Faces

var glassesWidth = 8;
var glassesHeight = 8;
var faceWidth = 350;
var faceHeight = 350;
var eyeSize = 50;
var irisSize = 30;
var pupilSize = 15;
var glimmerSize = 7;
var backgroundColor;
 
function setup() {
    createCanvas(640, 480);
    var red; random(50, 250);
    var green; random(100, 250);
    var blue; random(20, 250);
    backgroundColor = color(red, green, blue);
}
 
 function draw() {
    background(backgroundColor);

    //face
    noStroke();
    fill('tan');
    ellipse(width / 2, height / 2, faceWidth, faceHeight);

    //eyes
    fill('white'); //left eyeball
    var eyeLX = width / 2 - faceWidth * 0.25;
    ellipse(eyeLX + 10, height / 2 + 15, eyeSize, eyeSize);

    fill('white'); //right eyeball
    var eyeRX = width / 2 + faceWidth * 0.25;
    ellipse(eyeRX - 30, height / 2 + 15, eyeSize, eyeSize);

    fill(77,47,23); //left iris
    ellipse(eyeLX + 15, height / 2 + 20, irisSize, irisSize);

    fill(77,47,23); //right iris
    ellipse(eyeRX - 25, height / 2 + 20, irisSize, irisSize);

    fill('black'); //left pupil
    ellipse(eyeLX + 20, height / 2 + 25, pupilSize, pupilSize);

    fill('black'); //right pupil
    ellipse(eyeRX - 20, height / 2 + 25, pupilSize, pupilSize);

    fill('white'); //left eye shimmer
    ellipse(eyeLX + 25, height / 2 + 22, glimmerSize, glimmerSize);

    fill('white'); //right eye shimmer
    ellipse(eyeRX - 15, height / 2 + 22, glimmerSize, glimmerSize);

    //Glasses
    fill('black');
    rect(280, 250, 40, glassesHeight);

    fill('black');
    rect(280, 210, glassesWidth, 80);

    fill('black');
    rect(180, 210, 100, glassesHeight);

    fill('black');
    rect(180, 285, 108, glassesHeight);

    fill('black');
    rect(180, 210, glassesWidth, 75);

    fill('black');
    rect(155, 247, 30, glassesHeight);

    fill('black');
    rect(315, 210, glassesWidth, 80);

    fill('black');
    rect(315, 210, 100, glassesHeight);

    fill('black');
    rect(315, 285, 108, glassesHeight);

    fill('black');
    rect(415, 210, glassesWidth, 75);

    fill('black');
    rect(415, 247, 28, glassesHeight);
}

function mousePressed() {
    faceWidth = random(300, 400);
    faceHeight = random(250, 350);
    glassesWidth = random(5, 15);
    glassesHeight = random(5, 15);
    eyeSize = random(40, 60);
    irisSize = random(25, 35);
    pupilSize = random(10, 20);
    glimmerSize = random(7, 10);
    var red = random(50, 250);
    var green = random(100, 250);
    var blue = random(20, 250);
    backgroundColor = color(red, green, blue);
}

I found this project to be very interesting in that for me it started out with me knowing exactly what I wanted to do, but having no idea how to do it. Through trial-and-error I found out how to change dimensions and colors randomly by using variables to make an interactive project. This project has taught me how to use variables effectively to make my projects more fun and interesting.

Yingying Yan LookingOutwards-02

Bottom view of the project, showing how the new structure “grows” from the tower.

On Eiffel Tower’s 120th anniversary, its operator Société d’Exploitation de la Tour Eiffel held a remodeling competition to create more viewing space on the tower. Serero Architects, who proposed Eiffel DNA has won the competition. They proposed putting a carbon Kevlar structure made out of metal panels to the top of the tower and doubling the amount of viewing space.

Axon drawing showing the break down of the structure.

It is called Eiffel DNA because it uses a generative computer script to copy the pattern from the old structure, and then “grow” new branches from the primary structure of the tower. This redundancy, non-repetition of pattern, and complex woven form are three interconnected structural weaves generated by the computer script. It also has curvatures unfold alone the tower.

Detail showing the organic shape of the structure and the tectonic pattern.

As an architecture student, this project has introduced a new design method to me. I always like new technology and how technology can combine with art to create something unique. Eiffel DNA proved that the computer can be used to create architecture that better people’ life and the society. The new structure, although is not built, fits in the big idea of growing out of the tower and adds a new life to Eiffel. The generative design really gives designers the ability and flexibility to create something crazy. I do not know much about the algorithm, but I suppose they used some software similar to ph python in Grasshopper. No doubt, this is a project requires a lot of computational thinking.

People activating the space.

Looking Outwards 02: Miraj

When prompted with the idea of generative art for this Looking Outwards, I immediately thought of Miraj— an interactive work that generates animated visuals with your voice. It was originally conceived as a response to the new Apple tvOS open to developers in 2016.  Essentially they created an algorithm to fragment the images and collage them, while animating the shapes based on your voice. It was coded using both Swift and C++ and eventually integrating it using CV into the Apple TV.

I liked this project in particular because it went through several prototyping phases and had a large focus on user experience. It also heavily engages the user and creates a unique and lasting memory. Additionally because they were running it on Apple TV’s platform, they took some visual cues from Apple’s exisitng UI( (this was just an interesting fact I learned and appreciated about branding).

Sean McGadden Looking Outward- 02

Generative Art

Looking Outward – 02

Jean-Pierre Hébert

This artist has been making some really interesting computational and generative art for the past 50 years. Jean-Pierre began as one of the pioneers of experimental computer generated art in the 1970’s. Much of his work is very abstracted relying heavily on color and line to create complex tactile canvases that imply depth and texture extremely well.  His work is quite responsible because he does not abandon the notion of physical production. As a result Jean-Pierre does create computationally designed works but he executes these works with specific physical medium installed into special printers. The piece below is made with sepia ink on paper and pen plotter drawing. It is  called “quantic notions” made in 1989:

Jean-Pierre  describes his method for creating such works as a physically limitless, horizon less, infinite space for transcending traditional drawing techniques and space itself. He uses the assets of coding and programming to layer information that goes deeper than the visual. He is able to create pieces of incredible detail and scale without the strain of another traditional physical endeavor. I am very interested by this idea of computation and iteration. Jean-Pierre Hebert is able to create many variations on one piece of work before he is satisfies and this is easily done simply by multiple prints and changes in code. I can also see the connections in his style to modern day print-making. Using a physical input of etches or carves from a block, a print-maker is able to make many passes and address changes in the block. In this way, the computer code is Jean-Pierre’s printing block. His ideas are very modern and it seems he is beyond his time in generative art. Another older piece I quite liked was Vent Noir 2 (1989) below:

His pieces are evocative and memorable. They make the viewer question what it is they are seeing.  Jean-Pierre Hebert has also continued creating fascinating work well into the 2010’s. Another newer piece of his called “In Visible Cities Baucis” (2010) is pigment and metal type on paper, a digital drawing on niyodo paper. Below:

I think ultimately his work is limited by the programs he can use to code with and the data he has available. In his more current work he has resorted to larger more public pieces with much collaboration. His initial work is more creatively valuable becasue he was a trail blazer of generative art. In the new age of technology programmatic capabilities seem to evade him. He remains an influential personality.

September 7, 2018

Project 02- Jasper Rogal

Jasper Face 2

// Face variables
var eyeSize = 30;
var faceWidth = 80;
var faceHeight = 125;
var noseSize = 335;
var earSize = 15;
var mouthSize = 345;

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

function draw() {
    background('blue');
    //hair
    fill('brown');
    ellipse(width / 2, height / 2 -20, faceWidth,  faceHeight);
    //face
    fill(253, 228, 200);
    ellipse(width / 2, height / 2, faceWidth,  faceHeight);
    fill('white'); 
    //eyes
    var eyeLX = width / 2 - faceWidth * 0.25;
    var eyeRX = width / 2 + faceWidth * 0.25;
    ellipse(eyeLX, height / 2, eyeSize, eyeSize);
    ellipse(eyeRX, height / 2, eyeSize, eyeSize);
    //iris
    fill('brown');
    ellipse(eyeLX, height / 2, eyeSize * .25, eyeSize * .25);
    ellipse(eyeRX, height / 2, eyeSize * .25, eyeSize * .25);
    //nose
    fill(253, 228, 200);
    triangle(240,  320, 237, noseSize, 243, noseSize);
    //mouth
    arc(width / 2, mouthSize, 10, 10, 0, PI, OPEN);
    //ears
    ellipse(240 - faceWidth * .5, 285, 10, earSize);
    ellipse(240 + faceWidth * .5, 285, 10, earSize);
}

function mousePressed() {
    faceWidth = random(70, 125);
    faceHeight = random(120, 160);
    eyeSize = random(18, 37);
    noseSize = random(330, 340);
    earSize = random(12, 18);
    mouthSize = random(343, 348)
}

I had trouble with variables at first, but once I understood them more it was fine.