Kai Zhang – Page 2 – [OLD FALL 2018] 15-104 • Introduction to Computing for Creative Practice

Kai Zhang-Looking Outwards-06

Andrew Huang is a Youtuber/ musician who is known for his “Song Challenge” video series, which invites viewers to dare him in feats of musicianship, as well as for several viral videos feturing his music. The very unique talent of his is how he used unconventional recordings of pretty much everything as instruments to create his music pieces.

In this video of his, he challenged himself using random sounds that are sent from his Twitter followers to create a sound track. He didn’t specify any requirement of the sounds as long as they’re anywhere near useable for editing. And the sounds are recorded very randomly by his followers and used random recording devices. He explained in this video how he used various computational techniques to remix the sounds including pitch-shifting, pitch modulation, eqaulization, layering, etc.

What I appreciate the most is that despite how the sounds he picked are drastically different and totally random. His ability to manage all these sounds into a synchronized drop is very impressive. To his sensibility, there are quite much value from randomness, and things ignored by most people can often be picked up and become part of a great artwork. And it’s not only the sound, but also video editing part that really adds to the flavor of the whole experience.

Kai Zhang-Project-06-Abstract-Clock

sketch

//Kai Zhang
//Section B
//kaiz1@andrew.cmu.edu
//Project-06

var prevSec; //previous second
var msr = 0;//millisecond rollover
var wcol = 0; //wallpaper color
var scol = 0; //second loop color
var mcol = 0; //minute loop color
var hcol = 0; //hour loop color

function setup() {
    createCanvas(600, 600);
    colorMode(HSB, 100);
}

function draw() {
    var h = hour();
    var m = minute();
    var s = second();
    var mils; //millisecond
    var fcd = 0; //frame count decrease


    background(wcol, 40, 30);
    angleMode(RADIANS);

    wcol += 0.1;
    if (wcol > 99) {
        wcol = 0;
    }
    
    strokeWeight(4);
    stroke(20);
    noFill();

    if (prevSec != s) {
        msr = millis();
    }
    prevSec = s;
    var mils = floor(millis() - msr);

    
    //hour loop
    push();
    translate(300, 410);

    stroke(40);
    for (var size = 320; size < 401; size += 20) {
        ellipse(0, 0, size, 100);
    }

    stroke(hcol + 75, 40, 90);
    for (var size = 320; size < 401; size += 20) {
        arc(0, 0, size, 100, -PI / 2, h/12 * 2*PI - PI / 2);
    }

    hcol += 0.1;
    if (hcol > 25) {
        hcol = -75;
    }
    pop()


    //minute loop
    push()
    translate(300, 340);

    stroke(40);
    for (var size = 320; size < 401; size += 20) {
        ellipse(0, 0, size, 100);
    }

    stroke(mcol + 50, 40, 90);
    for (var size = 320; size < 401; size += 20) {
        arc(0, 0, size, 100, -PI / 2, m/60 * 2*PI - PI / 2);
    }


    mcol += 0.1;
    if (mcol > 50) {
        mcol = -50;
    }
    pop()


    //second loop
    push()
    translate(300, 270);

    stroke(40);
    for (var size = 320; size < 401; size += 20) {
        ellipse(0, 0, size, 100);
    }

    stroke(scol + 25, 40, 90);
    for (var size = 320; size < 401; size += 20) {
        arc(0, 0, size, 100, -PI / 2, (s/60 + mils/60000) * 2*PI - PI / 2);
    }

    scol += 0.1;
    if (scol > 75) {
        scol = -25;
    }
    pop()


    
    //mils loop
    push()
    translate(300, 200);
    stroke(77);
    strokeWeight(4);
    arc(0, 0, 320, 100, millis()/1000 * 2*PI, (millis() - 200)/1000 * 2*PI);
    arc(0, 0, 340, 100, (millis() - 100)/1000 * 2*PI, (millis() - 300)/1000 * 2*PI);
    arc(0, 0, 360, 100, (millis() - 200)/1000 * 2*PI, (millis() - 400)/1000 * 2*PI);
    arc(0, 0, 380, 100, (millis() - 300)/1000 * 2*PI, (millis() - 600)/1000 * 2*PI);
    arc(0, 0, 400, 100, (millis() - 400)/1000 * 2*PI, (millis() - 800)/1000 * 2*PI);
    pop()
}

For this project I’m also considering an apporach to do a 3 dimensional abstract clock using 2D primitives. There are 4 sets of loops running on the tracks stacking bottom up and each shows the hour, minute, second, and milisecond. However, the milisecond loops are moving too fast so I rather make it a infinite looping than resetting at each second. The color of the loops and background are also changing the hue constantly, and they’re offest in H value so they’re always in contrast colors.

Kai Zhang-Looking Outwards-05

Image result for doctor strange cgi

The Making of Movie CGI Effects – Doctor Strange

At the bottom of the page is a video that breaks down the computer generated imagery of the blockbuster movie Doctor Strange. I’m rather fascinated by the making process because at current time it’s getting more and more difficult to differentiate the CGI and real shooting in large budget Hollywood movies. And the reason is due to the rapid increasement of computing power and software capabilities.

However, one might not expect from the process is that the CGI making is not all about 3D generated objects that’s plugged into the filmed footages. There is a combination of 2D and 3D layers that makes up the full imagery, for example, the fogs or the ashes are usually 2D painted. And also a lot of the “people” in the movie aren’t real at all. In some cases, to create some of the visual effects, modeling human figures and manipulate it is even more efficient than shooting using chroma key.

The methodology is straightforward. Exporting 3D imagery into 2D workspaces and layer them in the timeline. Aftereffects is usually the most common tool to use. But in most cases, despite different components are exported from different files, algorithms are used to make sure they line up in 3D spaces. For example, the light-whip is tied virtually to the hand in another work file. Also, a large portion of the physical reaction of objects, particle effects, etc. are calculated using 3D engines that embeds all the physical equations needed for the result. One rather amazing thing is – by moving sliders of the physical reaction level can often result in totally different film styles easiliy perceived by the audiences.

In the end, the combination of different aspects of the element are tied together and rendered out as static imageries (frames) and played in the sequence, which results in the final grand state of the art.

Image result for doctor strange cgi

Kai Zhang-Project-05-Wallpaper

sketch

//Kai Zhang
//Section B
//kaiz1@andrew.cmu.edu
//Project-05

var i;

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


function draw() {
	background(160, 200, 200);
	translate(-20, -20 - 10 * sqrt(2)); //shift it left and up so it's covering the whole canvas
	noStroke();

	for (i = 0; i < 20; i ++) {
		for (j = 0; j < 20; j ++) {

			//doing the odd number rows
			fill(240, 220, 100);
			beginShape();
			vertex(0 + 60 * i, 10 + (20 + 20 * sqrt(2)) * j);
			vertex(10 + 60 * i, 0 + (20 + 20 * sqrt(2)) * j);
			vertex(20 + 60 * i, 10 + (20 + 20 * sqrt(2)) * j);
			vertex(30 + 60 * i, 0 + (20 + 20 * sqrt(2)) * j);
			vertex(40 + 60 * i, 10 + (20 + 20 * sqrt(2)) * j);
			vertex(20 + 60 * i, 30 + (20 + 20 * sqrt(2)) * j);
			endShape(CLOSE);
			//the first piece

			fill(50, 35, 200);
			beginShape();
			vertex(0 + 60 * i, 10 + (20 + 20 * sqrt(2)) * j);
			vertex(20 + 60 * i, 30 + (20 + 20 * sqrt(2)) * j);
			vertex(20 + 60 * i, 30 + 20 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			vertex(10 + 60 * i, 20 + 20 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			vertex(10 + 60 * i, 20 + 10 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			vertex(0 + 60 * i, 10 + 10 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			endShape(CLOSE);
			//the second piece

			fill(200, 35, 180);
			beginShape();
			vertex(40 + 60 * i, 10 + (20 + 20 * sqrt(2)) * j);
			vertex(20 + 60 * i, 30 + (20 + 20 * sqrt(2)) * j);
			vertex(20 + 60 * i, 30 + 20 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			vertex(30 + 60 * i, 20 + 20 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			vertex(30 + 60 * i, 20 + 10 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			vertex(40 + 60 * i, 10 + 10 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			endShape(CLOSE);
			//the third piece		



			push(); //doing the even number rows
			translate(30, 10 + 10 * sqrt(2));
			//shift the geometries where it should go, then just copy everything as they're completely the same
			
			fill(240, 220, 100);
			beginShape();
			vertex(0 + 60 * i, 10 + (20 + 20 * sqrt(2)) * j);
			vertex(10 + 60 * i, 0 + (20 + 20 * sqrt(2)) * j);
			vertex(20 + 60 * i, 10 + (20 + 20 * sqrt(2)) * j);
			vertex(30 + 60 * i, 0 + (20 + 20 * sqrt(2)) * j);
			vertex(40 + 60 * i, 10 + (20 + 20 * sqrt(2)) * j);
			vertex(20 + 60 * i, 30 + (20 + 20 * sqrt(2)) * j);
			endShape(CLOSE);

			fill(50, 35, 200);
			beginShape();
			vertex(0 + 60 * i, 10 + (20 + 20 * sqrt(2)) * j);
			vertex(20 + 60 * i, 30 + (20 + 20 * sqrt(2)) * j);
			vertex(20 + 60 * i, 30 + 20 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			vertex(10 + 60 * i, 20 + 20 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			vertex(10 + 60 * i, 20 + 10 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			vertex(0 + 60 * i, 10 + 10 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			endShape(CLOSE);

			fill(200, 35, 180);
			beginShape();
			vertex(40 + 60 * i, 10 + (20 + 20 * sqrt(2)) * j);
			vertex(20 + 60 * i, 30 + (20 + 20 * sqrt(2)) * j);
			vertex(20 + 60 * i, 30 + 20 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			vertex(30 + 60 * i, 20 + 20 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			vertex(30 + 60 * i, 20 + 10 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			vertex(40 + 60 * i, 10 + 10 * sqrt(2) + (20 + 20 * sqrt(2)) * j);
			endShape(CLOSE);			


			pop();
		}
	}


}

I’m interested in doing a 3D tessellation for the wallpaper. I got the inspiration from the Escher’s distorted architecture drawings and tessellation artworks. Then I’ve done a quick linework in Rhino to have precise placement of lines and lengths of them. So in the code I simple used the beginShape() function and connect all the points to create the geometry. The tricky part is that I’ve used 45 degrees for the diagonal lines, which I will need to calculate the exact location of vertex points using square roots. And in the end I just colored with high contrast colors for it to pop out and be more “3 dimensional”.

Image result for escher tessellations

Kai Zhang-Looking Outwards-04

A 4G Network Turned into Music

Project by – Andrius Šarapovas, Technarium.

Commissioned by – Tele2.

Video by – Some Films

This is an installation that uses algorithm to turn one second of browsing on the 4G network into one second of music. The number of connections to the network in different regions of Lithuania controls the volume of the notes being played and their rhythmic distribution, while the amount of data transferred during those sessions determines the notes’ pitches.

The walk-in kinetic sound installation consists of 77 segments distributed throughout the exhibition space. Each segment has a metal bar, a sound activator, a sound damper, a resonator, and mechatronics. The distribution of the segments in space forms 4 narrow and 11 wide directions of movement. The number of segments and their positions were in part determined by the spatial and acoustic characteristics of the exhibition space. The sound range of the installation consists of 4 notes in 4 octaves where a specific note is assigned to the North, the South, the East and West of Lithuania.

What amazed me about this project is how it embraced the coldness of technology and turned it into something warm. From the sound generated, I can hear how the everlasting signals are transfered through the globe, though it’s merely taking a piece of sample from it. The tuning of algorithm and tones is rather elegant and pleasing to listen to. The listeners could also sense the richness of the patterns of data that’s been carried into this room.

Another thing to give the creator credit is their ability to deal with space. It’s a farily large space with echos. The creators took advantage of the charcteristics of it can use it as a perfect stage for the music piece. And the sound wanders around for an extended piece of time to give people a sense of tranqility. When you’re walking in the matrix of sound machines, it’s almost like you’re touching the music, and the information lies beyond that. The installation carefully used materials that matches the flow of the tones. The instrument components are exposed and showcasing its fine details and simplicity, which adds to the overall experience for the audience.

“Statistics reduces the studied object into a few, several or a dozen features. This is a paradoxical trait of statistics – investigating the variability of an object it actually produces immutable characteristics, monitoring the differences, it observes repetitions. The average, however, is not reality, but rather a color that is the result of mixed different tints. The height or weight gets summed, but the noise, the smell or shadows are lost. Statistics draw the map of reality, making it two-dimensional. The effect of music is directly contrary.”

— Andrius Šarapovas

https://courses.ideate.cmu.edu/15-104/f2018/wp-admin/post-new.php

Kai Zhang-Project-04-String-Art

sketch

//Kai Zhang
//Section B
//kaiz1@andrew.cmu.edu
//Project-04

var a;
var x1;
var y1;
var x2;
var y2;
var x3;
var y3;
var x4;
var y4;
var x5;
var y5;
var x6;
var y6;
//assign all the coordinators

var d0 = 50;
var d1 = 80;
var d2 = 120;
var d3 = 160;
var d4 = 190;
//various diameters of curves

function setup() {
    createCanvas(400, 300);
    background(0);
    angleMode(DEGREES);
}


function draw() {
    
    for (a = -90; a <= 90; a += 5) {
        x1 = 80 + d0 * cos(a);
        y1 = 150 - d0 * sin(a);
        x2 = 320 - d0 * cos(a);
        y2 = 150 + d0 * sin(a);
        x3 = 80 - d0 * cos(a);
        y3 = 50 + d0 * sin(a);
        x4 = 320 + d0 * cos(a);
        y4 = 250 - d0 * sin(a);

        stroke(100 + 3 * a);
        line(x1, y1, x2, y2);
        line(x3, y3, x4, y4);
    }

    noFill();
    stroke(250);
    ellipse(200, 150, 40, 40);
    //first ring

    for (a = 90; a <= 180; a += 2) {
        x5 = 200 + d1 * cos(a);
        y5 = 250 - d1 * sin(a);
        x6 = 200 - d1 * cos(a)
        y6 = 50 + d1 * sin(a);

        stroke(0 + 2 * (a - 130));
        line(x5, y5, x6, y6);
    }

    stroke(190);
    ellipse(200, 150, 70, 70);
    //second ring

    for (a = 120; a <= 180; a += 2) {
        x5 = 200 + d2 * cos(a);
        y5 = 250 - d2 * sin(a);
        x6 = 200 - d2 * cos(a)
        y6 = 50 + d2 * sin(a);
        //the x and y variables can be reused because the previous marks wouldn't disappear

        stroke(0 + 2.5 * (a - 120));
        line(x5, y5, x6, y6);
    }
    
    stroke(120);
    ellipse(200, 150, 100, 100);
    //third ring

    for (a = 150; a <= 180; a += 1) {
        x5 = 200 + d3 * cos(a);
        y5 = 250 - d3 * sin(a);
        x6 = 200 - d3 * cos(a)
        y6 = 50 + d3 * sin(a);

        stroke(50 + 4 * (a - 160));
        line(x5, y5, x6, y6);
    }

    stroke(80);
    ellipse(200, 150, 130, 130);
    //fourth ring

    for (a = 130; a <= 170; a += 1) {
        x5 = 200 + d4 * cos(a);
        y5 = 250 - d4 * sin(a);
        x6 = 200 - d4 * cos(a)
        y6 = 50 + d4 * sin(a);

        stroke(50 + 4 * (a - 160));
        line(x5, y5, x6, y6);
    }
}

One of the rather stunning effects of string art is it’s using 1D lines to represent 2D surfaces. In this project, I’m willing to take the challenge of giving it the third dimension. To achieve this, I chose the monochrome color for the lines and assign them with gradient changing shades so as if they have depth into the canvas. On top of that, I also hooped the elegant flowing surfaces with rings that overlay on different layers of the drawing. In this case, we’re using 2D work space to create 3D rendering visual effects using merely different shades of gray.

Kai Zhang-Looking Outwards-03

Tverrfjellhytta,© diephotodesigner.de

Tverrfjellhytta / Snøhetta

Architects: Snøhetta

Location: Hjerkinn, Dovre Municipality, Norway

Interior And Landscape Architect: Snøhetta Oslo AS

Project Team: Knut Bjørgum landscape architect (Design Team Leader), Kjetil T. Thorsen (Partner in charge, Principal architect), Erik Brett Jacobsen, Margit Tidemand Ruud, Rune Grasdal, Martin Brunner (Architects) Heidi Pettersvold.(Interior Architect)

Area: 900.0 ft2

Project Year: 2011

Photographs: diephotodesigner.de, Ketil Jacobsen

The Norwegian Wild Reindeer Centre Pavilion is located at Hjerkinn on the outskirts of Dovrefjell National Park, overlooking the Snøhetta mountain massif. The 90 sqm building is open to the public and serves as an observation pavilion for the Wild Reindeer Foundation educational programmes. A 1,5km nature path brings visitors to this spectacular site, 1200 meters above sea level.

The signatured feature of this project is the sculptural interior installment. It’s fully designed digitally using parametric tools. They would like to create a form in a box to represent the geological effects of its sorrounding environment. So they generated the form in 3d modeling software. And later the raw wood material was sculptured using CNC machines – the digital controlled mills that can precisely shape the raw material into desired form.

The final state was rather stunning, the orgainic form grew on the boundary of another form of order. And the spaces created by the installment was also very natural inspired but also ergonomically comfortable. The hybrid of nature and artificial compound was exceptioonally beautiful and elegant.

https://www.archdaily.com/180932/tverrfjellhytta-snohetta

Kai Zhang-Project-03-Dynamic-Drawing

project03-kaiz1

//Kai Zhang
//Section B
//kaiz1@andrew.cmu.edu
//Project-03

var RECX = 255 / 480; //remap color index in X
var RECY = 255 / 640; //remap color index in Y

var REAX = 720 / 480; //remap angle index in X
var REAY = 720 / 640; //remap angle index in Y

var diffx = 0;
var diffx = 0;
var diffx1 = 0;
var diffy1 = 0;
var x = 240;
var y = 320;
var x1 = 240;
var y1 = 320;

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


function draw() {
	background(x*1.2, y*1.2, abs(x - y));
	
	//set delay for the movement
    diffx = mouseX - x;
    diffy = mouseY - y;
    diffx1 = mouseX - x1;
    diffy1 = mouseY - y1;

    x = x + 0.07*diffx;
    y = y + 0.07*diffy
    x1 = x1 + 0.06*diffx1;
    y1 = y1 + 0.06*diffy1;

    //the central dot
	translate(mouseX, mouseY);

	noStroke();
	fill(y * RECY, abs(x - y) * RECY, x * RECX)
	ellipse(0, 0, 20, 20)

	//the faster arcs
	translate(-mouseX, -mouseY);
	translate(x, y);//recenter canvas by using delayed variable

	strokeWeight(x/50 + y/50);
	noFill();

	stroke(y * RECY, x * RECX, abs(x - y) * RECY);
	arc(0, 0, 50, 50, REAX * x, REAX * x + 120);
	arc(0, 0, 130, 130, REAX * x - y, REAX * x - y + 120);
	arc(0, 0, 210, 210, REAX * y - x, REAX * y - x + 120);

	stroke(x * RECX, abs(x - y) * RECY, y * RECY);
	arc(0, 0, 70, 70, REAY * y, REAY * y + 120);
	arc(0, 0, 150, 150, REAY * y - x, REAY * y - x + 120);
	arc(0, 0, 230, 230, REAY * x - y, REAY * x - y + 120);

	//the slower arcs
	translate(-x, -y);
	translate(x1, y1);//recenter canvas again

	stroke(abs(x - y) * RECY, y * RECY, x * RECX);
	arc(0, 0, 90, 90, -REAX * x, -REAX * x + 120);
	arc(0, 0, 170, 170, REAY * y + x, REAY * y + x + 120);
	arc(0, 0, 250, 250, REAY * x + y, REAY * x + y + 120);

	stroke(abs(x - y) * RECY, x * RECX, y * RECY);
	arc(0, 0, 110, 110, -REAY * y, -REAY * y + 120);
	arc(0, 0, 250, 250, REAY * x + y, REAY * x + y + 120);
	arc(0, 0, 270, 270, -REAY * x + y, -REAY * x + y + 120);

}

In this project, I’ve created a series of arcs that rotates around the same center dot. There are four visual variables of the shapes, the arc rotation, arc colors, arc positions, and arc stroke weight. Also the canvas is changing the colors. All the variables are controlled by the mouse X and Y positions. In order to make it more visually pleasing, I’ve set delays of different parameters of the arc movings and color changings. So they would in fact spend some time to reach their desired conditions.

Kai Zhang-Looking Outwards-02

Abstracted, repeated image of human face.

Diffusion Choir

Client: Sosolimited

Architect: de Architedkten Cie

Year of Built: 2006

The Diffusion Choir consists with four hundred folding elements that celebrates the organic movement of an invisible flock of birds. Each of the element is able to open and close independently. There’s a consitant simulation of birds over the course of each hour. Smaller groups of birds coalesce into a single entity. The birds collaborated to perform a virtual choreographed gesture across the space.

The reason of the selection is because it’s close relationship with the parametric design workflow that I usually do in architectural practices. In the coding process, driving particles (aka the flock of birds in this project) are assigned as driving variables that initiate the change happening in the moving elements. They respond to the movement of the driving particles by calculating the distance and some other features of the “birds” by opening and closing. In such matrix, the large group had formed an elegant dance of waves that attrack the attention of the whole room, also evaporate a sense of pleasing tranquility.

http://sansumbrella.com/works/2016/diffusion-choir/

Kai Zhang-Project-02-Variable-Face

kaiz1_Project02

//Kai Zhang
//Section B
//kaiz1@andrew.cmu.edu
//Project-02

//eyes
var eyeLW = 40;
var eyeLH = 20;
var eyeRW = 40;
var eyeRH = 20;
var eyeR = 10; //eye rotation
var eyeX = -50;

//eye background
var eyeBW = 70;
var eyeBH = 60;

//face
var faceW = 240;
var faceH = 220;

//knife
var knifeX = 0;
var knifeY = 0;
var knifeR = 0;

//overall Rotation
var rotateA = 0;


function setup() {
    createCanvas(480, 640);
    background(80);
    angleMode(DEGREES);
}


function draw() {
	background(80);
	strokeWeight(5);
	fill(255, 0, 0);
	translate(240, 320);

	rotate(rotateA);

	//knife
	push();
		fill(255);
		translate(knifeX, knifeY);
		rotate(knifeR);
		//knife edge
		beginShape();
			vertex(0, 0);
			vertex(0, 45);
			vertex(12, 45);
			vertex(12, 13);
		endShape(CLOSE);
		//knife handle
		fill(0);
		beginShape();
			vertex(-5, 45);
			vertex(17,45);
			vertex(17, 47);
			vertex(11, 47);
			vertex(11, 65);
			vertex(1, 65);
			vertex(1, 47);
			vertex(-5, 47);
		endShape(CLOSE);

	pop();

	//face
	ellipse(0, 0, faceW, faceH);
	line(0, -faceH/2, 0, faceH/2);

	//eye background
	push();
		fill(0);
		ellipse(eyeX - 3, -20, eyeBW, eyeBH);
		ellipse(-eyeX + 3, -20, eyeBW, eyeBH);
	pop();

	//eyes
	push();
		fill(255);
		translate(eyeX, -20);
		rotate(eyeR);
		ellipse(0, 0, eyeLW, eyeLH);
	pop();
	push();
		fill(255)
		translate(-eyeX, -20);
		rotate(-eyeR);
		ellipse(0, 0, eyeRW, eyeRH);
	pop();
}



function mousePressed() {
	eyeX = (-faceW/5);
	eyeLW = random(37, 45);
	eyeLH = random(10, 40);
	eyeRW = random(37, 45);
	eyeRH = random(10, 40);
	eyeR = random(-13, 13);
	eyeBH = random(55, 80);
	eyeBW = random(65, 80);

	faceW = random(210, 280);
	faceH = random(150, 280);

	knifeX = random(-180, 180);
	knifeY = random(-280, 280);
	knifeR = random(-180, 180);

	rotateA = random(-30, 30);
}

Deadpool is one of my favorite Marvel characters. He made possible two amazing featured films and hundreds of comic stories. The reason I chose him as the protagonist of my project 2 is he makes perfect leap from and to 3D and 2D world. The kartoon version of him comes with countless different proportions of facial features and expressions (especially the eyes), easily fits into the gridlines of the project. In the code of this project, I’ve set up to 14 different variables, composing the different eye shapes, eye shade shapes, face shapes, orientations, etc. I’ve also added an “eastern egg”, a small knife that floats across the canvas that occasionally hits the little deadpool’s haed. Luckily, because of his super power, he would be easily recovered from that. 🙂