rkondrup-Looking Outwards-02

Alex Dragulescu developed a program which analyzes the content of spam emails and translates the variety of text patterns and keywords into three-dimensional architectural models which appear to have ‘grown’ from the base form of a cube. I particularly admire this project because it uses spam, something which is generally perceived as bothersome digital flotsam, and translates its contents into a work of digital art. The idea that words which are worthless in one form can produce very interesting meanings when passed through a particular algorithm is very exciting, and I feel that this project, as well as the columns made by the algorithms of Michael Hansmeyer, are both great examples of the potentialities that coding provides in the search for new spatial configurations. This sort of process of making something valuable from what many would consider digital ‘noise’ is a concept i would like to further explore, and I am also very intrigued by the idea that a known algorithm can produce unanticipated results which seem to mimic creativity. I think that the creative possibilities of this sort of programming is very promising and that it could change the way that designers work in the future.

NatalieKS-LookingOutwards-02

Created in 2002 by Jared Tarbell, Lola Brine, Corey Barton, and Wesley Venable, Moonlight is an interactive visualization of Beethoven’s No. 14 Sonata. As the audience member walked through the installation, colored blocks of varying opacity would display the sonata, allowing one to both see and hear the music being played. What I really admire about this project was not only the combination of computer generated colors and shapes, but also the fact that the user could modify these aspects of the installation as well. It really displays the power of computer science in art, as well as combing user experience and interactivity to create something truly musical. The creators had taken a MIDI file of the sonata, which was then compressed into an MP3 as well as converted in XML with the use of C++.  By using an actual recorded performance, the creator’s ensure that, although the installation itself was generated, the integrity of the intial performance was maintained.

 The first movement of the sonata, rendered into four sections.

The full sonata, displayed by using the varying degrees of opacity and color.

daphne-Section D-LookingOutwards 02

3D printing in a new way

Voxel Chair is a unique 3D printed design made by Manuel Jimenez Garcia and Gilles Retsin in 2017. 3D printing was introduced several years ago and have had many successes in creating specific objects; however, Garcia and Retsin took it one step up and tried to create a more intricate software that would allow them to further improve 3D printing itself. I really admire that the two of them together were able to pool together ideas to make more functional items out from 3D printing. If 3D printing starts from the beginning to the end, the recreated model of the new 3D robotic printer starts from the ending then slowly moves back to the beginning. By changing up the manner then process worked and by using robotic 3D printing, the two were able to vary their level of how dense and how intricate they wanted their designs to be based on the part of the chair they were working.

mecha-lookingoutwards-02

In July 2014, anonymous designer Strangethink created a video game exemplifying generative art in the form of a glitchy video game by the name of Error City Tourist.

Strangethink created Error City Tourist using Unity 3D as part of a “Glitch Jam” game design challenge, in which glitches are meant to be implemented in the gameplay and/or aesthetic of a game. What was most visually surprising to me about this game was its lack of consideration of the draw distance, as shown by the video above. Unlike most games that attempt to have objects in the distance fade in as they are generated, Error City Tourist does not attempt to hide this, adding to the glitchy appearance of the game.

This sparked his next project, Secret Habitat, a game in which the player is able to view generated art in a digital walk through gallery. Rather than being limited to visual art, the game includes both generated poetry and music.

 

Strangethink revealed that his fascination with procedurally-generated games came with his distaste of “heavily-stage managed” video games, or games in which the player is merely following a one-way path created by its designers. What I admire about both of these projects is its aesthetic consistency despite the nature of variables being generated.

alchan-Looking Outwards 02

Proteus is a video game developed by Ed Key, released in 2013. Players can wander around a colorful, pixelated, procedurally-generated island filled with plants, strange animals, and the occasional remnant of civilization. The game’s soundtrack, composed by David Kanaga, also changes depending on the time of day and where the player is standing. I couldn’t find too much about the algorithms behind the game, but from playing the game there’s a certain amount of features (such as plants, animals, or structures) that can be randomly generated around the island, depending on the island’s “season.” The island’s topography and weather also are randomly generated. All this works together to create a strange, peaceful space that’s different every time the player visits it.

Even though there’s not much gameplay in the “traditional” sense–all you can do is walk around, listen to music, and take screenshots of the places you encounter–and what gameplay there is is fairly limited, Proteus has a vague, dream-like feel to it that I really enjoy. I also admire the way Key has created a world with a specific feel to it, despite or perhaps working along with the purposefully low-resolution graphics.

Proteus by Ed Key and David Kanaga

Bettina-SectionC-Project-02-VariableFace

bettina-randomface-teal

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

//import math; 
/*head coordinates*/
var TLx=120; //top left x
var TLy=100; //top left y
var TRx=400; //top right x
var TRy=270; //top right y
var BRx=330; //bottom right x
var BRy=500; //bottom right y
var BLx=160; //bottom left x
var BLy=490; //bottom left y
/*eye coordinates*/
var LEx=110; //left eye x
var LEy=280; //left eye y
var REx=300; //right eye x
var REy=260; //right eye y
var eye=50
/*eyebrows*/
var high= 50; //how much higher than eyes
var BrowAngle=0; //angle of brows
var BrowThick=10;  //how thick brows
var lineStart= 60;//left starting x of brows
var lineLength= 30; //length of brows
var LBstart=60; //left brow start
var RBstart=275; //right brow start
var LBangle=0;
var RBangle=0
/*nose*/
var noseBLx=150;
var noseBLy=320;
var noseBRx=200;
var noseBRy=350;
var noseMx=180;
var noseMy=200;
/*mouth*/
var mouthTLx=150;
var mouthTLy=400;
var mouthWidth=100;
var mouthHeight=100;
var MouthRound=20;


function draw() { 
  background(255);
  strokeWeight(6);
/*face*/
  noFill();
  stroke(90,196,186); //teal
  beginShape();
    curveVertex(BRx,BRy);//ones on the ends are the "handles"
    curveVertex(BRx,BRy);//first point (bottom right)
    curveVertex(TRx,TRy);//top right
    curveVertex(TLx,TLy);//top left
    curveVertex(BLx,BLy);//bottom left
    curveVertex(BRx,BRy);//bottom right
    curveVertex(TRx,TRy);// last point (top right)
    curveVertex(TRx,TRy);//ones on the ends are the "handles"
  endShape();;
  
/*eyes*/
  stroke(119,117,224); //indigo
  ellipse(REx,REy,eye);//right eye
  ellipse(LEx,LEy,eye); //right eye
/*eyebrows*/
  strokeWeight(BrowThick);
  line(LBstart,LEy-high,LBstart+lineLength,(LEy-high)+LBangle); //left brow
  line(RBstart,REy-high,RBstart+lineLength,(REy-high)+RBangle); //right brow
/*nose*/
  strokeWeight(6);
  stroke(232,117,106);//red
  triangle(noseBLx,noseBLy,noseMx,noseMy,noseBRx,noseBRy);
/*mouth*/
  rect(mouthTLx,mouthTLy,mouthWidth,mouthHeight,MouthRound);

}

function mousePressed() {
/*face*/
  TLx=random(80,200);
  TLy=random(100,300);
  TRx=random(300,440);
  TRy=random(80,310);
  BLx=random(80,200);
  BRx=random(310,440);
/*eyes*/
  REx=random((TRx/2)+40,TRx);
  LEx=random(TLx,((TRx/2)-40));
  eye=random(10,45);
  REy=random(TLy,BLy);
  LEy=REy+random(-10,10);
/*eyebrows*/
  lineStart=random(-20,20);
  LBstart= (LEx-(eye/2)+lineStart);
  lineLength=random(30,80);
  BrowThick=random(6,14);
  RBstart=(REx-(eye/2)+lineStart);
/*nose*/
  noseBLx=random(LEx+20,LEx+((REx-LEx)/2));
  noseBRx=noseBLx+random(10,60);
  noseBLy=random(LEy+eye,BRy);
  noseBRy=noseBLy;
  noseMy=random((noseBLy-50),noseBLy);
  noseMx=random(noseBLx,noseBRx);
/*mouth*/
  mouthTLx=random(Math.max(TLx,BLx),(noseMx-20));
  mouthTLy=random((noseBLy+20),BLy);
  mouthWidth=random(20,150);
  mouthHeight=random(0,80);
  MouthRound=random(10,50);
  BrowCounter=3;
  LBangle=random(-30,31);
  RBangle=random(-30,31);
  }

I was inspired by Moka piece, which felt playful and childish. I wanted to challenge myself to create more organic lines as opposed to geometric ones I did for my first project. After a lot of math and quadrants, and bringing a bit of Math.min and Math.max, I was able to set enough rules for the randomization so the facial features were in believable positions.

I intended for each face to have the energy of children’s drawings, incorporating near primary colors for the lines. My concept was that generative art is not about creating a single perfect piece, but instead a system. Thus, while each face on it’s own seems laughable, I intended to present the outcome as patterns, showing the theme and variation throughout my system.

For the time being, I could not implement enough rules to draw all these faces in one program (my code was getting messy and I could not figure out how to put in conditionals), so I modified the program above to make the face outline different colors, add an additional curve vertex, as well as add an additional translated outline.

 

Bettina-Section C-LookingOutwards-02

Sample spread of the book

Conditional Design Workbook

This is a workbook created with Conditional Design studio. I admire it’s analogue interpretation of “programming” and generative art. Programming at it’s core is the logic and rules, whereas the syntax we learn is simply the language necessary to communicate the rules to a computer. Since these rules are communicated to people, there is freedom in how the information is presented, as well as opportunities for more organic, “hand-made” forms. I admire how inherently interactive the piece is; it reinforces my belief that interactive art forms are more palatable to a wider audience.

This system also relates to my design studies: our school head, Terry Irwin, asserts that to solve for “wicked”, or complex, problems, it is more effective to create rules for creation as opposed to simply creating a set number of things. In other words, it is creating a lasting system. Unlike set “things” rules for a system may outlast wear, as well as adapt to unpredictable conditions of an environment.

Looking Outwards: Jdbrown

Most of my interest in tech-based art centers around sound art and electro-acoustic performance. I’ve been really interested in the integration of performer movement (dance or instrument-playing, etc.) with the production of sound, and I’ve found “wearable instruments” especially intriguing.

Here is the website for one of the first instruments to catch my attention: a suit with cables, which are amplified through the bridge’s infrastructure to produce sound.

About

hannahk2- Project-01

sketch

//Hannah Kim
//Section A
//hannahk2@andrew.cmu.edu
//Project-01

function setup() {
    createCanvas(600, 600);
    background(0, 38, 74);
}

function draw() {
	//triangle top
	fill(0, 142, 214);
	stroke(0, 92, 153);
	strokeWeight(7);
	triangle(205, 176, 268, 237, 416, 322);

	//head curve
	fill(0, 142, 214);
	stroke(0, 92, 153);
	strokeWeight(7);
	triangle(224, 186, 259, 255, 293, 217);

	//head triangle
	fill(0, 142, 214);
	stroke(0, 92, 153);
	strokeWeight(7);
	triangle(212, 243, 161, 306, 239, 308);

	//hair top curve
	bezier(203, 180, 294, 177, 390, 231, 438, 300);

	//head
	fill(0, 142, 214);
	stroke(0, 92, 153);
	strokeWeight(7);
	ellipse(293, 308, 276, 176);

	//top quad cover
	fill(0, 142, 214);
	noStroke();
	quad(233, 196, 250, 297, 410, 378, 350, 222);

	//hair mid section quad
	fill(0, 142, 214);
	stroke(0, 92, 153);
	strokeWeight(7);
	quad(158, 293, 128, 426, 466, 463, 413, 322);


	//bottom hair curve
	fill(0, 142, 214);
	bezier(130, 403, 77, 457, 168, 467, 363, 447);

	//face
	fill(214, 219, 223);
	noStroke();
	ellipse(291, 375, 242, 185);

	//peak
	fill(214, 219, 223);
	noStroke();
	triangle(291, 271, 214, 343, 366, 331);

	//right eye
	fill(238, 249, 236);
	stroke(0, 38, 74);
	strokeWeight(5);
	ellipse(426, 377, 166, 150);

	//left eye
	fill(238, 249, 236);
	stroke(0, 38, 74);
	strokeWeight(5);
	ellipse(200, 366, 166, 150);

	//right pupil
	fill(0, 0, 0);
	stroke(0, 38, 74);
	strokeWeight(5);
	ellipse(434, 379, 91, 92);

	//left pupil
	fill(0, 0, 0);
	stroke(0, 38, 74);
	strokeWeight(5);
	ellipse(200, 379, 91, 92);

	//top lip
	fill(147, 221, 220)
	ellipse(330, 415, 64, 18);

	//bottom lip
	fill(45, 198, 214)
	ellipse(330, 435, 64, 16);






}

This project was very hard for me as it was one of my first times coding. I am kind of embarrassed with my results, and had a very difficult time forming some shapes such as curves and whatnot, but once I learn how to use the different shape functions better, I think i will be able to make more successful drawings.

monicah1- LookingOutwards-01

Generative Portrait made with processing by Diana Lange

Diana Lange Generative Portrait works started from taking photos of individual in context, to portrait outline created with small units, then adding on more and more units over and over. The portrait is created with multiple layers. The process reminded me of myself doing observational drawing with pencil. The small units with coding has this organic consistent texture. I am inspired by the generative portrait, having both the 2 dimensional sketching quality and the 3 dimensional depth at the same time. Moreover, they contain both organic and geometric systems.