Month: October 2017

rsp1-LookingOutwards-09

Hamza Qureshi Looking Outwards Week 8

I was very inspired by the Looking Outwards blog written by my peer Hamza Qureshi. Like Hamza, I am interested in the possibilities of design through user experiences and architecture, and found that this specific project exemplified just that. Artist Taeyoon Choi has skills in both the arts and computational coding, so he combines those skills to create something useful to all who come across his works. From Hamza’s blog post, Choi coins this term ‘poetic computation‘, in which it “allows an artist to intervene in a social space to use digital and computational tools to reorganize and reparametrize that space.”

Hacking IKEA

In his project, Choi makes a field recording while making noise with motors and microcontroller in the showroom, often interacting with the shoppers and the products on display. Since it is producing only harmlessly tiny noise, the symbolic importance is gained by paying attention to the noise created within the shop, and also the products, which will become a material noise in near future.

 

ikea_original_original
Choi at work

katieche looking outwards 09

dayoungl Looking Outwards -05

In her looking outwards, Sharon looked at the works of Columbian based artist, Daniel Aristizabal. I picked this looking outwards because I was shocked at the images were made from a computer program and not actually real. I love that the artist’s drive is to make mundane, everyday things look so surreal with the pop of contrasting colors, while at the same time maintaining the realism of the images. I also agree with the artist’s method of working: starting with pen and paper. I feel like the convenience of modern technology sometimes causes us to lock in on too many details before even having a desirable idea. I always became locked in on changing minute details in Photoshop or inDesign, and kind of got tunnel vision for hours, before realizing I wasn’t even that into the idea I was working on.

rgroves – Project09 – Portrait

sketch

var Will;

function preload() {
	var URL = "https://i.imgur.com/sdnZ6UU.jpg"
	Will = loadImage(URL);
}

function setup() {
    createCanvas(360, 480);
    background(120, 212, 204);
    Will.loadPixels();
    frameRate(3000);
}

function draw() {
	var px = random(0, width);
    var py = random(0, height);
    var ix = floor(px);
    var iy = floor(py);
    var color = Will.get(ix, iy);
    stroke(color);
    if (dist(px, py, 190, 320) < 10) { //centered at nose
    	line(px + 15, py + 15, 190, 320);
    } else {
    	line(lerp(190, px, .9), lerp(320, py, .9), px, py);
    }
}

For this project I used a picture of my friend Will. Because it’s a funny picture, I wanted to create a funny way to generate it. I decided to use lines that radiate out from his nose, which looks really big at this angle. I changed the background color after I took this screenshot, but this is what it looks like after you let it run for a while. I like how not only do the lines point to his nose, but they get longer as they get father away. It gives the picture a cool exploding effect.

This is photograph I used.

 

ikrsek-SectionC-Project-09

sketch

for this Project I experimented alot with the way that stroke were rendered by the program and how the user could interfere with that and in the end I decided on creating something slightly pixelated. I chose to have the program automatically render the photo in the form of  rectangles because of it’s interesting pixelated quality. I then decided to that the user’s stroke be rendered as empty ellipses so as to give the user the ability to make the image a little more interesting and the overlapping and intermixing of colors (without changing opacity) was something that struck me as rather pretty- the ellipses add a quality that I feel is reminiscent of rain drops on a body of water, or even just ripples across a small puddle.
I didn’t have a particular goal in mind at the beginning aside from encouraging the program to add a more painterly quality to images as it redrew them pixel by pixel

I feel the the top right and left corners as well as the bottom left corner look particularly watery in a good way.

Image with intervention from the user:

 

Here is what the image looks like without any interference:

katieche-project 09

katieche-09

var underlyingImage;

function preload() {
    var myImageURL = "https://i.imgur.com/bDkozta.jpg ";
    underlyingImage = loadImage(myImageURL);
}

function setup() {
    createCanvas(480, 480);
    background(0);
    underlyingImage.loadPixels();
    //frameRate(10);
}

function draw() {
    var px = random(width);
    var py = random(height);

    var w = random(0,20);
    var h = random(0,20);

    var ix = constrain(floor(px), 0, width);
    var iy = constrain(floor(py), 0, height);
    var theColorAtLocationXY = underlyingImage.get(ix, iy);

    noStroke();
    fill(theColorAtLocationXY);
    arc(px, py, w, h, PI+QUARTER_PI, TWO_PI);
    arc(px, py, w, h, PI+QUARTER_PI, TWO_PI);
    arc(px, py, w, h, PI+QUARTER_PI, TWO_PI);
    arc(px, py, w, h, PI+QUARTER_PI, TWO_PI);
    arc(px, py, w, h, PI+QUARTER_PI, TWO_PI);
    arc(px, py, w, h, PI+QUARTER_PI, TWO_PI);

    var theColorAtTheMouse = underlyingImage.get(mouseX, mouseY);
    fill(theColorAtTheMouse);
    noStroke();
    var z = random(0,80);
    var d = random(0, 10);
    ellipse(mouseX, mouseY, d,d);
    arc(pmouseX, pmouseY, w, h, PI+QUARTER_PI, TWO_PI);
}

My code creates lots of small arcs in random areas like scales. I was inspired by when you run your finger through scales and the sheen on them changes. The mouse also creates small ellipses like a brush, if you’d like to speed up the image creation process.

eeryan-LookingOutwards-09

I looked at what jwchou’s Looking Outwards assignment on generative art. He looked at the Postmodernist Art Generator by Don Relya, which took into account choices that artists make when creating art and used code to generate random postmodernist art instantaneously. With every iteration, the code is altered to take more factors into account. The last such iteration was in 2010.When responding to the piece, jwchou was interested in the artist’s statement where he said that while an artist’s actions can never be computationally reproduced completely, this parsed their actions, with constraints in order to create an algorithm for postmodernism.

I find this concept to be extremely interesting. The way it looks into the artistic process in an analytical way is very appealing to me, and I think presents an interesting counter argument to those who look down on modern and postmodern art as not being “real art” by presenting the complexity of the decisions that go into said art. I especially liked the final screenshot attached of the most recent iteration of the code, which I attached below.
Link to jwchou’s post

Link to artist’s website

PostModernist Generator, third iteration made in 2010

adev_LookingOutwards 09

jiaxinw-SectionB-LookingOutwards 04

Cloud Piano

I was looking through some of the posts and I found this one particularly intriguing. I am extremely drawn to the idea of the natural world represented through computational means in a very human way, that make these natural phenomena more present with us as humans. This is particularly striking because it provides a whole new sensory interaction with a natural phenomenon that is so elusive, so erratic and so notoriously mysterious.

I also really appreciate this because of it’s simplicity and innocence. It has truly been created from a place of curiosity and wonder and appreciation. I love that it takes this childhood fantasy and makes it accessible to us in a way that purely provides joy and pleasure.

It’s also really interesting that it sounds so beautiful and playful without sounding over-written or composed. It sounds like the most perfect string of serendipitous notes.

hqq – secE – LookingOutwards09

Rachel Park sure can look outwards. 

I’m really inspired by a project she found when researching in Week 7 called Digital Calligraffiti:

^Video trailer for the project

Calligraffiti isn’t necessarily new or groundbreaking – in fact, it’s become an important movement in the development of the underground organized abstract vandalism movement. However, in this project, the Public Art Lab did things a little differently. Digital Calligraffiti is a project that bands together refugees with visual and graphic designers to create art and computational visualizations to raise awareness of social justice issues.

The project acts as a canvas for refugees to express issues that they face in a universally noticeable medium. The installation took place throughout public spaces in Berlin in 2016 and served to help normalize the voices of refugees in a country whose influx of Syrian refugees proved to be a contentious point of debate to native Germans.

The project uses a computational derivation of a font scheme to allow refugees to partner with visual designers to create uniquely serifed and expressive works of art.

I’m inspired by pieces like this because it bands together designers with those whose voices are often silenced. These kinds of partnerships use computing for social good to help raise the perspectives of the underprivileged to the forefront of the public eye.

BrandonHyun-Project09

sketch

//Brandon Hyun
//Section B
//bhyun1@andrew.cmu.edu
//project09-PixelArt

var underlyingImage;

function preload() {
  //brings image from Imgur
    var ImageURL = "https://i.imgur.com/oSC8MC5.jpg";
    underlyingImage = loadImage(ImageURL);
}

function setup() {
    //creates canvas that fits the size of the picture
    createCanvas(778, 1219);
    background(0);
    underlyingImage.loadPixels();
    //draws the rectangles in certain speed
    frameRate(150);
}

function draw() {
    var px = random(width);
    var py = random(height);
    var ix = constrain(floor(px), 0, width-1);
    var iy = constrain(floor(py), 0, height-1);
    var theColorAtLocationXY = underlyingImage.get(ix, iy);

    noStroke();
    fill(theColorAtLocationXY);
    rect(px, py, 30, 70);



}

The portrait gets drawn onto the canvas is a rectangle that creates a mosaic of an image and the following image has the fast FrameRate that reveals the image quickly. I did not want the image to reveal so slowly since its hard for the viewers to view it. I also created the rectangles quite largely so the image can get revealed more quickly.

adev_Project09_Portrait

 

 

 

Project_09_adev

//Aisha Ghei Dev
//adev@andrew.cmu.edu
//Project-09
//Section E



var myPortrait;

function preload() {//loading baby photo
    var myPortraitURL = "https://i.imgur.com/GszICUU.jpg";
    myPortrait = loadImage(myPortraitURL);
}

function setup() {
    createCanvas(500, 500);
    background(0);
    myPortrait.loadPixels();
    frameRate(10);//low frame rate for faster processing.
    noStroke();
}

function draw() {
	//random position values
	var px = random(width);
    var py = random(height);
    var ix = constrain(floor(px), 0, width-1);
    var iy = constrain(floor(py), 0, height-1);
    //colour at specific pixel
    var theColorAtLocationXY = myPortrait.get(ix, iy);
 
    fill(theColorAtLocationXY);
    var sqDimensions = (random(10, 50));

    rect(px, py, sqDimensions/2, sqDimensions/2);
}

   
//Writing nickname
function mousePressed(){
	fill(255,0,0);
	textFont ("Georgia");
	textSize(28);
	text("$$$PAISHA", mouseX, mouseY);
}

For this project, I wanted to do something light and fun and kind of poke fun at myself. I chose this baby picture of me that I think is hilarious.

I played around with a few iterations of my code and I liked the one with the text the most because it makes is even more personal with a funny childhood nickname.