Inspired by the reading of AN EVOLUTIONARY ARCHITECTURE by John Frazer and the generative toolbox.

Structure generations based on John Orton Conway’s Game of Life.  The goal is to explore the emerging resulting patterns of the genetic algorithm whilst stacking all generations. The automation requires an initial finite array of cells and a maximum number of generations. Their initial state (life or death) is randomly assigned based on an arbitrary threshold. The script calls a recursive routine that decides the state of each cell (life or death) depending on the state of their neighbours (8 in total) at the end of each iteration. In order to best approximate an infinite game board, the automation wraps at the edges.

The stacking generates unexpected & elaborate patterns in xyz directions. The search for emergent behaviours is on.

The initial script has been developed in Python for Rhino5. This version is not optimized but presents a clear function split. The sumNeighbours function is inspired from an elegant solution by algorithmicdesign.net

Code:

import rhinoscriptsyntax as rs
import math
import random

def RandomGenesis(intGridi,intGridj):
arrPt=[]
for i in range(intGridi):
arrj=[]
for j in range(intGridj):
rnd = random.random()
if rnd>0.97:# density threshold for initial cells
arrj.append(1)
else:
arrj.append(0)
arrPt.append(arrj)
return arrPt # arrPt is a list of i no. lists _ each list contains j no. elements (1s or 0s)

def BrickCell(arrCtr):# BrickCell creates a square surface based on a centre point called arrCtr
arrBrickLowPt1=[(arrCtr[0]-0.5),(arrCtr[1]-0.5),arrCtr[2]]
arrBrickLowPt2=[(arrCtr[0]+0.5),(arrCtr[1]-0.5),arrCtr[2]]
arrBrickLowPt3=[(arrCtr[0]+0.5),(arrCtr[1]+0.5),arrCtr[2]]
arrBrickLowPt4=[(arrCtr[0]-0.5),(arrCtr[1]+0.5),arrCtr[2]]
arrBrickLowPoints = [arrBrickLowPt1,arrBrickLowPt2,arrBrickLowPt3,arrBrickLowPt4]
NewCell=rs.AddSrfPt(arrBrickLowPoints)
return NewCell

def ArrayCellMaker(arrPt,z): # calls BrickCell for each point in arrPt at z height
for i in range(len(arrPt)):
for j in range(len(arrPt[i])):
if arrPt[i][j]==1:
arrCtr=[i,j,z]
newCell=BrickCell(arrCtr)
return newCell
def SumNeighbours(arrPt,i,j): #sums neighbour cells values (cellN1 to >>> cellN8) starting from bottom left corner & anti clock-wise
iOneUp=i+1
iOneDown=i-1

jOneUp=j+1
jOneDown=j-1

if i==(len(arrPt)-1):iOneUp=0 #shifts missing neighbour cell at the begining of the grid’s i axis
if i==0:iOneDown=len(arrPt)-1 #shifts missing neighbour cell at the end of the grid’s i axis

if j==(len(arrPt[i])-1):jOneUp=0 #shifts missing neighbour cell at the begining of the grid’s j axis
if j==0:jOneDown=len(arrPt[i])-1 #shifts missing neighbour cell at the end of the grid’s j axis

cellN1=arrPt[iOneDown][jOneDown]
cellN2=arrPt[i][jOneDown]
cellN3=arrPt[iOneUp][jOneDown]
cellN4=arrPt[iOneUp][j]
cellN5=arrPt[iOneUp][jOneUp]
cellN6=arrPt[i][jOneUp]
cellN7=arrPt[iOneDown][jOneUp]
cellN8=arrPt[iOneDown][j]

SumNcells = cellN1+cellN2+cellN3+cellN4+cellN5+cellN6+cellN7+cellN8

return SumNcells

def MutateArray(arrPt):
newArrPt=arrPt
for i in range(len(arrPt)):
for j in range(len(arrPt[i])):
dblNumberOfMeighbours=SumNeighbours(arrPt,i,j)
if arrPt[i][j]==0:
if dblNumberOfMeighbours ==3:newArrPt[i][j]=1
if arrPt[i][j]==1:
if dblNumberOfMeighbours >3:newArrPt[i][j]=0
return newArrPt
def RecursiveGameOfLife(arrPt,Generation,intMaxGeneration):
if Generation>intMaxGeneration:return
ArrayCellMaker(arrPt,Generation)
newArrPt=MutateArray(arrPt)
RecursiveGameOfLife(newArrPt,Generation+1,intMaxGeneration)

def Main():
rs.EnableRedraw(False)

intGridi=rs.GetInteger(“number of cells in x direction”,70,5,80)
intGridj=rs.GetInteger(“number of cells in y direction”,70,5,80)
intMaxGeneration=rs.GetInteger(“number of generations”,30,10,150)
arrPt=RandomGenesis(intGridi,intGridj)
RecursiveGameOfLife(arrPt,0,intMaxGeneration)

rs.EnableRedraw(True)
return

Main()

The variety of forms in nature seems endless. Patterns can derive from mathematical rules. Habitats can derive from patterns. The pavilion is a temporary proposal for a historic hall. It reflects new built orders and hidden rules in contrast with those of its classical backdrop. Of course, a genetic algorithm is no guarantee of beauty but the outcomes can be striking. The matrix of self assembling timber cubes expresses the invisible forces of life and death that affect each brick… each of us.

CODE:
import rhinoscriptsyntax as rs
import random #import  random module

def SurfaceQuad():
    idSurface=rs.GetObject("Select Surface",8,True,False)
    if not idSurface:return
    intCountU = rs.GetInteger("Number of panels in U direction",20,10)
    if not intCountU:return
    intCountV = rs.GetInteger("Number of panels in V direction",7,5)
    if not intCountV:return
    uDomain=rs.SurfaceDomain(idSurface,0)
    vDomain=rs.SurfaceDomain(idSurface,1)
    uStep=uDomain[1] - uDomain[0]
    uStep=uStep / intCountU
    vStep=vDomain[1] - vDomain[0]
    vStep=vStep / intCountV

    #Tolerance in between panels
    dblTolU = uStep/100
    dblTolV = dblTolU*intCountU/intCountV

    rs.EnableRedraw(False)

    for v in rs.frange(vDomain[0],vDomain[1]-vStep-vDomain[0],vStep):
        for u in rs.frange (uDomain[0],uDomain[1]-uStep-uDomain[0],uStep):
            #Evaluate panel coordinates on idSurface

            ptA=rs.EvaluateSurface(idSurface,u+dblTolU,v+dblTolV)
            ptB=rs.EvaluateSurface(idSurface,u+uStep-dblTolU,v+dblTolV)
            ptC=rs.EvaluateSurface(idSurface,u+uStep-dblTolU,v+vStep-dblTolV)
            ptD=rs.EvaluateSurface(idSurface,u+dblTolU,v+vStep-dblTolV)

            #evaluate normal vectors at A,B,C,D on the surface
            vecNormA=rs.SurfaceNormal(idSurface,[u,v])
            vecNormB=rs.SurfaceNormal(idSurface,[u+uStep,v])
            vecNormC=rs.SurfaceNormal(idSurface,[u+uStep,v+vStep])
            vecNormD=rs.SurfaceNormal(idSurface,[u,v+vStep])

            #Side fixings projecting height
            #SurfaceNormal vectors are unitized by default_so we scale them according to the length of each panel
            dblPanelLength=rs.Distance(ptA,ptB)/10
            vecNormA=rs.VectorScale(vecNormA,dblPanelLength)
            vecNormB=rs.VectorScale(vecNormB,dblPanelLength)
            vecNormC=rs.VectorScale(vecNormC,dblPanelLength)
            vecNormD=rs.VectorScale(vecNormD,dblPanelLength)

            #Condition below prevent from adding a panel when surface is trimmed
            if rs.Distance(ptA,rs.BrepClosestPoint(idSurface,ptA)[0])< 0.1:
                strInfiniPlane=rs.PlaneFromPoints(ptA,ptB,ptD)
            if vecNormC:
                transPtC=rs.PointAdd(ptC,vecNormC)
                arrLine=[ptC,transPtC]
                interSecPtC=rs.LinePlaneIntersection(arrLine,strInfiniPlane)

            #Typical panel function call:
            PanelA(ptA,ptB,interSecPtC,ptD,vecNormA,vecNormB,vecNormC,vecNormD)

def PanelA(a,b,c,d,vecA,vecB,vecC,vecD):
        crv1=rs.AddLine(a,b)
        crv2=rs.AddLine(b,c)
        crv3=rs.AddLine(c,d)
        crv4=rs.AddLine(d,a)

        #Radius for filletted edges of panels
        dblRadius=rs.Distance(a,c)
        dblRadius=dblRadius/20

        #Filleted curves & curve endpoints
        crvFillet1=rs.AddFilletCurve(crv4,crv1,dblRadius)
        crvFilletPts1=rs.CurveFilletPoints(crv4,crv1,dblRadius)
        crvFillet2=rs.AddFilletCurve(crv1,crv2,dblRadius)
        crvFilletPts2=rs.CurveFilletPoints(crv1,crv2,dblRadius)
        crvFillet3=rs.AddFilletCurve(crv2,crv3,dblRadius)
        crvFilletPts3=rs.CurveFilletPoints(crv2,crv3,dblRadius)
        crvFillet4=rs.AddFilletCurve(crv3,crv4,dblRadius)
        crvFilletPts4=rs.CurveFilletPoints(crv3,crv4,dblRadius)

        #Panel nodes distribution and joining curve
        PtPane1=crvFilletPts1[1]
        PtPane2=crvFilletPts2[0]
        PtPane3=crvFilletPts2[1]
        PtPane4=crvFilletPts3[0]
        PtPane5=crvFilletPts3[1]
        PtPane6=crvFilletPts4[0]
        PtPane7=crvFilletPts4[1]
        PtPane8=crvFilletPts1[0]

        newCrv1=rs.AddCurve([PtPane1,PtPane2])
        newCrv2=rs.AddCurve([PtPane3,PtPane4])
        newCrv3=rs.AddCurve([PtPane5,PtPane6])
        newCrv4=rs.AddCurve([PtPane7,PtPane8])

        crvFace=rs.JoinCurves([crvFillet1,newCrv2,crvFillet2,newCrv3,crvFillet3,newCrv4,crvFillet4,newCrv1])

        #Side Fixing Plates
        NewPtPane1=rs.PointAdd(PtPane1,rs.VectorDivide((rs.VectorAdd(vecA,vecB)),2))
        NewPtPane2=rs.PointAdd(PtPane2,rs.VectorDivide((rs.VectorAdd(vecA,vecB)),2))
        NewPtPane3=rs.PointAdd(PtPane3,rs.VectorDivide((rs.VectorAdd(vecB,vecC)),2))
        NewPtPane4=rs.PointAdd(PtPane4,rs.VectorDivide((rs.VectorAdd(vecB,vecC)),2))
        NewPtPane5=rs.PointAdd(PtPane5,rs.VectorDivide((rs.VectorAdd(vecC,vecD)),2))
        NewPtPane6=rs.PointAdd(PtPane6,rs.VectorDivide((rs.VectorAdd(vecC,vecD)),2))
        NewPtPane7=rs.PointAdd(PtPane7,rs.VectorDivide((rs.VectorAdd(vecD,vecA)),2))
        NewPtPane8=rs.PointAdd(PtPane8,rs.VectorDivide((rs.VectorAdd(vecD,vecA)),2))

        Offnewcrv1=rs.AddCurve([NewPtPane1,NewPtPane2])
        Offnewcrv2=rs.AddCurve([NewPtPane3,NewPtPane4])
        Offnewcrv3=rs.AddCurve([NewPtPane5,NewPtPane6])
        Offnewcrv4=rs.AddCurve([NewPtPane7,NewPtPane8])

        arrDivOffCrv1=rs.DivideCurve(Offnewcrv1,5,False)
        ShortOffEdge1=rs.AddCurve((arrDivOffCrv1[2],arrDivOffCrv1[3]))

        arrDivOffCrv2=rs.DivideCurve(Offnewcrv2,5,False)
        ShortOffEdge2=rs.AddCurve((arrDivOffCrv2[2],arrDivOffCrv2[3]))

        arrDivOffCrv3=rs.DivideCurve(Offnewcrv3,5,False)
        ShortOffEdge3=rs.AddCurve((arrDivOffCrv3[2],arrDivOffCrv3[3]))

        arrDivOffCrv4=rs.DivideCurve(Offnewcrv4,5,False)
        ShortOffEdge4=rs.AddCurve((arrDivOffCrv4[2],arrDivOffCrv4[3]))

        arrSideFix1=[ShortOffEdge1,newCrv1]
        if arrSideFix1 is not None:
            SideFix1=rs.AddLoftSrf(arrSideFix1)
        arrSideFix2=[ShortOffEdge2,newCrv2]
        if arrSideFix2 is not None:
            SideFix2=rs.AddLoftSrf(arrSideFix2)
        arrSideFix3=[ShortOffEdge3,newCrv3]
        if arrSideFix3 is not None:
            SideFix3=rs.AddLoftSrf(arrSideFix3)
        arrSideFix4=[ShortOffEdge4,newCrv4]
        if arrSideFix4 is not None:
            SideFix4=rs.AddLoftSrf(arrSideFix4)

        #Panel base plate outline (with filletted corners)
        arrFace=rs.JoinCurves([crvFillet1,newCrv2,crvFillet2,newCrv3,crvFillet3,newCrv4,crvFillet4,newCrv1])

        #Petal pattern
        dblSwitch=random.random()#random number to generate random patterns
        strDiagonal=rs.AddCurve([a,c])
        arrPetalPtBase=rs.CurveMidPoint(strDiagonal)

        #Pattern threshold

        CrvPetalA=rs.AddCurve([arrPetalPtBase,PtPane1,PtPane8,arrPetalPtBase],3)
        CrvPetalB=rs.AddCurve([arrPetalPtBase,PtPane2,PtPane3,arrPetalPtBase],3)
        CrvPetalC=rs.AddCurve([arrPetalPtBase,PtPane4,PtPane5,arrPetalPtBase],3)
        CrvPetalD=rs.AddCurve([arrPetalPtBase,PtPane6,PtPane7,arrPetalPtBase],3)

        if dblSwitch > 0.7:
            rs.SelectObjects([arrFace,CrvPetalA,CrvPetalB,CrvPetalC,CrvPetalD])
            rs.Command ("_PlanarSrf")
            rs.Command ("_SelNone")
        else:
            rs.SelectObjects([arrFace,CrvPetalA])
            rs.Command ("_PlanarSrf")
            rs.Command ("_SelNone")

        #Brackets
        arrBracketBaseLinePt4=rs.DivideCurve(newCrv4,3)
        arrBracketBaseLinePt2=rs.DivideCurve(newCrv2,3)
        arrBracketBase1=rs.DivideCurve(rs.AddCurve([arrBracketBaseLinePt4[2],arrBracketBaseLinePt2[1]]),7)
        FoldBracket1=rs.AddSrfPt([arrBracketBase1[3],arrBracketBase1[4],arrDivOffCrv1[2],arrDivOffCrv1[3]])

        arrBracketBaseLinePt1=rs.DivideCurve(newCrv1,3)
        arrBracketBaseLinePt3=rs.DivideCurve(newCrv3,3)
        arrBracketBase2=rs.DivideCurve(rs.AddCurve([arrBracketBaseLinePt1[2],arrBracketBaseLinePt3[1]]),7)
        FoldBracket2=rs.AddSrfPt([arrBracketBase2[3],arrBracketBase2[4],arrDivOffCrv2[2],arrDivOffCrv2[3]])

        arrBracketBase3=rs.DivideCurve(rs.AddCurve([arrBracketBaseLinePt2[2],arrBracketBaseLinePt4[1]]),7)
        FoldBracket3=rs.AddSrfPt([arrBracketBase3[3],arrBracketBase3[4],arrDivOffCrv3[2],arrDivOffCrv3[3]])

        arrBracketBase4=rs.DivideCurve(rs.AddCurve([arrBracketBaseLinePt3[2],arrBracketBaseLinePt1[1]]),7)
        FoldBracket4=rs.AddSrfPt([arrBracketBase4[3],arrBracketBase4[4],arrDivOffCrv4[2],arrDivOffCrv4[3]])

        #Clean up
        rs.DeleteObjects([Offnewcrv1,Offnewcrv2,Offnewcrv3,Offnewcrv4,ShortOffEdge1,ShortOffEdge2,ShortOffEdge3,ShortOffEdge4])
        rs.DeleteObjects([crv1,crv2,crv3,crv4,newCrv1,newCrv2,newCrv3,newCrv4,crvFillet1,crvFillet2,crvFillet3,crvFillet4,strDiagonal])

SurfaceQuad()

SPECULATIVE MATERIALISM IN ARCHITECTURE

SYMPOSIUM / ROVINJ / CROATIA / 6-7 AUGUST// curated by Alisa Andrasek and Bruno Juricic

links: http://proto-e-co-logics.com and http://www.aaschool.ac.uk/STUDY/VISITING/rovinj.php

The symposium will tease out speculative directions for architecture that move beyond innocent and reductive approaches to ecology as in notions of “sustainability” and “green”. As Slavoj Zizek reminds us, the so called “balance of nature” is in itself a myth since catastrophes have always been an integral part of natural history. Rather than acting from a position of idealization with regards to nature, can we conceive of agency within a condition that isalready artificial, accepting noise and errors, embracing true face of complexity?

Recent tendencies in architecture take a unique point of view, with aesthetically novel and unnatural sensibilities emerging from a close scrutiny and study of apparently natural systems. These speculative tendencies are being driven by mathematical and computational abstractions that transform the way we understand the matter-information relationship. Instead of form being imprinted upon matter, matter is understood as an active agent in its own formation. It promotes dissolution of linear hierarchies, enabling heterogeneous and non-linear nature of complex agencies to hybridize and be incorporated into increasingly complex fabric of architecture. Under this accelerated convergence of matter-information, architecture can begin to speculate its own possible futures within denaturalized material ecology and conditions far from equilibrium.

Script developed to populate free-form surfaces with overlapping irregular panels otherwise known as ‘shingles’. Sculpture project for North Scotland by biomorphis.

during the course of my investigation of simplistic model ideas with large number of different outcomes, I found myself working on a circular stack of triangles which are defined by few simple parameters. each parameter was originally defined by the user (the coding was left within the script but deactivated), however, as I was going through different settings to get shapes which are very different from each other for testing purposes, I decided to fully randomise the script. I have settled for the boundary condition of 20 units randomly picked to speed up the process of the shape search. within a matter of several minutes I have generated some 30 random shapes which were eventually dubbed ‘spider evolution’. I’m now planning to expand the script or modify it for other purposes. the script is available for download.

.:script example:.

Option Explicit

‘Script written by shane gregoran

‘Script version 30 August 2010 00:20:56 updated 28 October 2010

Call p04TriangularSomethings()

Sub p04TriangularSomethings()

‘for this purpose all random numbers have been set to max of 20

‘Dim nPts : nPts = Rhino.GetReal(“how many segments”, 12)

Dim nPts : nPts = Floor(rnd*20)

If nPts < 3 Then

nPts = 3

End If

Dim cp : cp = Rhino.WorldXYPlane

cp(0)(2) = Floor(rnd*10)

‘Dim iR : iR = Rhino.GetReal(“length of short triangulation”,10)

Dim iR : iR = Floor(rnd*20)

If iR < 1 Then

iR = 1

End If

‘Dim R : R = Rhino.GetReal(“length of segments”,15)

Dim R : R = Floor(rnd*20)

If R < 1 Then

R = 1

End If

Dim iCirc, iLength, iPts

ReDim iPts(nPts)

iCirc = Rhino.AddCircle (cp,iR)

If Rhino.IsCurve(iCirc) Then

iLength = Rhino.CurveLength(iCirc)

End If

Dim i, S, iSc

For i = 0 To (nPts-1)

iSc = iLength/nPts

If i=0 Then

S=0

Else

S = iSc*i

End If

iPts(i) = Rhino.CurveArcLengthPoint(iCirc, S)

Next

Dim oCirc, oLength, oPts

ReDim oPts(nPts)

cp(0)(2) = Floor(rnd*10)

oCirc = Rhino.AddCircle (cp,R)

If Rhino.IsCurve(oCirc) Then

oLength = Rhino.CurveLength(oCirc)

End If

Dim outS, oSc

For i = 0 To (nPts-1)

oSc = oLength/nPts

If i=0 Then

outS=0

Else

outS = oSc*i

End If

oPts(i) = Rhino.CurveArcLengthPoint(oCirc, outS)

Next

‘Dim apxH : apxH = Rhino.GetReal(“height of apex guide curvature points”, 6)

Dim apxH : apxH = Floor(rnd*20)

Dim Origin, Direction, Normal, hPlane

Origin = array(0,0,apxH)

If IsArray(Origin) Then

Direction = array(0,0,apxH+1)

If IsArray(Direction) Then

Normal = VectorCreate(Direction, Origin)

Normal = VectorUnitize(Normal)

hPlane = Rhino.PlaneFromNormal(Origin, Normal)

End If

End If

‘Dim apxR : apxR = Rhino.GetReal(“distance of apex point from base”, 5)

Dim apxR : apxR = Floor(rnd*20)

If apxR < 1 Then

apxR = 1

End If

Dim hCirc, hLength, hPts

ReDim hPts(nPts-1)

hCirc = Rhino.AddCircle (hPlane,apxR)

If Rhino.IsCurve(hCirc) Then

hLength = Rhino.CurveLength(hCirc)

End If

Dim hS, hSc

For i = 0 To (nPts-1)

hSc = hLength/nPts

If i=0 Then

hS=hSc/2

Else

hS = (hSc/2)+(hSc*i)

End If

hPts(i) = Rhino.CurveArcLengthPoint(hCirc, hS)

Next

Dim wo : wo = array (0,0,(apxH/2))

Dim crvInnerPTS, crvOutterPTS, crvInnerPTSstring, crvOutterPTSstring

ReDim crvOutterPTS(nPts-1), crvInnerPTS(nPts-1), crvInnerPTSstring(nPts-1), crvOutterPTSstring(nPts-1)

For i = 0 To (nPts-1)

crvOutterPTS(i) = array(wo, hPts(i), oPts(i))

crvOutterPTSstring(i) = Rhino.AddCurve (crvOutterPTS(i))

Next

For i = 0 To (nPts-1)

If i = 0 Then

crvInnerPTS(i) = array(wo, hPts(nPts-2), iPts(i))

Else

If i = 1 Then

crvInnerPTS(i) = array(wo, hPts(nPts-1), iPts(i))

Else

crvInnerPTS(i) = array(wo, hPts(i-2), iPts(i))

End If

End If

crvInnerPTSstring(i) = Rhino.AddCurve (crvInnerPTS(i))

Next

Dim capCurve, capCurveString

ReDim capCurve(nPts-1), capCurveString(nPts-1)

For i = 0 To (nPts-1)

If i = (nPts-1) Then

capCurve(i) = array(oPts(i), hPts(i), iPts(1))

Else

If i = (nPts-2) Then

capCurve(i) = array(oPts(i), hPts(i), iPts(0))

Else

capCurve(i) = array(oPts(i),hPts(i), iPts(i+2))

End If

End If

capCurveString(i) = Rhino.AddCurve (capCurve(i))

Next

Dim LoftA, rr, LoftB, SurfA, rrr

ReDim LoftA(nPts-1), LoftB(nPts-1), SurfA(nPts-1)

For rr = 0 To nPts-1

If rr = nPts-2 Then

rrr = 0

Else

If rr = nPts-1 Then

rrr = 1

Else

rrr = rr + 2

End If

End If

LoftA(rr) = Array(crvOutterPTSstring(rr), crvInnerPTSstring(rrr), capCurveString(rr))

rhino.DeleteObject iCirc

rhino.DeleteObject oCirc

rhino.DeleteObject hCirc

Rhino.AddEdgeSrf LoftA(rr)

Next

End Sub

Organized by Politecnico di Milano and friends from Co-de-iT .  One of the most interesting events for 2011 in Italy on advanced construction,  with some great people lecturing.

Gfield script is an attempt to visualize the units of space-time as they are distorted by a gravity type field. given that each ‘cube’ represents a unit of space-time, greatly enlarged for this purpose, the distortions of each said unit will continue until the geometry can no longer represent a ‘cube’ type space, at which point the ‘cube’ will vanish. at a later time I plan to add additions to the script to uphold a change in geometry from a standard eight point geometric shape to one that can support seven or less points as well as adding mass value which will increase the strength of field generated by the attractor point for each unit of space-time that has collapsed onto the attractor point. the following video is a top view of the change in the quantity of space-time units and how they are distorted over time.

I will, given time, make another ‘perspective view’ video to further represent the three dimensionality of the changes taking place. script is available for download.

.: script example:.

Option Explicit
‘Script written by shane gregoran
‘Script version 06 May 2010 18:31:30 updated 21 October 2010

Call SpaceDistortionAttractor()
Sub SpaceDistortionAttractor()
‘first we create our playground
Dim Area : Area = Rhino.GetInteger(“Area covered”,10)
If IsNull(Area) Then Exit Sub
Dim side : side = Rhino.GetReal(“Distance between points”,0.5)
If IsNull(side) Then Exit Sub
Dim Gforce1 : Gforce1 = Rhino.GetReal(“Strength of the field (higher number yields bigger projection)”, 0.1)
If IsNull(Gforce1) Then Exit Sub
Dim PtNumber : PtNumber = Area^3 – 1
Dim x : x = 0
Dim y : y = 0
Dim z : z = 0
Dim m1 : m1 = 1
Dim m2 : m2 = 1

Dim Sphere, boxID
Dim AttPt, AttPx, AttPy, AttPz
AttPx = (Area*side)/2
AttPy = (Area*side)/2
AttPz = (Area*side)/2
AttPt = Array(AttPx,AttPy,AttPz)
‘Sphere = Rhino.AddSphere (AttPt,2)
‘Rhino.ObjectColor Sphere,RGB(255,0,0)

Dim Box, i, j, k
Dim T : T = -1
Dim A, B, C, D, E, F, G, H
ReDim Box(PtNumber), A(PtNumber), B(PtNumber), C(PtNumber), D(PtNumber), E(PtNumber), F(PtNumber), G(PtNumber), H(PtNumber)

Call Rhino.EnableRedraw(False)
Rhino.Print “please wait… universe is being sucked into a hole”

For i = 0 To Area – 1
For j = 0 To Area – 1
For k = 0 To Area – 1
T = T + 1
A(T) = Array((x+i)*side,(y+j)*side,(z+k)*side)
B(T) = Array(((x+i)*side)+side,(y+j)*side,(z+k)*side)
C(T) = Array(((x+i)*side)+side,((y+j)*side)+side,(z+k)*side)
D(T) = Array((x+i)*side,((y+j)*side)+side,(z+k)*side)
E(T) = Array((x+i)*side,(y+j)*side,((z+k)*side)+side)
F(T) = Array(((x+i)*side)+side,(y+j)*side,((z+k)*side)+side)
G(T) = Array(((x+i)*side)+side,((y+j)*side)+side,((z+k)*side)+side)
H(T) = Array((x+i)*side,((y+j)*side)+side,((z+k)*side)+side)
Box(T) = Array(A(T),B(T),C(T),D(T),E(T),F(T),G(T),H(T))
‘boxID = Rhino.AddBox (Box(T))
‘Rhino.ObjectColor boxID, RGB(120,120,120)
Next
Next
Next
‘now we work out the distances
‘F=G*((m1*m2)/r^2)
‘G in this case will be valued at a scale where effects will be obvious
‘m1 and m2 will be added later

Dim GF, dist, n
Dim nAx, nBx,nCx, nDx, nEx, nFx, nGx, nHx
ReDim nAx(PtNumber), nBx(PtNumber), nCx(PtNumber), nDx(PtNumber), nEx(PtNumber), nFx(PtNumber), nGx(PtNumber), nHx(PtNumber)
Dim nAy, nBy, nCy, nDy, nEy, nFy, nGy, nHy
ReDim nAy(PtNumber), nBy(PtNumber), nCy(PtNumber), nDy(PtNumber), nEy(PtNumber), nFy(PtNumber), nGy(PtNumber), nHy(PtNumber)
Dim nAz, nBz, nCz, nDz, nEz, nFz, nGz, nHz
ReDim nAz(PtNumber), nBz(PtNumber), nCz(PtNumber), nDz(PtNumber), nEz(PtNumber), nFz(PtNumber), nGz(PtNumber), nHz(PtNumber)
Dim timeloop
Dim time : time = 1000
Dim cTime, GFchange, GForce, runTime
runTime=0
GForce = Gforce1
GFchange = 0.01

For cTime = 0 To time-1
Gforce = Gforce+GFchange
Rhino.Print “change is ” & (Gforce)

Call Rhino.EnableRedraw(False)

For n = 0 To PtNumber
‘for Ax process
dist = Rhino.Distance(A(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (A(n)(0)) < AttPx Then
nAx(n) = (A(n)(0)) + GF
End If
If (A(n)(0)) = AttPx Then
nAx(n) = (A(n)(0))
End If
If (A(n)(0)) > AttPx Then
nAx(n) = (A(n)(0)) – GF
End If
If GF > dist Then
nAx(n) = AttPx
End If

‘for Bx process
dist = Rhino.Distance(B(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (B(n)(0)) < AttPx Then
nBx(n) = (B(n)(0)) + GF
End If
If (B(n)(0)) = AttPx Then
nBx(n) = (B(n)(0))
End If
If (B(n)(0)) > AttPx Then
nBx(n) = (B(n)(0)) – GF
End If
If GF > dist Then
nBx(n) = AttPx
End If

‘for Cx process
dist = Rhino.Distance(C(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (C(n)(0)) < AttPx Then
nCx(n) = (C(n)(0)) + GF
End If
If (C(n)(0)) = AttPx Then
nCx(n) = (C(n)(0))
End If
If (C(n)(0)) > AttPx Then
nCx(n) = (C(n)(0)) – GF
End If
If GF > dist Then
nCx(n) = AttPx
End If

‘for Dx process
dist = Rhino.Distance(D(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (D(n)(0)) < AttPx Then
nDx(n) = (D(n)(0)) + GF
End If
If (D(n)(0)) = AttPx Then
nDx(n) = (D(n)(0))
End If
If (D(n)(0)) > AttPx Then
nDx(n) = (D(n)(0)) – GF
End If
If GF > dist Then
nDx(n) = AttPx
End If

‘for Ex process
dist = Rhino.Distance(E(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (E(n)(0)) < AttPx Then
nEx(n) = (E(n)(0)) + GF
End If
If (E(n)(0)) = AttPx Then
nEx(n) = (E(n)(0))
End If
If (E(n)(0)) > AttPx Then
nEx(n) = (E(n)(0)) – GF
End If
If GF > dist Then
nEx(n) = AttPx
End If

‘for Fx process
dist = Rhino.Distance(F(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (F(n)(0)) < AttPx Then
nFx(n) = (F(n)(0)) + GF
End If
If (F(n)(0)) = AttPx Then
nFx(n) = (F(n)(0))
End If
If (F(n)(0)) > AttPx Then
nFx(n) = (F(n)(0)) – GF
End If
If GF > dist Then
nFx(n) = AttPx
End If

‘for Gx process
dist = Rhino.Distance(G(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (G(n)(0)) < AttPx Then
nGx(n) = (G(n)(0)) + GF
End If
If (G(n)(0)) = AttPx Then
nGx(n) = (G(n)(0))
End If
If (G(n)(0)) > AttPx Then
nGx(n) = (G(n)(0)) – GF
End If
If GF > dist Then
nGx(n) = AttPx
End If

‘for Hx process
dist = Rhino.Distance(H(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (H(n)(0)) < AttPx Then
nHx(n) = (H(n)(0)) + GF
End If
If (H(n)(0)) = AttPx Then
nHx(n) = (H(n)(0))
End If
If (H(n)(0)) > AttPx Then
nHx(n) = (H(n)(0)) – GF
End If
If GF > dist Then
nHx(n) = AttPx
End If

‘for Ay process
dist = Rhino.Distance(A(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (A(n)(1)) < AttPx Then
nAy(n) = (A(n)(1)) + GF
End If
If (A(n)(1)) = AttPx Then
nAy(n) = (A(n)(1))
End If
If (A(n)(1)) > AttPx Then
nAy(n) = (A(n)(1)) – GF
End If
If GF > dist Then
nAy(n) = AttPy
End If

‘for By process
dist = Rhino.Distance(B(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (B(n)(1)) < AttPx Then
nBy(n) = (B(n)(1)) + GF
End If
If (B(n)(1)) = AttPx Then
nBy(n) = (B(n)(1))
End If
If (B(n)(1)) > AttPx Then
nBy(n) = (B(n)(1)) – GF
End If
If GF > dist Then
nBy(n) = AttPy
End If

‘for Cy process
dist = Rhino.Distance(C(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (C(n)(1)) < AttPx Then
nCy(n) = (C(n)(1)) + GF
End If
If (C(n)(1)) = AttPx Then
nCy(n) = (C(n)(1))
End If
If (C(n)(1)) > AttPx Then
nCy(n) = (C(n)(1)) – GF
End If
If GF > dist Then
nCy(n) = AttPy
End If

‘for Dy process
dist = Rhino.Distance(D(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (D(n)(1)) < AttPx Then
nDy(n) = (D(n)(1)) + GF
End If
If (D(n)(1)) = AttPx Then
nDy(n) = (D(n)(1))
End If
If (D(n)(1)) > AttPx Then
nDy(n) = (D(n)(1)) – GF
End If
If GF > dist Then
nDy(n) = AttPy
End If

‘for Ey process
dist = Rhino.Distance(E(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (E(n)(1)) < AttPx Then
nEy(n) = (E(n)(1)) + GF
End If
If (E(n)(1)) = AttPx Then
nEy(n) = (E(n)(1))
End If
If (E(n)(1)) > AttPx Then
nEy(n) = (E(n)(1)) – GF
End If
If GF > dist Then
nEy(n) = AttPy
End If

‘for Fy process
dist = Rhino.Distance(F(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (F(n)(1)) < AttPx Then
nFy(n) = (F(n)(1)) + GF
End If
If (F(n)(1)) = AttPx Then
nFy(n) = (F(n)(1))
End If
If (F(n)(1)) > AttPx Then
nFy(n) = (F(n)(1)) – GF
End If
If GF > dist Then
nFy(n) = AttPy
End If

‘for Gy process
dist = Rhino.Distance(G(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (G(n)(1)) < AttPx Then
nGy(n) = (G(n)(1)) + GF
End If
If (G(n)(1)) = AttPx Then
nGy(n) = (G(n)(1))
End If
If (G(n)(1)) > AttPx Then
nGy(n) = (G(n)(1)) – GF
End If
If GF > dist Then
nGy(n) = AttPy
End If

‘for Hy process
dist = Rhino.Distance(H(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (H(n)(1)) < AttPx Then
nHy(n) = (H(n)(1)) + GF
End If
If (H(n)(1)) = AttPx Then
nHy(n) = (H(n)(1))
End If
If (H(n)(1)) > AttPx Then
nHy(n) = (H(n)(1)) – GF
End If
If GF > dist Then
nHy(n) = AttPy
End If

‘for Az process
dist = Rhino.Distance(A(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (A(n)(2)) < AttPx Then
nAz(n) = (A(n)(2)) + GF
End If
If (A(n)(2)) = AttPx Then
nAz(n) = (A(n)(2))
End If
If (A(n)(2)) > AttPx Then
nAz(n) = (A(n)(2)) – GF
End If
If GF > dist Then
nAz(n) = AttPz
End If

‘for Bz process
dist = Rhino.Distance(B(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (B(n)(2)) < AttPx Then
nBz(n) = (B(n)(2)) + GF
End If
If (B(n)(2)) = AttPx Then
nBz(n) = (B(n)(2))
End If
If (B(n)(2)) > AttPx Then
nBz(n) = (B(n)(2)) – GF
End If
If GF > dist Then
nBz(n) = AttPz
End If

‘for Cz process
dist = Rhino.Distance(C(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (C(n)(2)) < AttPx Then
nCz(n) = (C(n)(2)) + GF
End If
If (C(n)(2)) = AttPx Then
nCz(n) = (C(n)(2))
End If
If (C(n)(2)) > AttPx Then
nCz(n) = (C(n)(2)) – GF
End If
If GF > dist Then
nCz(n) = AttPz
End If

‘for Dz process
dist = Rhino.Distance(D(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (D(n)(2)) < AttPx Then
nDz(n) = (D(n)(2)) + GF
End If
If (D(n)(2)) = AttPx Then
nDz(n) = (D(n)(2))
End If
If (D(n)(2)) > AttPx Then
nDz(n) = (D(n)(2)) – GF
End If
If GF > dist Then
nDz(n) = AttPz
End If

‘for Ez process
dist = Rhino.Distance(E(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (E(n)(2)) < AttPx Then
nEz(n) = (E(n)(2)) + GF
End If
If (E(n)(2)) = AttPx Then
nEz(n) = (E(n)(2))
End If
If (E(n)(2)) > AttPx Then
nEz(n) = (E(n)(2)) – GF
End If
If GF > dist Then
nEz(n) = AttPz
End If

‘for Fz process
dist = Rhino.Distance(F(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (F(n)(2)) < AttPx Then
nFz(n) = (F(n)(2)) + GF
End If
If (F(n)(2)) = AttPx Then
nFz(n) = (F(n)(2))
End If
If (F(n)(2)) > AttPx Then
nFz(n) = (F(n)(2)) – GF
End If
If GF > dist Then
nFz(n) = AttPz
End If

‘for Gz process
dist = Rhino.Distance(G(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (G(n)(2)) < AttPx Then
nGz(n) = (G(n)(2)) + GF
End If
If (G(n)(2)) = AttPx Then
nGz(n) = (G(n)(2))
End If
If (G(n)(2)) > AttPx Then
nGz(n) = (G(n)(2)) – GF
End If
If GF > dist Then
nGz(n) = AttPz
End If

‘for Hz process
dist = Rhino.Distance(H(n), AttPt)
If dist <> 0 Then
GF = Gforce*((m1*m2)/dist^2)
Else GF = 0
End If
If (H(n)(2)) < AttPx Then
nHz(n) = (H(n)(2)) + GF
End If
If (H(n)(2)) = AttPx Then
nHz(n) = (H(n)(2))
End If
If (H(n)(2)) > AttPx Then
nHz(n) = (H(n)(2)) – GF
End If
If GF > dist Then
nHz(n) = AttPz
End If

‘Rhino.AddPoint Array(nAx(n), nAy(n), nAz(n)) – test purposes
Next

Dim nBox, nA, nB, nC, nD, nE, nF, nG, nH, m, IDbox
ReDim nA(PtNumber), nB(PtNumber), nC(PtNumber), nD(PtNumber), nE(PtNumber), nF(PtNumber), nG(PtNumber), nH(PtNumber), nBox(PtNumber), IDbox(PtNumber)
For m = 0 To PtNumber
nA(m) = Array(nAx(m), nAy(m), nAz(m))
nB(m) = Array(nBx(m), nBy(m), nBz(m))
nC(m) = Array(nCx(m), nCy(m), nCz(m))
nD(m) = Array(nDx(m), nDy(m), nDz(m))
nE(m) = Array(nEx(m), nEy(m), nEz(m))
nF(m) = Array(nFx(m), nFy(m), nFz(m))
nG(m) = Array(nGx(m), nGy(m), nGz(m))
nH(m) = Array(nHx(m), nHy(m), nHz(m))
nBox(m) =  Array(nA(m), nB(m), nC(m), nD(m), nE(m), nF(m), nG(m), nH(m))
IDbox(m) = Rhino.AddBox(nBox(m))
Next

Call Rhino.EnableRedraw(True)
‘Rhino.CreatePreviewImage “G1r” & cTime & “.jpg”,,array(1000,800),,True

If runTime = 0 Then
Call Rhino.EnableRedraw(False)
For timeloop = 0 To PtNumber
If IsNull(IDbox(timeloop)) Then
‘Rhino.Print(“space is being eaten by a massive black hole !!!!!”)
Else
Rhino.Sleep 5
Rhino.DeleteObject IDbox(timeloop)
End If
Next
Call Rhino.EnableRedraw(True)
End If
runTime = 0
Next

End Sub

Option Explicit

‘Script written by <pierre forissier> for nCodon

Call Main()
Sub Main()

‘>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
‘Points cloud for twirl base curve

Dim arrPoint0, arrPoint1, arrPoint2, arrPoint3
Dim arrCtlPts()
Dim i
Dim N
Dim crvBase
N=0

For i = 0 To 500 Step 5

arrPoint0 = array(rnd*10,(rnd*10),i)
arrPoint1 = array(90+rnd*10,(10*rnd),i)
arrPoint2 = array(90+10*rnd,(90+rnd*10),i)
arrPoint3 = array(rnd*10,(90+10*rnd),i)

ReDim Preserve arrCtlPts(N)
arrCtlPts(N) = arrPoint0

ReDim Preserve arrCtlPts(N+1)
arrCtlPts(N+1) = arrPoint1

ReDim Preserve arrCtlPts(N+2)
arrCtlPts(N+2) = arrPoint2

ReDim Preserve arrCtlPts(N+3)
arrCtlPts(N+3) = arrPoint3

N=N+4

Next

crvBase = Rhino.AddCurve(arrCtlPts,2)

‘>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
‘Twirl

Call Rhino.EnableRedraw(False)

Dim intSamples : intSamples = 1000

Dim crvDomain : crvDomain = Rhino.CurveDomain(crvBase)
Dim t, M

Dim arrCrossSections(), CrossSectionPLane
Dim crvPoint, crvTangent, crvPerp, crvNormal

M=0

For t = crvDomain(0) To crvDomain(1) + 1e-9 Step (crvDomain(1)-crvDomain(0))/2000

crvPoint = Rhino.EvaluateCurve(crvBase,t)
crvTangent = Rhino.CurveTangent(crvBase,t)
crvPerp = Array(0,0,1)
crvNormal = Rhino.VectorCrossProduct(crvTangent, crvPerp)

CrossSectionPlane = Rhino.PlaneFromFrame(crvPoint,crvPerp,crvNormal)

ReDim Preserve arrCrossSections(M)
arrCrossSections(M) = Rhino.AddCircle(CrossSectionPlane,1)

M = M+1

Next

Call Rhino.AddLoftSrf(arrCrossSections)

‘>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
‘Twirl connectors

Dim arrPtBaseConnect1, arrPtBaseConnect2
Dim arrPtTopConnect1
Dim j

For j = crvDomain(0) To crvDomain(.7) Step ((crvDomain(1)-crvDomain(0))/intSamples)*20.1
Dim dblRandom1 : dblRandom1 = rnd*.3
arrPtBaseConnect1 = Rhino.EvaluateCurve(crvBase, j+dblRandom1)
arrPtBaseConnect2 = Rhino.EvaluateCurve(crvBase, j+dblRandom1+.1)
arrPtTopConnect1 = Rhino.EvaluateCurve(crvBase, j+4.3)
Dim crvConnector1 : crvConnector1 = Rhino.Addline(arrPtBaseConnect1, arrPtTopConnect1)
Dim objBaseSphere1 : objBaseSphere1 = Rhino.AddSphere(arrPtBaseConnect1, 2)
Dim objBaseSphere2 : objBaseSphere2 = Rhino.AddSphere(arrPtBaseConnect2, 2)
Dim objTopSphere1 : objTopSphere1 = Rhino.AddSphere(arrPtTopConnect1, 2)
Dim objCylindLink1 : objCylindLink1 = Rhino.AddCylinder (arrPtBaseConnect1, arrPtTopConnect1, 0.3)
Dim objCylindLink2 : objCylindLink2 = Rhino.AddCylinder (arrPtBaseConnect2, arrPtTopConnect1, 0.3)

Next

Call Rhino.EnableRedraw(True)

End Sub

It is suggested that a change/time is a fundamental element of a form and that it is necessary to view the change sequence as an intrinsic component of it. Perceiving change/time as inseparable quality implies that all of the parameters that are impacting a particular formation are directly linked to its basic structure and acting together.

As the change is perceived as a fundamental element of a form, than all of the factors and conditions that are impacting it, become essential to the form itself – it can not be viewed as a separate entity any longer – it becomes evident that its actual structure and the conditions shaping it along the streamlines of change/time are fused and working in essentially interconnected way.

It is suggested that changing the way in which we think about the forms to view them as inseparable of the flux of change, can give birth to a ‘higher’ level method planning, where parameters of change/time are included in the initial description and the basic structure of the form, giving it an integrated response mechanisms and a living entity qualities.

Most importantly, the spontaneous processes of change present a very powerful source of energy. The knowledge that would enable ‘connecting’ the forms with the processes and fluxes that are already in place, would empower in a sense that instead of giving a solutions that are made to withstand the change and in principle work against it, it would present a mean of ‘tapping’ into these resources.

Realizing and implementing this force of change, ie. the flow of matter, will potentially present a very powerful resource, whose occurrence in the architectural practice so far has been seen more along the lines of the external conditions, a sort of a consequence, rather than seeing it as a very potent source.

The rest of this entry on orig. website »

PDF  full text

an infinite number of possible forms

Overview

1. Introduction
2. The cultural background
3. The perfect form
4. Mathematics of space, objects and relationships
5. “Unspecified form” – the ‘cubes’ project
6. Design given as a function
7. Neutral configuration – dealing with the complexity
8. Designing the ‘essence’

Read the rest of this entry »

Exploring T-Splines options and manual operations.

Pavilion modelled with T-Splines trial version for rhino. It’s a really nice plug-in….

based on ‘Bounding box, divide interval and box component’ definition found at ARTC MIAMI / ARTC Miami / (requires registration/otherwise free)

gh definition / download /

Overview

1. Introduction
2. Planning
3. Spontaneity
4. The Issue of Complexity
5. Planned versus Spontaneous
6. Planned Spontaneity

7. Conclusion

Read the rest of this entry »

• THEVERYMANY, USA, www.theverymany.net
• Tina Manis Associates, USA, www.tinamanis.com
• 3SIX0 Architecture & Design, USA, www.3six0.com
• AREA [Architecture Research Athens], Greece, www.areaoffice.gr
• Alexander Malm, Anna H. Denis & Henrik Börjesson, Sweden
• BCK Design, Canada, www.bckdesign.ca
• Cesare Grifffa, Mauro Fassino, Federico Rizzo, Italy, www.studiogriffa.net
• Diana Dina & Magdalena Vieriu , Romania, www.diana-dina.com
• Feix&Merlin Architects with Martin Stockley Associates, UK, www.feixandmerlin.com
• GABPA architects, USA, www.gabpa.com
• Interlaced (Britta Knobel, Carine Cohen & Florien Dubiel), UK, www.floriandubiel.net
• IN & EDIT Architecture, France
• Karim Muallem, UK
• LINKsignatur, Denmark, www.link-signatur.dk
• Maciej Walczuk, UK
• M. Olejniczak, A. Strzelecki, D. Kabza, M. Janiec, Poland
• Pracownia Projektowa Wloskowicz, Poland, www.wloskowicz.pl
• Swona (Andre Guimond & Evan Erlebacher), UK

More information at the art fund pavilion news website

Congratulations!!

Congratulations to everyone involved, especially to curators Andrea Graziano, Lorena Alessio and Davide Del Giudice for making this event possible.

Parametric pavilion modelled in rhino + grasshopper.

I started the whole pavilion with 5 curbs (that will be lofted) and a grid of perpendicular lines (that will make the ribs of the pavilion).

The build-up (essentialy creating the ribs with adjustable parameters) was made with grasshopper.

And the final frame looks as below

The whole thing was eventually exported to 3d Studio and rendered with vray as this is my favorit combination to render.

You will see that the grasshopper definition is far from short as I did not manage to get the result in any other way.

Here is at last a link to the GH file http://dl.dropbox.com/u/20191438/ncodon/Panelion%20GHX/panelion.ghx

As I commented below, this is far from pretty as I ran short of time for the competition and had to get a result.. So any suggestion to make this smarter is welcome!

Once modelled with Rhino, I exported the model to 3d Studio and rendered all with vray. You can download the scene here http://drop.io/panelscene3ds

Modeled in rhino3d using panelingtools. The timber structural components ended up being curved which isn’t correct, and strictly speaking I could have modeled it using other methods. The trickiest part was probably working out the shape of the component. All dimensions are guessed… Rendered in 3dstudio with vray as always.

An example of a structure which would be much more difficult to model without panelingtools: