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!

We parametrically explored possible future configurations for the study area (450ha large, at the intersection of two main planned road-infrastructure extensions) and tried to push for a solution that would maximize performance (density, height, shading, access to natural elements and connectivity) of the whole region while leaving ample potential that allows for unplanned emergent evolution.

Our goal was to envision an urban tissue that could flexibly respond to all local input factors as well as accommodate desired (planned) goals. An universal 130m by 130m grid was proposed and then deformed to differentiate and create a unique lattice that allows for surprise and yet is easily mapped due to its inner space-partitioning algorithm.

We iteratively cycled through several circulation analysis (using Depthmap) and continuously changed the main axial map of the area to maximize integration.

The text on the boards is in romanian, sorry about that – hopefully the explanations given around the post should be enough. Here are the final boards, reduced:

It was great to work on this project, and also great to find recognition for an approach that is considered risky by our faculty’s standards   We used Rhino and its parametric plugin Grasshopper for the main work and Depthmap for the integration analysis.

Project teachers: Tiberiu Florescu, Sebastian Guta.

Grasshopper’s scripting capabilites are now a huge super cool feature, especially if you’re coding in visual studio (c#) and then pasting the shit or making dlls. I did this some time ago when i suddenly realized that you can declare your own static variables inside scripting nodes (and these guys hold up their values during the updating procedure). And the vector math is already there too.

This is an implementation based on Craig Reynolds‘s neurons, and a little bit on Daniel Shiffman’s processing example (which was updated and used some time ago for this.

Now, if somebody will be nice and implement some collision detection…

PS: I will upload the def. soonish (i have to clean it up a bit first). Ok i didn’t clean it up; here’s the link.

Here’s a new 10 day link: http://dl.transfer.ro/boidsT-Transfer_RO-16Nov-ad56f6.zip

Final link, stable and sound: http://improved.ro/Grasshopper/boidsTCAV.zip

The line-up includes:

Ioulietta Zindrou, Maite Bravo, Verena Volger, Luis Fraguada (of Barcelona/IAAC fame);
Yours truly Dimitrie (of Bucharest fame);
Henning Rambow, Patrik Bedarf (Leipzig crew);

I haven’t been that productive lately due to the many things happening all the time, but hopefully I’ll be able to get back on the research track in summer.

(27.05.09) The Symposium takes place at 18:00 in the Geodätenstand 6 O.G. TU Berlin Hauptgebäude, Straße des 17. Juni 135, 10623 Berlin.

The Rule Based Design Symposium highlights contemporary academic and practice based research employing CAD, CAM, Coding/Web tools in addressing & communicating architectural design intents & constraints. The research spectrum ranges from theory to the digital crafting of buildings and their components.

Organized by Christophe Barlieb.

Flexibility in thought and expression is vital to all creative fields. The power of a new generation of parametric and bespoke CAD tools lies in the ability to negotiate and communicating the design intent clearly. This streamlining saves time, materials while integrating architecture, engineering and fabrication over the course of the entire architectural design process.

The symposium features research works by young contemporary academics in the fields of mathematics, architecture and fabrication

Schedule:
Time Speaker Affiliation Theme
18:00 Gisela Baurmann TU Berlin RBD Opening Statements
18:05 Kristoffer Josefsson TU Berlin Mathematics in Architecture
18:25 Dimitrie Stefanescu U.Bucharest Scripting Architecture
18:45 Christophe Barlieb TU Berlin Integration of Engineering & Design
19:05 Norbert Palz CITA Rapid Prototyping in Architecture
19:25 Martin Tamke CITA Fabrication of Architecture
19:45 Baurmann, Barlieb, Pfeiffer TU Berlin Discussion with Speakers & Public
20:00 PARTY

Deprecated. Here’s the new version.

More as a scripting experiment, when i was mucking about trying to make the delaunay triangulation work in grasshopper i somehow found the wonderfully complex qhull library which i promptly set to push and pull to get it to work with grasshopper. As advised on their website, the best way to do it is to call it as an external program, which is exactly what i’ve done:  no files are written or read, no dos windows pop up, everything’s smooth.

Given that you don’t have many complex operations in grasshopper after the solution is generated, you’ll be able to handle quite an impressive amount of points (say 200 on my three-year old toplap) in real time. If you add the simple planarSrf operation, then say 60-70 and it gets sloppy.

What you’ll need to do to get things rolling:

0. Download the 3dvqhull definition and example file, and remember not to use it for commercial purposes, share-alike whatever you do with it and take the time to give the proper credits: 

1. Download qhull, and unzip it in a folder of your choice.

2. Get going and search for “System.dll”. What you’re interested in is the 2.0 version which you’ll usually find in here: “C:\WINDOWS\Microsoft.NET\Framework\v2.0.5[...]\”. If you can’t find it, I’m amazed grasshopper works for you. Anyway, you can find and install it from here.

3. Add the newly found System.dll version 2.o as a referenced assembly of the qhull component in the definition file.

If it turns orange, it’s cool.

4. Write in the panel that is linked to the “path” input the full path to the qhull program qvoronoi. You don’t need to add the .exe extension, but you can do it if you feel confortable.

5. There’s just one more thing you should know: facets that contain the infinite vertex are omitted altogether, without remorse. So as to have as little facets tending towards infinitum, I always add the corners of the points bounding box to the input sites.

You can scale the bounding box in respect with its center, or you can just call the whole thing off – it’s your choice.

I think this just about covers everything. Take care and have fun.

didi out.

PS: Qhull does more than voronoi. So if you have the time to explore and test, please do – the package is very powerfull and it can be used for more than this.

For those who really like to play with voronoi regions and stuff, here’s the final grasshopper definition file (right click, save target as – else you’ll get a ~250kb of useless xml in your browser window).

The vcell component outputs now individual cells as closed polylines and closed nurbs curves. This is useful if you are using this for some urban project like i am i would have liked to, mostly due to easy offsetting and area calculation possiblities – included in the definition file – or height extrusion – included as well. You can even go further and color (using shaders) each cell coresponding with its mass/area/height etc.

SPRscrpts

for Rhino is out now. Grab it while it’s fresh (and buggy).

Sorry for the huge delay.

SPRscrpts is coming (with documentation). It brings to your Rhino 4 SuperShapes, SphericalHarmonics, SuperTori and Shells. Below is an illustration of what it can do (that’s the shell script at work).

Well, you easily can.

The following will generate quite a few possible shapes, some of which will surely look better than this.

Option Explicit
‘Script written by didi stefanescu
‘Released under the Creative Commons Attribution-Noncommercial-Share Alike 3.0
‘http://creativecommons.org/licenses/by/3.0/legalcode

Dim arrVertices
Dim arrFaces

””””””””””””””””””””””””
”CHANGE THE RESOLUTION/DETAIL LEVEL BELOW    ”
”BUT BEAR IN MIND THAT 128 IS QUITE HIGH     ”
”SO IF YOU’RE ON A SLOWER COMPUTER YOU WOULD ”
”LIKE TO USE SOMETHING LIKE res = 64         ”
””””””””””””””””””””””””

Dim res : res = 128
Dim PI : PI = Rhino.Pi()
Dim du, dv

Dim m0, m1, m2, m3, m4, m5, m6, m7
Dim colors : colors = True
Dim MESH

Call Main()

Sub Main()

du = PI * 2 / res
dv = PI / res

Call initParams()
Rhino.EnableRedraw(False)

arrVertices = createVertices()
arrFaces = createFaces()

MESH = Rhino.AddMesh(arrVertices,arrFaces)

If(colors) Then
Call ColorMe(MESH)
End If

Rhino.EnableRedraw(True)
End Sub

””””””””””””””””””””””””
”CHANGE THESE PARAMETERS TO WHATEVER YOU LIKE”
”AS LONG AS THEY STAY INTEGERS               ”
””””””””””””””””””””””””

Function initParams()
m0 = 4 : m1 = 1 : m2 = 5 : m3 = 2
m4 = 2 : m5 = 1 : m6 = 4 : m7 = 5
End Function

Function createVertices()
Dim u, v, i, j
Dim k : k = -1
Dim arrVert()

For    i = 0 To res Step 1
u = i * du
For j = 0 To res Step 1
k = k + 1
v = j * dv
ReDim Preserve arrVert(k)
arrVert(k) = sphHarmonics(u, v)
Next
Next
createVertices = arrVert
End Function

Function createFaces()
Dim i, j
Dim k : k = -1
Dim base
Dim arrF()
For i = 0 To res – 1 Step 1
For j = 0 To res – 1 Step 1
k = k + 1

ReDim Preserve ArrF(k)
base = i * (res + 1) + j
arrF(k) = Array(base, base + 1, base + res + 2, base + res + 1)
Next
Next

createFaces = arrF

End Function

Function sphHarmonics(ByVal th, ByVal phi)

Dim r, x, y, z

r = sin(m0 * phi) ^ m1 + cos(m2 * th) ^ m3 + sin(m4 * phi) ^ m5 + cos(m6 * th) ^ m7

x = r * sin(phi) * cos(th)
y = r * cos(phi)
z = r * sin(phi) * sin(th)

sphHarmonics = Array(x, y, z)
End Function

Function colorMe(ByVal obj2Color)
Dim vert : vert = Rhino.MeshVertices(obj2Color)
Dim face : face = Rhino.MeshFaceVertices(obj2Color)
Dim color() : ReDim color(Ubound(vert))

Dim i, tempV

For i = 0 To Ubound(vert) Step 1
tempV = vert(i)
color(i) = RGB(abs(tempV(0)*200), abs(tempV(1)*200), abs(tempV(2)*100))
Next

Call Rhino.AddMesh(vert, face, , , color)
Call Rhino.DeleteObject(obj2Color)
End Function

Python (in Blender and NodeBox), RhinoScript/VBScript, Java/Processing, ActionScript, a little PHP (in highschool) and the allmighty C++. And, why not, I do dabble a bit in JavaScript.

And here’s what sphere harmonics done in processing exported in dxf imported in sketchup and rendered with this cool thing can do:

The project’s challenge was to transpose the notion of perfume in an architectural form. Wikipedia suggests many trails. Chevalier’s Dictionary of Symbols suggests some more. Balzac: “Tout parfum est une combinaison d’air et de lumiere.”; Hugo: “Le parfum est de la lumiere.”. Floral motifs, blobitecture, incense and religion, drugs – it was up to you to decide on how to visually speculate perfume.

I was fed up of the meanings and interpretations of perfume. Perfume nowadays is synthetic. Leave me be. Smell chemistry. You can’t contradict that.

I broke the visual representations of the chemical components of a standard perfume (chemical representations have very strict geometric rules – 120 deg angles, pentagons and hexagons) and got voronoi regions.

Ahhh, sweet metaphor of computational architecture. Isn’t it beautiful? Elegant? Yet it has nothing to do with architecture. Form is detached from function and we are approaching a similar crisis of that of modernism, when the exact opposite happened. People don’t find themselves included in such designs. Computation that strictly refers to form/ellegance alienates architecture from its goals. I don’t trust the starchitect theory as being the solution; it won’t last or it will split us into sculptors and engineers. 

(Please do read that article. It’s a must. It shows past (as in blobitecture and zaha), present(not the “so last year” deconstructivism or – worse even – post-modernism) and pushes through to the question posed by the future.)

Enough theoretical blabber. I’m giving all this computational business some thought. Code in architecture is nice, as long as it serves the people, not just ellegance. (Please do notice I didn’t use the term “function”. I prefer the much more accurate and revelatory word “people” = complex emergent system.)

Here are some pics of the model:

Programmed in Rhino. Finished in Sketchup. Model made in ManualManufacturyCAD(hand glued). Laser cutting here.