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

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.

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…

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

parametric variation of given frame (lateral walls) in given limits. each house becomes uniqe, escaping repetition. hints of emergence.

Basically the facades are independent from the core. Each lateral wall (calcan/blind wall) starts from an ideal shape that is subtly altered by a small script. This creates variation, as opposed to the usual repetition of a terraced housing lot. Mass production of 18 identical houses becomes mass production of 18 identical and UNIQUE houses. I would like to stress that: Mass production of 18 identical houses becomes mass production of 18 identical and, in the same time, UNIQUE houses.

There. Now I feel better.