The idea behind the project was to build a “tool” of some sorts to generate hodgepodge mash-up chair designs from mixing and matching pieces from prominent Contemporary and Modern furniture designs. My hope was to create a unique design from these pre-existing ones and to pair their parts in ways that may not usually be considered.
I used Dan Shiffman’s example of a genetic algorithm paired with user input from his book “Nature of Code” to make this project. The program stores different attributes about the parts as well as the parts themselves as genes, which are then carried over or phased out in the next generation depending on the “fitness” of the combination. (The fitness is the number displayed below each chair option.) There is also a mutation function to keep a bit of variety by adding varying degrees of randomness in the gene pool each time a new generation is produced. By pressing ‘s’ and image of the designs currently displayed on the screen can be saved in the project sketch folder.
There are a few things I would like to improve about the program such as having a more refined method of aligning the parts, more selective way to save the images, to push the bounds of what constitutes a chair and eventually, I would like to make some of the designs produced by the program.

I became interested in glass slumping when some friends became interested in architectural cast and slumped glass.

architectural slumped galss

Slumping is the process of heating glass and letting gravity pull it into a mold.  Friends are working on a mold with a reconfigurable floor which moves via servos.  Imagine a tile floor where each tile could raise to it’s own height.

One drawback to the process is that certain configurations push the glass beyond it’s physical limit.  Another is that to test a new configuration in the real world is expensive in electricity, glass, and time.  So a computer simulation is advantageous.  Software does exist to do this but it can prohibitively expensive.  I wanted to try building a cheap program that begins to simulate the effects of slumping glass.

Workflow:

my workflow

In the end, a real simulation software would be much more sophisticated but I think this proves the power of an extensible open source program to begin competing with the proprietary stuff that costs 10’s of thousands of dollars.

Pros:

• The sim allows you to control time.  That’s something you can’t get in a 15000 degree kiln.
• The sim is interactive.  While it is possible to manipulate glass in mid-process, it would be much easier in sim.
• Some details, like the stretching of the material are working well.
• It’s fun, and fast compared to the real world version which is largely trial and error and a lot of the time, a failure

Cons:

• I didn’t make the jump to 3d.  I will have to.
• As of now, it isn’t modeled on the mathematics of glass as a phase change material, but, oh well.

Demo:
[youtube https://www.youtube.com/watch?v=grTGPsiGhtw]

Code:

/*Simulation project for Golan Levin's I.A.C.D 2012
copywrite 2012 Zack Jacobson-Weaver...Uses ToxicLibs
extensively!  Toxiclibs.org
 
 Reset the whole show
 Increase the "heat" of the environment: excess of 
    15,000 deg F threatens catastrophic failure!
*/
 
import toxi.physics2d.constraints.*;
import toxi.physics2d.behaviors.*;
import toxi.physics2d.*;
 
import toxi.geom.*;
 
List  springs;
 
VisibleRectConstraint [] rects = new VisibleRectConstraint[20] ;
 
PFont font;
 
// number of particles for string
float STRING_RES = 80;
// number particles for ball
int BALL_RES=24;
// ball size
int BALL_RADIUS=60;
 
// squared snap distance for mouse selection
float SNAP_DIST = 20 * 20;
 
VerletPhysics2D physics;
VerletParticle2D selectedParticle;
 
float stn,rl;
int temp;
 
void setup() {
  size(680,480);
  springs = new ArrayList ();
  temp = 0;
  initPhysics();
 
}
 
void draw() {
  // 1st update
  physics.update();
  // then drawing
  background(255);
  // draw all springs
  for (int i=0; i 0) {
      VerletParticle2D q=physics.particles.get(i-1);
      VerletSpring2D s=new VerletSpring2D(p,q,delta*0.8,0.8);
      physics.addSpring(s);
      springs.add(s);
 
    }
  }
  // lock 1st & last particles
  physics.particles.get(0).lock();
  physics.particles.get(physics.particles.size()-1).lock();
 
for (int i =0; i < rects.length; i++){
  Rect R = new Rect(i*width/rects.length,random(height/4, height), width/rects.length,width/rects.length/2);
  VisibleRectConstraint r = new VisibleRectConstraint(R);
  VerletPhysics2D.addConstraintToAll(r,physics.particles);
  rects[i] = r;
  }
}

class VisibleRectConstraint extends RectConstraint {
 
  public VisibleRectConstraint(Rect r) {
    super(r);
  }
 
  public void draw() {
 
    stroke(184);
    strokeWeight(2);
    noFill();
    rect(rect.x, rect.y, rect.width, rect.height);
  }
}

Inspiration-

Early on I had the idea of creating an adventure generator. I wasn’t quite sure what that meant, I knew I wanted to create outdoor adventures to cool new places. Upon talking with my classmates I was reminded of the ‘old school’ text adventures. I was intrigued by the mystery of the interactions in these games and ended up playing quite a bit as “research”. I decided to pursue a modern twist on these games by incorporating location awareness through using an iphone and leading players on a physical adventure in addition to a fantastical & fictional one.

Method

I used a free app called “GPS Mail” as an “interface” for the game play. Ultimately I would have loved to create my own app, but I have never used xcode and it would have been impossible in the project scope. GPS Mail however let me send gps data from the iphone to an email address. I was also able to utilize a text entry field usually used for naming locations as an entry point for player actions/chooses.

I read the “emails” in processing using code based on an example by shiffman. *Shout out to Blase and Billy for helping me to figure out how to do this*

In my first real encounter with strings, I searched the emails for latitude/longtiude data and checked if a player enter an action or choice. This step proved to be more difficult that I would have imagined.

Once those functions were running, it was easy to send a response back to the phone through and email to the phone number.

The Story

Writing the story also proved to be a time consuming part of the process because of the many avenues and steps I wanted to include. Here is where I met a hurdle, because the GPS data did not function as accurately as I had hoped and I could not define areas as close as I wanted. (The results ranges in 16-213ft accuracy… yikes!)

I decided that I wanted players to adventure from the cfa steps to the amazon room at Phipps Conservatory. I rode around on my bike taking gps readings from my phone and recording them for later use.

In the end, I was unable to write and code the entire story (getting 2/3rds of the way through took VERY LONG) but I am proud that I was able to get it working as I had.

Reflections

Going forward I would love to finish the story and wrap the idea up in its own beautiful app bundle. Because of the hacking with GPS Mail the user experience is far from ultimate and I would enjoy working on this further to make it into a full functioning adventure app!

http://issuu.com/lucilaffitte/docs/text_adventure_presentation2?mode=window&backgroundColor=%23222222

I initially started the project with a desire to somehow generate actual 3D forms. Let’s just say that didn’t go so far… Anyways, I settled on satirizing my own field of study, design.

In a pretty straightforward process, I created essentially three gimmicky graphic elements: a grid of facets, a circle, and text. My intention was to trivialize the graphic system of creating ‘cool’ designy posters by assembling these three graphic elements at the click of a button. Indeed, it was a pretty superficial goal, but primarily I was unsatisfied with the state I left my last project and I really wanted to make something that looked good and worked (I guess it’s still a superficial goal, but hey).

I dove into experimenting with toxiclibs and the crazy amount of things people have done with the comprehensive library.

[vimeo https://vimeo.com/37573779]

[vimeo https://vimeo.com/37573778]

Second set of experimentation.

All in all, it was enjoyable to actually have an idea of what problems I needed to figure out and the methods to do so. I only wish I could have devised more relationships between the photos I grabbed and the resulting graphic poster. Then again, superficiality was my intention wasn’t it?

20th Century Urban Design Theory in a Nutshell

The 20th Century was a time of great experimentation and theorizing in the planning of towns and cities. Architects and planners were given massive amounts of control over the layout and design of cities and used this power to forward their ideals.

Garden City Movement – 1900’s

Began in the United Kingdom as a backlash to the smoggy, crowded state of cities during the industrial revolution. The idea was to have multiple self-sufficient cities encircled with “green belts” of open space. Cities would be linked by trains and arrayed around a central city.

Garden City Concept

Le Corbusier/ Modernism – 1920’s

Le Corbusier was one of the first architects to apply the aesthetics of Modernism to Urban Design. His Ville Contemporaine (Contemporary City) plan included demolishing a significant chunk of Paris to house 3 million people in blocks of 60 story cruciform skyscrapers. Le Corbusier took ideas from the Garden City Movement and imagined a future where the main form of transportation was the automobile. Although his plans were never realized, similar projects were erected in most major cities around the world.

Le Corbusier's Ville Contemporaine

sketch by Le Corbusier

Jane Jacobs – 1960’s

Jane Jacobs was not a trained urban planner or architect, but her book, The Death and Life of Great American Cities, significantly influenced urban design. She spoke out against the top-down, monolithic plans of Modernist urban planners and advocated pedestrian-centric, medium-rise, high-density, mixed-use neighborhoods such as Manhattan’s West Village where she lived. New Urbanism (the current fad in urban design) can be seen, in my opinion, as a sterilized realization of her ideals.

Parametric City Modeling

The goal of this project is to model three different versions of Pittsburgh that follow the rules of the three urban design theories outlined above. I used ESRI’s CityEngine software, which uses the CGA Shape Grammar language to control the modeling of streets and buildings. I first created a base map of Pittsburgh by obtaining a grey-scale elevation image and projecting this based on brightness. I then created a black and white obstacle map so that the program would know not to grow streets or buildings into the rivers. I wrote 3 CGA files that control how the streets and buildings are laid out, following logic that mimics the urban design theories I am analyzing. Pittsburgh’s hills were a challenge for CityEngine’s street growing tool but after tweaking the CGA code I managed to get a semi-realistic network.

Garden City Pittsburgh

Plan of Garden City Pittsburgh

Aerial view of Garden City Pittsburgh

Garden City Pittsburgh from Sam Lavery on Vimeo.

Le Corbusier Pittsburgh

Plan of Le Corbusier Pittsburgh

Aerial view of Le Corbusier Pittsburgh

Le Corbusier Pittsburgh from Sam Lavery on Vimeo.

Jacobs Pittsburgh

Plan of Jacobs Pittsburgh

Aerial view of Jacobs Pittsburgh

Jacobs Pittsburgh from Sam Lavery on Vimeo.

While this project wasn’t very coding intensive, I did learn a lot about parametric modeling. Just wrapping my brain around the dense CityEngine UI took a lot of time. I’m very happy to have learned the fundamentals of this software and I hope to use it in future projects. I hope this project teaches people a little about these three famous and infamous urban design theories. It is interesting to imagine what Pittsburgh could be today if any of these three design theories had completely taken over.

My proposed project for project 3 is a generative history of time. My software will generated a series of sentences proceeding from a certain origin, using a crawler that drifts between topics until it hits a dead end. This software will begin with the phrase “In the beginning there was” to initiate an internet search. A returned search term will determine the subject of this first sentence, and furthermore, be used to initiate another internet search that will determine another sentence, denoting the next step in history. Illuminating the free-associative nature of information on the web, this text will generate histories that proceed unbound by a linear progression of time and space.

I will be using python to generate this text. Currently I am working with Wikipedia to provide the source material for the text. My goal is to produce a printed book, where each page is a completely different history of the world.

For the Generative Art portion of the course, I had 2 project ideas that I was interested in working on. Realistically, given the time frame I’m thinking that the first one might be better.

Modelling orchid (or flower) petal (pigmentation) patterns.

This project idea is mainly inspired from work done by nervous system (link). I initially wanted to work on a project with some sort of 3d printing portion, just so I would get experience working on a project like that. I doubt I’ll be able to get to that. I also wanted to simulate something in nature. The generative portion could be different petals based on the algorithm. Also different petals have different patterns so one possibility is to have a combination of those in some way that evokes the same balance.

Some background research showed that flower pigmentation patterns have been simulated using reaction diffusion algorithms (so toxiclib’s simutils comes in handy here). However, just looking at an orchid you’ll notice a leaf/venation pattern, so my algorithm is likely to be a mix of these.

Although mapping these petal patterns on an actual orchid could be pretty, it seems pretty hard to do that mapping + color scheme. So I’m thinking of looking at 1 petal for now and then maybe applying it to something else: like jewelry/etc (I haven’t figured this part out yet).

The toxiclibs’ simutils library will be helpful.

Some more links about the biology of the patterns (for completeness):
Molecular bases of pigmentation in flowers
Some more on venation pigmentation patterns in the SnapDragon

Sacred Tiling & QuasiCrystals.

This was something I really wanted to work on but my idea is still quite unformed and I haven’t found a good library that I can leverage. The idea was to use Arabic tiling patterns that are well established and use that for some generative form. I grew up in the Middle East so saw these beautiful patterns everywhere. I also think there is potential for something generative in the mathematics behind these patterns. For example, they’ve been used to explain how quasicrystals could form (link to a good article & link to 2011’s Nobel Prize on the topic). Quasicrystals & these tiles are aperiodic: so they follow mathematical tiling rules but don’t repeat the same pattern over and over. They have also been mapped to Penrose tiles (so maybe something like this could be interesting).

Some potentially relevant links:
Symmetric Chaos
Space Filling in Penrose Tiles & Fractals
Penrose Tile Gallery
Tile Patterns

So right now this is an interesting tangent and I’m not sure where this would go. I find this interesting but I think this is definitely not something that can be done in this timeframe and I don’t see it being generative as it is. The tile patterns seem not random enough? But I am interested in libraries that could help or discussions.

GOD FEARING AMOEBA?
For my generative art piece I had the idea that if my code is generating an approximation of life it would make sense that the life-like forms generated would be in awe of the source of their creation. It would be beyond their understanding but they would worship it and be fearful of it. The mouse pointer would be their god, and the source code their holy manuscript.

I want to create a community of amoeba-like creatures that will worship the mouse pointer. I want the simulation of worship to be playful. It should include some kind of circular arrangement of the creatures along with swaying, dancing, and chanting. I think good sound will be key to the success of the project. I will attempt to generate the chanting by stringing together random phonemes. Other possible explorations include formation of holy sites, prophets (or spiritual leaders), and sacrifice.

For this generative project, I am inspired by ribbon generative art series. I love the texture and pattern of the ribbon series done by many different artists. Therefore, I would like to implement similar series using different texture such as 3D. My purpose of this project is to creating something flows continuously, algorithmically, and randomly. As the ribbon flows as time goes, I want it to become vanity.

Below are some projects on the ribbon series.

Likewise, I want my series to be animated in real-time. My biggest challenge is to create unique texture of the ribbon and to choose right pixels to implement beautiful/colorful ribbon image.

For my third project, I want to explore the relationship between landscapes, soundscapes, and digital media. I plan to take video taped scenes and use their soundscapes to dynamically generate patterns of digital, visual distortion. I want to use the subtle interruptions of nature – birdsongs, gusts of wind, twig snaps – as moments that cut through the visual serenity of the scene. With each of these sounds, another digital polygon will ripple to the image’s surface, threatening to mask our view of nature entirely. I’m thinking of it as a kind of virtual meditation. Yes, I know this sounds pretty asinine. Also, I’m not exactly sure how it will become a more fully ‘generative/morpho-synthesis’ project quite yet. As I pursue the idea, however, I’ll be sure to guide it in that direction as much as possible.

I was heavily inspired by Quayola’s Strata series. I’m fascinated by the juxtaposition between the real and the virtual that he is able to bring forward. These simple geometric ripples seem to take on a life of their own, like some kind of digital mold expanding onto the canvas.

These images from the same artist’s Bitscapes project are another strong influence on the project:

Last is Meno Akten’s recent video for the Wombats, “Techno Fan.” The gradual deconstruction from reality to an abstract digital realm is somehow incredibly captivating.

So far I’ve used OpenFrameworks with Kyle McDonald’s excellent ofxFFT addon. Next I will be searching for something to do Delaunay triangulation on my images, but those should be the only libraries this requires.