There are three different system(expel, attract and block) which there are 30 balls in each system:

In the first one, each of the ball in the system will randomly pick another one in the system and make attraction with it. Thus later the whole groups will move around. In the second one, the ball will do the same thing but in the opposite way(to expel the other ball).  In the third system, the ball will always go into the middle of two balls. They act like they are trying to block the sight of the other two balls. The idea comes from the Improvisational Acting class I took in the last semester. I remember that my teacher, Brenda Bakker Harger, asked us together into the center of the space and pick two people and try to form an equilateral triangle with the other two people. But the actor is not gonna let the other two people know who did the actor pick. So I am thinking it will be fun to let the balls to simulate the system. Also it just like how people behave in the society. They try to get away from somebody; they try to get close to somebody; they try to block the relationship of the others.etc.. It maybe interesting to add more behaviors to the balls.

For this program, I was using Processing with the physical system “TRAER.PHYSICS 3.0″.

It is very interesting to see the process of the movement and the stage when it gets stable.  Here are some of the screen shots.

[youtube=”https://www.youtube.com/watch?v=iXCVfmLTB4c”]

Inspiration 

For generative art project, I was heavily inspired by Anthony Mattox’s generative ribbon art.

My purpose of this project is to create something flows continuously, algorithmically, and randomly. As the pattern flows as time goes, I want it to become void. With this in mind, I designed a generative art that re-displays an image in a ribbon-like or smoke-like pattern in a way an image becomes void. So, I tried to implement an algorithm that breaks an image into smaller pixels and reads the pixels to generate unique smoke-like pattern.

Algorithms

I hacked Daniel Shiffman’s Explode() function to break an image into particles. Then, I stored each pixel of each particle, and drew random curves based on the pixel using infinite loop.

Screenshot

Final Outcome

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

Experiments/Examples

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

For my project, I decided to generate love songs. I started with a model – the song “Their Hearts Were Full of Spring” by The Four Freshmen:

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

Using the syllabic structure of this song, and using an aggregated database of love song lyrics, I created a program that synthesizes love songs.

Presentation

I used this generative assignment as a chance to execute an idea I’ve had on my mind for a year or so now: creating a photoshop plugin to do some physical simulations… physically. The plugin sends the image to another computer, displays it on the screen, generates a physical effect, snaps a photo, and sends it back. The three filters are ripples, perspective skew, and fog.

http://f.cl.ly/items/3C2b211H2O3E3u0o1O1N/composite.jpg

Inspiration

My goal with this project from the proposal: 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.

I spent the majority of my learning about the math behind these patterns and their relationship to quasicrystals (so potentially self similar patterns). I found a paper that describes a method to create self similar patterns. My current goal is to implement a parameterized version of that method, and then play with the parameters to see what happens. I can also use this as a library to combine to get other affects.

Specific notations: {10|3} for star polygons

Algorithms

Considered geomerative & point2D libraries but PVector was good enough. I’m not at that point yet, but I think I might be using L-systems further down the line.

Image from Paper

Screenshots

Look at slideshow.

References

The global long-range order of quasi-periodic patterns in Islamic architecture

Decagonal and Quasi-crystalline Tilings in Medieval Islamic Architecture

Tilings and Patterns

Moving forward

Interlace Patterns in Islamic & Moorish Art

Quasi-Crystals and Geometry

Specific directions forward: space filling algorithms (around the red stars), making it repeat at different levels, or making this 3d (link & link). This can then be used for for some sort of printing like here.

[vimeo https://vimeo.com/37591698 width=”600″]

So, full disclosure, I love particle systems. I think it’s one of the best/easiest ways to get generative organic flowy motion when coding. When I’m making art by hand, that’s generally my aesthetic, and I usually want it to carry over into my computational art as well. Of course with this sentiment also comes a total abuse of perlin noise, which accomplishes much of the same feeling with significantly less math/hard work. So for this project I wanted to code up a real physics system that wasn’t just based off of perlin noise/ flocking rules and hopefully get some different behaviors/motions. I decided to focus on magnetism, since magnetic particle paths also have a very curvy graceful motion.

So my initial sketch had user placed gravity wells, which are those really cute brightly colored drops. The user can click to place them, drag them around, and then right click to be rid of them. Unlike boids in the flocking algorithm, these particles have no behavior of their own, but are entirely controlled by these external forces. Unfortunately, the final result didn’t look that different from any other swarming/ perlin noise flock despite following  a completely different rules. However I did have this pretty powerful/adaptable system so I started exploring other ways I could create something useing the underlying interaction to power it.

My first instinct was just to create a delaunay triangulation and mesh it. However this was still kind of eeeeeh, though I did have fun working with the Toxiclibs color library to get a really nice palate. I’ve been in an illustration/comicy sort of kick lately. In my hand drawn work, I tends to cling to super ornamental patterns and really bright colors.

And as much as I love their effect, I hate drawing them! They are tedius and take a  ridiculously long time for an effect that is purely decorative. I’d love to have a tool where I could just get fast combinations of them in different arrangements on the fly that I could use for background effects, whether just for gutters or fillers on dresses and cloth, similar to this sketch here.

So I added repeller gravity wells where you could just drop in, for example, a comic panel or some other element that they system would then do its best to avoid.

And I started playing around with different texturing systems. I came across this idea rather late in the design process so I didn’t have time to hand watercolor the large swatches of pattern I would need to execute my above pattern, so I experimented just using various texture files from my graveyard folder for such things on my drive.

Introduction

I took the long route to get to this project. If you look at my proposal, you’ll see that I initially wanted to grow buildings in response to light. I still want to do that at some point. But as I started to explore the field of procedural generation and computational architecture, I soon ended up well beyond what I could accomplish in two weeks. After spending several days trying to figure out what I meant by “grow a building in response to light” and how I might actually do that, I decided it was time to re-evaluate.

There were three parts to my initial idea, and any one of them could have been the basis for a project. I decided that I was really interested in some combination of form generation and experience/emotion generation (the original seed of the building idea was the emotional response of being in a room that makes excellent use of natural light). Around the same time, I had also been reading about alternative playgrounds, and thought that some kind of algorithmic playground would be a fun thing to build.

But with time running short, playground equipment and landscapes had many of the same problems as generating buildings. So I started where I imagine many architects start: in their basement with a lot of cardboard boxes.

Box Fort

[vimeo https://vimeo.com/37590932 w=600&h=340]

Box Fort generates 2D layouts for cardboard box forts with the help of a genetic algorithm. The generated forts are tree-like, with long tubes branching into smaller passages. Every fort has a dedicated entrance box, and some have one or more additional entrances or exits. While the layouts are only drawn in two dimensions, care was taken to ensure optimal fort-itude if the layout was realized with actual boxes; gaps in the layouts should be covered by box flaps.

I admit up front that this is probably not the best use of genetic algorithms. In many ways, the problem is under-constrained and the algorithm has too much freedom. But I think the results are fun and interesting and surprising. And perhaps more importantly, it was a good place to experiment; complicated enough to be interesting, but simple enough to be achievable.

In the 2D layouts, the green dot is the starting box, the black dot is the desired start locations, any purple dots are additional entrances, and the blue lines overlaid on the boxed show orientation.

Technical Details

The most important technical aspect is probably how the genotype is designed. I ultimately decided on a mash-up the the directed graph Karl Sims used in Evolving Virtual Creatures and the “array-of-values” approach which Daniel Shiffman describes in The Nature of Code. There are actually four different representations of the fort in the program. First, is the Genome, which is an array of floating point values. The genome determines how to build the Tree form. This has the same topology as the actual fort, but without any geometric constraints. Finally, the tree form is parsed into FortGeometry, which is where fitness and validity are measured. It’s straightforward to draw the geometric form on the screen, giving the fourth representation.

The genome is designed so that early sections describe the parts of the fort near the entrance and later sections describe deeper branches. Forts are bred by crossing sections of the genome, although ten to twenty percent of each generation is produced asexually with mutation. Most of the images were produces with a population of 600 to 800 running for 250 to 400 generations. The fittest fort on the last generation is displayed.

As mentioned earlier, there are probably too few constraints to really take advantage of a genetic algorithm. Fitness is increased by total length and number of dead ends (good for hiding!) and decreased by number of boxes, distance from the desired starting point, and number of boxes outside the bounds. Because there are no geometric constraints on the genome, forts which self-intersect are common. These are automatically given zeros as a fitness score. As an aside, intersections are calculated using the Separable Axis Theorem, helpfully described here.

Future Work

As always, many things were not achieved within the deadline. These are some things I’d like to do later:

• Add a GUI for altering parameters in the system
• Spend more time tuning the genetic algorithm
• Add additional constrains, like desired exit locations or furniture to avoid
• Automatically turn the 2D layouts into 3D models
• Actually build on of the forts

Regardless of whether I work more with box forts, I really enjoyed working with genetic algorithms and generative form. I suspect that my final project will be a deeper exploration of these areas, perhaps with some interaction.

For this project, I wanted to explore flocking behavior. Rather than letting a screen mediate the interaction between observer and flocking behavior, I used a strand of 25 LED lights to create a physical embodiment of flocking behavior. Each individual light is mapped to one of 25 birds flying through simulated 3-D RGB space. Birds cannot overlap, yet they exhibit flocking behavior. As a result, all lights are always in the same color family, yet no two lights are ever the exact same color at a particular instance.

I used a Processing language version of Dan Shiffman’s 3-D Flocking Boids example that I edited to exhibit the flocking behavior I had in mind, in addition to a set of 25 lights that I bought from Adafruit. I used an Arduino to control the lights, adding my own control code on top of the demo code that Adafruit provides. I’m not sure I like how I mounted the lights in a straight line on a white background, but that was mostly to more clearly demonstrate the colors changing. In actuality, I would imagine these lights being attached to a wall or ceiling in a more interesting layout.

Process Overview

For Project 3 we were asked to generate form or simulate nature algorithmically. I thought about the ways that I create form in my daily life, most specifically about my love of cooking and fine cuisine. On a suggestion from Golan, I began playing with Markov Chain based text synthesis to create synthesized recipes.

I used what I consider to be the three seminal works of American cooking:
“Joy of Cooking” – Irma Rombauer
“Mastery of French Cooking” – Julia Child
“The Silver Palate” – Julee Russo and Sheila Lukins

I used some regex to clean out page numbers, chapter titles etc, then manually edited out things like ingredient lists and notes. (NOTE: This was not a short process). I played around with n-gram size (final setting: 3) and with seed phrase (final seed “Beat a tablespoon”) to generate the following book:

Final Product

Link goes to a preview of the cookbook, which I’m currently having printed

Cooking Walkthrough

Sole Fishburgers served with Puréed Mushrooms and Quiche:
Beat a tablespoon of minced fresh herbs such as parsley, chervil, chives, and tarragon into the eggs after they have been boiled makes a wholesome drink when cold, or a nourishing basis for a vegetable soup. To make a nice sweet in a few minutes. Take out the mushrooms, drain them, sprinkle them with grated cheesefor preference with Gruyère. On half the number of rounds place a bit of it in a mixing bowl until blended, then beat in the boiJjng liquid, pepper, and salt to taste. Boil, stirring, for 1 minute. Beat egg yolk and cream in a small bowl cheese. Bake for twenty minutes. Put on some water to boil. Take your lettuce, and choose the round kind, and wash it well. Take out neatly with your fingers the center leaves, and fill up with hot chopped mushrooms, that have been soaked and stewed to a purée. If you use an electric blender z1/2 lbs. sole or flounder fi• Poach the fish filets in any of the following sauces are made separately. After the hamburgers have been sauteed and removed from the shells before the dish is now ready for filling, as directed in pre­ceding paragraph 6 quarts rapidly boiling wa­ter for 4 to 6 hours, or until the flesh is tender when pierced with a toothpick. Bouchees, GaZettes, Baguettes

“Take out the mushrooms, drain them, sprinkle them with grated cheesefor preference with Gruyère.”
.

“Beat a tablespoon of minced fresh herbs such as parsley, chervil, chives, and tarragon into the eggs after they have been boiled…”
.

“Take your lettuce, and choose the round kind, and wash it well…”
.

“…fill up with hot chopped mushrooms, that have been soaked and stewed to a purée”
.

“Boil, stirring, for 1 minute. Beat egg yolk and cream in a small bowl cheese. Bake for twenty minutes.”

..

“z1/2 lbs. sole or flounder fi• Poach the fish filets in any of the following sauces are made separately.”
.

“Poach the fish filets in any of the following sauces are made separately. After the hamburgers have been sauteed”

.

.

“the dish is now ready for filling, as directed in pre­ceding paragraph”
.

.

Conclusions and Junk

I started this project out getting ready to make some horrifying things. Obviously, this looks pretty good. Last Thursday, I was convinced it was a problem. Now, I just think it just means that my hypothesis about cuisine not being able to come from a generator was wrong. What’s interesting to me is that I used all cookbooks that are of generally “high” quality as source text. It would be intriguing to repeat using some more everyday cookbooks.

I’d like to cook all or most of the recipes and add some more photos. I also think it would be interested to hand off some recipes to other food-oriented souls to see how they interpret them. I’m getting the cookbook printed from blurb (probably).

Generative Form with Verlet Physics and Toxiclibs

___________________________________________________________________________________

___________________________________________________________________________________

___________________________________________________________________________________

[vimeo https://vimeo.com/37585051 w=600&h=450]