| edmondo occhipinti architect |

TAC & LIVE at Politecnico di Milano

2010-11-17T09:34:00.004+01:00

I'm glad to share what I believe is one of the most interesting events of 2011 in Italy on advanced construction. The TAC program will take place at Politecnico di Milano and will be a combination of open lectures and dedicated courses for a limited number of students.

PCA PB22 | Morphogenetic Strategies

2008-02-10T19:08:00.001+01:00

During last months I was contacted as morphogenetic consultant by PCA-Architecture for the skyscrapers project PB22, at the Defense in Paris. The project will be officially presented at the end of February, and I wish to publish some sample studies I did for this project. The idea was to use the environmental site-specific analysis as a vectors field able to determine an optimal morphology according to reduce the wind pressure over the towers bodies and to have an optimal solar exposure for energy absorption and use. At the end of the morphogenetic process I was asked to build the stereolithography model.

Edmondo Occhipinti

On Archistorm #29

2008-02-10T18:50:00.000+01:00

Archistorm #29 [January-February 2008] published one of my recent essays, appeared on this blog, last year. I would like to thank Paul Ereth for the interest on my work. After ten months this blog appears still very small due to my day by day work that makes really hard to produce and post regularly. I really appreciate the interest of my twenty-five readers, and I also would like to thank Andrea Graziano [digitag] for his moral support since the beginning.

Edmondo Occhipinti

Laser-Cutter Model

2007-11-25T02:11:00.000+01:00

Some weeks ago an architectural firm from paris asked me to build a conceptual model for
An interactive façade. I had a very simple idea (I had no time too!). so this is the result. I rationalized the manufacturing process in rhinoscript. I create a simple automated process able to create the solid model (for presentation, just like in this image) from an input nurbs surface, and also able to extract every section of the model for laser-cutter manufacturing. A very simple stuff, but useful.

2007-10-11T22:47:00.001+01:00

In mathematics exists a lot of affirmations which nobody has ever been able to demonstrate, as the one of most notorious linear Diophantine equation a^n + b^n = c^n has no solutions in non-zero integers for n > 2 (last Fermat’s theorem). In nineteen-thirty-one Alan Turing was twenty y.o. and just three years before the world had knew the deductible trueness system by the aka Hilbert’s program (is mathematics complete, consistent and decidable?). In that time Turing was in Cambridge studying mathematics, and trying to dematerialize the mathematics’ decidability (Kurt Gödel had just demonstrate one of the most famous theorem about the incompleteness of mathematics, discrediting the first point of Hilbert’s program). Woking on decidability -on the hilbertian question given an axiomatic system and an arbitrary proposition, does exist a procedure that allows to determinate if that proposition is true or false, inside the system?- Turing arises to formulate a different related question –does exist a mechanical procedure to make that?- that evidently call for the more general question –what is a mechanical procedure, that is what is a machine?
A machine is a man-made object with a finite number of configurations, that for everyone of those configurations has completely determined comportments, and is also an object that manipulate symbols. Thus Turing thought was no useful to build specialized machines, able to play check, to translate from Italian and to solve differential equations; his idea was to define the different rules tabula for everyone of these activities, to introduce, then, in an universal machine which, having appropriate codes, would be able to simulate every specialized machine (in that time such concepts like hardware and software simply didn’t exist!). But in that time, nineteen-thirty-four, this idea was so innovative that nobody was able to understand it. The Turing Machine expression will be familiar just later, but today this is the name of that platonic idea, that kantian noumenos of “machinity”. Being celebrated in the small room of the formal logic, Turing moved to Princeton, where he stayed for two years; after that he refused the proposal to assist the teaching of John von Neumann, and come back to Cambridge, where Wittgenstein were lecturing. In that time, nineteen-thirty-seven, he saw the Disney animated feature “Snow White and the Seven Dwarfs”; some of his friends tale that Turing singed, over the months, the witch’s melody while she putted the poison in the apple. Then, the war arose, and nobody had news of Turing’s life.
What really happened at that time, is quite interesting to tale. The Britannic secret services were working to try to penetrate the strategic messages’ coding system, based on Enigma, an infernal machine, able to code and decode messages, using a recto-verso rotors system. The Reich guessed Enigma, absolutely inviolable and used that machine among the entire war. Alain Turing was recruited by the Government Code and Cyber School, dependent by Foreign Office (!), as a decoder. This was his best occupation as long as this was his best enjoyment: thus was under his direction that GC&CS was able to build the anti-Enigma machine, best known as Bomb. In April nineteen-forty Bomb, perfectly working, was installed in a cantina with all the listening-systems of Britannic intelligence; everything intercepted by radio repeaters in all the world, arose Bomb, able to identify and decode, among hundred thousands of messages, those ones which had a war meaningful interest.
We’ll never know if Turing understood the importance of his work, this is, if he was able to understand what responsibility he had, but the Bomb become, in few months, the Major State oracle, and Turing, as a medium able to make Bomb communicate, the head of Britannic war machine. From nineteen-forty-three the man who, exploring the logic problems, had dematerialized Enigma, starts lo loose his importance and begins to study a code system of human voice, named Dalila. The start point was a registration of Churchill discourses, progressively coded in no understandable sounds, and sequentially decoded. Few people knew that the Normandy invasion, the victory of allied and that strange man, that played the role of pythagoric Archimedes, were strictly linked. Perhaps Turing guessed that if he had told how he won the war, people had thought he was completely crazy. Thus, he won the war, but he lost his peace. Coming back to Cambridge and then to Manchester, as an academic researcher, he works to the project for an English computer, against the famous American one, the Electronic Numerical Integrator And Computer, aka ENIAC. Thus Turing was interested by the implicated logic system: his dream was to build a machine able to execute every kind of application, and to build applications able to execute and simulate every known process; a machine, he said, is no more able to execute calculus than to play check or translate Italian, but his applications could be able to manipulate formal symbols in such a way that the machine will look as if she really does those activities. Exactly the same thing happens with the human brain. Thus, his idea to create a brain.
In the Forty’s nobody talked about informatics, but of cybernetics, so with the greatest names of Neumann, Wiener and Haldane, sometimes one should also find Turing’s name, as a precursor of the cyber, since his article in the thirty-four. In the fifty’ he publish an interesting article on “Mind”, regarding artificial intelligence, contributing to the eternal debating between materialists and spiritualists; he suggested an operational way to decide if a machine can think as the human do: is a machine able to make believe that she thinks like a human? (I suggest to talk few minutes with A.L.I.C.E.). In Turing opinion nobody, human or machine, “really” thinks, “really” makes mathematics operations, “really” plays checks, “really” feels the sweetness of kisses: at the level of formal system, everybody, machine or human, manipulate symbols, and this manipulation, at other levels, can be named as one of those activities. Some weeks after this publication, considered as one of the most important in the A.I. field Turing was condemned by the law that prohibited the against-nature relationships. Definitively expulsed from the university, he started studying embryology and morphogenesis: his question was how living being know and execute their applications. He tested his models by computer, spending most of his time in his house and following extremely personal protocols.
In nineteen-fifty-four, the 8th of June the housekeeper discovered the body of Turing, on the bad, in his little house of Manchester. He had put poison in his apple. We could resume the salient points of his life, saying he was an important mathematic and pioneer of artificial intelligence, an eccentric actor of the espionage history, during the second world war, and finally an homosexual martyr. Thank to Andrew Hodges, mathematic and gay, who published in the nineteen-eighty-four an amazing biography of Turing, but also thanks to Sara Turing, Alan’s mother, who wrote the first not-so-exciting biography of her son, and finally thanks to Emmanuel Carrère, for his Alain Turing portrait, published in nineteen-ninety-five on Revue de Littérature Générale.
Edmondo Occhipinti

triangulation networks

2007-06-15T14:26:00.001+01:00

Editing previous density points script this is an interesting application of that logic. this script creates a network between three d points, defining an interior volume. adding spheres to every point we can also think to link spheres and obtain something similar to the 3d cristals structure of prevous post.
this script could be used as a diagrammatic tool for networking programatic or functional informations as well as a volumetric tool based on some external information-based points.
to be developped.

edmondo occhipinti

Option Explicit
'This Script Generate network pipes based on Points set and their Relative Distances

'Structural optimization based on reticular triangulation network

'Code by Edmondo Occhipinti Architect [codesign.lab] 2007

MsgBox "Code by Edmondo Occhipinti Architect

edmondo@co-design-lab.net"

Sub network

Dim arrpts, strline, strcmd, piperadius

Dim dbdist, dbtotdist

Dim i, u

arrpts = Rhino.GetPointCoordinates ("Select Points to Create Skeleton Pattern")

If IsNull (arrpts) Then

Exit Sub

End If

For i = 0 To UBound (arrpts)

dbtotdist = 1000000
For u = 0 To UBound (arrpts)

strline = Rhino.AddLine (arrpts(i), arrpts(u))

dbdist = Rhino.Distance (arrpts(i), arrpts(u))

piperadius = 1

strCmd = "! _Pipe _SelID " & strline & " " & pipeRadius & " _Enter _Enter"

Rhino.Command strCmd
If u = UBound (arrpts) And dbdist = 0 Then

Exit Sub

End If

If dbdist = 0 Then

u = u+1

dbdist = Rhino.Distance (arrpts(i), arrpts(u))

End If If

dbdist

dbtotdist = dbdist

End If

Dim arrPlane, crv, text

text = Rhino.AddText (dbtotdist, arrpts(i), dbtotdist/5)

arrPlane = Rhino.PlaneFromFrame (arrpts (i), Array(1.0,0.0,0.0), Array(0.0,1.0,0.0))

crv = Rhino.AddCircle (arrPlane, dbtotdist/2)

Rhino.AddSphere arrpts(i), dbtotdist/2

End Sub

network

RhinoScript Workshop. Student Training ESA 2

2007-06-06T23:43:00.000+01:00

And here a second script developed by Taichi Sunayama. Taichi’s idea was to create a structured script able to attempt to different project phases. His quite long script works for sections and interact with users preferences. The aim was to create a script which calculates the site specific pollution levels and translates it into a faded point cloud. By doing this he is able to create a growing structure (voronoi based) able to proportionate cells’ dimension to pollution levels. He inserts specific values of sound and air pollution into the script. The user can choose some sample parameters of a specific site (such as routes, number of vehicles, heights, dimensions, etc.) and the script will print some prompt-based data. The script will use these values to build the final site-specific structure. Here I’m pleased to post the 42th version of his script… to be continued and updated.

edmondo occhipinti

Option Explicit

'workshop growing structuresgenerative scripts
'Script supervisor edmondo occhipinti architect COdesignLab
'Script written by taichi sunayama ecole speciale d'architecture
'Script version lundi 12 mai 2007 18:32:03

Call HighRise()

Sub HighRise()

Dim strHead1 : strHead1 = "PollutionCloud"
Dim strHead2 : strHead2 = "PollutionCloud > Intention de forme"
Dim strHead3 : strHead3 = "Localisation"
Dim strHead4 : strHead4 = "Intention de form"
Dim strHead5 : strHead5 = "Creation de module"
Dim strHead6 : strHead6 = "Intention de form > Creation de module"
Dim strHead7 : strHead7 = "Identification des modules"
Dim strHead8 : strHead8 = "extract surfaces"
Dim arrRoute , strRoute
arrRoute = array(strHead1 , strHead2 , strHead3 , strHead4 , strHead5 , _
strHead6 , strHead7)
strRoute = rhino.ListBox(arrRoute , "selection de Route")
Select Case strRoute
Case strHead1
Call Route1()
Case strHead2
Call Route2()
Case strHead3
Call Route3()
Case strHead4
Call Route4()
Case strHead5
Call Route5()
Case strHead6
Call Route6()
Case strHead7
Call Route7()
Case Else Exit Sub
End Select
End Sub

Sub Route1()
'********************************************************************
'--------------------------------------------------------------------
Dim strPtCloud : strPtCloud = InputPollution()
'--------------------------------------------------------------------
End Sub '"PollutionCloud"

Sub Route2()
'********************************************************************* INPUT **************
'--------------------------------------------------------------------------- CONDITION ----
Dim strPtCloud : strPtCloud = InputPollution()
'--------------------------------------------------------------------------- INTENTION ----
Dim strSite : strSite = rhino.GetObject("selection de site" , 4) '
Dim dblHigh : dblHigh = rhino.RealBox("hauteur de gabarit" , 50)
'-------------------------------------------------------------------
Dim arrEnv : arrEnv = FormGenerator(strPtCloud , dblHigh , strSite)
'-------------------------------------------------------------------
End Sub '"PollutionCloud > Intention de forme"

Sub route3()
Dim strPtCloud : strPtCloud = rhino.Getobject ("select Pointcloud" , 2)
Call Localisation(strPtCloud)
End Sub

Sub Route4()
'************************************************************************
'------------------------------------------------------------------------
Dim strPtCloud : strPtCloud = rhino.Getobject ("select Pointcloud" , 2)
'------------------------------------------------------------------------
Dim strSite : strSite = rhino.GetObject("selection de site" , 4) '
Dim dblHigh : dblHigh = rhino.RealBox("hauteur de gabarit" , 50)
'------------------------------------------------------------------------
Dim arrEnv : arrEnv = FormGenerator(strPtCloud , dblHigh , strSite)
Dim strVlEnv : strVlEnv = arrEnv(0)
Dim strPtEnv : strPtEnv = arrEnv(1)

End Sub '"Intention de forme"

Sub Route5()
Dim strPtEnv : strPtEnv = rhino.Getobject ("select Pointcloud" , 2)
Call Rhino.MessageBeep (5)
Dim strVlEnv : strVlEnv = rhino.GetObject ("selection volume" , 16)
Call Rhino.MessageBeep (5)
'-----------------------------------------------------------------------
Dim arrBbox : arrBbox = rhino.BoundingBox(strPtEnv)
Dim dbldiagonale : dbldiagonale = Rhino.Distance(arrBbox(0), arrBbox(6))
'------------------------------------------------------------------------
Dim arrPtEnv : arrPtEnv = Rhino.PointCloudPoints(strPtEnv)
'------------------------------------------------------------------------
Dim arrType : arrType = array("aligneXY" , "aligneXYZ" , "normal")
Dim strType : strType = rhino.ListBox(arrType , "Type de cell" )
Dim arrPts
Select Case strType
Case "aligneXY"
arrPts = AlignXY(arrPtEnv)
Case "aligneXYZ"
arrPts = AlignXYZ(arrPtEnv)
Case "normal"
arrPts = arrPtEnv
Case Else Exit Sub
End Select
'------------------------------------------------------------------------
Dim arrCells : arrCells = VoronoiCell(arrPts , dbldiagonale , strVlEnv)
End Sub '"Creation de module"

Sub Route6()
'********************************************************************
'--------------------------------------------------------------------
Dim strPtCloud
strPtCloud = rhino.Getobject ("select Pointcloud" , 2)
'--------------------------------------------------------------------
Dim strSite , dblHigh
strSite = rhino.GetObject("selection de site" , 4)
dblHigh = rhino.RealBox("hauteur de gabarit" , 50)
'--------------------------------------------------------------------
Dim arrEnv : arrEnv = FormGenerator(strPtCloud , dblHigh , strSite)
Dim strVlEnv : strVlEnv = arrEnv(0)
Dim strPtEnv : strPtEnv = arrEnv(1)
'--------------------------------------------------------------------
Dim arrBbox , dbldiagonale
arrBbox = rhino.BoundingBox(strPtEnv)
dbldiagonale = Rhino.Distance(arrBbox(0), arrBbox(6))
'--------------------------------------------------------------------
Dim arrPtEnv : arrPtEnv = Rhino.PointCloudPoints(strPtEnv)
'--------------------------------------------------------------------
Dim arrType : arrType = array("aligneXY" , "aligneXYZ" , "normal")
Dim strType : strType = rhino.ListBox(arrType , "Type de cell" )
Dim arrPts
Select Case strType
Case "aligneXY"
arrPts = AlignXY(arrPtEnv)
Case "aligneXYZ"
arrPts = AlignXYZ(arrPtEnv)
Case "normal"
arrPts = arrPtEnv
Case Else Exit Sub
End Select
'--------------------------------------------------------------------
Dim arrCells
arrCells = VoronoiCell(arrPts , dbldiagonale , strVlEnv)
End Sub '"Intention de form > Creation de module"

Sub Route7()
Dim arrCells : arrCells = rhino.GetObjects("selection de module" , 16)
Dim arrPM : arrPM = Identity(arrCells)

End Sub '"Identification des modules"

Sub Route8()
Dim arrCells : arrCells = rhino.GetObjects("selection de module" , 16)
Dim arrIE : arrIE = Extractor(arrCells)

Call rhino.DeleteObjects(arrIE(0))
End Sub 'extract surfaces

'========================================================================
Function InputPollution()
Dim arrRoads()
Dim arrNCar()
Dim arrList2()
Dim arrRoad
Dim nCar
'------------------------------------------------------------------------------------------
Dim i : i = 0
Do
Dim arrEntry1 : arrEntry1 = array ("ok" , "fin" )
Dim strList1 : strList1 = rhino.ListBox(arrEntry1 , "selectionne de la rue")
If strList1 = "ok" Then
arrRoad = rhino.GetObject("selectionne de la rue" , 4)
If isnull(arrRoad) Then Exit Function
End If
If strList1 = "fin" Then Exit Do
'--------------------------------------------------------------------------------------
Dim arrTextPt : arrTextPt = rhino.DivideCurve(arrRoad , 4)
Dim strText : strText = rhino.AddText ("<" & i + 1 & ">" , arrTextPt(1) , 2)
'-------------------------------------------------------------------------------------
Call rhino.UnselectAllObjects
Call rhino.SelectObject (arrRoad)
Call rhino.SelectObject (strText)
'---------------------------------------------------------------------------------------
Dim arrEntry2 : arrEntry2 = array("3000 ~ 6000" , "1500 ~ 3000" , "1000 ~ 1500" , "500 ~ 1000" , "250 ~ 500" , "0 ~ 250")
Dim strList2 : strList2 = Rhino.ListBox(arrEntry2 , "Input nombre de voiture sur la rue < " & i + 1 & " > (/heure) ")
Select Case strList2
Case "3000 ~ 6000"
nCar = 6000
Case "1500 ~ 3000"
nCar = 3000
Case "1000 ~ 1500"
nCar = 1500
Case "500 ~ 1000"
nCar = 1000
Case "250 ~ 500"
nCar = 500
Case "0 ~ 250"
nCar = 250
Case Else Exit Function
End Select
'-------------------------------------------------------------
ReDim Preserve arrNCar(i)
arrNCar(i) = nCar
'--------------------------------------------------------------
ReDim Preserve arrRoads(i)
arrRoads(i) = arrRoad
'----------------------------------------------------------
ReDim Preserve arrList2(i)
arrList2(i) = strList2
'------------------------------------------------------------
i = i + 1
Loop
'------------------------------------------------------------------------------------------
'DIFINITION DE PORTEE D'EFFET
Dim dblRange : dblRange = rhino.IntegerBox ("largeur de agencement" , 50 )
If isnull(dblRange) Then Exit Function
'------------------------------------------------------------------------------------------
'INTENSITE DE DEVELLOPEMENT
Dim arrEntrys3: arrEntrys3 = array ("fort" , "moyen" , "faible")
Dim strList3 : strList3 = Rhino.ListBox(arrEntrys3, "Intensite de devellopement")
Dim dblSquare , intRaise
Select Case strList3
Case "fort"
dblSquare = sqr(dblRange)
intRaise = 2
Case "moyen"
dblSquare =sqr(sqr(dblRange))
intRaise = 4
Case "faible"
dblSquare =sqr(sqr(sqr(dblRange)))
intRaise = 8
Case Else Exit Function
End Select
'------------------------------------------------------------------------------------------
Dim arrBbox : arrBbox = rhino.BoundingBox(arrRoads)
Dim arrListPt
For i = 0 To UBound(arrRoads)
arrListPt = array(arrBbox(2)(0) , arrBbox(2)(1) - (i * 16) , 0)
Dim txtN , txtCond , txtNCar , txtVar , txtLA , txtID
txtN = rhino.AddText("<" & i+1 & ">" , arrListPt , 1)
Call rhino.ObjectName(txtN , "text")
txtCond = rhino.AddText("-- condition de la rue --", array(arrListPt(0),arrListPt(1)-2,0) , 1)
Call rhino.ObjectName(txtCond , "text")
txtNCar = rhino.AddText ("nombre de voiture : " & arrList2(i) & " / heure" , array(arrListPt(0),arrListPt(1)-4,0) , 1)
Call rhino.ObjectName(txtNCar , "text")
txtVar = rhino.AddText ("-- variable de generation des points --", array(arrListPt(0),arrListPt(1)-8,0) , 1)
Call rhino.ObjectName(txtVar , "text")
txtLA = rhino.AddText ("largeur de agencement : " & dblRange & "m" , array(arrListPt(0),arrListPt(1)-10,0) ,1)
Call rhino.ObjectName(txtLA , "text")
txtID = rhino.AddText ("Intensite de devellopement : " & strList3 ,array(arrListPt(0),arrListPt(1)-12,0) , 1)
Call rhino.ObjectName(txtID , "text")
Next
'----------------------------------------------------------------------------------------------------
Dim arrPts : arrPts = PollutionCloud(arrRoads , dblRange , dblSquare , intRaise ,arrNCar , arrBbox)
'----------------------------------------------------------------------------------------------------
Dim strPts : strPts = rhino.AddPointCloud(arrPts)
InputPollution = strPts
End Function

Function PollutionCloud(arrRoads , dblRange , dblSquare , intRaise ,_
arrNCar , arrBbox)

Dim arrPtsJ()
Dim i , j , N
'------------------------------------------------------------------------
N = 0
For i = 0 To UBound(arrRoads)
'NOx mg/h sur une rue
Dim dblLengthRoad : dblLengthRoad =rhino.CurveLength(arrRoads(i))
Dim dblGas
dblGas = 80*(dblLengthRoad/1000)*(arrNCar(i))
'*echapement de gaz(NOx):80mg/km
dblGas = (int(dblGas*100))/100
'--------------------------------------------------------------------
'AGENCEMENT DE POINTS
Dim arrPtStart : arrPtStart = rhino.CurveStartPoint (arrRoads(i))
Dim arrPtEnd : arrPtEnd = rhino.CurveEndPoint (arrRoads(i))
Dim vecS2E : vecS2E = rhino.VectorCreate(arrPtStart , arrPtEnd)
Dim dblLength : dblLength = rhino.VectorLength (vecS2E)
Dim vecNormal : vecNormal = Rhino.CurveNormal(arrRoads(i))

'----------------------------------------------------------------
Dim dblVolume : dblVolume = 3.14*dblRange*dblRange*dblLength
' NOMBREDE DE POINT
Dim nPoints : nPoints = int(((dblGas*dblVolume)/10^10)) ' int((dblGas*dblVolume)/10^6)30m 'indice ??????? > photocatalyse
Call rhino.Print ( "npoints :" & nPoints)
'----------------------------------------------------------------
'CALCUL DE DENSITE DE POINT
Dim dblDensity : dblDensity = nPoints/(dblVolume/1000^3) '!!
dblDensity = int(dblDensity)
'----------------------------------------------------------------
For j = 0 To nPoints
Dim dblRandom : dblRandom = rnd*nPoints
Dim arrDomain : arrDomain = Rhino.CurveDomain(arrRoads(i))
Dim dblParam : dblParam = ( ( arrDomain(1)-arrDomain(0) ) / ( nPoints ) ) * ( dblRandom )
Dim arrPt : arrPt = Rhino.EvaluateCurve(arrRoads(i), dblParam)
Dim dblRandamEx : dblRandamEx = (rnd*dblSquare)^intRaise
Dim vecDir
vecDir = rhino.VectorRotate (vecS2E , 90 , vecNormal)
vecDir = rhino.VectorRotate (vecDir , rnd*180 , vecS2E)
If vecDir(2) < 0 Then
vecDir = rhino.VectorReverse(vecDir)
End If
vecDir = rhino.VectorDivide ( vecDir , dblLength/dblRandamEx )
Dim arrPtEx : arrPtEx = rhino.PointAdd (arrPt , vecDir)
'------------------------------------------------------------
ReDim Preserve arrPtsJ(N)
arrPtsJ(N) = arrPtEx
N = N + 1
'------------------------------------------------------------
Next
'----------------------------------------------------------------
Dim arrListPt : arrListPt = array(arrBbox(2)(0) , arrBbox(2)(1) - (i * 16) , 0)
Dim txtNOx , txtDMP
txtNOx = rhino.AddText ("NOx : " & dblGas & " mg / heure" , _
array(arrListPt(0),arrListPt(1)-6,0) , 1)
Call rhino.ObjectName(txtNOx, "text")
txtDMP = rhino.AddText ("densite moyenne de point : " & _
dblDensity & "/ km3" , array(arrListPt(0),arrListPt(1)-14,0) , 1)
Call rhino.ObjectName(txtDMP , "text")
'----------------------------------------------------------------
Next
'--------------------------------------------------------------------
PollutionCloud = arrPtsJ
End Function

'========================================================================

Function Localisation(PtCloud)
Dim arrPts : arrPts = rhino.PointCloudPoints(PtCloud)
Dim arrPoint
Dim arrPoints()
Dim i , j
For i = 0 To UBound(arrPts)
Dim intRnd : intRnd = int(rnd*100)
If intRnd = 0 Then
arrPoint = rhino.AddPoint(arrPts(i))
ReDim Preserve arrPoints(j)
arrPoints(j) = arrPoint
j = j + 1
End If
Next
call rhino.Print(UBound(arrPoints))
Call Rhino.SelectObjects (arrPoints)
End Function

'====================================================================

Function FormGenerator(PtCloud , High , Base)
Dim arrType : arrType = array ("Normal" , "Varie" , "Varie Coubure")
Dim strType : strType = rhino.ListBox(arrType , "selection de type de generation de la form")
'=====================================================================================
Dim strGab : strGab = Gabarit(High , Base)
'---------------------------------------------------------
Dim Bbox : Bbox = rhino.BoundingBox(strGab)
Dim strText1, strText2 , strText3 , strText4
strText1 = rhino.AddText("Type de enveloppe : " & strType , array(Bbox(6)(0), Bbox(6)(1)-2,Bbox(6)(2)),1)
Call rhino.ObjectName(strText1 , "Text")
'----------------------------------------------------------------------------------
Dim strPtLimite : strPtLimite = PtLimitor(PtCloud , strGab)
Dim arrPtSite : arrPtSite = rhino.PointCloudPoints(strPtLimite)
'======================================================================================
Dim strForm
Dim strPtEnv
Dim strHigh
Select Case strType
'----------------------------------------------------------------------------------
Case "Normal"
strForm = strGab
strPtEnv = strPtLimite
'----------------------------------------------------------------------------------
Call rhino.UnselectAllObjects
'----------------------------------------------------------------------------------
Case Else
Dim nDiv : nDiv = rhino.IntegerBox("creer la variation - division par : " , 3)
'=====================================================================================
strText2 = rhino.AddText("division des points : " & nDiv , array(Bbox(6)(0), Bbox(6)(1)-4,Bbox(6)(2)),1)
Call rhino.ObjectName(strText2 , "Text")
'=====================================================================================
Call rhino.DeleteObject(strGab)
'-------------------------------------------------------------------------------------
Dim arrGet
Dim arrPoints()
Dim i , j
For i = 0 To UBound(arrPtsite)
ReDim Preserve arrPoints(i)
arrPoints(i) = rhino.AddPoint(arrPtsite(i))
strHigh = (int((arrPtsite(i)(2))*100))/100
Call rhino.ObjectName(arrPoints(i) , strHigh)
Call rhino.Print (strHigh)
Next
'------------------------------------------------------------------------------------
Dim arrPt()
Dim arrPtCord()
i = 0 : j = 0
Do
If i >= High Then Exit Do
arrGet = rhino.ObjectsByName(i)
If isArray(arrGet) Then
ReDim Preserve arrPt(j)
arrPt(j) = arrGet(0)
j = j + 1
End If
i = i + 0.01
Loop
'------------------------------------------------------------------------------------
For i = 0 To UBound (arrPt)
ReDim Preserve arrPtCord(i)
arrPtCord(i) = Rhino.PointCoordinates(arrPt(i))
Next
'------------------------------------------------------------------------------------
Dim nPts : nPts = UBound(arrPtCord) + 1
Dim nPtEns : nPtEns = (nPts/nDiv) -1
'------------------------------------------------------------------------------------
strText3 = rhino.AddText("Nombre des points chanque division : " & int(nPtEns + 1) , array(Bbox(6)(0), Bbox(6)(1)-6,Bbox(6)(2)),1)

Call rhino.ObjectName(strText3 , "Text")
'------------------------------------------------------------------------------------
Dim arrPtGroup()
Dim arrGroup()
Dim N : N = 0
For i = 0 To (nDiv - 1)
j = 0
Do
If j > nPtEns Then Exit Do
If N >= nPts Then Exit Do
ReDim Preserve arrPtGroup(j)
arrPtGroup(j) = arrPtCord(N)
N = N + 1
j = j +1
Loop
ReDim Preserve arrGroup(i)
arrGroup(i) = arrPtGroup
Next
'-----------------------------------------------------------------------------------
Dim arrPtLevel
Dim strPtLv
Dim arrPtLv
For i = 0 To UBound(arrGroup)
strPtLv = "PtLv" & i
For j = 0 To UBound(arrGroup(i))
arrPtLevel = array(arrGroup(i)(j)(0) , arrGroup(i)(j)(1) , arrGroup(i)(UBound(arrGroup(i)))(2))
arrPtLevel = rhino.AddPoint(arrPtLevel)
Call rhino.ObjectName(arrPtLevel , strPtLv)
Next
Call rhino.UnselectAllObjects
arrPtLv = rhino.ObjectsByName(strPtLv , True)
Call rhino.Command ("!_Delaunay" & " " & " " & "_enter _enter" & "_shader" & " " & "_none" & " " & "_enter")
Call rhino.DeleteObjects(arrPtLv)
Next
'-----------------------------------------------------------------------------------
Dim arrMesh : arrMesh = rhino.ObjectsByType(32 , True)
For Each i In arrMesh
Call rhino.ObjectName(i, "Delaunay")
Next
'-----------------------------------------------------------------------------------
' Dim dblAreaBase : dblAreaBase = rhino.CurveArea (Base)
'-----------------------------------------------------------------------------------
Dim arrOLine
Dim arrOLines()
Dim strOline
Call rhino.Command ("!_CPlane" & " " & "_World" & " " & "_Bottom")
For i = 0 To UBound(arrMesh)
Call rhino.UnselectAllObjects
Call rhino.Command ("!_bottom")
Call rhino.SelectObject(arrMesh(i))
Call rhino.Command("!_Meshoutline" & " " & "_enter")
arrOLine = rhino.ObjectsByName("",True)
strOline = arrOLine(0)
Call rhino.ObjectName(strOline,"Outline")
Call rhino.MoveObject(strOline , array(0,0,0) , array(0,0,arrGroup(UBound(arrGroup)-i)(UBound(arrGroup(i)))(2)))
Call rhino.command("!_Perspective")
'-----------------------------------------------------------------------------------
If strType = "Varie Coubure" Then
Dim arrVertice : arrVertice = rhino.PolylineVertices(strOline)
strOline = Rhino.AddInterpCurveEx (arrVertice , 3 , 1 )
End If
'-----------------------------------------------------------------------------------
ReDim Preserve arrOLines(i)
arrOLines(i)= strOline
Next
Call rhino.Command ("!_CPlane" & " " & "_World" & " " & "_Top")
'----------------------------------------------------------------------------------
Call rhino.UnselectAllObjects
Call rhino.DeleteObjects(arrPoints)
'----------------------------------------------------------------------------------
Dim strSite : strSite = rhino.CopyObject(Base)
Dim arrLoft()
For i = 0 To UBound(arrOlines) + 1
If i <> UBound(arrOlines) + 1 Then
ReDim Preserve arrLoft(i)
arrLoft(i) = arrOlines(i)
End If
If i = UBound(arrOlines) + 1 Then
ReDim Preserve arrLoft(i)
arrLoft(i) = strSite
End If
Next
Dim arrForm
arrForm = Rhino.AddLoftSrf (arrLoft , , , 2 , 0 , , False)
Call rhino.ObjectName(arrForm , "Enveloppe")
Dim arrCap : arrCap = rhino.ObjectsByName("Enveloppe")
Call rhino.CapPlanarHoles(arrCap(0))
strForm = arrCap(0)
'----------------------------------------------------------------------------------
strPtEnv = PtLimitor(strPtLimite , strForm)
'----------------------------------------------------------------------------------
Call rhino.DeleteObjects(arrMesh)
Call rhino.DeleteObjects(arrLoft)
'----------------------------------------------------------------------------------
End Select
'----------------------------------------------------------------------------------
Dim nPtEnv : nPtEnv = rhino.PointCloudCount(strPtEnv)
strText4 = rhino.AddText("nombre de point dans volume : " & nPtEnv , Bbox(6),1)
Call rhino.ObjectName(strText4 , "Text")
'----------------------------------------------------------------------------------
FormGenerator = array(strForm , strPtEnv)
End Function

Function Gabarit(dblHigh , strSite)
Dim arrLimite
arrLimite = array(strSite)
arrLimite = rhino.AddPlanarSrf(arrLimite)
Dim strHigh : strHigh = rhino.AddLine(array(0,0,0) , array(0,0,dblHigh))
Dim strLimite
strLimite = rhino.ExtrudeSurface(arrLimite(0) , strHigh , True)
'-----------------------------------------------------------------------------
Call rhino.DeleteObjects(arrLimite)
Call rhino.DeleteObject(strHigh)
Call rhino.UnselectAllObjects
'-----------------------------------------------------------------------------
Gabarit = strLimite
End Function

Function PtLimitor(PtCloud ,Limite)
Dim Points : Points = rhino.PointCloudPoints(PtCloud)
Dim arrPtsIn()
Dim arrPtsOut()
Dim i , j , N
j = 0
N = 0
For i = 0 To UBound(Points)
If rhino.IsPointInSurface(Limite , Points(i)) Then
ReDim Preserve arrPtsIn(j)
arrPtsIn(j) = Points(i)
j = j + 1
Else
ReDim Preserve arrPtsOut(N)
arrPtsOut(N) = Points(i)
N = N +1
End If
Next
'---------------------------------------------------------------------------
If isArray(arrPtsIn) Then
Dim strPtsIn : strPtsIn = Rhino.AddPointCloud (arrPtsIn)
Call rhino.ObjectColor(strPtsIn , RGB(139,121,94))
Call rhino.ObjectName(strPtsIn , "PtsIn")
End If
If isArray(arrPtsOut) Then
Dim strPtsOut : strPtsOut = Rhino.AddPointCloud (arrPtsOut)
Call rhino.ObjectColor(strPtsOut , RGB(230,230,230))
Call rhino.ObjectName(strPtsOut , "PtsOut")
End If
'---------------------------------------------------------------------------
Call rhino.DeleteObject(PtCloud)
'---------------------------------------------------------------------------
PtLimitor = strPtsIn
End Function

'====================================================================

Function VoronoiCell(Points , Length , Evlp)

Dim arrCells
Dim arrSrfs()
Dim i, j ,N
'-------------------------------------------------------------------
For i = 0 To UBound(Points)
'------------------------------------------------------------------------
N = 0
For j = 0 To UBound(Points)
If j <> i Then
Dim vecDir : vecDir = rhino.VectorCreate (Points(j) , Points(i))
Dim vecMid : vecMid = rhino.VectorDivide (vecDir , 2)
Dim arrMidPt : arrMidPt = rhino.PointAdd(Points(i) , vecMid)
Dim arrPlane : arrPlane = rhino.PlaneFromNormal (arrMidPt, vecDir)
Dim strSrf : strSrf = Rhino.AddPlaneSurface (arrPlane, 2*Length, 2*Length)
Dim arrCenter : arrCenter = Rhino.SurfaceAreaCentroid (strSrf)
Call rhino.MoveObject(strSrf , arrCenter(0) , arrMidPt)
ReDim Preserve arrSrfs(N)
arrSrfs(N) = strSrf
N = N + 1
' Call Rhino.HideObject (strSrf)
'--------------------------------------------------------------
End If
Next
'-----------------------------------------------------------------------------------
' Call Rhino.ShowObjects (arrSrfs)
Dim strEvlp : strEvlp = rhino.CopyObject(Evlp)
Dim strCell : strCell = strEvlp
Dim arrInput1 : arrInput1 = array(strCell)
For j = 0 To Ubound(arrSrfs)

Dim arrInput2 : arrInput2 = array(arrSrfs(j))

Dim arrCell : arrCell = Rhino.BooleanIntersection (arrInput1, arrInput2)

If isArray(arrCell) Then
arrInput1 = arrCell
Else
Call rhino.DeleteObject(arrSrfs(j))
End If

Next
'----------------------------------------------------------------------------
Next
'---------------------------------------------------------------------------
Call rhino.DeleteObject(Evlp)
VoronoiCell = rhino.ObjectsByName("Cell")
End Function

Function AlignXY(Points)
Dim arrPts()
Dim arrNear , dblNear
'-------------------------------------------------------------------------
Dim i ,j
For i = 0 To UBound(Points)
dblNear = 10000
'-----------------------------------------------------------------------
For j = 0 To UBound(Points)
If i<>j Then
Dim arrPtXY1 : arrPtXY1 = array(Points(i)(0), Points(i)(1),0)
Dim arrPtXY2 : arrPtXY2 = array(Points(j)(0), Points(j)(1),0)
Dim dblDis : dblDis = Rhino.Distance(arrPtXY1 , arrPtXY2)
If dblDis < dblNear Then
dblNear = dblDis
arrNear = Points(j)
End If
End If
Next
'-------------------------------------------------------------------------
If i<>j Then
arrPtXY2 = array(arrNear(0), arrNear(1),0)
Dim vecDir : vecDir = rhino.VectorCreate (arrPtXY2 , arrPtXY1)
Dim vecMid : vecMid = rhino.VectorDivide (vecDir , 2)
Dim arrMidPt : arrMidPt = rhino.PointAdd(arrPtXY1 , vecMid)
Dim arrMidPtZ : arrMidPtZ = array(arrMidPt(0) , arrMidPt(1) , Points(i)(2))
ReDim Preserve arrPts(i)
arrPts(i) = arrMidPtZ
End If
'-------------------------------------------------------------------------
Next
'-------------------------------------------------------------------------------
AlignXY = arrPts
End Function

Function AlignXYZ(Points)
Dim arrPts()
Dim arrNear , dblNear
'-------------------------------------------------------------------------
Dim i ,j
For i = 0 To UBound(Points)
dblNear = 10000
'-----------------------------------------------------------------------
For j = 0 To UBound(Points)
If i<>j Then
Dim dblDis : dblDis = Rhino.Distance(Points(i), Points(j))
If dblDis < dblNear Then
dblNear = dblDis
arrNear = Points(j)
End If
End If
Next
'-------------------------------------------------------------------------
If i<>j Then
Dim vecDir : vecDir = rhino.VectorCreate (arrNear , Points(i))
Dim vecMid : vecMid = rhino.VectorDivide (vecDir , 2)
Dim arrMidPt : arrMidPt = rhino.PointAdd(Points(i) , vecMid)
Dim arrMidPtZ : arrMidPtZ = array(arrMidPt(0) , arrMidPt(1) , Points(i)(2))
ReDim Preserve arrPts(i)
arrPts(i) = arrMidPtZ
'call rhino.AddLine(Points(i) , arrMidPtZ )
End If
'-------------------------------------------------------------------------
Next
'-------------------------------------------------------------------------------
'call rhino.AddPoints(arrPts)
AlignXYZ = arrPts
End Function

'====================================================================

Function Identity(Volumes)
Dim i
Dim arrM3
Dim arrM3s()
Dim dblTotal : dblTotal = 0
Dim nVolumes : nVolumes = UBound(Volumes)
For i = 0 To nVolumes
arrM3 = Rhino.SurfaceVolume(Volumes(i))
Call Rhino.Print ("polysurface volume : " & arrM3(0))
dblTotal = dblTotal + arrM3(0)
ReDim Preserve arrM3s(i)
arrM3s(i) = arrM3(0)
Next
Call Rhino.Print ("totale volume : " & dblTotal)
'-------------------------------------------------------------
Dim N : N = 0
Dim M : M = 0
Dim dblIndice :dblIndice = dblTotal/nVolumes '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Dim arrPlus()
Dim arrMinus()
For i = 0 To nVolumes
If arrM3s(i) > dblIndice Then
ReDim Preserve arrPlus(N)
arrPlus(N) = Volumes(i)
N = N + 1
End If
If arrM3s(i) <= dblIndice Then
ReDim Preserve arrMinus(M)
arrMinus(M) = Volumes(i)
M = M + 1
End If
Next
'------------------------------------------------------------------
Dim arrBbox : arrBbox = rhino.BoundingBox(Volumes)
Dim strText1 , strText2 , strText3
strText1 = rhino.AddText ("indice de classement volume : " & dblIndice , array(arrBbox(6)(0) ,arrBbox(6)(1) - 4 , arrBbox(6)(2)) , 1)
strText2 = rhino.AddText("cell + : " & UBound(arrPlus)+1 , array(arrBbox(6)(0) ,arrBbox(6)(1) - 6 , arrBbox(6)(2)) , 1)
strText3 = rhino.AddText("cell - : " & UBound(arrMinus)+1 , array(arrBbox(6)(0) ,arrBbox(6)(1) - 8 , arrBbox(6)(2)) , 1)
'------------------------------------------------------------------------
Call Structure(arrMinus)

End Function

Function Structure(Volumes)
Dim arrStrctr()
Dim i,j
'--------------------------------------------------------------------------------
For i = 0 To UBound(Volumes)
If Rhino.IsPolysurfaceClosed ( Volumes(i))Then
'---------------------------------------------------------------------------------------
Dim arrSrfs : arrSrfs = rhino.ExplodePolysurfaces( Volumes(i) , True )
'-------------------------------------------------------------------------------
For j = 0 To UBound(arrSrfs)
Dim arrCvs1 : arrCvs1 = rhino.DuplicateEdgeCurves(arrSrfs(j))
Dim arrPl1 : arrPl1 = rhino.JoinCurves(arrCvs1,True)
Dim arrCenter : arrCenter = Rhino.SurfaceAreaCentroid (arrSrfs(j))
Dim strSrfSc : strSrfSc = rhino.ScaleObject(arrSrfs(j) , arrCenter(0) ,array(0.9 , 0.9 , 0.9) , False)
Dim arrCvs2 : arrCvs2 = rhino.DuplicateEdgeCurves(strSrfSc)
Dim arrPl2 : arrPl2 = rhino.JoinCurves(arrCvs2,True)
Dim arrVts : arrVts = Rhino.PolylineVertices(arrPl2(0))
If isarray(arrVts) Then
Dim strHole : strHole= Rhino.AddCurve (arrVts , 3)
End If
Dim arrContours : arrContours = array(arrPl1(0) , strHole)
Dim strSurface : strSurface = Rhino.AddPlanarSrf (arrContours)
'-----------------------------------------------------------------------------------------
' ReDim Preserve arrStrctr(j)
' arrStrctr(j) = strSurface(0)
'------------------------------------------------------------------------
Call rhino.DeleteObject(strSrfSc)
Call rhino.DeleteObjects(arrPl1)
Call rhino.DeleteObjects(arrPl2)
Call rhino.DeleteObject(strHole)
'-------------------------------------------------------------------------------
Next
' Call rhino.JoinSurfaces(arrStrctr,True)
End If
Next
End Function

Function Extractor(Modules)
Dim arrInte()
Dim arrExte()
'----------------------------------------------------
Dim arrParois : arrParois = Rhino.ExplodePolysurfaces(Modules , True)
Dim arrCentre
'---------------------------------------------------
Dim blnONOFF
Dim i , j
Dim N , M
N = 0
M = 0
For i = 0 To UBound(arrParois)
If rhino.IsObject(arrParois(i)) Then
blnONOFF = False
For j = 0 To UBound(arrParois)
If rhino.IsObject(arrParois(j)) Then
If j<>i Then
arrCentre = Rhino.SurfaceAreaCentroid (arrParois(i))
If rhino.IsPointOnSurface(arrParois(j) , arrCentre(0)) Then
Call rhino.DeleteObject(arrParois(j))
ReDim Preserve arrInte(N)
arrInte(N) = arrParois(i)
blnONOFF = True
N = N + 1
Exit For
End If
End If
End If
Next
If blnONOFF = False Then
ReDim Preserve arrExte(M)
arrExte(M) = arrParois(i)
M = M + 1
End If
End If
Call rhino.Print (i)
Next
'---------------------------------------------------------------------------
Extractor = array(arrInte , arrExte)
End Function

Function SurfaceEvaluateDivide(Surface)

Dim i , j

Dim arrDomainU, arrDomainV
Dim arrParam(1)
Dim arrPt
Dim nDivideU: nDivideU = 6
Dim nDivideV: nDivideV = 10

ReDim Matrix(nDivideU, nDivideV)

arrDomainU = Rhino.SurfaceDomain(Surface, 0)
arrDomainV = Rhino.SurfaceDomain(Surface, 1)

For i=0 To nDivideU
For j=0 To nDivideV
arrParam(0)=((arrDomainU(1)-arrDomainU(0))/nDivideU)*(i)
arrParam(1)=((arrDomainV(1)-arrDomainV(0))/nDivideV)*(j)
arrPt = Rhino.EvaluateSurface(Surface,arrParam)
' Call Rhino.addpoint (arrPt)
Matrix(i,j) = arrPt
Next
Next
Dim Pt1, Pt2, Pt3, Pt4
For i=0 To nDivideU-1
For j=0 To nDivideV-1
Pt1 = Matrix(i,j)
Pt2 = Matrix(i+1,j)
Pt3 = Matrix(i+1,j+1)
Pt4 = Matrix(i,j+1)
Call Paneling(Pt1,Pt2,Pt3,Pt4)
Next
Next
End Function

Function Paneling(Pt1,Pt2,Pt3,Pt4)

Dim arrPts1 : arrPts1 = array(Pt1,Pt2,Pt3)
Dim panel1 : panel1 = Rhino.AddSrfPt (arrPts1)
Dim arrPts2 : arrPts2 = array(Pt1,Pt3,Pt4)
Dim panel2 : panel2 = Rhino.AddSrfPt (arrPts2)

End Function

Function XGrid(Pt1,Pt2,Pt3,Pt4)

Dim linonetwo, lintwothre, linthrefour, linfourone, linonethre, lintwofour

linonetwo = Rhino.AddLine (Pt1, Pt2)
lintwothre = Rhino.AddLine (Pt2, Pt3)
linthrefour = Rhino.AddLine (Pt3, Pt4)
linfourone = Rhino.AddLine (Pt4, Pt1)
linonethre = Rhino.AddLine (Pt1, Pt3)
lintwofour = Rhino.AddLine (Pt2, Pt4)

End Function

RhinoScript Workshop. Students Training ESA

2007-06-06T23:02:00.000+01:00

I’m pleased to post one of the scripts developed during the Generative Script workshop at Ecole Special d'Architecture de Paris I superviewed d in middle April. This is a first draft of further developing scripts by Joaquim Silvestre. The aim of Joaquim was to generate a parametric ramp for vehicles, based on site, functional and structural constraints. Thus the idea was to develop a script able to grow into a vertical structure for car storage. This is one of the first training. I want acknowledge the students from Esa for their participation and their constant interest to go ahead in this first essay.

edmondo occhipinti

Option Explicit

'workshop growing structuresgenerative scripts
'Script supervisor edmondo occhipinti COdesignLab
'Script written by silvestre joak ecole speciale d'architecture
'Script version lundi 16 april 2007 13:54:22

Sub CDR

Dim X
Dim Y

Dim arrRect
Dim tempcuba
Dim tempoint(4)
'creation du rectangle limitatif
arrRect=Rhino.Getrectangle (2)
Dim surface
surface = Rhino.addsrfpt(arrrect)

tempoint(4)=Rhino.addpointCloud(arrRect)

Dim bala
bala= Array(1,1,1)
Dim aroo
aroo=Array(0,0,0)
Dim Xi,Yi
X= Rhino.vectorCreate(arrRect(0), arrRect(1))
Xi=(Rhino.vectorLength(X))
Y= Rhino.vectorCreate(arrRect(0), arrRect(3))
Yi=(Rhino.vectorLength(Y))
Dim balpha
balpha=Rhino.Angle (arrRect(0), arrRect(1))
'balpha=(Rhino.VectorDotProduct(Array(1,0,0),X))
Rhino.print (balpha(0))
'Rhino.print(Rhino.ToDegrees(balpha))
If IsNull (balpha) Then
Rhino.print"Pb avec variable balfa"
End If
Dim gloubi
gloubi=(Rhino.vectorAdd(x,y))
Dim boulga
boulga=(Rhino.vectordivide(gloubi,2))
Dim pluto
pluto=(Rhino.PointAdd (aroo,boulga))
If IsNull(pluto) Then
Rhino.print"Pb avec variable pluto"

End If
'Dim gepeto
'gepeto=Rhino.pointcoordinates (pluto)
'//////////////////////////////////////////////////
Dim no
no=70
Dim arrpoint,arrpointO
Dim radius
Dim strRamp
Dim strRampO
ReDim arrPoints(0)
ReDim arrPointsO(0)
Dim bi
Dim g
ReDim g(2)
radius=(Rhino.Distance(arrRect(0), arrRect(3)))/2
Dim a,az,baz
az=1
a=1

Dim n,deltah
n=0

Do
no=n+1
'new new new new

baz=n/4
'For bi= -5 To 10 Step 0.025
'g(0)=(bi * Sin(5*bi))
'g(1)=(bi * Cos(3*bi))
Dim XB,YB,ZB

Dim XU,YD,ZF
'XU=((radius)*Sin(n))
XB=baz*2
XU=(((radius)*Sin(n))*(Xi/(radius*2)))'+XB

'YD=((radius)*Cos(n))
YB=n+5
YD=(((radius)*Cos(n))*a*(Yi/(radius*2)))'+YB
ZB=n/2'*(((n*n)+5*n+4)/no)
ZF=ZF
arrPoint=Array(XU,YD,ZF)
If n>1 Then
Dim vector,ptprec

Call Rhino.Print("intheboucle"&n)
vector= Rhino.vectorcreate (ptprec,arrPoint)
deltah= Rhino.vectorlength (vector)/7
Call Rhino.Print("deltah"&deltah)

ZF=ZF+deltah
Call Rhino.Print("ZF"&ZF)
Else
ZF=0
End If
arrPoint=Array(XU,YD,ZF)

If Abs(XB)>Xi/2 Then

az=0.25
End If
If Abs(XB)>Xi Then

a=-a
End If
If n>no/4 Then

a=Sin(baz)
End If
If n>no/2 Then
baz=-n/4

a=Sin(baz)
End If
If Abs(YB)>Yi Then

a=-a
End If
'If XB<(-1*Xi) Then
' a=-a
' End If
arrPointO=Array(XB,YB,ZB)
'arrPoint=Array((radius/sqr(n+1) * Sin(5*n)), (radius/sqr(n+1) * Cos(3*n)),n/2)
Dim teemp
'teemp=(arrPoint
Call Rhino.Print("n"&n)
ReDim Preserve arrPoints(n)
arrPoints(n)=arrPoint
ptprec=arrPoints(n)
ReDim Preserve arrPointsO(n)
arrPointsO(n)=arrPointO
'change radius
Dim random:random=Rnd()
If random<0.5 Then
radius=radius+.1+(Rnd()*2.1)
radius=radius+.1-(Rnd()*1.5)
End If
'Next
n=n+1
If ZF>200 Then Exit Do
Loop
Dim arrLine,arrLineO
arrline=arrpoints
arrLineO=arrpointsO
StrRamp=Rhino.AddCurve(arrLine)
StrRampO=Rhino.AddCurve(arrLineO)
Dim longroute
longroute=Rhino.curvelength (StrRamp)
Call Rhino.Print("longueurroute"&longroute)

Dim ctrRect
ctrRect=(Rhino.PointSubtract (arrRect(0),boulga))
If IsNull(ctrRect) Then
Rhino.print"Pb avec variable ctrRect"
End If
'ligne pr tester
Dim testline,stato,arivo

stato=Array(0,0,0)
arivo=Array(10,0,0)
'testline=rhino.addline( stato,arivo)
Dim movtest,movtestO
movtestO=Rhino.RotateObject (StrRampO, Array(0,0,0), (balpha(0)))
movtest=Rhino.RotateObject (StrRamp, Array(0,0,0), (balpha(0)))
Dim movu,movuO
movuO=Rhino.MoveObject (movtestO, Array(0,0,0), ctrRect)
movu=Rhino.MoveObject (movtest, Array(0,0,0), ctrRect)

End Sub
CDR

cyber.|N|.ethics

2007-06-06T22:42:00.000+01:00

CyberNethics

Ethic and pathetic! It looks like a funny text, as intensive as I was able to hide the “in between”, and as naïve as I didn’t hide the indecent rave against pseudoscientific-form-workers. Something potently emerges from some kind of considerations about the increasing development of a wide range of new disciplines in the middle twentieth century. [As just noted, by someone else, it’s not so obvious that the inventor of telephone and the engineer of the first reticular structures, are (quite) the same man]. What I need, what I would try to do, it’s to link, to find links, to re-reduce disciplines to their own principles and to allow an “essential” richness of interdisciplinary field. Quite a hard aim, but I’m not a scientist; thus everything is permitted, since while wearing clothes of an architect, people don’t matter about my approach. (That’s False! But let me believe it).

Based on first studies about self-organization and organic systems constitution , Shannon information theory, Wiener cybernetic with control and servomechanism theory and a bad-named discipline (artificial intelligence) born and developed in the early Fifties. What was really focused in this period was the increasing interest for reducing animate phenomena into physic-chemic ones; it demonstrated the favour for reductionism more than for vitalism. Emergent biologic discipline had to make use of external organizational principles such as information, code, communication, inhibition, repression, control. As noted by Morin, these notions had a cybernetic character in what they identified cellule as a self-controlled and information-based machine. Cybernetic is one of the sciences focused on structure and organization (and control); a machine I an organised whole that cannot be studied beginning on individual feature of its constituents. (The same concept is the base of complex systems theory and this is something I would like to discuss in further text).

Demonstrating that there’s no living matter, but a structured organization of physic-chemic matter, informational and cybernetic notions are not just referred to high-organized machine: paradigmatically jumping from matter to structure, all the matter relative metaphors change in structure relative ones. [Note the same amplitude and nature of jumping from Euclidian space to topological structures, from Cartesians coordinate (x, y and z) to directional vector fields (U and V), from striated to smooth Deleuzian form of space, and so on]. Thus physic, body, substance, energy, physic world, quantitative analysis changes into cybernetic, form, mind, communication, biological world, whole’s organization and qualitative analysis. Cybernetics pustules that physics are just a cybernetic branch since its interest bases on matter stabilized structures.

No surprises about the whole cybernetics evolutionary theory-one that begins on the level of individual atoms and molecules, continues through the origin of life and the development of plants and animals, reaches the level of man and self-consciousness, and develops further in the intellectual creations of man, particularly in scientific knowledge- by Turchin. The idea that give from to cybernetic development I that the model, or structure, organize the physic process; this lead inevitably with the concept of retroaction, command of an activated system, able to reinsert in its own the results of its behaviours. In few steps, we’ll assist to the emergence of self-organization, particularly of self-reproducing automata by Von Neumann, of order from noise by Von Foerster and of case-self-organizing by Atlan.

When, in the Sixties, Lorenz introduce the butterfly effect successfully emphasize the way to think relationships and interactions. But also in this case –just like the telephone and the reticular structures- we’ll not be surprised to recognize that an embryonic expression of the butterfly effect was just introduced in ’50 by Alain Turing in Computer Machinery and Intelligence (in that case Turing express how the smallest electron movement can cause the death of a human being determining the extinction of its future generation end of its genetic improvements). If on one hand human being is trying to investigate complexity, to define it and to reproduce it, on the other hand, we assist to several efforts to rationalize it, to simplify its rules, to control it. Computer science is a fundamental discipline to fully understand these steps. The Wolfram New Kind of Science is just one example of most comprehensive essays on explaining complexity in every phenotypic manifestation, by postulating simple computer-based rules that determine it. (Could we find axiomatic relationship between Wolfram computer-based approach and Turchin cybernetic logics? It’s not the point, but it doesn’t prevent to fascinate me). What is the real affordance of chaos’s theory, of catastrophes’ theory, of complex systems theory? An epistemology of complexity seems the only paradigm we can auspicate to implement in every field of human sciences today.

Organize means to determine descriptive constraints, like spatial form, volume, limits; it means to create selective interactions between elements; it means to define the existence of energy for interactions; thus it means self-produce-by available energy and hypothesized interactions- organization. Artificial intelligence and computer science are born. Now, what is a script?

Edmondo Occhipinti

Structural Optimization. 3d Phononic Crystals

2007-05-16T16:08:00.000+01:00

Structural optimization molecular modelling (not based on the molecular modelling tool by Reconstructivism). I’m working on coding it. I would like to save the work-in-progress code until the end, just to avoid several actualizations dues to changing and re-structuring the actual code. In few words, it bases on a structural module made by two meatball spheres, built by parametric dimensions, inputted in the code. Right now the code places the module according to characteristic angles of sixty spatial degrees, building three-dimensional cells, based on hexagons; something really similar to photonic and phononic 3d crystal structures. The aim would be to begin varying the module according to different external conditions: I’m thinking to compression, dilatation, and modification of internal proportions. I’ll put generative component to work.

Morphogenetic, Ethic and Pathetic

2007-05-14T22:23:00.000+01:00

The introduction, by Leibniz, of differential calculus, which paradigm was surely constituted by the variable curvature, and of the consequent topologic geometry, rationalized in the end of nineteenth century by Felix Klein (which introduces the concept of vectorial field, differential shape and curvilinearity, bases of the general relativity theory), determines the passage from the discrete pace, Descartes’ prerogative, to a space-time. In this new spatial-temporal logic, every morphological entity cannot be seen as not as a continuum, nerved by forces, that is, by dynamic differentials. It’s just on these bases that the illuminist dream of describing reality by differential equations became a even unreal possibility. But it’s only in the twentieth century that the research of solving natural forms by a mathematical approach, push forward as powerfully as it began to be compressed into an individual discipline, commonly (un)known as morphogenetic.

Publishing, in nineteen seventeen, On Growth and Form puts the Scottish biologist Wentworth D’Arcy Thompson at the origin of a research field that will fill the entire scientific cursus of the twentieth century. His analysis, however based on extrapolating intuitive mathematic relationships and on dynamic reactions, always still reminiscent of Newtonian physics – let’s remember that just ten years before the space become curve –fixes a revolutionary paradigm on natural, organic and inorganic forms genesis; as Lynn notes, the grateful merit of Thompson was to have identified gradient forces, both endogenous and exogenous, able to form, (in)form, (de)form and (trans)form, natural structures and optimize their geometries according to external physic-contextual and environmental variables.

The interest was pushed, in the short range of a human life, from the result to the process, from the form to the structure: form is not longer an aprioristic data, but a process, a result of progressive metamorphosis, ruled by geometric-topological, physic and mathematic laws. Then, as exactly happened with the projective geometry, which expressed, with Desargues first and - more structurally - with Monge after, how was always possible to homologically deduce the geometric rules that transform one shape into another, just from the features of the original one, at the same time, systems of homographic analysis and morphogenetic previsions are introduced in biology.

It’s not surprising that one doesn’t understand the complex mathematic-geometric whole that characterize the chaotic systems and the fractal theories of Benôit Mandelbrot –neither that the not simpler morphogenetic theory of René Thom, commonly known as catastrophes’ theory –produce significant considerations in the consciences of these ones that, consciously or not, daily work with shapes; but what is not surprising, I hope, it’s that by sure the progressive development of a morphogenetic research field, legitimized by a topologic-differential dialectic, produced a substantial reconsideration of the form, the space and its dynamic coordinates. It will become legal to discuss the real opportunities that the introduction of a morphogenetic logic provides to the architectural field.

Digital technologies had definitively modified our approach to the space, allowing us to work with vectorial fields and topological geometries, in a intens(iv)e space, not just defined by traditional Cartesian coordinates, but even by movements, forces and interactions fluxes and, last but not least, by the temporal variable and it generative potential; I don’t think superfluous to remember the n-dimensionality of vectorial spaces. The topological space vectorial definition call an intensive work on diagrammatic structuring information, consciously mediating different order’ variables, aided-proliferating more complex genetic patrimonies, constantly transacting stable evolutionary path and unexpected bifurcations.

Form became negation of its own circumstantial singularity, became phylum, a topologically equivalent shapes’ family, binary combination, a data’ metamorphic flux, auto-organising and unpredictable sequence. The introduction of morphogenetic dynamics in architecture needs a revaluation of standardized models (I mean modules): it implies to think the project in an inverse procedural way – let’s say bottom-up – as the unfolding of a process in which the diagrammatic structuring of information (information related with meta-project conception) became generative reason of unexpected results. Specifically, I see the integration of interdisciplinary tools, techniques and competences as the best way to optimize the architectural result according to characterizing variables; this could allow us to introduce the user into a complete emotive dynamics, into a continuous sensational metamorphose.

Dilatation of interdisciplinary involved panorama is needed. We need to introduce osmotic and synergic dynamics, focusing the definition of a morphogenetic sustainability where bio-mimetic and eco-performing logics could be able to afford (with Gibson) significant and proved legitimacies to the architectural result. Just in this sense form, in its architectural paradigm too, cannot be see as an aprioristic and unconditioned dictate, neither as a visionistic or intuitional creation; form we’ll be considered as a procedural equilibrium, always contingent and conditional, but anyway as a product of structural and associative information. This will bring new feelings, new ways, and new dimensions to live the space, to affect it and to be affected by it, suggesting suggestive finalities, catastrophic scenarios, chaotic spatiality. Innovation is not just transformation, but transformation related with contemporary socio-cultural effects; we always have to find it useful, or, at least, meaningful.

I apologise my English. This is also a problem of form…

Edmondo Occhipinti

growing structures workshop

2007-04-20T21:09:00.000+01:00

this workshop was organized by paolo cascone during two days of the eco.logical high-rise atelier atecole speciale d'architecture de paris. i was invited to introduce the students to script in rhino. here the abstract of my lesson.

The first aim of this workshop was to teach the basics of the RhinoScript language end the logic of its use. The main focus of my approach was to use a scripting techniques that allow the generation of growing structures families based on parametric variations into the body of the script. On making this we just worked on vertical structures and on the growing possibilities of these structures according to the crucial geometric rules which constitute the genetic matter of our design purposes. The advantage of this logic is the possibility to evaluate and test an ideally infinite forms family by just modifying some specific variable’s values.
Structure
The workshop was divided in three main phases: a basic first, an analyzing second and an operational third. Every phase included example and sample exercise.
-basics
In the first phase i exposed the fundamentals of the Script in general, and of the VB.Rhino script in detail. We studied the basic grammar of this language and the main structural rules: variables, conditionals, flow control of a script will be the main focused topics of this first approach. Practical example and dedicated exercises completed this phase.
-script analysis and editing
Once learned the basics of grammar and syntax we leaded with the structure of a script. How to build a basic script, how to run it, how control variations, errors, etc…, this was the main focus of this phase. We also leaded with basic examples and exercise, but we also analyzed some more complex script, trying to understand their logic and their structure.
-script generation
In this last phase we focused on scripting. We began to build our own script and to test them. We focused our attention on building scripts able to output vertical structures, and able to be dynamics, that is, able to grow, to be edited and modified during their execution.

the output of this workshop will be soon available at the blog of the atelier.

edmondo occhipinti

density points based pattern

2007-04-18T22:07:00.000+01:00

this is a little simple script that allows to output different radii circles based on a point set input.my aim was to map a density values from some environmental numerical datas. with this code i can have a circle based pattern that changes its dimension according to the distance between every point and all the other ones. in this first phae of developping i implemented also an extrusion value based on the distance too. every circle will generate inscripted polygons with different height, and will print the smallest distance from the center of the nearest circle. basic, i mean beginner's all purpose symbolic instruction code , but useful. in progress...

Option Explicit

'This Script Generate Different Circles and Boxes based on Points set and their Relative Distances

'Transformation of the Compartments into Tube or Spine in IL 38 Diatom II

'Code by Edmondo Occhipinti Architect [codesign.lab] 2007

MsgBox "Code by Edmondo Occhipinti Architect edmondo@co-design-lab.net"

Sub Circles

Dim arrpts

Dim dbdist, dbtotdist

Dim i, u

arrpts = Rhino.GetPointCoordinates ("Select Points to Create Skeleton Pattern")

If IsNull (arrpts) Then

Exit Sub

End If

for i = 0 To UBound (arrpts)

dbtotdist = 1000000

For u = 0 To UBound (arrpts)

dbdist = Rhino.Distance (arrpts(i), arrpts(u))

If u = UBound (arrpts) And dbdist = 0 Then

exit Sub

End If

If dbdist = 0 Then

u = u+1

dbdist = Rhino.Distance (arrpts(i), arrpts(u))

End If

If dbdist <>

dbtotdist = dbdist

End If

Dim arrPlane, crv, text

text = Rhino.AddText (dbtotdist, arrpts(i), dbtotdist/5)

arrPlane = Rhino.PlaneFromFrame (arrpts (i), Array(1.0,0.0,0.0), Array(0.0,1.0,0.0))

crv = Rhino.AddCircle (arrPlane, dbtotdist/2.1)

Dim arrone, arrtwo, arrthree, arrfour, arrpolyline

Dim base, height, basept, heightpt, secondpt

Dim strbox, strpath, two, three, four, deletepts

Rhino.EnableObjectGrips crv

arrone = Rhino.ObjectGripLocation(crv, 0)

arrtwo = Rhino.ObjectGripLocation(crv, 2)

arrthree = Rhino.ObjectGripLocation(crv, 4)

arrfour = Rhino.ObjectGripLocation(crv, 6)

Rhino.EnableObjectGrips crv, vbFalse

basept = Rhino.AddPoint (arrone)

two = Rhino.AddPoint (arrtwo)

three = Rhino.AddPoint (arrthree)

four = Rhino.AddPoint (arrfour)

base = Array (0, 0, 0)

height = Array (0, 0, 300/dbtotdist)

heightpt = Rhino.CopyObject (basept, base, height)

secondpt = Rhino.PointCoordinates (heightpt)

strpath = Rhino.Addline (arrone, secondpt)

deletepts = Array (basept, two, three, four)

arrpolyline = Array (arrone, arrtwo, arrthree, arrfour, arrone)

strbox = Rhino.AddPolyline (arrpolyline)

Rhino.ExtrudeCurve strbox, strpath

Rhino.DeleteObject strpath

Rhino.DeleteObject heightpt

Rhino.DeleteObjects deletepts

End Sub

Circles

edmondo occhipinti

dim.strP_rdl v.1 beta

2007-03-22T14:47:00.000+01:00

Voila. this is the complete code to draw parametric cells, and to grow them into specified number of floor. by varying the input value we'll have different pattern organization, and different scale, and different heights. just to try....and to be completed.

Option Explicit
'This script create structural cells grid based on honeycomb logic

'Edmondo Occhipinti Architecte codesign-lab 2007
MsgBox "Code by Edmondo Occhipinti Architecte codesign-lab 2007 edmondo@co-design-lab.net"

Sub DrawCell

Dim floors

Dim wth

Dim lng

Dim geomvalue

Dim udiv, vdiv

floors = Rhino.GetReal ("Enter the Number of floors", 4, 2, 20)

If IsNull(floors) Then

Exit Sub

wth = Rhino.getreal ("Enter the width of cell", 2, 0.001, 1000)If IsNull(wth) Then Exit Subgeomvalue = Rhino.getreal ("Enter cell geometry factor", 3, 0.1, 10)

If IsNull(geomvalue) Then

Exit Sub

udiv = Rhino.getreal ("Enter the number of division in U direction", 2, 1, 100)

If IsNull(udiv) Then

Exit Sub

vdiv = Rhino.getreal ("Enter the number of division in V direction", 2, 1, 100)

If IsNull(vdiv) Then

Exit Sub
lng = wth*geomvalue

''''''draw the conrol points of cell main spline''''''

Dim arrpt01, arrpt02, arrpt03, arrpt04, arrpt05, arrpt06, arrpt07, arrpt08, arrpt09

Dim arrpt1, arrpt2, arrpt3, arrpt4, arrpt5, arrpt6, arrpt7, arrpt8, arrpt9

Dim arrtotpts, arrcrvpts

arrpt01 = array (wth/2, 0, 0)

arrpt02 = array (wth/2, wth/2, 0)

arrpt03 = array (wth/4, lng/4, 0)

arrpt04 = array (0, lng/3, 0)

arrpt05 = array (0, lng/2, 0)

arrpt06 = array (0, lng * 2/3, 0)

arrpt07 = array (wth/4, 3*lng/4, 0)

arrpt08 = array (wth/2, 5* lng/6, 0)

arrpt09 = array (wth/2, lng, 0)

arrtotpts = array(arrpt01, arrpt02, arrpt03, arrpt04, arrpt05, arrpt06, arrpt07, arrpt08, arrpt09)

arrcrvpts = Rhino.addPoints (arrtotpts)

''''''draw the cell main spline''''''

Dim crv

crv = Rhino.AddCurve (arrtotpts)

Rhino.DeleteObjects arrcrvpts

Dim radius, circlebase, component, cmnd

radius = wth/10

circlebase = Rhino.AddCircle (arrpt01, radius, arrpt09)

component = Rhino.ExtrudeCurve (circlebase, crv)

''''''mirror the spline''''''

Dim arrone

Dim arrtwo

Dim mirrcomponent

Rhino.EnableObjectGrips crv
arrone = Rhino.ObjectGripLocation(crv, 0)

arrtwo = Rhino.ObjectGripLocation(crv, 8)
Rhino.EnableObjectGrips crv, vbFalse

Rhino.DeleteObject crv

Rhino.DeleteObject circlebase
mirrcomponent = Rhino.MirrorObject (component, arrone, arrtwo, vbTrue)

''''''copy cell into uv grid''''''
Dim cell

Dim strcrvs

Dim arrendptu, arrendptv, arraxis, scdpoint, arrenddeepu

Dim i, j

Dim arrtotudiv, arrtotvdiv, arrfirst, arrseconduline

cell = array (mirrcomponent, component)

scdpoint = array (wth, lng/2, 0)

arraxis = array (arrpt05, scdpoint)
For i = 1 To udiv - 1

arrendptu = array (wth*i, lng/2, 0)

arrenddeepu = array (0, (wth*vdiv)+(wth+(wth/2)), 0)

'ReDim Preserve arrtotudiv (i)

arrtotudiv = Rhino.CopyObjects (cell, arrpt05, arrendptu)

Rhino.RotateObjects arrtotudiv, arrpt01, 90, arraxis, vbFalse

'ReDim Preserve arrseconduline (i)

arrseconduline = Rhino.CopyObjects (arrtotudiv, arrpt05, arrenddeepu)

''''''solving first cell and v direction cells''''''

Dim cellvdir, rotcell, arrenddeepv, arrendmove

Dim vaxis

Dim firstrotpt, firstcopy, arrsecondvline

rotcell = Rhino.RotateObjects (cell, arrpt01, 90, arraxis, vbFalse)

firstrotpt = array (0, 0, lng/2)

cellvdir = Rhino.RotateObjects (rotcell, firstrotpt, 90, , vbTrue)

firstcopy = Rhino.CopyObjects (rotcell, arrpt05, arrenddeepu)

For j = 1 To vdiv

arrendptv = array (0, wth*j, lng/2)

'ReDim arrtovdiv (j) arrtotvdiv = Rhino.CopyObjects (cellvdir, firstrotpt, arrendptv)

arrenddeepv = array ((wth*udiv), wth/2, 0)

'ReDim Preserve arresecondvline (j)

arrsecondvline = Rhino.CopyObjects (arrtotvdiv, arrpt05, arrenddeepv)

arrendmove = array (0, wth/2, 0)

Rhino.MoveObjects arrtotvdiv, arrpt05, arrendmove

Rhino.DeleteObjects cellvdir

''''''copying floors''''''

Dim arrfirstfloor, arrptone, arrpttwo, arrotherfloors

Dim u, arrtotfloors, axeptend, axetwist
arrfirstfloor = Rhino.ObjectsbyType (8)

For u = 1 To floors-1

arrptone = array (udiv*wth/2, vdiv*wth/2, 0)

arrpttwo = array (udiv*wth/2, vdiv*wth/2, u*lng)

Rhino.CopyObjects arrfirstfloor, arrptone, arrpttwo

Next
axeptend = array (udiv*wth/2, vdiv*wth/2, floors*lng)

'axetwist = array (0, 0, 0)

axetwist = Rhino.AddLine (arrptone, axeptend)

arrotherfloors = Rhino.ObjectsbyType (8)

arrtotfloors = Array (arrfirstfloor, arrotherfloors)
''''''twisting''''''

Dim strObject

If IsArray (arrfirstfloor) Then

For Each strObject In arrfirstfloor

Call PipeOne(strObject, axetwist)

End If
End Sub
'Sub PipeOne(strObject, axetwist)
'Dim strCmd, axetwist2'angle = 90'axetwist2 = Array (0, 0, 10)
'strCmd = "! _Twist _SelID " & strObject & " _Enter _Enter" & axetwist & " _Enter" & axetwist2 &amp;amp;amp;amp;amp;amp;amp; " _Enter" '& angle & " _Enter"'Rhino.Command strCmd
'End SubDrawCell

''''''''To Be Completed'''''''''

edmondo occhipinti

dim.strP_rdl v.01

2007-03-17T00:53:00.000+01:00

implementing the same presvous logic into skyscaper generation script. the cell geometry of previous sample was rationalized into 3d box. two cells for every face. very box of 1:3 relation was divided by four plans generating three identical cube. every plans rotate progressivly of 120° degree. in this way i was able to repeat the box, growing the tower at the wished height and preserving continuity between floors. i'm also working more generally on tower generator scripts. ....to be updated....

'''''''''''''''''''''''''''''''''''''''
Sub crtplan

Dim IntFloorNumber
Dim IntFloorHeight
Dim DblFloorRotation
Dim arrObjects
Dim i

IntFloorNumber = Rhino.GetReal ("number of floors", 10, 2, 100)
IntFloorHeight = Rhino.GetReal ("height of floors", 4, 3, 6)
DblFloorRotation = Rhino.GetReal ("rotation of floors", 30, 0, 359)
arrObjects = Rhino.GetObjects("Select planar curve as a tower base plan", 4)
axispoint = Rhino.CurveAreaCentroid (arrObjects)

'Dim arrPlnSrf
'If IsArray(arrObjects) Then
'arrPlnSrf = Rhino.AddPlanarSrf (arrObjects)
'End If

''''copy floors

Dim arraystart
Dim arrayend
Dim intLevel
Dim arrCrv
Dim axispoint
For i = 1 To intFloorNumber
intLevel = IntFloorHeight * i
arraystart = Array(0, 0, i)
arrayend = Array(0, 0, intLevel)
arrCrv = Rhino.CopyObjects (arrObjects, arraystart, arrayend)

'''''''''''''''''''''''''''''''''''''''
workinprogress

dim.strPT_rdl v.00

2007-03-16T18:26:00.000+01:00

By studying the self-organizing basic structures from micro-organic samples, I’m working on a generative script able to adapt this pattern according to surface's curvature adaptation. Thinking on reverse engineering logics this pattern could be used to adapt the curvature to specific performance requirements. So if one needs to close or to extend the pattern as a responsive behaviour i.e. driven by solar exposure values, he should control the morphologies’ curvature according to this variable, reducing curvature radius in super-exposed zones and increasing it in sub-exposed ones. We should imagine to implement the sun movement (i.e. along a day) and to link this movement with a variable able to coherently change the curvature of an input surface…….To be Updated…..

edmondo occhipinti

''''''''''''''''''''''''''''''''''''''''''''

Sub AddCrv
Dim arrptDim arrcontrolDim crv
'arrpt = Rhino.GetObjects ("select control points for curve", 1)arrpt = Rhino.command ("selPt")
arrcontrol = Rhino.getPointcoordinates (,arrpt)
crv = Rhino.AddCurve (arrcontrol)
Rhino.UnselectAllObjects
Dim strMirDim arrgripDim arroneDim arrtwo
Rhino.EnableObjectGrips crv
arrone = Rhino.ObjectGripLocation(crv, 0)arrtwo = Rhino.ObjectGripLocation(crv, 8)
Rhino.EnableObjectGrips crv, vbFalse
Rhino.MirrorObject crv, arrone, arrtwo, vbTrue
End Sub

''''''''''''''''''''''''''''''''''''''''''''

Sub rectangle
Dim wth Dim lngDim strCmd
wth = Rhino.getreal ("enter the width of cell", 10, 0.001, 1000)lng = wth*3
strCmd = "! _Rectangle 0,0,0 " & wth & " " & lngRhino.Command strCmd End Sub
'Sub crvpoints ' Dim arrpt1' Dim arrpt2' Dim arrpt3' Dim arrpt4' Dim arrpt5' Dim arrpt6' Dim arrpt7' Dim arrpt8' Dim arrpt9' Dim arrtotpts ' arrpt1 = Mid ' arrtotpts = arrpt1 + arrpt2 + arrpt3 + arrpt4 + arrpt5 + arrpt6 + arrpt7 + arrpt8 + arrpt9' Rhino.addPoints (arrtotpts) rec
Dim divide Dim strrect strrect = Rhino.FirstObject divide = "! _Rebuild _SelID" & strrect & " _Enter" & " " & 0 & 8 & " _Enter _Enter" Rhino.Command divide

''''''''''''''''''''''''''''''''''''''''''''

workinprogress

2007-03-08T23:02:00.000+01:00

Let’s begin. By the requests of some students, friends and colleagues, here i am with the first post. This is both virtual and real, since virtual is not opposite to the real, but just part of it. here you will find several experiments about my research. the aim is also to launch an exchanging space of opinion, resources, both technique and theorical.