rfarn-project02

For this project, I started with a very complicated idea. I wanted to create three faces that would all have similar randomly changing variables that could flash around the screen like random lights.

However, I soon realized this would just be a lot of work and my code kept getting longer and longer with more and more variables to the point that I started confusing myself. In the end, I decided to just simplify my concept into one face with simple variables that could change.

sketch

var hairWidth = 160;
var hairHeight = 135;
var faceWidth = 130;
var faceHeight = 110;
var mouthHeight = 15;
var mouthWidth = 15;

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

  }


function draw() {
	 background(245, 235, 230);
	
	//blue hair
	strokeWeight(10);
	stroke(172, 216, 242);
	fill(180, 225, 255);
	rectMode(CENTER);
	rect(width/2, height/2, hairWidth, hairHeight, 20);
	noStroke();
	fill(250, 218, 190); //face
	rect(width/2, height/2 + 13, faceWidth, faceHeight, 20);
	fill(180, 225, 255); //bangs
	arc(width/2 + hairWidth/2 - 5, height/2 - 50, hairWidth*(7/5), 100, PI/2, PI, PIE);
	arc(width/2 - hairWidth/2 + 5, height/2 - 50, hairWidth*(2/3), 90, 0, PI/2, PIE);
	strokeWeight(3); //eyes
	stroke(255);
	fill(188, 235, 203);
	ellipse(width/2 - faceWidth/4, height/2 + 15, 20, 20);
	ellipse(width/2 + faceWidth/4, height/2 + 15, 20, 20);
	noStroke(); //mouth
	fill(231, 90, 124);
	ellipse(width/2, height/2 + 35, mouthWidth, mouthHeight);
 
}


function mousePressed(){
	hairWidth = random(160, 250);
	hairHeight = random(135, 225);
	faceWidth = random(130, 220);
	faceHeight = random(110, 100);
	mouthWidth = random(15, 30);
	mouthHeight = random(15, 30);
}

Chickoff-Project-02-Section D

Chickoff Seagull

//Cora Hickoff
//Section D 9:30AM-10:20AM
//chickoff@andrew.cmu.edu
//Project-02

var faceWidth = 350;
var faceHeight = 300;
var eyeSize = 20;
var pupilSize = 9;
var beakSize = 50;
var x = 170;

function setup() {
    createCanvas(640, 480);
}
 
function draw() {
    background(130,180,200);

    //face
    strokeWeight(0);
    fill(235,235,235);
    ellipse(width / 2, height / 2, faceWidth,  faceHeight);

    //body
    strokeWeight(0);
    fill(235,235,235);
    ellipse(340,430,270,250);

    //beak
    strokeWeight(0);
    fill(255,220,25);
    rect(width / 10, height / 2, x, beakSize);

    //feather 1
    strokeWeight(0);
    fill(220,220,220);
    ellipse(370,440,20,100);

    //feather 2
    strokeWeight(0);
    fill(200,200,200);
    ellipse(380,440,20,120);

    //feather 3
    strokeWeight(0);
    fill(180,180,180);
    ellipse(390,440,20,100);

    //feather 4
    strokeWeight(0)
    fill(200,200,200);
    ellipse(400,440,20,90);

    //eyes
    strokeWeight(2);
    fill(250,250,210);
    var eyeLX = width / 3 - faceWidth * 0.12;
    var eyeRX = width / 2 + faceWidth * 0.25;
    ellipse(eyeLX, height / 2, eyeSize, eyeSize);
    ellipse(eyeRX, height / 2, eyeSize, eyeSize);

    //pupils
    strokeWeight(2);
    fill(0,0,0);
    var pupilLX = width / 3 - faceHeight * 0.12;
    var pupilRX = width / 2 + faceWidth * 0.25;
    ellipse(pupilLX, height / 2, pupilSize, pupilSize);
    ellipse(pupilRX, height / 2, pupilSize, pupilSize);

}
 
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(200, 350);
    faceHeight = random(200, 300);
    eyeSize = random(20, 30);
    pupilSize = random(7,11);
    beakSize = random(30,50);
    beakWidth = random(10,50);

}

When creating this project, I was originally hoping to make a dog of some sort. I made a lot of sketches for this, trying to simplify the shapes. However I ended up changing my direction after a happy accident. When I wrote the code to create a rectangle, it turned out to be yellow because of the color variables I had randomly set. I immediately thought it looked like a seagull’s beak and so I went with it!

hqq-secE-LookingOutwards-02

Hi guys!

Generative design is a huge part of what has led to the resurgence of the architecture industry in the past few decades. Methods of parametric modelling and design have monumentally transformed the way that architects develop a formal logic to designing complex buildings.

Photo: Zaha Hadid Architects (ZHA)

One of the pioneering pieces of parametrically designed architecture came just after the turn of the century. Designed by Zaha Hadid in 2003, the Guangzhou Opera House has become a major staple to the community while expressing a generative algorithm derived from an early prototype of a now-popular modelling language called Grasshopper. The algorithm considered various inputs including topography, sunlight, and population density projections to achieve a superfluous design that achieves optimally designed sonic clarity while adapting to environmental conditions in China.

Grasshopper is now used throughout the architecture industry to make important considerations like weather, topography, or mathematical logic a staple in the design process.

Lrospigl-Project02-VariableFaces

sketch

  var eyeSize = 20;
  var faceWidth = 170;
  var faceHeight = 170;
  var eyeColor = 150;
  var shirtColor = 150;
  
function setup() {
  createCanvas(400, 400);
}

function draw() {

  background(127, 155, 245);

  //hair
  strokeWeight(0);
  fill (138,109,90);
  rect (width/2 - (faceWidth/2) - 10, 
  height/2 - (faceHeight / 2) - 10, 
  faceWidth + 20, 
  faceHeight + 40, 30);
  
  //hairShadow
  strokeWeight(0);
  fill (121,96,79);
  rect (width/2 - (faceWidth/2), height/2 - (faceHeight / 2) - 10, 
  faceWidth, faceHeight + 40, 15);
  
  //neck
  strokeWeight(0);
  fill(239, 205, 182);
  rect (width/2 - 10, 200, 20, 200, 10);

  //neckshadow
  strokeWeight(0);
  fill(211, 179, 158);
  rect (width/2 - 10, 150 + (faceHeight / 3), 20, 100, 10);
  
  //head
  strokeWeight(0);
  fill(239, 205, 182);
  rect (width/2 - (faceWidth/2), height/2 - (faceHeight / 2), 
  faceWidth, faceHeight, 30);
  
  var eyeXpos = (width / 2 - faceWidth * 0.25);
  var eyeYpos = (width / 2 + faceWidth * 0.25);

  //eyes
  strokeWeight(1);
  arc(eyeXpos, height / 2, eyeSize, eyeSize, 0, 2*HALF_PI);
  arc(eyeYpos, height / 2, eyeSize, eyeSize, 0, 2*HALF_PI);

  //shirt
  strokeWeight(0);
  fill(76, shirtColor, 91);
  rect (width/2 - (faceWidth*1.2 / 2), 340,
  (faceWidth * 1.2), 80, 10);
  
  //smile
  
  fill (246,180,211); 
  arc(200, 200 + (faceHeight / 4), 
  (faceWidth/3), faceHeight/4, 0, 2*HALF_PI);
  
  //teeth
  fill (255,255,255);
  arc(200, 200 + (faceHeight / 4), 
  (faceWidth/3), faceHeight/10, 0, 2*HALF_PI);
  
  //eyebrows
  noFill ();
  strokeWeight(0.2);
  bezier(eyeXpos - 17, height / 2 - 10, 
  eyeXpos + 10, height / 2 - 20,
  eyeXpos + 10, height / 2 - 12,
  eyeXpos + 15, height / 2 - 10);
  
  bezier(eyeYpos - 17, height / 2 - 10, 
  eyeYpos + 10, height / 2 - 20,
  eyeYpos + 10, height / 2 - 12,
  eyeYpos + 15, height / 2 - 10);
  
  //bangs
  strokeWeight(0);
  fill (138,109,90)
  rect (width/2 - (faceWidth/2) + 2, 
  height/2 - (faceHeight / 2) - 10,
  faceWidth - 4, 
  faceHeight - (faceHeight/1.6), 10);
  
}

function mousePressed() {
  faceWidth = random(100, 200);
  faceHeight = random(100, 250);
  eyeSize = random(15, 30);
  shirtColor = random(0,150);
}

alchan-Project 02-variable face

alchan project 02

//face shape
var faceShade = 100;
var faceWidth = 150;
var faceHeight = 200;
var faceAngle1 = 10;
var faceAngle2 = 10;
var faceAngle3 = 10;
var faceAngle4 = 10;

//eyes
var eyeSize = 50;
var eyeStroke = 4;
var eyeNumber = 2;
var eyeX = 320;
var eyeY = 210;
var eyeDistance = 30;

//antlers
var antlerX = 50;
var antlerY = 120;
var antlerLeft1 = 80;
var antlerLeft2 = 180;
var antlerLeftSize = 100;
var antlerRight1 = 0;
var antlerRight2 = 100;
var antlerRightSize = 100;
var antlerStroke = 8;

//determine whether to show/hide
var crestType = 1;
var showEars = 0;

//ears
var earX = 320;
var earY = 100;
var earWeight = 50;

//spike
var spikeX = 320;
var spikeY = 240;
var spikeWidth = 20;
var spikeHeight = 100;

//specimen label
var n1 = 0;
var n2 = 0;
var n3 = 0;

function setup() {
    createCanvas(640, 480);
    rectMode(CENTER);
    angleMode(DEGREES);
    smooth();
}

function draw() {
    background(237, 234, 218);

    //antlers
    noFill();
    stroke(0);
    strokeWeight(antlerStroke);
    arc(320 - faceWidth/2, antlerY, antlerLeftSize, antlerLeftSize, antlerLeft1, antlerLeft2, OPEN);
    arc(320 + faceWidth/2, antlerY, antlerRightSize, antlerRightSize, antlerRight1, antlerRight2, OPEN);

    //determine additional crest type: antlers, ears, spike
    if(crestType === 1) {
      strokeWeight(antlerStroke - 2);
      arc(320 - faceWidth/2, antlerY - 20, antlerLeftSize - 50, antlerLeftSize - 50, antlerLeft1, antlerLeft2, OPEN);
      arc(320 + faceWidth/2, antlerY - 20, antlerRightSize - 50, antlerRightSize - 50, antlerRight1, antlerRight2, OPEN);
    } else if (crestType === 2) {
      noStroke();
      fill(50);
      triangle(spikeX - spikeWidth/2, 245 - faceHeight/2, spikeX + spikeWidth/2,
        245 - faceHeight/2, spikeX, spikeHeight);
    }

    //determine whether or not to draw ears
    if(showEars >= 0.5) {
      stroke(faceShade);
      strokeWeight(earWeight);
      line(earX - faceWidth/2, antlerY + earY, earX + faceWidth/2, antlerY + earY);
    }

    //face
    noStroke();
    fill(faceShade);
    rect(320, 240, faceWidth, faceHeight,
      faceAngle1, faceAngle2, faceAngle3, faceAngle4);

    //eyes: determine how many, then draw
    stroke(256);
    strokeWeight(eyeStroke);
    fill(0);
    if(eyeNumber === 1) {
      ellipse(eyeX, eyeY, eyeSize, eyeSize);
    } else if(eyeNumber === 2) {
      ellipse(eyeX - eyeDistance, eyeY, eyeSize, eyeSize);
      ellipse(eyeX + eyeDistance, eyeY, eyeSize, eyeSize);
    } else if (eyeNumber === 3) {
      ellipse(eyeX - eyeDistance, eyeY, eyeSize, eyeSize);
      ellipse(eyeX + eyeDistance, eyeY, eyeSize, eyeSize);
      ellipse(eyeX, eyeY - eyeDistance, eyeSize, eyeSize);
    }

    //caption: specimen number
    noStroke();
    textFont('Georgia');
    textSize(16);
    textAlign(CENTER);
    textStyle(ITALIC);
    text('specimen no. ' + n1 + n2 + n3, 320, 440);
}

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(180, 250);
    faceHeight = random(200, 250);
    faceAngle1 = random(10, 60);
    faceAngle2 = random(10, 60);
    faceAngle3 = random(10, 60);
    faceAngle4 = random(10, 60);
    faceShade = random(80, 150);

    eyeSize = random(30, 70);
    eyeStroke = random(3, 10);
    eyeNumber = Math.floor((random() * 3) + 1); //need a whole number
    eyeX = random(290, 350);
    eyeY = random(180, 240);
    eyeDistance = eyeSize/2 + random(5,30);

    antlerX = random(90, 125);
    antlerY = random(100, 180);
    antlerLeft1 = random(70, 90);
    antlerLeft2 = random(170, 200);
    antlerLeftSize = random(80, 120);
    antlerRight1 = random(-20, 10);
    antlerRight2 = random(90, 110);
    antlerRightSize = random(80, 120);
    antlerStroke = random(4, 15);

    crestType = Math.floor((random() * 2) + 1); //need a whole number
    showEars = random();

    earY = random(80, 120);
    earWeight = random(40, 80);

    spikeX = random(260, 380);
    spikeY = random(50, 100);
    spikeWidth = random(10, 40);
    spikeHeight = random(25, 80);

    n1 = Math.floor((random() * 9) + 1); //need a whole number
    n2 = Math.floor((random() * 9) + 1);
    n3 = Math.floor((random() * 9) + 1);
}

I first figured out which elements of my face I wanted to be randomized. I then decided which elements would be constant (antlers, eyes) and which would only be drawn for some faces (2nd set of antlers, ears, horn, number of eyes). From there it was just working out dimensions, coordinates, and ranges for the randomly generated variables.

jiaxinw-LookingOutwards-02

Concentric Squares, Frank Stella, 2015

This is a piece of installation arts created by Montreal-based digital art studio Iregular, and It was inspired by Concentric Squares of Frank Stella, an American painter. This project was projected on a rounded curved wall to allow the audience to look at the animation from different aspects. But wherever they stood, they could always see a square shape on the wall. The animation looked like a tunnel floating in the air with a black background, and somebody called it an “infinite digital wormhole”.   The whole visual content was fully generative, random and infinite.

This installation inspired me as of how we could create the infinity of visual effects by using a computer program. I particularly admired that it combined the physical environment with the visual content to strengthen the immersion of the arts, and because of the non-repetitive animation, the audience can stay in the immersion even longer.

I guess the creator wrote a specific program to generate random moving lines along the four sides of a square. At the same time, these lines follow a “deep space” rule on the surface, so that to create a feeling of a tunnel.

Iregular created the animation following the one point perspective rule to fulfill the need of making a digital aisle. The random movements and changes of lines had its own rhythm to make the animation look comfortable.  The original painting has been completely transformed into a futuristic and mesmerizing visual content.

 

jiaxinw-Project02-Variable Faces

sketch

//body
var bodyWidth = 350;
var bodyHieght = 400;
var bodyColor = 170;

//face
var faceWidth = 250;
var faceHeight = 300;

//ear
var eyeSize = 30;
var earWidth = 50;
var earHeight = 70;

//the two middle points of eyebrows
var eyebrowPoint1 = 180;
var eyebrowPoint2 = 180;

//mouth left side
var mouthCornerL = 300;

//mouth right side
var mouthCornerR= 340;

var mouthHeight = 350;

//skin color
var skinR = 250;
var skinG = 230;
var skinB = 220;

//background begin color
var BackLR = 255;
var BackLG = 249;
var BackLB = 223;

//background end color 
var BackRR = 211;
var BackRG = 248;
var BackRB = 238;


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

}

function draw() {
	//background colors
	noStroke();
    from = color(BackLR, BackLG, BackLB);
    to = color (BackRR, BackRG, BackRB);
    colorMode(RGB);
    interA = lerpColor(from, to, .25);
	interB = lerpColor(from, to, .65);
	fill(from);
	rect(0, 0, 160, 480);
	fill(interA);
	rect(160, 0, 160, 480);
	fill(interB);
	rect(320, 0, 160, 480);
	fill(to);
	rect(480, 0, 160, 480);

    //body
    fill(bodyColor);
    rect(width/2 - bodyWidth/2, height/2 + bodyHieght*0.25 , bodyWidth, bodyHieght, 100);

	//face
	fill(skinR, skinG, skinB);
	ellipse(width/2, height/2, faceWidth, faceHeight);

    //ears
    fill(skinR, skinG, skinB);
    ellipse(width/2 - faceWidth/2, height/2, earWidth, earHeight);
    ellipse(width/2 + faceWidth/2, height/2, earWidth, earHeight)

	//eyes
	fill(31, 28, 27);
	var eyeLX = width/2 - faceWidth*0.25;
	var eyeRX = width/2 + faceWidth*0.25;
	var eyeHeight = height/2
	ellipse(eyeLX, eyeHeight, eyeSize, eyeSize);
	ellipse(eyeRX, eyeHeight, eyeSize, eyeSize);

    //left eyebrow
    noFill();
    stroke(70);
    strokeWeight(2);
    beginShape();
    curveVertex(width/2 - faceWidth*0.375,  height/2 - faceHeight*0.125);
    curveVertex(width/2 - faceWidth*0.375,  height/2 - faceHeight*0.125);
    curveVertex(width/2 - faceWidth*0.3, eyebrowPoint1);
    curveVertex(width/2 - faceWidth*0.2, eyebrowPoint2);
    curveVertex(width/2 - faceWidth*0.125,  height/2 - faceHeight*0.125);
    curveVertex(width/2 - faceWidth*0.125,  height/2 - faceHeight*0.125);
    endShape();

    //right eyebrow
    noFill();
    stroke(70);
    strokeWeight(2);
    beginShape();
    curveVertex(width/2 + faceWidth*0.375,  height/2 - faceHeight*0.125);
    curveVertex(width/2 + faceWidth*0.375,  height/2 - faceHeight*0.125);
    curveVertex(width/2 + faceWidth*0.3,  eyebrowPoint1);
    curveVertex(width/2 + faceWidth*0.2,  eyebrowPoint2);
    curveVertex(width/2 + faceWidth*0.125,  height/2 - faceHeight*0.125);
    curveVertex(width/2 + faceWidth*0.125,  height/2 - faceHeight*0.125);
    endShape();

    //mouth   
    fill(236, 39, 70);
    noStroke();
    beginShape();
    curveVertex(mouthCornerL, height/2 +70);
    curveVertex(mouthCornerL, height/2 +70);
    curveVertex(width/2 - 10, mouthHeight);
    curveVertex(width/2 + 10, mouthHeight);
    curveVertex(mouthCornerR, height/2 +70);
    curveVertex(mouthCornerR, height/2 +70);
    endShape();
    

}

    //when the user clicks, variables are assigned to random values within specifid ranges
function mousePressed(){

    //face size change
    faceWidth = random(150, 300);
    faceHeight = random(200, 350);
    
    //eye size change
    eyeSize = random (10, 50);
    
    //ear size change
    earHeight = random(60, 80);
    earWidth = random(40, 60);
    
    //eyebrow change
    eyebrowPoint1 = random(200, 220);
    eyebrowPoint2 = random(180, 220);

    //mouth change
    mouthCornerL = random(280, 300);
    mouthCornerR = random(340, 360);
    mouthHeight = random(300, 350);

    //skin color change
    skinR = random(240, 260);
    skinG = random(220, 240);
    skinB = random(210, 230);

    //background color change
    BackLR = random(220, 256);
    BackLG = random(180, 280);
    backLB = random(200, 250);
    BackRR = random(210, 256);
    BackRG = random(170, 248);
    BackRB = random(50, 238);

    //body change
    bodyWidth = random(350, 400);
    bodyHieght = random(400, 450);
    bodyColor = random(70, 170)
}



To start this project, I thought about what parts of a face can affect the appearance of it obviously. I came up with the size of the face, size of eyes, shapes of eyebrows and the shape of the mouth. Therefore, I set up different variables for these different part to be changed. Later, I realized the color of skin is also a good point, and I also made it changeable. For the background, I wanted to do something different, I wanted to make it changeable too. I found the function of lerpcolor() in reference, and I thought it would be a fun to make a background that generates gradual colors randomly.

sophiaq-LookingOutwards-02

  1. Turbulence: Watercolor + Magic

http://blog.drwoohoo.com/turbulence-watercolor-magic/

Explain, inspires, critique, research their inspiration

Dr. Woohoo created a series which explores the dynamic between automated robots and the natural movement of humans in order to combine the strengths of each and create exciting art. He codes a robot to paint with watercolor designs, and you can see the how the pattern fluctuates because of the natural elements of watercolor. Some of his other work in the series include robots carving mandalas on wood and the use of leap frog technology to copy his human movement onto robots. His work inspires me because of the finished product of the human+robot arts – the art strokes are surprisingly inconsistent even though they were created by robots. I’m interested in the fluctuations of automatization which will inspire my art later on. As a critique, Dr.Woohoo could create more mixed media art with robots and human rather than just one-on-one robot with the material. What is working is that all his artwork looks beautiful and he should continue that. Dr. Woohoo specializes in algorithmic art, generative patterns, and design.

Quayola-Looking Outwards-02

Strata#3

The Strata series by Quayola is a form of digital art combining custom-prgrammed algorithms and traditional cathedral paintings. To be specific, Quayola creates three-dimensional art with layers built up out of “The Triumph of the Name of Jesus”. The process is that the artist would film a cathedral painting in a very high resolution. Then, he will use custom-programmed algorithms to fracture the image in parts and fill color.

At first, the color choice of the geometric shapes prevent me from realizing the essence of the piece; I was attracted to its vintage look. The matching color of the original work, the correspondence of the background music, and the pattern of the geometric shapes, all build up a harmony that admires the feature of the Ancient Rome and also delivers the geometry and iconography of perfection. Continue exploring the piece, I found that this creates a visual metaphor for history. “Strata” here refers to the layers of stones. Although the method of building the algorithms here is not explicitly stated, I observed that the size, color, and the location of the geometric shape is related to the background music and the historical understanding of baroque and renaissance periods. I assume that the artists determine the sizes of each fold and layer first and program them in a way that the shapes interact with other elements. The relationship between complex algorithm and the painterly traditions is most effectively represented in Strata #3 where the geometric shapes are first drawn on the painting, according to the structure of the subjects, the folds of clothes, and the concentration of movements.

Strata #3 by quayola, 2009 | The process where there is pure geometry
‘strata #3’ by quayola, 2009 | The process when some layers of colored shapes have built up

Together, Quayola built a successful bridge between the conceptual and philosophical spirits with the scientific and numerical combination of geometric shapes. While the two subjects may seem to be unrelated to each other, they correspond and echo from each other.

Strata #1
(HD Video on 1-ch projection with 2-ch sound, Edition of 6, 2008)

Strata #3
(HD Video on 1-ch projection with 2-ch sound, Edition of 6, 2009)

karinac-LookingOutwards-02

This particular work is part of Leonardo Solaas’s coding experiment called Walking in Color Space. He wanted to generate art that made color seem explosive and omnipresent. Therefore, the artist took sample pictures, in this case, the Powerpuff girls, and extracted the colors. He then took those colors and projected them in a 3-D manner by adjusting and specifying the direction of the colors to create these trajectories that you see in the picture. In addition to the various translations of the image, Solaas introduced contrasting colors in the multiple trajectories to make the color variations stand out and more visible.

I was intrigued by this work because the artist utilized an already existing image and made it his own simply by taking the colors and directing the lines in a 3-D setting.