foamy pictures

We have done two partial tests in the CNC, equivalent to a beer for each one. Tested both transparency and endmills, we now have explored some fundamental parameters for the further development of the moke-up model for our modular (modular-parametric, parametric-modular) cealing. The built models made us realize the importance of the lines drawn by the mill, considering the fact that the surfaces can be defined by curves. We will take this fact into account when wrapping up the final script.  The two tests show a certain tendency to carve too thin sections in unexpected areas of the model, where the material easily breaks so that we will need to fix the minimum thickness for a propper transparency effect to be achieved.

Initial Script

Script: initial state

Option Explicit
‘Script written by Adolfo Nadal, Ignacio Senra, Sergio Gomez
‘Script copyrighted by <insert company name>
‘Script version viernes, 07 de noviembre de 2008 11:26:37

Call Main()
Sub Main()
Dim i, j,k,l, strPt(),strtmpPt(),arrPt()
Dim Light, strLights, arrLights()
strLights = Rhino.GetObjects(“Lights”,1)
Dim thresholdDist
Dim testDist
Dim scalefactor

‘PROCESS INPUT POINTS SUCH AS LIGHT SOURCES
If IsNull (strLights) Then
Rhino.Print “light sources were required… creating n random sources”
Dim n : n = CInt(Ceil(arbitraryValue(1,4)))
Dim x,y,z
ReDim strLights(n-1)
ReDim arrLights(n-1)
For l = 0 To n-1
x = arbitraryValue(0,20)
y = arbitraryValue(0,13)
z = arbitraryValue(0,-2)
strLights(l)= Rhino.AddPoint(array(0.1*x,0.1*y,0.1*z))
arrLights(l)= array(0.1*x,0.1*y,0.1*z)
Next
Else
For k=0 To Ubound(strLights)
ReDim Preserve arrLights(k)
arrLights(k) = Rhino.PointCoordinates(strLights(k))
Next
End If

‘CREATE LAYERS
AddLayers
Rhino.ObjectLayer strLights,”Lights”
Rhino.EnableRedraw False

‘CREATE POINT GRID FOR CIRCLES
Rhino.CurrentLayer(“Points”)
Dim arrPlane, arrCircles(),arrtmpCircles(), arrCloseLight,dblLength
For i= 0 To 20
thresholdDist = 10
For j = 0 To 13
ReDim Preserve arrtmpPt(j)
arrtmpPt(j) = array(0.1*i,0.1*j,0)
For Each Light In arrLights
testDist = Rhino.Distance (arrtmpPt(j), Light)
If testDist < thresholdDist Then
thresholdDist = testDist
arrCloseLight = Light
End If
‘IF THE SCALE FACTOR IS LOCATED HERE, A MORE UNIFORM PATTERN OCCURS
’scalefactor = (1/(100*(dblLength)))
Next
dblLength = Rhino.Distance(arrCloseLight,arrtmpPt(j))
‘IF THE SCALE FACTOR HAPPENS TO BE CALCULATED HERE, MORE GRADUAL RESULTS WILL HAPEN
scalefactor = 2*(1/(100*(dblLength)))
If dblLength = thresholdDist Then
Rhino.Print “they are the same” & i & ” ” & j & ” “
End If
If dblLength = testDist Then
Rhino.Print “they are the same…2…” & i & ” ” & j & ” “
End If
arrPlane = Rhino.PlaneFromFrame(arrtmpPt(j),array(0.1*i+1,0.1*j,0),array(0.1*i,0.1*j+1,0))
ReDim Preserve arrtmpCircles(j) : arrtmpCircles(j)=Rhino.AddCircle(arrPlane,scalefactor)
Next
ReDim Preserve arrPt(i)
arrPt(i) = arrtmpPt
‘ReDim Preserve strPt(i)
’strPt(i) = Rhino.AddPoints(arrPt(i))
ReDim Preserve arrCircles(i)
arrCircles(i) = arrtmpCircles
Next

‘WE NEED TO CONVERT THE NESTED ARRAY arrCircles INTO A 1-DIMENSIONAL ARRAY
Dim counter, p, m, arrCirclesIntersection()
counter = 0
For p = 0 To Ubound(arrCircles)
For m = 0 To Ubound(arrCircles(l))
ReDim Preserve arrCirclesIntersection(counter)
arrCirclesIntersection(counter) = arrCircles(p)(m)
counter = counter +1
Next
Next

‘NOW WE CAN PASS THE DATA TO THE FUNCTION
MultipleDifferences arrCirclesIntersection

‘FINALIZE SCRIPT AND WRAP-UP
Rhino.CurrentLayer(“Script”)
Rhino.Print “Done”
Rhino.EnableRedraw True

End Sub

Function arbitraryValue(min, max)
Randomize
arbitraryValue = Int((max – min + 1) * Rnd + min)
End Function

Function AddLayers
If Not IsLayer(“Script”) Then
Rhino.AddLayer “Script”,RGB(0, 0, 0),True,False
End If

If Not IsLayer(“Lights”) Then
Rhino.AddLayer “Lights”,RGB(128, 0, 128),True,False,”Script”
Rhino.LayerLinetype “Polylines”, “Continuous”
End If

If Not IsLayer(“Points”) Then
Rhino.AddLayer “Points”,RGB(0, 0, 0),True,False,”Script”
Rhino.LayerLinetype “Polylines”, “Continuous”
End If
End Function

Function MultipleDifferences(strCrvs)

Rhino.Print “calculating intersection for ” & CStr(Ubound(strCrvs)^2) & ” curves. Please wait…”
Dim strCrv1, strCrv2, strCrvresult
Dim i, j
For i=0 To Ubound(strCrvs)
strCrv1=strCrvs(i)
For j=0 To Ubound(strCrvs)
strCrv2=strCrvs(j)
strCrvresult = Rhino.CurveBooleanDifference (strCrv1,strCrv2)
If Not IsNull(strCrvresult) Then
strCrv1 = strCrvresult(0)
‘ERASE ALL INBETWEEN STEPS IN THE CALCULATION OF SUCCESIVE DIFFERENCES
If j < Ubound(strCrvs) And i <> Ubound(strCrvs) Then
Rhino.HideObjects strCrvresult
Else
‘FOR THE LAST CURVE IT WORKS DIFFERENTLY
If i=Ubound(strCrvs) Then
If j<Ubound(strCrvs)-1 Then
Rhino.HideObjects strCrvresult
End If
End If
End If
End If
If j Mod 50 = 0 And i Mod 40= 0 And i>0 Then
Rhino.Print (i/Ubound(strCrvs)) & “% completed”
End If
Next
Rhino.EnableRedraw True
Rhino.EnableRedraw False
Next
Rhino.Print “completed”
Rhino.DeleteObjects strCrvs

End Function

Foamy…

Having taken into account different materials, fabrication techniques and extremely pragmatic programatic constraints, we will approach design from an exploration point of view. We will build a parametric modular cealing.

Lighting, aircon and sprinklers will be drivers for creating patterning densities and develop some especific conditions which could theoretically shift the project in many different directions, according to boundary conditions and/or local circumstances.

Foamy porosity, foamy lightness, foamy materiality, foamy performance… what else can you ask for?

Vase roots

Some vases: added compression circles

Initial idea... still to work

Option Explicit

Call Main()
Sub Main()
Dim i, j, k, n, v
Dim dblConv, arrPts(), arrPtsb(), circle, arrcircles(), strCrv
dblConv = 0.0174532925
Dim intLoop : intLoop = 10
ReDim dblRadius(intLoop)
Dim iterations : iterations = Rhino.GetInteger(“nr of iterations”,5)
If isNull (iterations) Then Exit Sub
Dim arrPlane

Rhino.EnableRedraw False

For v = 0 To iterations-1
For k = 0 To intLoop
dblRadius(k) = Rnd*10
If dblRadius(k) < 2 Then
dblRadius(k) = 2
End If
Next
For i = 0 To 36 Step 12
n=0
For j = 0 To intLoop
ReDim Preserve arrPts(j)
ReDim Preserve arrPtsb(j)
ReDim Preserve arrcircles(j)
arrPts(j) = (array(cos((i-n)*10*dblConv)*dblRadius(j)+50*v, (sin((i-n)*10*dblConv)*dblRadius(j))*-1, (j^1.2)*4))
arrPtsb(j) = (array(cos((i+n)*10*dblConv)*dblRadius(j)+50*v, (sin((i+n)*10*dblConv)*dblRadius(j))*-1, (j^1.2)*4))
arrPlane = PlaneFromPoints (array(50*v,0,(j^1.2)*4),array(1,0,(j^1.2)*4),array(0,1,(j^1.2)*4))
If j Mod 2 = 0 Then
arrcircles(j) = Rhino.AddCircle (arrPlane,dblRadius(j)+0.5)
Else
arrcircles(j) = Rhino.AddCircle (arrPlane,dblRadius(j)-0.5)
End If
n=n+1
Next

strCrv = Rhino.AddInterpCurve (arrPts)
Call Rhino.SelectObject (strCrv)
Call Rhino.Command (“pipe d 1 .25 enter enter”)
Call Rhino.unselectallobjects
Call Rhino.Deleteobject(strcrv)

For Each circle In arrcircles
Call Rhino.SelectObject (circle)
Call Rhino.Command (“pipe d .25 .25 enter enter”)
Call Rhino.unselectallobjects
Next

strCrv = Rhino.AddInterpCurve (arrPtsb)
Call Rhino.SelectObject (strCrv)
Call Rhino.Command (“pipe d 1 .25 enter enter”)
Call Rhino.unselectallobjects
Call Rhino.Deleteobject(strcrv)
Next
Next
Rhino.EnableRedraw True
End Sub

Project References

Five examples showing five different realizations of parametric walls (in fact, only half of them have been realized, the others can be considered as wishes or visions). We aim to create a fully operational mocke-up model of a parametric wall, whereby various conditions will be taken into account: relation to environmental conditions (the sooo long discussed and overused input) ,possible interactions with the user or users and functionality.

We have discussed several options to explore the materialization of the final product: while aiming for a reduced budget, optimization in results is a key point of the design. Foam, chipboard and other “quick and dirty” materials could be appropiate for these goals (either to build components themselves or to be applied onto them, operating as molds). Nevertheless we are open to explore several possibilities during future iterations throughout the process.