This project is an attempt to generate, and describe geometric objects in computational terms. The point of departure would be a set of “simple” constraints to generate the basic geometry and then a more “complex” constraint (daylight in this case) to manipulate and affect the base geometry.

Geometric constraints:
Span a canopy between a 4 sided polygon on the outside and a circle on the inside (similar to the ‘British Museum great court roof’).

External constraints:
Deform the geometry of the canopy in an attempt to either “cut-off” or “let-in” maximum daylight for a specific range of hours specified for any particular day in a year.

Advisor: Panagiotis Michalatos Course: Computational design – Numerical descriptions as design tools (Fall 2010, GSD, Harvard).

While the first set was an attempt to describe a knot surface (topologically complex) by subjecting two 3dimensional splines through a series of operations (rules) that are inherently simple in nature; the second set of surfaces was an attempt to embed parametric intelligence within the generative geometric model (in this case, the surface developed was an “approximation” of a  triply periodic minimal surface from the batwing family). This facilitates the study of variations within the surface so built and hence a deeper understanding of the volumetric variations that could perhaps lead to a possible architectural intervention. The surface after being discretized, was subjected to a simple modular population act which at its local scale was also embedded with parametric intelligence. This allowed for a powerful model of a complex topological surface that owing to its ability to be controlled at both its global and local scales with a different set of parameters, facilitated its easy “taming”.

The above set of operations were implemented within the Digital Projects interface (Geometric modeling + Powercopies + Knowledge Patterns).
Advisor : Andrew Witt;  from the course 2107m1 (Fall 2010, GSD Harvard)

Knot Surface.

Triply Periodic Minimal Surface – Batwing family.
For more info : Schoen’s batwing surface

Surface construction sequence

Parametric Variations

Physical model

Module Population

Rhino Scripting + Rhino Nest + Microsoft Excel + MasterCam + RobotMaster

Random info :
25 Sheets of Black coated aluminum 3′x4′x0.03″ cut into 560 pieces
25 Sheets of Plywood 3′x4′x0.25″ used to support aluminium on the waterjet bed
90 hrs (including re-cut pieces) waterjet cutting on 5 axis robot
Couple of thousand rivets
20 hrs assembling time

Team Credits : Karthik Dondeti, Fai Au, Jeremy Keagy, Evangelos Kotsioris, Yin Xiao

Course : 2408 InOrganic Assemblies (Spring 2010, GSD Harvard)
Instructor : Marc Fornes (http://www.theverymany.net/)

The ability to simulate performance is more often undermined by the lack of tools that facilitate a clear and efficient analysis of the data outputted. Hence a custom visualization tool was built in Processing, that allows users to plugin  simulation data from Energy Plus. The tool presents a series of interactive graphic displays of the energy performance for the target space. This would allow a user to comprehend the complexity of simulation results with much ease and facilitates a clear understanding of the performative potential of the building. The current version is the first in the development of this tool and possibly, a couple of iterations down, a much wider repertoire of interactions will be facilitated.

more about “Thermal Analysis Visualization Tool 1…“, posted with vodpod

An investigation into the inter-relatedness among the three seemingly different disciplines of geometric development, material behavior and digital manufacturing processes, manifests into this series of six beer mugs. Each of these are unique in form and encapsulate a complex interlocking ability, which enables them to be carried all together when held at the ends by pressing against each other.

Such is the potential of parametric geometry, that allows issues of function, form, ergonomics, aesthetics, and most importantly, the ability to manufacture with high precision of accuracy, all to be tackled simultaneously.

Geometry creation : Digital Projects, Fabrication : MasterCam + CNC milling of hardwood

Team work. Credits : Karthik Dondeti, Fai Au, Evangelos Kotsioris, Jeremy Keagy

Wouldn’t take long to realize the potential of recursion in its ability to generate relatively high levels of complexity from relatively few lines of code. Immediate objective of this exercise is to develop subdivision strategies (work in progress) for surfaces. Shown here are the sequential progress of recursive iterations developed starting from a simple rectangular grid of points.

Code is inefficient and unclean, and I am far too lazy to correct it, nevertheless, it works

Option Explicit
'Script written by <karthik.dondeti>
'Script copyrighted by <yet.another.script>
'Script version Wednesday, February 17, 2010 10:48:30 AM

Call Main()
Sub Main()

	f_face array(0,0,0),array(0,1,0),array(0,0,0),-90
	f_face array(0,0,0),array(1,0,0),array(0,0,0),90
	f_face array(0,0,0),array(1,0,0),array(0,0,180),0

	arrObjects = rhino.AllObjects
	rhino.UnlockObjects arrObjects
End Sub

Function f_face (arrBase,arrAxis,arrMove,angle)
	Dim arrCrvPt,gridPt,count,index,arrObj
	Dim strCrv,i,j,iMax,jMax,k,height,n
	n=10:iMax=n:jMax=n:index=0:height=0
	ReDim arrCrvPt(3),gridPt(iMax-1,jMax-1)

	For i=0 To iMax-1
		For j=0 To jMax-1
			If i=0 Or j=0 Or i=iMax-1 Or j=jMax-1 Then
				gridPt(i,j)=array(i*20,j*20)
			Else
				gridPt(i,j)= array(i*20+rnd*20,j*20+rnd*20)
			End If

			If i>0 And j>0 Then
				arrCrvPt(0)=gridPt(i,j)
				arrCrvPt(1)=gridPt(i-1,j)
				arrCrvPt(2)=gridPt(i-1,j-1)
				arrCrvPt(3)=gridPt(i,j-1)
				count = int(rnd*5)+2
				f_recurse arrCrvPt,count,index,0
			End If
		Next
	Next
	arrObj = rhino.AllObjects (True)
	arrObj = rhino.SelectedObjects
	rhino.RotateObjects arrObj,arrBase,angle,arrAxis
	rhino.MoveObjects arrObj,arrBase,arrMove
	rhino.LockObjects arrObj
End Function

Function f_recurse (arrPts,count,ini_index,height)
	Dim index,strSrf,k
	index= int(rnd*4)
	k = (rnd*(1/2))+(1/4)

	Dim midPt,arrCrv,arrCentro,strCrv,arrCrvPt,i
	ReDim midPt(3),arrCrv(3),arrCrvPt(3)

	For i=0 To 3
		If i<3 Then
			arrCrv(i)=rhino.AddCurve (array(arrPts(i),arrPts(i+1)))
			midPt(i)=array((1-k)*arrPts(i)(0)+k*arrPts(i+1)(0),(1-k)*arrPts(i)(1)+k*arrPts(i+1)(1))
		Else
			arrCrv(i)=rhino.AddCurve (array(arrPts(i),arrPts(0)))
			midPt(i)=array((1-k)*arrPts(i)(0)+k*arrPts(0)(0),(1-k)*arrPts(i)(1)+k*arrPts(0)(1))
		End If
	Next
	strCrv = rhino.JoinCurves (arrCrv)
	strSrf = rhino.ExtrudeCurvestraight (strCrv(0),array(0,0,count-2),array(0,0,count))
	rhino.CapPlanarHoles strSrf
	rhino.MoveObject strSrf,array(0,0,0),array(0,0,height)
	rhino.DeleteObjects arrCrv

	arrCentro = rhino.CurveAreaCentroid (strCrv)
	arrCrvPt(0)=arrCentro(0):arrCrvPt(1)=midPt(index)
	If index<3 Then
		arrCrvPt(2)=arrPts(index+1):arrCrvPt(3)=midPt(index+1)
	Else
		arrCrvPt(2)=arrPts(0):arrCrvPt(3)=midPt(0)
	End If
	count=count-1
	height=height+2
	If count>0 Then
		f_recurse arrCrvPt,count,index,height
	End If

End Function

Audio input is analysed using the Fast Fourier Transform algorithm within VVVV [fft node]. Audio frequency scales up the height of boxes. ‘Low mid out’ value scales the boxes along the base plane. ‘High mid out‘ value is responsible for the color change and finally the ‘high out‘ value controls the rotation of the boxes about the vertical axis.

Audio played back is by the artist Zero and the song’s called PSP 12′.

The next stage in this process was to stream the frequency values from VVVV into a text file that is being updated continuously in real time. This text file was further read inside grasshopper using a ‘Read File‘ component. These values are then utilized to manipulate the height of boxes inside rhino in real time. Currently, the test was attempted under simple conditions involving just the height of boxes. There seems to be a major jump in the processing power absorbed by rhino while attempting to update changes in real time. The setup seems to be clunky and slightly less responsive in updating the heights continuously.

more about “Realtime audio response in Grasshopper“, posted with vodpod

The second artist performing here apart from Zero is Darude and piece is called “Sandstorm”.

All attempts so far have been directed towards studying responses in real time. However, it might be feasible to “record” audio input response on geometry as a static exercise, which would mean the possibility of attaching a physical connotation “form” to audio signals . It is quite early at this point of time to speculate whether this could have any architectural implications. However, what is definitely feasible (and this currently is already being implemented) is the development of an interactive response to audio signals in the real world.

36 hour marathon in an attempt to assemble the “box”.  Under-estimating density of threads/ hand-cut of a zillion notches since the laser machines decide to throw up at critical time/ surprise moments when there was no available space to put hand inside “box” for assembly/ thread depth that disallowed “weave” at corners and non-afford ability of ton of red-bulls, all eventually resulted in a semi-complete model (hope to finish assembling it soon) albeit an interesting one.

click on images for enlarged versions.

Image below, a small scale model under partial test conditions. The weave seemed to work perfectly. Following the excitement, got ambitious and scaled the model up only to realize much later, there was no space for one thread to turn inside another for the interlocking

`

The much anticipated final “box” A series of modelling and render studies had to be undertaken before attempting to calculate “notches” on the threads.

All the coding’s on Mathcad yet again. Fairly straight forward conditional statements. The range here becomes extremely critical, since the box subdivision parameters were hard coded and not parametric (things got fairly complicated by now and code extremely long. Debugging was a big pain. So, beyond a point, the subdivision parameters were simply hard coded).

click below to enlarge, for a detail math.

The piecemeal function was reduced to a simple box at its most basic version and then coded sequentially building up/ breaking down the box iteratively. The scale of the box is a direct reflection of the “levels” of subdivision – in this case 3.

Animation in right corner indicates the scaling of apertures on the North facade of a hypothetical building in New York while the one in center displays the incoming daylight at a height 1m above ground. Radiance rendered interior shots (pseudo-real time ) to follow soon.

A careful study into the equations and its subsequent outcomes indicate an increase in the frequency of the period along the “j” threads results in the thread knotting around itself. When carefully stitched along the subsequent three sides throws up interesting phenomena. There is suddenly a close resemblance to the tectonics of a mobius strip.

Using a custom script developed by George in Lisp, for autocad, these threads could be then imported into autocad for further study.

It was not long before the realization dawned in that the implementation of thickness into these threads would indicate an inability for the threads in the corners to “knot” around. Further, each of these threads are inclined with the “horizontals” that are not perpendicular to it. Hence, I had to resort to scripting on grasshopper to ease the process of extruding the rectangular cross section along these threads. This enabled me to test the threads in the corner for the failure of knots and I eliminated them for the purposes of fabrication. This further enhanced the peculiarities of the “knot” which increases from a near zero in the corners to a certain maximum on the other end.

Scripting in grasshopper further eased the process of implementing boolean transformations on the threads. This was critical since otherwise, it is impossible to guess how the threads would lock up against each other. The “notches” installed into the threads are all inclined at different angles and dimensions.

The poly-surfaces so derived were then exploded. I was gambling with using the laser cutter to install these notches and this meant the impossibility of creating a swarf cut in the material (for the purposes of this study, I was working with an eighth of an inch – chip board). I tried making all the notches larger so as to accommodate the “incoming” threads. These were then laid out in autocad to be laser cut.

And finally, there was the catastrophe!! Everything seemed to work to a certain extent. But, pretty soon, it ended up being impossible to notch the threads one against another. This problem could also be attributed in part to the depth of horizontals not being too large. There was an intrinsic problem towards making the depth fairly large, since the knotting of the thread imposed a certain maximum on it. In all probability, my best guess would be an unavoidable swarf cutting or perhaps an extremely thin material.

So, after some excruciatingly large amounts of time and energy exhausted with this process, net result seems be tending towards zero……. LOL!!

And yes, I would be henceforth willing to share all code written be me, if requested (base Mathcad seeds do not belong to me. Apologies. Anything else. Yes)