I’ve got a huge interest in anthropic growth – namely growth enabled by humanity – and the rules behind its development. More importantly, we can now see a new materialist framework being contoured by philosophers like Manuel DeLanda together with Adrian Bejan and Constructal Theory, framework which encompasses both natural and anthropic growth and development under the same paradigm. The world is no longer split into Nature and Culture – Modernity’s dichotomy is being erased by rules and principles which guide both, making the distinction irrelevant.

Anyway, the main reason for this post is not to blabber about modernity and its dissolution (maybe that will come in the future in the writings section), but to share with you a processing implementation of RRT (Rapidly-exploring Random Trees) which is repurposed to grossly simulate growth through the perspective of Constructal Theory.

If you have a given surface (or volume) consisting of a population and the main goal of that population is to reach, or flow towards a specific point in the given surface, the most efficient structure, imposing the least flow resistance, is a dendritic one as shown in the video below.

In the case of a city (or the built environment), the main difference between it and a tree is that it does not have a single attractor, and flow is not linear in one direction. A city is composed of many attractors of different forces, each generating a different type of traffic flow which can be described as having different velocities, therefore requiring different flow resistances. For example, the average traveling speed in a medieval city was low, therefore the highly tortuous street network. As travel velocity increased, so the need for less flow resistance, which ultimately resulted in the Manhattan Grid. In this way you can differentiate between layers and layers of infrastructure. The video below shows how the networks of five different attractors merge with each other. Flow resistance is slowly decreased as the simulation progresses.

Finally, here’s a zipped processing sketch which contains a basic implementation of Constructal Theory generating infrastructure (based on this sketch). Of course, this can be enhanced further by limiting growth to certain angle variations and a host of other tricks which would more accurately simulate infrastructural growth. Each infrastructure type has different needs and limitations which can be transformed into parameters for this sketch.

You can play with an online version here!

Enjoy, and share alike. I am sharing out of goodwill, please do the same and do not abuse. Everything here is released under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Licence if not specified otherwise.

Recently I’ve tutored a Processing workshop for the Hyperbody department at the TU Delft. I’ve decided to share the sketches with the open world – who knows, maybe someone will find them useful. There’s quite a few variations included – clustering, attractors, collision avoidance, etc. Read below for the download link and some screens of some of the sketches.

2d and 3d clustering:

Swarms interacting:

Attractors and structures:

Collision avoidance:

Here’s a .zip file containing everything – including some Grasshopper sketches which allow for some basic interchange between Rhino and Processing via standard text files.

Here’s a movie of the thing in action (realtime):

Importing geometry (lines) from Rhino+GH into Processing, then switching back. Springs are rendered via a nifty hack, ie inverse proportional to the tension inside them. This corresponds to the most cluttered areas where particles get together more. The attraction force is good ‘ol newton’s law.

Of course, you can use it in 2d as well for any number of geometrical network relaxation uses you may find it useful for (street networks, for one, infrastructure at a more abstract scale, city planning, fancy urbanism projects, the like).

For the more architecturally inclined, here’s what happens when gravity enters the mix:

Nice, isn’t it? A nifty form-finding algorithm for a fancy support system of, well, any surface you please (I used a rectangle in example, a bit dull, but aren’t you fed up of double curvatures?). Here’s some screen grabs:

The structures presented here are self-normalizing, ie they reach an equilibrium at some point in the system. However, this is achieved via a delicate balance of quite a few parameters in the processing sketch: path resolution, spring strength and damping, world physics damping & min distance for the attraction force. I strongly recommend taking a look at traer’s physics lib documentation before starting to juggle the values (and to know where to look to juggle the values).

Enjoy & share alike!

Definition file (.ghx).

Referenced assembly (.dll).

Please note that the referenced assembly is based entirely on code from luvtechno.net.

Here it goes:

This project is a collaboration between Veronica and me.

Creation

The urban bacteria is a responsive structure that is not built; it grows following the path dictated by an algorithm that takes into account the geometry of the site as well as the available sunlight. It adapts to almost any given urban space, evolving into an organism fit for the conditions it encounters.
We created in processing (processing.org) an autonomous system that is emergent (it demonstrates an “internal will to reach coherence” – Cecil Balmond). It was used to compute the structure of the bacteria and simulate its growth in a variety of conditions.

Pulse

It has a life of its own. It pulses along with the variations in sunlight: when there’s a excess/high amount of sunlight available it increases its volume, regaining its initial form as a direct result of a decrease in available sunlight (caused by clouds, sunset). In its “expanded” form it offers more shadow to the pedestrian space below when it is most needed, increasing its quality and, therefore, inviting people to use it.

Daylight > nightlight; natural light > artificial light

During the day, the “urban bacteria” stores the excess energy resulted from sunlight and releases it during the night. The quality of an urban space is linked with the amount of light it receives during the night – this “living structure” proposes an ecological/economical way of transforming daylight into night light, sunlight into artificial light.

Materials

The membrane of the structure has a multiple role: absorb sunlight and create shadow during the day and release light during the night. We propose a multi-layered material consisting of two layers of polarizer sheets (in between which there’s another layer of cellophane) superimposed over a photovoltaic lattice that transforms sunlight into energy. The double layer of polarizing material creates an intense visual effect (by speculating small shifts in geometry and sunlight angle) that can be used to enrich the surrounding urban space.

“Urban bacteria” is an autonomous shape living in concordance with the rhythm of the environment.

Final boards:

This project was developed for the Velux IVA competition.

Scripts

RhinoScript and Processing

Process

Existing geometry in which the bacteria would evolve was constructed in Rhino and then custom-exported as simple rectangular planes in a specially built p55.in file. This would be custom-imported in Processing.

The growth algorithm was programmed in Processing. Running inside the imported geometry the bacteria would grow. The thus-grown (see above for details) structure would be custom-exported for Rhino.

Via RhinoScript, the “bacteria” would be imported and given a form via a custom script that took into consideration the time of day. Fin.

We started out on this by analyzing the area and its surroundings from the point of view of circulation (more on how we did this). How would people move around? The conclusions from this study where integrated later on in the project.

Next we took on the task of (re)creating the landscape – modify the terrain in a functional yet unobtrusive way. Formal concepts revolved around radiolaria, foam, water, waves etc. Luckily we had a working circle packing applet in processing ready (which was used for this). From here on, it was quite straightforward: expand the circles to smooth spherical caps and smartly transform them into urban furniture.

The interstitial space that remained between the”bubbles” is packed with wood alongside the routes we discovered to be ideal using the circulation study. The rest is English lawn pure green smartly-cut grass.

This project is a collaboration between Veronica and me.

Tools we used include:
Processing was VERY important early on in the design process – we used it for the circulation study as well as for the early circle packing experiments (size, density, spread etc).

Rhino and RhinoScript: RhinoScript is great – we used it extensively (create spherical caps based on the generating circle’s radius, expand circles, contract circles, import circles which the processing applet generated, etc.). Rhino was used for everything else – 3D modelling and, of course, making valid STL files for the 3D printer and also exporting the right things for the laser printer.

Laser cutting was done here (as always).

3D wax models were kindly made for us by mazarom (at the moment the only 3D printing service in Bucharest). If you need a complicated model, don’t hesitate to contact them!

Plotting the final presentation was done at studio spot. They don’t have a webiste…

Work done for the current school project by Veronica and me. This is just a snapshot, stay tuned for more. I’ve written 2 pretty interesting scripts for this one… so stay tuned.

Using processing to make a circulation study in a public area. It’s for the current school project. More details later.

I’ve used Shiffman‘s boids sketch as a start, and gradually started building up with some attractors, Point Obstacles (which are attractors with negative pull basically), and Linear Obstacles (which were a little bit tricky, but this helped out a lot). Also very inspirational were kokkugia‘s experiments.

When it’s nice and propper, I will  add some details and upload the code/sketch.

Ribbon effect obtained quite simple instead of i++ in the main for loop we now have i+=2 or i+=3

Windows application is here, Mac application is here. No sketch-in-a-browser for this one. The code is in the zip file.

Yep, and music credits – soma.fm presenting “Urchin” – not the 70′s band google’s throwing in its searches.

A nice way of using lookup tables – tribute to toxi.
No applet for this one, nor for the DLA fractals toy – this one uses sound, and it’s a big hassle getting the applet singed and then making opengl work properly in a browser; maybe in some distant future, i’ll export the apps and upload them. Code available on request – there’s not much to it, though
Oh, and exporting the video using Shiffman‘s moviemaker library.

Thank you and you for inspiration. Check those links out to see how real masters are doing it

Now everything’s smoother – esp. camera movement (the camera now aims towards the overall center of the flock).
The applet is here (does not work 100% since opengl in a browser isn’t that common. it surely won’t work if java 5 (1.5) is installed on your machine).
Applications are here (download the appropriate folder for your os).
Command list (ripped from the code):

void keyPressed() {
switch(key) {
case RETURN:
changeCenterAtRandomCode();
break;
case ‘e’:
evade = !evade;
didi.evade(evade);
break;
case ‘b’:
bgclr = color(0, 0, 0);
break;
case ‘w’:
bgclr = color(255, 255, 255);
break;
case ‘r’:
didi.lines();
break;
case ‘h’:
big = !big;
default:
break;
}

Later edit: zipped mac app here, inside the os folder. never thought of this.
Also, take care when using ‘e’ (evade key). press it twice.