jennyzha, Project-05-Wallpaper

sketch

//Jenny Zhang
//Section D
//jennyzha@andrew.cmu.edu
//Project 05: Wallpaper

var tw = 0;
var th = 0;
var oy = 0;
var ox = 0;

function setup() {
	createCanvas(480,480);
	background(179, 217, 255);
}	

function draw() {
	background(180, 215, 255);
	var tw = 55;
	var th = 55;
	var oy = 45;
	var ox = 45;
	
	for (var x = 0; x < width; x = x + 1) {
		for (var y = 0; y < 8; y += 1) {
		stroke(255);
		point(x, (y * 100) + 60 - 50 * sin(radians(x)));
		stroke(255, 255, 0);
		point(x, (y * 100) + 60 - 50 * cos(radians(x)));
		}
	}

	for (var y = 0; y < 7; y += 2) { //writes the code for the circles on every odd x and y value 
		for (var x = 0; x < 7; x+= 1.5) {
			var py = oy +y *th;
			var px = ox +x *tw;
			fill(185,145,255);
			noStroke();
			rect(px, py, 50, 50);
			noStroke();
			rect(px, py, 60, 60);
		}
	}
	for (var y = 0; y < 7; y += 2) { //writes the code for the circles on every odd x and y value 
		for (var x = 0; x < 7; x+= 1.5) {
			var py = oy +y *th;
			var px = ox +x *tw;
			fill(255);
			noStroke();
			rectMode(RADIUS);
			rect(px, py, 25, 25);
			rectMode(RADIUS);
			noStroke();
			rect(px, py, 25, 25);
		}
	}
	for (var y = 0; y < 7; y += 2) { //writes code for the circles of every even value -- these two loops help to create the honeycomb-like off-set grid
		for (var x = 1; x < 7; x+= 1.5) {
			var py = oy +y *th;
			var px = ox +x *tw;
			noStroke();
			fill(255, 255, 225);
			ellipse(px, py, 30, 30);
		}
	}
		for (var y = 0; y < 7; y += 2) { //writes code for the circles of every even value -- these two loops help to create the honeycomb-like off-set grid
		for (var x = 1; x < 7; x+= 1.5) {
			var py = oy +y *th;
			var px = ox +x *tw;
			noStroke();
			fill(255);
			ellipse(px, py, 15, 15);
		}
	}
	noLoop();
}

For this project, I was inspired by assignment 05B for this week’s deliverables. I wanted to gain a deeper understanding of how the program worked and added a couple more shapes, lines, and colors to make it my own and make it into a more aesthetically pleasing wallpaper.

ghou-project-05-Wallpaper

sketch

//Grace Wanying Hou
//15-104 Section D
//ghou@andrew.cmu.edu
//Assignment 05 A

//globals
//rectangles
var lx = 60;
var ly = 40;
var rx;
var ry;
//diagonals
var dx = 0;
var dy = 0;
var dyn = 0;


function setup(){
    createCanvas(600,600);
    background (255);
    angleMode(DEGREES);
}

function draw(){
    for (var y = 0; y < height/ly; y++) {
        for (var x = 0; x < width/lx; x++) {
            //local variable (needs to change w each square);
            //circles
            var sizes = [0,0,0,lx,lx*2,lx*3];
            var csize = random(sizes);
            //transparency
            var tran1 = random(20,100);
            //lineweight
            var linew = random(0.1,1);
            var cirw = random();
            
            //colour
            var colr = randomGaussian(200,20);
            var colg = randomGaussian(200,20);
            var colb = randomGaussian(200,20);
            
            //rectangles
            noStroke();
            rx = x * lx;
            ry = y * ly;
            fill(colr,colg,250,tran1);
            rect(rx,ry,lx,ly);            
            
            //circles
            strokeWeight(linew);
            stroke(255);
            fill(250,colg,colb,tran1);
            ellipse(rx,ry,csize);
        }
    }
    
    for (var y = -2; y < height/ly; y++) {
        for (var x = -2; x < width/lx; x++) {
            var linew = random(0.5,1);
            //rect strokes
            rx = x * lx;
            ry = y * ly;
            stroke(255);
            strokeWeight(2);
            noFill();
            rect(rx,ry,lx,ly);
            
            //diagonals
            dx = (x + 1) * lx;
            dy = (y + 1) * ly;
            strokeWeight(linew);
            //lines crossing rectangle
            line(rx,ry,dx,dy);
            line(dx,ry,rx,dy);
            //lines crossing each 3 rectangles
            dyn = (y + 3) * ly;
            line(rx,ry,dx,dyn);
            line(dx,ry,rx,dyn);
            
        }
    }
    noLoop()
}













I wanted to create a wallpaper more suited to be a wallpaper for a phone or an iPad. Based on that, I wanted to make something more geometric. I used a Gaussian randomizer to more easily make it look more naturally generated.

yunzhous-Looking Outward-03

Oblique Circulation 3

My eyes were immediately drawn to this image when I opened Pinterest. I’m an architecture student and this computer-generated building looks almost magical to me. As an architectural student I need to think about how to divide up space when I design. Using algorithm to do the work might not be the most functional solution but the result is definitely interesting. The artists tries to show circulation around the building through computer-generated curves. I didn’t find what algorithm the artist used but this reminds me of Grasshopper, a plug-in for Rhino that architect students often uses. Grasshopper is designed for parametric modeling. Using grasshopper to generate geometries is like using grasshopper’s language to tell it to do certain things.
The artist is Benjamin Dillenburger and the work title is Oblique Circulation 3. You can see more of his work here.

yunzhous-project-03

sketch

//elephant
var LeftEarW = 110;
var LeftEarH = 150;
var RightEarW = 70;
var RightEarH = 100;
//heights of mountains
var mh1 = 150;
var mh2 = 230;
var mh3 = 260;
var mh4 = 300;
var mh5 = 200;
var Y = 300; // y coordinate of snow
var R = 229;    
var G = 247;
var B = 224;

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

function draw() {
    background(R, G, B);
    //skycolor change
    if (mouseX > 0 & mouseX < width){
        R = 229 - mouseX/20;
        G = 247 - mouseX/50;
        B = 224 + mouseX/20;
    }
    
    //mountains
    //mountains decrease
    if (mouseX < width/2){
        mh1 ++;
        mh2 ++;
        mh3 ++;
        mh4 ++;
        mh5 ++;
    }

    //mountain stop decreasing
    if (mh1 > 250){
        mh1 = 250;
    }
    if (mh2 > 330){
        mh2 = 330;
    }
    if (mh3 > 360){
        mh3 = 360;
    }
    if (mh4 > 400){
        mh4 = 400;
    }
    if (mh5 > 300){
        mh5 = 300;
    }

    //mountains increase
    if (mouseX > width/2){
        mh1 --;
        mh2 --;
        mh3 --;
        mh4 --;
        mh5 --;
    }

    //mountains stop increasing
    if (mh1 < 150){
        mh1 = 150;
    }
    if (mh2 < 230){
        mh2 = 230;
    }
    if (mh3 < 260){
        mh3 = 260;
    }
    if (mh4 < 300){
        mh4 = 300;
    }
    if (mh5 < 200){
        mh5 = 200;
    }
    //mountains
    noStroke();
    fill(185, 230, 191);
    triangle(400, height, 700, height, 530, mh1);
    fill(164, 201, 169);
    triangle(300, height, 700, height, 470, mh2);
    fill(97, 147, 147);
    triangle(300, height, 400, height, 350, mh3);
    triangle(450, height, 580, height, 520, mh4);
    fill(62, 109, 92);
    triangle(360, height, 500, height, 430, mh5);

    //sun turns to moon
    fill(255, 255, 238);
    ellipse(mouseX, 90, 70, 70);

    if (mouseX > width/2){
        var offset = map(mouseX, 0, width, 100, 0); //offset of the ellipse to make moon
        fill(R, G, B);
        ellipse(mouseX - offset, 90, 70, 70);
    }

    //snow
    if (mouseX > width/2){
        Y ++;
        if (Y > 400){
            Y = 400;
        } 
    } else {
        Y = 300;
    }
    fill(255, 255, 238);
    ellipse(350, Y, 10, 10);
    ellipse(390, Y + 20, 10, 10);
    ellipse(450, Y - 30, 10, 10);
    ellipse(500, Y + 40, 10, 10);
    ellipse(530, Y + 20, 10, 10);
    ellipse(600, Y - 50, 10, 10);

    //elephant
    //body
    push();
    translate(-150, 130);
    noStroke();
    fill(210);
    beginShape();
    curveVertex(200,  250);
    curveVertex(220,  260);
    curveVertex(175,  330);
    curveVertex(165, 400);
    curveVertex(300, 400);
    curveVertex(330, 240);
    curveVertex(350, 240);
    endShape();
    pop();

    push();
    translate(-150, 130);
    var angle = map(mouseX, 0, width, 0, 5);
    rotate(angle);
    if (mouseX > 640){
        mouseX = 640;
    }

    //right ear
    push();
    rotate(10);
    noStroke();
    fill(210);
    ellipse(270, 120, RightEarW, RightEarH);
    fill(252, 225, 225);
    ellipse(270, 120, RightEarW/1.5, RightEarH/1.5); //inner ear
    pop();

    //Left ear
    noStroke();
    fill(210);
    ellipse(220, 210, LeftEarW, LeftEarH);
    fill(252, 225, 225);
    ellipse(220, 210, LeftEarW/1.5, LeftEarH/1.5); //inner ear

    //face
    noStroke();
    fill(210);
    ellipse(300, 220, 150, 150);

    //eye
    fill(50, 32, 32);
    ellipse(345, 220, 10, 10);

    //cheek
    fill(232, 200, 200);
    ellipse(330, 250, 35, 20);
   

    //nose
    fill(210);
    beginShape();
    curveVertex(350, 200);
    curveVertex(355, 190);
    curveVertex(375, 180);
    curveVertex(425, 130);
    curveVertex(420, 145);
    curveVertex(420, 175);
    curveVertex(400, 195);
    curveVertex(390, 220);
    curveVertex(365, 255);
    curveVertex(365, 260);
    endShape();

    fill(255, 255, 238);
    ellipse(450, 150, 10, 10);
    ellipse(470, 110, 10, 10);
    pop();

}

In this project, I try to depict the change from day to night. The background color, the sun and moon, the snow, and the elephant’s head all changes with mouseX. I also use map function to set limit for the change.

creyes1-LookingOutwards-05

Created in January 2017 by Sasha Vinogradova, Gods of Egypt is a print series that reimagines Egyptian gods as more contemporary characters. The figures themselves – Anubis, Hathor, and Horus, in order – are sculpted and rendered using Maxon Cinema 4D and Zbrush, then manipulated with photo editing software for the final print.

   

Anubis and Horus from Vinogradova’s “Gods of Egypt”

I’ve always been interested in mythology and ancient world religions, so to see them reimagined into something more modern while keeping the original context in mind is really admirable. Vinogradova achieves this with an incredible degree of photorealism that I initially thought this was straight photography and photomanipulation. It’s a really interesting and satisfying blend of mediums that Vinogradova includes here, with small graphical elements bringing out the quality of the sculpture.

This project along with Vinogradova’s other work can be found on both her website and Behance.

hyt-Looking-Outward-05: Nature and Algorithm

“Nature and Algorithm” is a 100-day consecutive project created by a multidisciplinary artist and programmer Liu Chang. Throughout the 100 days, she collected textural landscape photos and transformed them into dimensional, abstract productions through an algorithm she developed independently.

Day 035
Day 048
Day 012

What was drawn to me the most was her consistency with her choice of medium, as well as her juxtaposition between the original landscape images and computer-generated “landscapes” — the latter one especially intriguing, since the transformation was applied with similar color tone, shadows, and even pattern, but the image is no longer the same, and only functions as a representation of the image. I was also curious about why the artist describes the project as “a question to the relationship between nature and AI.” Unfortunately, she did not mention the softwares and algorithms used for this project, but relating to this comment, I think she is inquiring for a line between authenticity and artificiality, and how how we can incorporate learned AI into reality but still different from reality.

You could view more of her 100-day work here: http://www.liuchang.work/#/natureandalgorithm/

Jihee Kim_SectionD_Project-05 (Wallpaper)

jiheek1_project5

//Jihee Kim
//15-104 MWF 9:30
//jiheek1@andrew.cmu.edu
//project5 WallPaper
//section D

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

function draw() {

    background(0);
    // make a grid of colorful ellipses
    //draw small ellipses on top of grid to make crescent shapes
    //the position of smaller ellipses changes the orientation of the crescent
    //form a heart shape with the crescents in the middle of canvas
    //other black voids should look like fish
    drawGrid();

    // form crescents on left half of canvas
    // draw smaller circles that cover up bottom right of the bigger circles
    for (var y = 25; y < height+40; y += 40) { // offset center by 5
        for (var x = 25; x < width/2; x += 40) {
            fill (0);
            ellipse(x, y, 30, 30); // draw smaller circles
        }
    }
   // draw rectangles that look like eyes for the fish on left
    for (var y = 20; y < height+40; y += 40) { // offset center by 5
        for (var x = 20; x < width/2-40; x += 40) {
            fill (255);
            rect(x, y, 3, 3); // draw rectangles
        }
    }
    // form crescents on right half of canvas
    // draw smaller circles that cover up bottom left of the bigger circles
    for (var y = 25; y < height+40; y += 40) { //offset center by -5
        for (var x = width/2 + 15; x < width+40; x += 40) {
            fill (0);
            ellipse(x, y, 30, 30); // draw smaller circles
        }
    }
    // draw rectangles that look like eyes for the fish on right
    for (var y = 20; y < height+40; y += 40) { // offset center by 5
        for (var x = width/2 + 60; x < width; x += 40) {
            fill (255);
            rect(x, y, 3, 3); // draw rectangles
        }
    }

    // each heart is where fish lay eggs. draw arrays of dots
    // if needed divide up the line and treat the heart as item with two sides
    // arrays converge in the middle
    for (var y = 13; y < height + 30; y += 40) {
        // line 1 (left)
        for (var x = width/2 - 19; x < width/2 - 10; x += 6) {
            fill(255); //white dots
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 13; y < height + 30; y += 40) {
        // line 1 (right)
        for (var x = width/2 + 12; x < width/2 + 19; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 16; y < height + 30; y += 40) {
        // line 2 (left)
        for (var x = width/2 - 25; x < width/2 - 3; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 16; y < height + 30; y += 40) {
        // line 2 (right)
        for (var x = width/2 + 6; x < width/2 + 27; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 19; y < height + 30; y += 40) {
        // line 3 (left)
        for (var x = width/2 - 25; x < width/2 -1; x += 6) {
            fill(255); //white dots
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 19; y < height + 30; y += 40) {
        // line 3 (right)
        for (var x = width/2 + 6; x < width/2 + 26; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 22; y < height + 30; y += 40) {
        // line 4 (left)
        for (var x = width/2 - 24; x < width/2; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 22; y < height + 30; y += 40) {
        // line 4 (right)
        for (var x = width/2 + 5.5; x < width/2 + 26; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 25; y < height + 30; y += 40) {
        // line 5 (left)
        for (var x = width/2 - 29; x < width/2; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 25; y < height + 30; y += 40) {
        // line 5 (right)
        for (var x = width/2 + 4.5; x < width/2 + 31; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 28; y < height + 30; y += 40) {
        // line 6 (left)
        for (var x = width/2 - 28; x < width/2; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 28; y < height + 30; y += 40) {
        // line 6 (right)
        for (var x = width/2 + 3.5; x < width/2 + 32; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 31; y < height + 30; y += 40) {
        // line 7 (left)
        for (var x = width/2 - 26; x < width/2; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 31; y < height + 30; y += 40) {
        // line 7 (right)
        for (var x = width/2 + 2; x < width/2 + 29; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 34; y < height + 30; y += 40) {
        // line 8
        for (var x = width/2 - 24; x < width/2 + 26; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 37; y < height + 30; y += 40) {
        // line 9
        for (var x = width/2 - 21; x < width/2 + 24; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 40; y < height + 30; y += 40) {
        // line 10
        for (var x = width/2 - 12; x < width/2 + 17; x += 6) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 43; y < height + 30; y += 40) {
        // line 11
        for (var x = width/2 - 8; x < width/2 + 10; x += 5) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 46; y < height + 30; y += 40) {
        // line 12
        for (var x = width/2 - 4; x < width/2 + 7; x += 4) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 49; y < height + 30; y += 40) {
        // line 13
        for (var x = width/2 - 2; x < width/2 + 4; x += 4) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 52; y < height + 30; y += 40) {
        // line 14
        for (var x = width/2; x < width/2 + 2; x += 2) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    for (var y = 55; y < height + 30; y += 40) {
        // line 15
        for (var x = width/2; x < width/2 + 2; x += 2) {
            fill(255);
            ellipse(x, y, 1, 1);
        }
    }
    noLoop();
}

function drawGrid() {
    //cover canvas with grid of ellipses
    for (var y = 20; y < height+40; y += 40) {
        for (var x = 20; x < width + 40; x += 40) {
            fill(249 - x/2, 145, 145); // apply a color gradient to the circles
            ellipse(x, y, 40, 40);
        }
    }
}

For this project, I wanted to apply learned concepts and use grids and loops. Using the same shape(ellipses) at different scales and varying the position of them, I created a flowing pattern that takes advantage of both positive and negative spaces. I basically created crescents by using two different ellipses and by putting them in a grid, I made it so that the negative space( in black) would read as fish shapes and hearts. The heart-shaped spaces in the middle are filled with fish eggs!

sketches

Jihee Kim (Section D)– LookingOutwards-05

Danilton: The Brutal Deluxe is a computational art project that was created by visual artist, Daniel Brown. The project is basically a rendered image that was first based on some photographs that were manipulated with an algorithmic program that the author created himself. There is not much information on the specifics of this program that he made, but considering the known fact that he did not 3D model each building components, one can assume that he could have used a plug-in similar to Grasshopper.

end product

To generate the parasitic, massive buildings, Brown first plugged in random numbers to the program that produces the masses through fractal mathematics. He then searches for a particular area or geometries that he finds interesting within the randomly generated field, or 3D graph and adds to that particular shape. He basically gets the general from through algorithms and make the shapes even more complex and interesting by applying images of apartments from the 1970s and having the computer to generate infinite patterns, thereby creating a giant, maze-like cityscape that looks both retro and futuristic to a certain extent.

Brown has always been exploring with mathematical space before and after Danilton (2016), trying to create unlimited, boundless environments without constraints of physical building and modeling each component. The particular project and his other works clearly reflect his desire to use computational design as a means to discover and explore areas that were perhaps intangible. It is interesting how computer programs made something like creating a hyper-realistic image with tremendous amount of detail more plausible for artists.

More information on the project and other computational art by Daniel Brown can be found on his website:
Daniel Brown
More images are available here:
Daniel Brown Flickr

danakim-LookingOutwards-05

Insomnia; Tomasz Artur Bolek

Insomnia by Tomasz Artur Bolek, a 3D artist/ animator, is a typographic study where he externalizes his interest in urban structures. Bolek used 3D rendering and animation softwares, Blender and Keyshot, to articulate this typographic study.

I’m an architecture student so this project immediately caught my eye while I was looking through Behance. I found Bolek’s use of negative space to establish the shapes of the letters quite clever. I also like that he uses the lights shining through the windows as a way of creating contrast and making the letters pop. I admire the balance he was able to create between simplicity and detail.

Tomasz Artur Bolek; Insomnia

I, J, K, L; Tomasz Artur Bolek

ghou-lookingoutwards-05

Motion Graphics

like many teens in this generation, one way i discover graphics and trends are through social media. This week I chose to focus on an Instagram account that I’ve been following @motiongraphics_collective, this account collects 3D computer graphic works from other artists and posts them in short video form. This week I chose to check out a couple artists featured on this account.

@ef.social

This is a pretty new account based in Singapore. Their graphics mainly include complex shapes and a series of graphics that leads to forming/deforming it. I admire the geometries created by this artist and the simplicity in its generations.

 

@lvmtn

This artist is a freelance designer. [his portfolio] His work is very organic and have a natural characteristic.

it is very interesting “stalking” artists on social media because a lot of times the works are very raw. It is nice to see everyone’s individual aesthetic on their accounts.