Winning entry for DuPont + igloo’s Changing the Face – Casa Poporului. Idea sparked off with Raresh Dragoiu of drr_____ fame.

Jury was composed of:

prof. arh. Dorin Stefan (DSBA)

arh. Bruno Andresoiu (igloomedia)

Anne-Line Citrene (DuPont France)

Gabi Rottes (DuPont Germany)

Some pictures from the exhibition, which can be seen at the University Underground Passage until the 7th of December (09):

Recently we were allowed the use of computers at one of our one-day-long exams – so my school is finally living up to the attribute change in my about page – it used to be horrible, now it’s damp. A real improvement in life quality.

Here’s the outcome: judge it lightly since the overall design was conceived with a specific public in mind during a brief four hour period, including plotting.

Man, this post is definitively sarcastic. I’m working on improving that (as in downplaying the sarcastic note).

The assignment was loosely formulated so as to allow maximum freedom in identifying problems and needs in the Lipscani area and proposing an architectural (built) solution that would tackle the aforementioned points.

My vision concentrated on issues relating to the poor visibility/readability of the overall area (and the necessity of a landmark) and the lack of “free” public urban space. The functional program was mainly derived from the observation that most historic centers (Lipscani being a prime example in this) loose their initial cultural and traditional economic value in favor of the over-dominant bar/cafe. This leads to a certain repetition of fluxes (economic, cultural, pedestrian) which harms the respective area.

Geometry-wise, my proposal respects local aspects of the area, namely its porosity and the way the urban tissue coagulated around narrow winding streets and small interior courtyards in a constantly surprising lattice.

In respect to this approach, i considered the lot as a solid volume on which forces are applied in respect with the openings and general director lines of the site. Performing a “structural” analysis on the site revealed the patterns by which these forces would naturally flow towards given points of rest (namely the designated openings of the courtyards).   Using topological optimization techniques these patterns were transformed into geometry which was later subtracted from the original body thus giving the overall shape of the building.

By following this design method I ensure an optimal circulation flow through the built site, encouraging interaction and furthering the development of the local urban tissue in a manner very close to its characteristics (gained by spontaneous evolution) thus fully integrating the new implant.

That’s wrapper of the last month, give or take.

Call them what you will, but there’s been a huge hype about them some time ago.

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

Ion Mincu Architecture School, Bucharest:

collab with drr.

21 22

just a quick note so i don’t forget.

/sneak preview.

Definition file (.ghx).

Referenced assembly (.dll).

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

I have been (re)invited to teach at the upcoming Parametric Design Workshop that’s going to take place at the HTWK Leipzig.

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.

I’m on the speaker list at the Rule Based Design Symposium at the TU Berlin. Thank you Christophe for the invite!

(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

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.

How about 60 points for real-time 3d voronoi manipulation in grasshopper?

Here’s a screenshot:

This isn’t a scam. Stay tuned for more free voronoi PrOn (and other qhull-enabled goodies.)

(right click save target as)

Delaunay Triangulation in Rhino’s Grasshopper plugin.

It’s pretty straightforward. Just don’t input in the magic node duplicating points or everything will start blowing up.

First one to make it output the voronoi diagram wins a candybar.

Who’s interested can just grab a pdf file of the whole 91 page keynote here (quite a large file).

I talked about some projects I did (some together with Veronica Popescu) over the last two years, always insisting on the computational approach and detailing the techniques used.

I presented scripting approaches and more interactive (parametric) grasshopper based modeling. Some  Processing based approaches were presented and I insisted on the necessity of using multiple open tools that can be made to communicate between one another.

I tried to clearly mark out the relationship between fabrication and the overall design – how material properties and building techniques inform the design and viceversa.

Reactions were good, and it seems computational approaches are definetively stirring people up.

Thanks are required to Patrick Bedarf, who made this possible and is proving to be an excellent host in Leipzig, and also to prof.  Henning Rambow for all the support.

Also if you are reading this from Leipzig and are interested in joining us tommorow at 16.oo @ HTWK computer pool for some hands-on grasshopper work, there’s  no one stopping you.

Team project with Veronica Popescu.

Our solution proposed the creation of several interlinked interior and exterior courtyards that both encouraged interaction with the surrounding busy streets while at the same time offering an intimate place to retreat to. Various social and commercial functions requiring different visibility/exposure levels can occupy this space at ground floor level.

The space-partitioning algorithm we used (Voronoi), though a cliche, provided us with the ability to fill-out the space alloted for the project in a coherent, integrated manner without the urbanistic disruptions created by bar-type blocks (or modernist urbanism and its present refinements). Through the parametric approach used (see previous post) we were able to continualy search for the best solution (regarding geometry, overall&floor height/number of stories, surface areas, access at pedestrian level, acces towards the apartments) within a fluent design process. This allowed us to strictly respect the main given restrictions (POT, CUT, etc.) of the assignement while at the same time keeping and fostering the added benefits of continous and easy experimentation.

I get to speak on the 2nd of April there about parametric modelling and show off some projects. Suggestions are more than welcome.

This is just a prototype for our current school assignement involving collective housing (~80+ apartments + commercial and community spaces).

We are using the excellent space-partitioning properties of the Voronoi algorithm to create a lattice of interior and exterior courtyards that progressively make a transition from public space to semi-public, semi-private, and, in the end private space. This way we propose the creation of a coherent urban lattice encouraging interaction with the busy city outside while in the same time offering various degrees of protection/”cosiness”. We are not proposing a new type of urban tissue in itself, but merely adapting and reinterpreting some qualities of sponaneous developement and local tradition(“fundatura”) in a flexible (yet highly accurate) digital framework.

As I was saying at the begging of the post, this is just a technical showdown – everything you see rendered above is far from what the end product will probably be  (since also the way the assignement was formulated forms that evade from some general bar-variation are quite difficult to fit in the judging criteria). Yet it indeed demonstrates the versatility of parametric/generative architecture and the capabilities of the digital framework proposed to control and manipulate with accuracy all aspects of the project (from raw geometry and algorithm to technical: floor height, floor areas, built/unbuilt ratio, sun exposure and so on – the possibility to expand the definition to apartment level details is definitively there).

That above graphic  is a watered down version of the grasshopper definition (I will not release it under any license for now).

Here’s the latest school project, finished some time ago in early January. After pondering wether to reveal it or not (not that proud of it), I decided for the former in the end…

Again, out of popular requests during some time since the original was made, I have cleaned up the multiple attractors definition file. Included is also an example of attractors influencing the aperture openings of a given surface. The definition is now much more explained (exccesive use of post-it notes). Have fun, and download!

Download. ( 40kb .zip)

Out of popular demand, I have compiled a nice file detailing the possible uses of the Voronoi node, complete with the accompanying rhino file.

Download. (60 kb .zip)

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.

Download the definition.

(right click and save target as)

Some nice people over in Spain (Laboratorio de Arquitectura y Computación) have made a nifty video detailing on how to use the thing:

Source code of the Vornoi2D node.

Have fun, and drop a line if something isn’t working the way it should (take care to select the boundary points in order – clockwise or trigonometric – doesn’t really matter).

Latest school project:

(board 1)

(board 2)

(board 3)

{input}

The project required us to design an archeological center consisting of one conference room (75 seats), three workshop spaces and a bar/buffet [+ reception and service spaces]. Adjacent we will have to design a small hotel/pension, so our projects will have to be able to scale up formally (and function-wise).

{output}

My project is based on the act of cutting open the ground and inviting people and light inside pays tribute to a defining part of archeology “per se”: excavating sites in order to recover cultural remains and other artifacts in order to better understand mankind.

The overall form of the building emerges in a subtle way from the surrounding landscape, inviting its discovery in a less violent manner. Not choosing to mark its presence in a classical/standard way was a decision taken so as to echo the fact that archeology has the task of surveying areas in order to find new sites – information is never out in the open and its artefacts are hidden – at the same time not disrupting the surrounding beautifully curved landscape. 

The space inside curves gently around three interior courtyards, following the natural terrain. Luminaries assist the inerior courtyards both formally (composition-wise) and functionally (in providing natural sunlight).

{model}

3D Print and cardboard:

——

3d printing done on a  nice ZCorp 510 at Spot Desing – thanks for the flexible payment option and patience!

Boards printed at duostudio (Y!: studio.plot) inside the English passage – thanks for the longlasting quality, 15% early bird price cut and friendly staff

Also thanks to our assistant teacher (andra panait) which happily provided help and counseling during her private (spare) time.

Just a quick update on the workings of the latest project. Philosophy of the whole thing will come later/

UPDATED HERE!

Having some more haha with the previous grashopper sketch, this time working on curves.

This is intended in some sort of terrain manipulation for the ongoing project – too bad things started shaping like some sort of electrical field/strange attractor (it has nothing to do with the above, the similarity is purely formal).

Download the .ghx file here. (right click, save target as)

Also there’s a bug in the code – something’s not working right. Initial attractors seem to have much more power than the latter. Maybe someone that takes a fresh look over the code could point out my mistakes.

– LATER EDIT –

There seems to be also a little glitch in provding the code for curve_gen scripting node, so here it is (copy and paste it):

UPDATED HERE!

Multiple Attractors working in Rhino’s Grasshopper, all handled in a nice VBScript Component.

Works with quite anything (initially deisgned for surfaces).

Download the definition file.

Have fun with it. I still didn’t have the time to put this to a proper, nicely rendered use and it’s been almost a month now since it’s finished. Quite fustrating.

Back in school, Veronica and me hosted a big tryout of the waffle code advertised earlier (which is now used in Chile, San Fransisco and Bucharest – sorry i couldn’t help boasting).

The assembly of roughly 486 ribs into an alien-looking 1/500 terrain model generated quite a nice social event…

We still owe the laser cutter guys some obscene amount of money, but we hope to repay our studio’s debt asap.

First run:

Advances in Architectural Geometry – Conference proceeding + Poster abstracts (PDF, 80mb).

Have fun!

Some nice images:

Here’s the link to download the grasshopper .wrm file.

Thanks to Manuel, who took interest in the scripts posted earlier, we both put up some work and came up with a better result. 

English version.

Spanish version.

(they are the same)

The script works now with intersections in any direction (swithch from scale to extend line). Also handles somehow geometries that have holes inside and finnaly some little extra options added (you can choose to extend the split line or not, material thickness). 

Also, there is one think to keep in mind when using the scripts. You will sometimes get errors when using a too low absolute tolerance in Rhino. So go to Tools>Options>Units and set Absolute tolerance to 0.0000001 or something absurdly accurate.

Over time, a lot of my research into architecture and scripting/algorithms overlooked – due to the conditions present in my school and country- the ever-important fabrication side of things. It’s easy to get distracted, create nice shapes, and then completely forget that, hey, i have to build them!

As I’ve learned recently, the best approach (and, of course, the hardest) is to go both-ways. Material properties and construction tehniques inform the final product as much as algorithm, concept and anything else does. This is an emerging system, constantly exchanging information back and forth between each component of the design process.

I’m writing these banalities because i feel they need to be pushed up front a bit, especially in my school. Anyobdy can create blobs, what about being able to construct (not sculpt!) them, even at a 1:50 model scale? Thinking of fabrication expands your way of architectural creation not by adding a surplus of superficial constraints (like the over-empasis on concept and/or philosophy that’s highly praised here) but by adding real challanges that, as an architect, you will encounter not at a model 1:50 scale but at real-life 1:1 scale.

That’s why i’ve created a small tutorial-like presentation on how to laser-cut a surface.

• There’s a new nifty script to help you through all of this, which basically creates the joints for you.
  

  Download the rib script here.

• Also, i’m using an older script that would need some tweaking, but for the moment it does it what it’s supposed to : unrolling all given surfaces and numbering them in the process.
  

  Download the unroll script here.

• And then there’s the compiled .pdf with the baby steps.
  

  Download the .pdf here.

As always, if there’s any questions or curses, drop a line.

NOTE:

CutMyOwnRibs script updated.

Trying out Grasshopper:

Grasshopper brings to you real close to actual parametric architecture. I guess you’ll be better off reading the description over on the mcneel site.

Though the visual programming paradigm is a bit hard to grasp from the begining, you’ll be on your own quite soon. You’ll be flying if you’ve used PD, vvvv or max/msp before.

boring random surface, as seen on the cover of this book.

Here’s the script:

Option Explicit
‘Script written by Dimitrie Stefanescu
‘Script version 11 August 2008 16:47:28

Call Main()
Sub Main()

Randomize

Dim surf : surf = Rhino.getObject(“Sel plane”)
Dim detL : detL = Rhino.GetReal(“Detail level”, 20)
‘Dim attPt : attPt = Rhino.GetPoint(“get att point”)

Call Rhino.EnableRedraw(False)

Dim uDom, vDom, uStep, vStep

uDom = Rhino.SurfaceDomain(surf,0)
uStep = (uDom(1)-uDom(0)) / detL

vDom = Rhino.SurfaceDomain(surf,1)
vStep = (vDom(1)-vDom(0)) / detL

Dim i, j, pt

Dim arrPnts : arrPnts = Array()
Dim k,m : k = -1 : m = -1
Dim ptN, arrCrv : arrCrv = Array()
Dim range, distance

For i = uDom(0) To uDom(1) + uStep Step uStep
m = m + 1
ReDim Preserve arrCrv(m)
For j = vDom(0) To vDom(1) – vStep Step vStep

‘Rhino.Print(j)

k = k + 1
pt = Rhino.EvaluateSurface(surf,Array(i,j))

‘distance = Rhino.distance(pt, attPt)
‘range = distance * distance  / ( distance /3)
range = 0.0001 + j

ptN = Array(pt(0) + RandomNumber(-range, range), pt(1) + RandomNumber(-range, range), pt(2) + RandomNumber(-range, range))

ReDim Preserve arrPnts(k)
arrPnts(k) = ptN
Next
k = -1
arrCrv(m) = Rhino.AddInterpCurve(arrPnts)
Next

Call rhino.AddLoftSrf(arrCrv)

Call Rhino.EnableRedraw(True)
End Sub

Function RandomNumber(nMin, nMax)
RandomNumber = Null
If Not IsNumeric(nMin) Then Exit Function
If Not IsNumeric(nMax) Then Exit Function
If nMin >= nMax Then Exit Function
Randomize
RandomNumber = ((nMax – nMin + 1) * Rnd + nMin) / 50
End Function

I’m here, all’s well. I thought I might share the view from my apartment from alelulya:

(clikc for a bigger picture)

Now that we didn’t win anything (so it seems) I can publish this project. It was great working on it, though a bit stressful towards its final stages…

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.

The following workshop, during the dates below:

Thanks to a bunch of people (OAR, parental funds and Nemetschek Romania – if you want to expand the list – there are still a lot of expenses to be taken care of – drop a line).

Thanks also to Aleluya! Barcelona for providing special rates to eastern students…

I had some fun some time ago with plexiglass, a laser printer, rhino, and a very limited and buggy script that made “ribs” out of a surface.

The results were nice, so I decided to share:

Here’s the bugged up script (it’s quite useless, but people may find inspiration where I didn’t):

Option Explicit
‘

‘Script written by Dimitrie Stefanescu
‘Released under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
‘№ 5:28:35 AMW ednesday, May 21, 2008

Call Main()
Sub Main()

Dim surf : surf = Rhino.GetObject(“sel surf “, 8, True)

Dim detailLevel : detailLevel = Rhino.GetInteger(“det lev “, 10, 5, 50)
Dim matTh : matTh = Rhino.GetReal(“mat thickness “, .4, .1, 2)
Dim hght : hght = Rhino.GetReal(“rib height “, 1.5,  matTh, 10)

Dim uDomain : uDomain = Rhino.SurfaceDomain(surf, 0)
Dim uStep : uStep = (uDomain(1) – uDomain(0))/detailLevel

Dim vDomain : vDomain = Rhino.SurfaceDomain(surf, 1)
Dim vStep : vStep = (vDomain(1) – vDomain(0))/detailLevel

Call rhino.enableredraw(False)

Dim pts : pts = Array()
ReDim pts(detailLevel)

Dim i, j, k : k = -1
Dim rib

‘
‘U direction
‘

For i=uDomain(0) To uDomain(1) Step uStep
For j=vDomain(0) To vDomain(1) Step vStep
k = k + 1
ReDim Preserve pts(k)
pts(k) = Rhino.EvaluateSurface(surf, Array(i, j))
Next
rib = addRib(pts, matTh, hght)
k = -1
Next

‘
‘V direction
‘

‘k = -1
‘For j=uDomain(0) To uDomain(1) Step uStep
‘    For i=vDomain(0) To vDomain(1) Step vStep
‘        k = k + 1
‘        ReDim Preserve pts(k)
‘        pts(k) = Rhino.EvaluateSurface(surf, Array(i, j))
‘    Next
‘    rib = addRib(pts, matTh, hght)
‘    k = -1
‘Next

Call rhino.enableredraw(True)

End Sub

Function addRib(pts, matThickness, height)

Dim crv, crvPlane, norm, ppp, art, crvOff, arrCrvs, ribb, perpFrame, fff, dirV, extSurf

crv = Rhino.AddInterpCurve(pts)

crvPlane = Rhino.CurvePlane(crv)

If Not isArray(crvPlane) Then
Call rhino.print(“Surface not ribbable by this script. SORRY!”)
End If

norm = Rhino.CurveNormal(crv)
ppp = Rhino.AddPlaneSurface(crvPlane, 1, 1)
art = Rhino.SurfacePoints(ppp)

crvOff = Rhino.OffsetCurve(crv, art(1) , height , norm)
arrCrvs = Array(crv, crvOff(0))

ribb = Rhino.AddEdgeSrf(arrCrvs)

perpFrame = Rhino.CurvePerpFrame(crv, 0)
fff = Rhino.AddPlaneSurface(perpFrame, matThickness, matThickness)
art = Rhino.SurfacePoints(fff)
dirV = Rhino.AddLine(art(0), art(2))

extSurf = Rhino.ExtrudeSurface(ribb, dirV)

Call Rhino.DeleteObjects(Array(fff, ppp, dirV, ribb))

addRib = extSurf
End Function

As I promised, I hand out some of the scripts I’ve written in the course of the latest project.

Massive unroll Script:

Select as many surfaces as you like and then unroll each one of them.

Download it.

Adaptive fenestration script:

An interesting script that cuts holes in a surface based on the relation with a given attractor(point). I used it to generate a porous membrane for my latest project.

Download it.

Here are some other potentially super-bugged scripts:

Faceting. – Does the same as the adaptive fenestration script only it also “facets” the seed surface.

Ribs. – My attempt (quite sucesefull) at writing a honeycomb script.

home/house: an architectural organism

The house must not be seen as an opaque shell, but as an osmotic membrane.

The built environment intersects with the living environment.

Create a formal and functional interdependence between the architectural object (building) and the subjective object (home).

So you can see what porosity led to.

And here are some pictures of the model:

Balsa wood and plexiglass, nicely cut by CO2 laser.

First step of the project is here.

(1of2)

First set of drawings from a single-family home project for school.

Getting a grip on the surroundings:

After an initial study of the surroundings, several ways of tackling this project have been bouncing up and down in my head. I won’t go through all the urban analysis of the area, suffice to say that taking into account the general characteristics (building regulations, urban tissue, the relation between buildings and their respective lots) and specific characteristics (how much sun do I get and from where? how much privacy? what role does vegetation play?) I was able to identify some “core variables” around which I could start working.

The site is a corner site. This must be reflected in the construction.

I  can’t directly attack the corner due to the constraint pushed by the general characteristic mentioned above – the relation between buildings and their respective lots – they all are free-standing separate objects.

Sunlight. The south is blocked by high-rise (10 stories) buildings. I must get the most out of what reaches the site while still offering a decent level of privacy (imagine 20 apartments looking down into your house).

The program was a classical single-family home (living room, kitchen, dining, 3 bedrooms, study/library, garage). I also wanted to open up the spaces inside towards the garden and the trees (which act as a natural privacy shield) surrounding the lot.

Air must come in and then out (get as much natural ventilation as possible).

Porosity sprang to mind. What if I can create a living, adaptive porous block that acts as a retreat and yet still opens up to let in fresh air, sunlight, perspective and, most important, a family? I investigated a little bit of fractals, went through to fractal architecture and, most important early-on in the design process, (Steven Holl’s) porosity architecture.

Initial concept (working towards porosity): *note: this is not how the final project looks like. the img below is just a concept sketch.

So, all talk and no scripts? Wait, no!

More to come in the next post. I promise you adaptive (in relation to an attractor/point) porosity on a given surface and a massive unroll script.

Here’s a nifty script to create a menger sponge in Rhino:

Option Explicit

‘
‘Script written by Dimitrie Stefanescu
‘Released under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0
‘

Call sponge()

Sub sponge()
‘
‘Set var “menger” to 0 if you want just a plain divide
‘else if “menger” is 1 you will get a menger sponge
‘
Dim menger : menger = 1

Dim objs : objs = Rhino.GetObjects(“select cubes to divide:”, 16, True, True)
Dim obj
Dim scale : scale = 1/3

For Each obj In objs
Dim faces : faces = Rhino.ExplodePolysurfaces(obj)
Dim points : points = Rhino.SurfacePoints(faces(0))
Dim orig : orig = points(0)
Dim L : L = Rhino.Distance(points(0), points(1))
Dim ll : ll = L /3
Dim nobj : nobj = Rhino.ScaleObject(obj, orig, Array(scale, scale, scale))
Dim i, j, k
Dim loc

Call rhino.EnableRedraw(False)

For i = 0 To 2 Step 1
For j = 0 To 2 Step 1
For k = 0 To 2 Step 1
If menger = 1 Then
If Not((i=1 And j=1) Or (j=1 And k=1) Or (i=1 And k=1)) Then
loc = Array(orig(0) + ll * i, orig(1) + ll * j, orig(2) + ll * k)
Call Rhino.CopyObject(nobj, orig, loc)
End If
End If
Next

Next
Next

Call rhino.DeleteObjects(faces)
Next

Call rhino.EnableRedraw(True)

End Sub

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…

To have found someone in a 50km radius that is sharing the same interest in architecture. You can find him Here.

Things evolve:

Veronica and me (Dimitrie). This could have looked better, but alas, we had to make a 1m x 1.3m model in the same time.

How things are going on:

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.

 or swarm intelligence?

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.

SPRscrpts

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

Sorry for the huge delay.

RELEASED!

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).

Soon, superFormula for Rhino. Developing a plugin collection with SphHarmonics (previous post), SuperFormula and maybe superTorus…

See you soon,

D.

Wanna be more inventive than Liebeskind, Ghery or Zaha?

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