Forty of the 2nd year students of the University School of Architecture and Planning (USAP) who were a part of the architectural design studio exercise with Abhishek Bij, Malini Kochupillai, Kanishka Prasad and me, completed the full-scale structures for their college festival. A big thank you to everyone who was a part of this!
You can read a detailed description of the project in this previous post.
Today I’m going to talk about the use of computation in architecture. A lot has been said about computation and its role in architecture since the early 1980s. Today, virtually any architectural practice uses computers in some form or the other. But it is not just architecture. Today, virtually any profession uses a computer in some form or the other.
So what is it that computation offers?
I am sure that all of you have wished that there was an “UNDO” command that you could use when you have made a mistake while building a model for your design studio. But of course, there is no “UNDO” command outside the computer. Have you ever wondered why?
In order to understand why this is so, I am going to have to briefly switch from architecture to thermodynamics. I am sure that all of you are familiar with the Second Law of Thermodynamics from your physics class in school. One version of this law states that “The disorder in a closed system will always increase.”
What this means is that you are not going to see spilt milk spontaneously gather back into a glass. You cannot “UNDO” the spilling of milk. And some people argue that the Second Law is what defines the direction in which time flows.
But how is it that a computer allows us to “UNDO” things? How is a plant able to grow with soil, water and sunlight? How does a machine make something as complex as a computer in the first place? These are all examples of more order being made from less order.
Well, there is a very convenient loophole to the Second Law. If you add energy to a system then you can increase order. The addition of energy from outside means that the system is no longer closed, but then no system is ever completely closed anyway.
The addition of energy therefore frees us from the second law. Plugging a Xerox machine into a socket allows it to make copies. Light falling on a leaf enables a plant to grow through photosynthesis and ultimately reproduce. Powering up a computer lets it “UNDO.”
So the way a system uses energy determines its relationship to disorder. On this basis, one can think of four different “Realms” or “Paradigms” – the mineral realm, where disorder always increases; the biological realm where order is propagated; the mechanical realm where disorder is controlled and order is created; and the digital realm where there is no disorder.
So what does the digital realm, with no disorder, offer the architecture?
It offers a clean slate as the starting screen of any CAD software will show you. It offers a void with no disorder where you are free to design without any encumbrances. You are free to do what you want.
While a blank sheet of paper is a two dimensional “void,” the computer offers a three dimensional blank slate. In addition to this, the computer offers the ability to process large amounts of information quickly.
If we think of “complexity” as the amount of information required to describe an object or phenomenon, then we can say that the information processing power of a computer allows architects to deal with complexity.
A project done by the studio that made use of what the digital realm offers is the Gateway to the JSPL power plant in Chhattisgarh, built in 2006. The form of this gateway creates a dialogue between local tribal geometries and industrial technology. The design development was undertaken through physical and 3D digital modelling with the geometric information of the digital model being used to create CNC pre-fabricated components that were assembled on site.
There was therefore a seamless flow of information from the digital model to the fabrication of the components by computer controlled machines which used data directly from the model. This allowed for very high precision and the coming together of the pre-fabricated parts smoothly on site in spite of the complexity of the form.
But if we re-visit the construction process of the gateway, we see that the digital realm, from which the design and the computer controlled fabrication comes, must eventually interact with the mineral, biological and mechanical realms. You see this in the critical step of fixing the structure to the footing in the ground. Had there been any mistake in the foundations, and had it not matched the digitally fabricated structure, there would have been no “UNDO.”
Another factor not immediately apparent is the amount of energy needed to manufacture the steel needed for the digital fabrication process. This energy is needed to create a material which is completely homogenous and uniform. The energy is needed to fuel machines which remove the disorder present in the mineral realm.
The removal of disorder from materials is needed when designing in the digital realm because design in the digital realm always begins with a perfectly ordered blank slate. And as long as one stays in the digital realm, there is no way of interacting with the disorder of other realms. While the digital design process can generate complexity, it cannot deal with disorder.
This is not a new thing in architecture. Historically, what has differentiated the architect from the master builder has been that the architect works on paper, in a space free of disorder. But the power of digital technologies available to architects today highlights the issue like never before.
The most obvious way to overcome this is to NOT start the design process in the digital realm – which is what I did in this small experiment with bamboo. Instead of starting with a blank slate, I started by scanning a piece of bamboo on a simple flatbed scanner, thereby digitizing disorder.
I used the scans of two pieces of bamboo to create digital models of them. Because I did not start with a blank slate but instead started by digitizing the disorder of the irregularly shaped bamboo, the computer had no problem in dealing with the complexity of its shape.
I then designed a joint between the two pieces where the angle is exactly 60 degrees. This joint was cut in the bamboo using a computer controlled router and the two pieces of bamboo were then tied with rope by hand. The computer was therefore able to negotiate the complexity of disorder and impose the order of a 60 degree joint on the bamboo.
But humans are much better at dealing with disorder. So can computers and humans collaborate with each other to build complex designs while negotiating disorder?
The first attempt at answering this question was the Parametric Pavilion project. For this project a parametric model was made to create a family of bamboo pavilions that can be built cheaply and quickly for a variety of functions. The parametric model can be manipulated to generate new forms based on programmatic requirements and site conditions. The parametric model outputs dimensioned drawings for construction on site where craftsmen negotiate the disorder inherent in bamboo with the computer generated dimensions.
The hyperbolic paraboloid shape of the pavilion as well as the gateway is part of a larger group of shapes known as ruled surfaces – surfaces that can be made from straight lines.
This geometry is such that the structure can be built using only length dimensions and there is no need to measure angles, curvatures, areas, etc. Linear measurements are the easiest to measure, requiring only a measuring tape to be placed against a piece of bamboo and lengths marked. The use of linear measurements minimizes the chances of errors and also makes the work of the craftsmen on site easier.
But can this technique of linear measurements be extended to more complex geometry?
If you take a flexible member and reduce the distance between its end points then it will curve. If you have a network of such members intersecting each other, then you can obtain virtually any surface you like. And this is nothing but weaving.
The Nest Roof is an on-going project where we are using weaving to construct a complex computer generated surface from bamboo through linear measurements alone.
The shape of the roof was the result of an algorithmic form-finding process resulting in a funicular shell structure. The shape of this shell was dictated by the plan form of the building.
It was decided to weave this shape out of bamboo as a reticulated shell structure. A reticulated shell is a doubly curved structure made from intersecting members of a flexible material. The flexibility of bamboo increases as it becomes thinner, but as it becomes thinner it also becomes weaker. The less a bamboo member has to curve, the thicker and stronger it can be. So an algorithm was created to find paths of minimal curvature along the shell surface along which to weave the bamboo.
The use of this algorithm allowed us to have 4” dia half-round bamboo members arranged in 6 layers to achieve a beam-depth of 2’.
In order to construct this, drawings were made where the lengths of bamboo between each intersection were given for each step of the weaving sequence. Since these lengths were more than the linear distance between the end points of each member, the desired curvature was achieved.
The craftsmen of site could therefore build this structurally optimized reticulated shell structure using only linear measurements. The craftsmen themselves could then focus on negotiating the disorder inherent in the bamboo such as joining two pieces of bamboo to create a continuous structural member, and place spacers of different sizes to absorb variations in the size of bamboo.
So, in this project the computer deals with the ordered aspect of design while human craftsmen deal with disorder, and, as architects we found an efficient way to transfer information from the computer to the craftsmen through linear measurements and weaving.
Some months ago I found an article about an exhibition titled The Machine organized by the Design Hub Limburg that includes a fascinating tool for designers. This tool is the result of a project called Computer Augmented Craft, which, the head of the project, Christian Feiberg, says, “is an attempt to utilise advanced technologies without sacrificing the unique qualities of craftsmanship.” The tool combines a set of sensors with Arduino and an interface created in Processing to enable a designer to have a real-time digital model of an artefact that they are physically producing. The software interface also provides “suggestions” at each step of construction to enable the designer to conform to an initial set of parameters or choose not to do so. The following video shows the system in use –
Reading about this tool and the exhibition reminded me of a student project I had done in the Command & Control design studio with Simon Kim, Skylar Tibbits and Juhong Park in 2009 at MIT. My project in this studio (focusing on using scripting as a design tool) included a script that created mass-customised joints for a post-earthquake shelter constructed as an irregular space frame out of found rubble. In this project the script did not dictate the form of the structure but only created fabrication data for a mass-customised joint component after the human builder had decided what member to use (from the post-earthquake rubble at hand) and where in the structure to place it. The script overcame the unpredictability of the materials at hand by taking inputs (on the length of a found member that the builder wanted to attach at a particular location) incrementally. The resulting digital model grew in tandem with the physical model allowing the builder to take independent design decisions while the script recorded the builder’s design moves and output fabrication data for the joint components needed at each step. If the builder got stuck and was unable to triangulate the space frame at any point then the script would suggest a method to triangulate.
Re-visiting this old student project in the light of the “The Machine” exhibition resulted in a project for the Patterns and Performance 2nd year, B.Arch design studio I am teaching with Abhishek Bij at the University School of Architecture and Planning (USAP). For this exercise we collaborated with the studio taught by Malini Kochupillai and Kanishk Prasad to design a learning space for a group of 20 students. I wrote a new version of the script I had coded for my Command & Control project for use by the students. The new script did not focus on the joints and instead was designed for the specific design problem given to the students for this exercise – the design of a learning space housing 15 to 20 people using a space frame structure constructed from available members of irregular lengths. The students were given tutorials on space frames and introduced to the script written for them. They were introduced to different forms of education and their spatial implications – both interior and exterior.
After this, the students began their designs in groups of four, constructing 1:10 or 1:20 scale physical models of their structures and simultaneously using the script to “grow” a 3D computer model. This studio exercise exposed the students to the advantages and disadvantages of physical versus digital design processes, issues of error and tolerance in design and construction, the importance of improvisation and contingency and its incorporation into the design process.
While my initial script written for the Command & Control studio focused on creating digitally fabricated joints, the script written for the USAP students included a panelization tool. This tool allowed the students to choose where to place panels on the space frame and have the script add these panels to the 3D model and also provide fabrication data for the panels so that they could be printed as a 2D triangle, cut and be added to the physical model.
The next step in the design studio will be to use what one has learnt constructing models and build a full-scale bamboo space frame as a learning space on the college campus. Observing the students work on the models I have updated the script for the full-scale structure. The updated script calculates the centre of gravity of the structure at each iteration of the design and construction process and gives a warning if the structure is likely to topple over without support. The reason for the addition of this feature in the script is that while it is easy to support a table-top model by hand if it is toppling over, this is not a trivial task during full-scale construction. This feature will allow the script to inform the steps in the physical construction process, while design decisions in response to space and material are taken in the physical world and fed into the script. Such a design process will aid in bringing the digital and physical worlds closer together to create a digitally augmented, craft-based, design process.
The latest version of the script written for the studio is given below (please note that there are still some bugs in calculating the centre of gravity) –
‘Script written by <Ayodh Kamath>
‘Script version 18 November 2012 12:02:10
Dim strStart, arrExist
Dim arrDots, arrLines, strExit
arrDots = Rhino.GetObjects(“Please drag a selection box around the existing text dot points and ‘Click+Cntrl’ to de-select any unwanted geometry.”,8192)
arrLines = Rhino.GetObjects(“Please drag a selection box around the existing lines and ‘Click+Cntrl’ to de-select any unwanted geometry.”,4)
arrDots = Sort(arrDots)
strExit = “A”
arrDots = Tetrahedron(arrDots, arrLines)
strExit = Rhino.GetString(“Make another tetrahedron [A], or exit [X]?”,”A”, Array(“A”,”X”))
Loop While strExit <> “X”
ElseIf strStart = “T” Then
ElseIf strStart = “P” Then
Loop While strStart <> “X”
Function Triangle(ByRef arrLines)
Dim dblLt1, dblLt2, dblLt3
Dim strLn0, strLn1, strLn2
Dim strDotP0, strDotP1, strDotP2a, strDotP2b, strDotP2
Dim strTempCirc1, strTempCirc2
Dim arrInt, arrIntPt0, arrIntPt1, strPt0, strPt1, strPt2
Dim strChoice, blnLoop
Call Rhino.MessageBox(“The member lengths can not be triangulated. Please try a different set of members.”)
Dim strMin, blnSwap
Dim i, j, k
blnSwap = False
For i = 1 To UBound(arrTxtDot)
If Rhino.TextDotText(arrTxtDot(i-1)) > Rhino.TextDotText(arrTxtDot(i)) Then
Dim arrIntSrf, strJoinCrv, arrIntCrvSrf
Dim strChoice, arrIntPt
Dim i, j
Dim blnGoal, arrGoalPt
blnLoop = 0
Do While blnLoop = 0
blnGoal = Rhino.GetString(“Select a goal point?”,,Array(“Y”,”N”))
blnLoop = 0
Call Rhino.MessageBox(“The member lengths can not be triangulated. Please try a different set of members.”)
strChoice = Rhino.GetString(“Point IntA[A] or point IntB[B]?”,”A”, Array(“A”,”B”))
If strChoice = “A” Then
arrIntPt = arrIntCrvSrf(0,1)
ElseIf strChoice = “B” Then
arrIntPt = arrIntCrvSrf(1,1)
blnLoop = 0
Call Rhino.MessageBox(“The member lengths can not be triangulated. Please try a different set of members.”)
Function RhinoUnrollSurface(strSurface, arrCurves, blnExplode, blnLabels)
‘ Default return value
RhinoUnrollSurface = Null
‘ For speed, turn of screen redrawing
‘ Save any selected objects
Dim arrSaved : arrSaved = Rhino.SelectedObjects
‘ Unselect all objects
‘ Select the surface to unroll
‘ Format curve string
Dim i : i = 0
Dim strCurves : strCurves = ” _Enter”
If IsArray(arrCurves) Then
strCurves = “”
For i = 0 To UBound(arrCurves)
strCurves = strCurves & ” _SelId ” & arrCurves(i)
strCurves = strCurves & ” _Enter”
‘ Format explode string
Dim strExplode : strExplode = ” _Explode=_Yes”
If (blnExplode = False) Then strExplode = ” _Explode=_No”
‘ Format labels string
Dim strLabels : strLabels = ” _Labels=_No”
If (blnLabels = True) Then strLabels = ” _Labels=_Yes”
‘ Script the command
Dim strCommand : strCommand = “_-UnrollSrf” & strExplode & strLabels & strCurves
Call Rhino.Command(strCommand, 0)
‘ Return the results
RhinoUnrollSurface = Rhino.LastCreatedObjects
‘ Unselect all objects
‘ If any objects were selected before calling
‘ this function, re-select them
If IsArray(arrSaved) Then Rhino.SelectObjects(arrSaved)
‘ Don’t forget to turn redrawing back on
Function CG(arrDots, ByRef arrLines)
Dim dblSumLength, arrMidPt
Dim dblX, dblY, dblZ, dblLength
Dim strTempCGPt, strTempCGLine, intCount
intCount = 0
Dim arrSortBasePts, strBaseCrv, intInside, arrCGBasePt
Dim dblMemDens, dblJtWt
dblMemDens = 1 ‘average bamboo density assumed to be 1kg/running meter = 1g/running mm
dblJtWt = 2000 ‘average weight per joint assumed to be 2kg = 2000g
Dim intPolyCount, intPtCount, intInOut
Dim i, j
Dim arrTempPoly, strTempPoly
Dim dblDist, dblMinDist, intMinPt, bolMin
Dim dblParam, arrClsPt
intPtCount = 0
intPolyCount = 2
bolMin = 0
After some delays in the project, construction on the woven bamboocrete “Ghosla” (nest) roof has finally begun. The video below shows how the weaving process enables a team of traditional bamboo craftsmen to easily construct the digitally form-found, double-curved, funicular shell using only linear measurements read out to them by the contractor. The drawing provided by Kamath Design Studio to the contractor is a plan consisting of linear dimensions along each bamboo member where that member intersects other members. The drawing also communicates the weaving scheme, that is, whether a member goes above or below another member when they intersect. Our studio provided the height above ground at each intersection to verify that the bamboo members are curving as desired, and that the shape of the shell conforms to the digitally form-found funicular shape.
While a 1:50 scale construction model of this roof had been built using the same drawing set to test the concept of weaving a complex curved surface using only linear dimensional information, the idea was so far untested at full scale.
I had outlined the concept of using weaving to build complex digitally modeled surfaces using manual methods of construction in this earlier post.
Historically, craft and industrial production have been incompatible because craft produces variation while industry requires standardization. Contemporary digital design and fabrication opens up the possibility of dealing with variation in an industrial context, thus eliciting parallels with craft. In the context of the large-scale industrialization of Western economies the comparisons between craft and digital design and fabrication are largely rhetorical. In developing economies such as India, however, industrial and non-industrial modes of production occur side-by-side and are often competing for the same resources.
This talk will attempt to illustrate, through examples, different kinds of design and production systems that combine craft with digital design and fabrication, and their contextual implications for architectural design.
This is a very simple curve fitting script to find where a short curve fits best along longer curve. I’ve developed this script in the context of my on-going work with bamboo weaving.
The Nest Roof is a result of woven bamboo beams following paths of minimum curvature along a funicular surface.
While the bamboo beams may follow paths of minimum curvature, one is still left with the possibility to further optimize the selection of where along a beam profile to use each individual piece of bamboo. Bamboo being a natural material does not have uniform properties and every piece of bamboo is different. Every piece has a different shape and bends by a different amount. Therefore different pieces of bamboo will be suited to different parts of the roof with different beam curvature. Selecting the right piece of bamboo for a given segment of a beam is fundamentally finding where along the beam a given piece of bamboo fits best so that it will have to be bent a minimum amount, which is what this script does. However, it is far from clear how exactly, and if at all, the script can be used during construction. The principal problem is finding a work flow whereby the curvature of each individual piece of bamboo can be recorded and digitized so as to form an input for this script (or some version of it) during construction, and a way to convey the result of the script in real time to the craftspersons building the roof. These issues were tackled in my SMArchS thesis, but only at a theoretical level and at a table top model scale. I hope to be able to carry this forward to a building scale and a live project through the Nest Roof.
The script uses a very crude brute force algorithm that incrementally slides a short curve (representing an individual piece of bamboo) along a longer curve (the beam profile) while checking the deviation between the two curves at each increment. The length of the increment can be specified and the smaller the increment the more accurate the result will be. An interesting by-product of the brute force algorithm is the plant like shapes that it produces. “Leaves” appear to sprout as the script slides one curve along the other, and then the “leaves” are then shed as the script deletes all but the best-fit result.
Below is a version of the script that works on planar curves, but the same idea can be expanded to apply to 3D curves as well –
‘Script written by <Ayodh Kamath>
‘Script copyrighted by <Kamath Design Studio/PostScriptDesign>
‘Script version 08 April 2012 14:18:42
Dim strCrv1, strCrv2, dblDivLength, arrDivPts1, arrDivPts2
Dim intCheckPt, strAlignCrv
Dim intCount, intMin
Dim j, i
strCrv1 = Rhino.GetObject(“Select guide curve to check against”,4)
strCrv2 = Rhino.GetObject(“Select curve to check”,4)
A part of this semester’s 3rd year design studio at Sushant School of Art & Architecture consisted of an introductory workshop on the use of digital design tools that we called Spanz. The workshop was taught by Abhishek Bij and me (both visiting design faculty at the 3rd year design studio) and supported by the rest of the 3rd year design faculty consisting of Shikha Doogar, Gaurav Shorey, Swati Singh, Thomas Oomen and Neeraj Khosla. The workshop started with a crash course on a variety of digital design tools including 3D modelling software, form finding tools, parametric modelling software and form rationalization tools – tools that are applicable to different stages of the digital design workflow, from conceptualization to fabrication. The tools developed tackled a range of structural systems (tensile membranes, funicular shells and folded plates) and fabrication methods (weaving, pipe bending, sheet metal forming, concrete casting etc.).
The students were encouraged to mix and matched these tools to suit their design goals and design styles and no specific methodology was imposed on them. The tools were applied to various real life campus development projects as a part of their annual college festival (Atharva 2012, 30th-31st March) and ranged from canopies to installations to lighting design. The nuances of the digital tools were mastered by them while using them for their developing their designs.
A student installation of specific interest here is “The Interlace” designed by Akshita, Anushree, Gauri, Parush, Sumit and Suvrita because it is the first time the weaving script I had developed and posted earlier has been applied to a large scale project. The weaving script simply takes a given fibre spacing and fibre thickness and uses the U- and V- curves of a surface to derive fabrication data for the weaving process. My interest in weaving comes from the way it allows complex 3D curved surfaces to be fabricated using only linear measurements (which I have discussed in detail in this earlier post). In “The Interlace” the students started out by using a form finding algorithm based on David Rutten’s classic mesh relaxation algorithm. The basic mesh relaxation algorithm was modified specifically for the workshop to allow the students to model the effects of gravity and thereby generate funicular forms in addition to tensile membranes (I will be explaining the modifications made to the algorithm in another blog post shortly). The relaxed mesh was converted to a NURBS surface and the weaving script was applied to it. The script outputted the lengths of individual fibres and the points of intersection with other fibres along their length. The fabrication data was used to first build a 1:10 scale construction model where the students could test the fabrication process and the steps involved.
Once the construction process was developed and understood in the studio, the students proceeded to build the final installation. Since the college festival is student-run and student-managed, the direct role of the design faculty ended at the construction model stage. Comparing the construction model to the final installation, it is interesting to note that the percentage error in the linear measurements was more in the construction model and less in the final installation, meaning that the final installation was a closer match to the computer model than the construction model. The properties of the pipe used to make the final installation were different from the construction model in terms of their ability to resist compression, resulting in a small amount of creasing of the surface of the final installation. Overall, however, this installation appears to verify the feasibility of using weaving to manually fabricate computer generated 3D curved surfaces at a 1:1 scale.
“Ghosla” (meaning “nest” in Hindi) is a bamboocrete roof designed by Kamath Design Studio for a 150 square meter guest house unit at the Gnostic Centre in New Delhi, India.
The shape of the roof comes from a structural form-finding process dictated by the floor plan of the building and the resulting positions of the supporting columns. A RhinoScript was used to find optimized paths for woven members on this surface. The paths found using the script are those with minimum cumulative curvature passing through a given set of points on the surface. This enables the bamboo members used in the weaving to have as large a cross-sectional diameter as possible (and thus as high a load bearing capacity as possible) since they do not need to bend much and need not be extremely flexible. The advantage of using these optimized paths can be seen when comparing them (extreme right, above) to the simple UV transformed hexagonal grid (second from the right, above). The simple UV transformed grid has member paths with significantly higher curvature which will require more flexible (and thus thinner and weaker) bamboo members for its construction.
Stepping back in the design process, the design-computational reason for constructing this roof by weaving bamboo came from the need to devise a work-flow and construction methodology that would enable the construction of a digitally designed complex curved surface (the form-found roof shape) by simple manual construction techniques in a non-industrial setting. Weaving is an ancient process that is in the technological repertoire of most cultures. What makes weaving especially suited to the construction of curved surfaces is the fact that it can use linear, one-dimensional elements to produce a surface curving in three-dimensions and requires only linear measurements during construction. I have discussed the details of this in my earlier post on Weaving and Linear Measurement in Digitally Guided Construction.
The success of this digital-to-physical work-flow can be seen in the 1:25 scale model of the roof that was constructed by carpenter Ram Lakhan with the guidance of Inderjeet Singh Seera of Kamath Design Studio using linear dimensional information obtained from a 3D computer model of the woven roof. Here are some photographs of the model just before completion –
While there is no doubt that there will be numerous challenges that will have to be overcome during full-scale construction, the progress on this project so far shows the ability of weaving to be used for the construction of complex curved surfaces by manual means using linear dimensional information.
The bamboocrete roof that this woven structure will support will be similar to earlier bamboocrete roofs designed by Kamath Design Studio. The woven bamboo structure of the “Ghosla” roof will replace the steel and eucalyptus log trusses used to support these earlier roofs.
Measuring the length of a straight line in the physical world is to test the geometric congruency of two one-dimensional objects – an object of standardized length against an object of unknown length. All one-dimensional objects share the property of similarity and can therefore be “placed against each other” as physical objects (strictly speaking there are no “real” one-dimensional objects but this statement will still apply to the one-dimensional edges of higher-dimensional objects). To make two one-dimensional objects congruent requires breaking/cutting the longer of the two at a single point or stretching the shorter of the two along a single direction.
While all this may seem painfully obvious, the uniqueness of the situation is highlighted when you think about how hard it is to make two non-similar objects of higher dimensions congruent or similar. For example, here is a device for replicating three-dimensional sculptures with the ability to change the size of the reproduction. (For more information about this device you can read this article). Now compare this device to using a ruler and pair of scissors to make two pieces of string the same length.
George Stiny shows how a boundary function is able to map algebras of different dimensions to each other (Shape: Talking About Seeing and Doing, p. 98). In terms of construction, a boundary function can provide ‘templates’ or ‘jigs’ or ‘frameworks’ or ‘guides’ (depending on your method of construction) for objects of a higher dimension using objects of lower dimensions. To cite an example of a project I was personally involved in, the form-work of the Santa Monica Cradle project is an example of two-dimensional plywood ribs being used as a framework for creating a complex, curved, three-dimensional surface from strips of flexible ‘luaun’ ply. In fact, most approaches to constructing an architectural surface involves some kind of underlying linear framework.
If a complex three-dimensional shape can be built using a ‘framework’ of linear shapes, then it can be constructed through simple measurements of length. The most basic way to go from a one-dimensional boundary to a two-dimensional shape through linear measurement alone is through triangles. This method has been used since the time of ancient Egypt where it was used to measure the (two-dimensional) area of land holdings using (one-dimensional) rope as a measuring device.
The ‘Suspension’ series of installations by Ball-Nogues Studio (some of which I was fortunate to be a part of) consist of a series of threads cut to specific lengths, coloured at specific intervals and hung from specific points to form a series of catenaries. When seen together, the strings form complex, multi-coloured, three-dimensional “clouds” suspended in mid air.
“Suspensions: Feathered Edge by Ball-Nogues Studio”. MoCA PDC, Los Angeles, 2007.
A sturdier and more ancient way of combining linear elements into objects of higher dimensions is weaving. The weaving of cloth goes from one-dimensional thread to a two-dimensional cloth, and the weaving of baskets goes from one-dimension strips (of cane, bamboo, rattan or other materials) to a three-dimensional surface. Kenneth Snelson shows how a tensegrity structure can be thought of as a three-dimensional polyhedron woven out of linear elements.
The process of weaving is therefore an ideal candidate for a manual construction process involving only linear measurement that can be used to construct a digitally designed, complex curved surface. I had woven a quick model based on this premise some months ago using linear fabrication data obtained by running this script on a test surface. After the successful construction of the first bamboo Parametric Pavilion I am now attempting the design and construction of a more complex woven bamboo roof structure for a 150 square meter guest house building. This project will be a test case for implementing the idea of using digitally derived linear construction data for the manual weaving of a complex curved surface.