The Image is the Building

A photograph I shot was on the cover of this month’s issue of Domus India (March, 2013).

The Cover Photograph
The Cover Photograph

I had shot this at 400 ISO with my Nikon D 7000, and what was published was a fairly tight crop of  the original image (below). Another, less cropped version of the same photograph also appeared in the article on the Museum of Tribal Heritage in Bhopal designed by Kamath Design Studio in the same issue.

The Original Image
The Original Image

It must have taken some very skilled raw editing to get an acceptable cover image out of something shot with what is essentially an amateur camera at what is not a low ISO setting. This is definitely not something I’ve been able to achieve with the Nikon ViewNX2 software that comes bundled with the camera. Since a majority of the photographs featured in the article were shot by me with this camera, I think I might be better off investing in a good raw converter instead of a Nikon D600 which I have been eyeing ever since its release.

My camera geekiness aside, this article on the Museum in Domus has given me a lot to think about, both as an architect closely involved with the design of the building, and as the photographer who shot most of the images seen of the building. But before I go further, I must confess that I have not yet read anything by Susan Sontag, not read On Photography, nor read anything else of significance on the role of photography in architecture and the media. What I write here is a lay person’s opinion based on a single experience –

I had started  working on the Museum of Tribal Heritage when I was still doing my bachelor’s degree in architecture. It was very exciting to be working on this project because it was the first time I was applying my newly acquired knowledge of architecture in a professional setting. Preparing a setting-out plan of the complex, interlinked circular and rectilinear shapes taught me the need for accuracy and discipline in drafting and dimensioning a drawing.

I was also responsible for preparing a 3D model of the building which was used in presentations and discussions with the various stakeholders in the project.

External Views from the 3D Model
External Views from the 3D Model
An Interior View from the 3D Model
An Interior View of the Introduction Gallery from the 3D Model

Despite being involved in the project from its outset, I was not able to travel from Delhi (where I was studying) to the site in Bhopal until after I finished college some two years later. But when I did visit the site, it was quite amazing to see the actual building. What made this experience especially surreal was the fact that the site engineer drove us in his car straight into what was the main visitor’s (pedestrian) circulation spine of the museum. The building was bigger than I had imagined. And yet, when I got out of the car and walked around, it seemed to have a very human scale – a scale of a village street, not the scale one usually associates with a museum building.

The circulation spine where I drove in with a car on my first visit to the site.
The circulation spine where I drove in a car on my first visit to the site.

After walking around the building, I soon got my bearings and started observing deviations from the plan and defects in construction, like any architect would. The building eventually took over five years and many more site visits to build, and the museum is still to formally open as of March, 2013.

When we were contacted by Domus India about their wanting to feature the project in their magazine, we were very excited by the idea. Like most architectural publications around the world today, the team at Domus asked us, as the architects of the building, to provide them with images for the article. What we gave them was a photographic “walk-through” of the building with details of where in the building each photograph was shot from, and what the photograph showed. Other than basic project drawings, this was all the information on the project that the Mumbai-based team writing the article had. Even as someone so closely involved with the design, having prepared its setting out plan and 3D model; actually experiencing the building physically and spatially gave me a completely new perspective on its design. I was therefore fascinated by the article on the Museum that appeared in Domus titled “Debating Tactile Engagements” when no one from the magazine had seen the building other than through the photographic images we had supplied them. The article goes on to talk about the scale of the building, the delicacy of the steel structure supporting large spans, the way the building negotiates the terrain of the site and engages with the local climate. It is understandable that time and financial constraints make it impossible for every architectural critic to visit every building they write about. But as an architect who respects the opinions of serious critics of design, it makes me wonder if I should design for the user or design for the camera in an age where pixels are equal to perception, where bits can travel across the planet but bricks stubbornly stay rooted in walls, where ones geographic location is immaterial but “ecological footprint” is supposed to matter, where global weather data is available at a keystroke but the sound of subtly directed rain water is lost in the din of esoteric discussions on design philosophy.

Advertisements

Ghosla Roof Update: Paper Accepted to CAADRIA, 2013

A paper outlining the theoretical and technical ideas behind the “Ghosla (nest) Roof” titled “Digitally Designed Architectural Form Built Using Craft-Based Fabrication: Weaving a Complex Surface as a Bamboo Reticulated Shell” has been accepted to the CAADRIA, 2013 conference of the The Association for Computer-Aided Architectural Design Research in Asia, to be held at the National University of Singapore’s Department of Architecture from May 15th to 18th this year. The theme of the conference this year is “Open Systems” which suits the collaborative nature of the Nest Roof project where digital design methodologies are combined with craft-based construction and non-industrial materials.

On site, the bamboo work has been completed, giving final form to the shell. Here are some pictures from the site –

This slideshow requires JavaScript.

Welcome to the Craft Machine

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 KimSkylar 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.

My poster from the Command & Control studio in 2009. The green members in the main figure denote “found” members while the red members denote those added by the script to triangulate the space frame.

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.

2012-11-26 12.10.07
The physical and digital models growing side-by-side in the studio.

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) –

Option Explicit
‘Script written by <Ayodh Kamath>
‘Script version 18 November 2012 12:02:10

Call Main()
Sub Main()

Dim strStart, arrExist
Dim arrDots, arrLines, strExit
Dim i

Call Rhino.AddLayer(“uncut_members”, RGB(0,255,0))
Call Rhino.CurrentLayer(“uncut_members”)

Do

strStart = Rhino.GetString(“Start from scratch [S], use existing geometry[G], triangulate with a single member [T], panelize [P], or exit[X]?”,,Array(“S”,”G”,”T”,”P”,”X”))

arrExist = Rhino.AllObjects()

If strStart = “S” Then

If IsArray(arrExist) Then

Call Rhino.DeleteObjects(arrExist)

End If

arrDots = Triangle(arrLines)
Call Rhino.UnselectAllObjects
arrDots = Tetrahedron(arrDots, arrLines)
Call Rhino.UnselectAllObjects

ElseIf strStart = “G” Then

Call Rhino.ZoomExtents(,True)
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”

Do

arrDots = Tetrahedron(arrDots, arrLines)
Call Rhino.UnselectAllObjects
strExit = Rhino.GetString(“Make another tetrahedron [A], or exit [X]?”,”A”, Array(“A”,”X”))

Loop While strExit <> “X”

ElseIf strStart = “T” Then

Call Triangulate(arrLines,arrDots)

ElseIf strStart = “P” Then

Call Panelize()

End If

Loop While strStart <> “X”

End Sub

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

blnLoop = 0

Do While blnLoop = 0

dblLt1 = Rhino.GetReal(“Enter first lenght:”)

strLn0 = Rhino.AddLine(Array(0,0,0), Array(dblLt1,0,0))
strDotP0 = Rhino.AddTextDot(“P0”,Array(0,0,0))
strDotP1 = Rhino.AddTextDot(“P1”,Rhino.CurveEndPoint(strLn0))
Call Rhino.ZoomExtents(,True)

dblLt2 = Rhino.GetReal(“Enter second lenght:”)

strTempCirc1 = Rhino.AddCircle(Rhino.WorldXYPlane(),dblLt2)
strTempCirc1 = Rhino.MoveObject(strTempCirc1,Array(0,0,0),Array(dblLt1,0,0))

dblLt3 = Rhino.GetReal(“Enter third lenght:”)

strTempCirc2 = Rhino.AddCircle(Rhino.WorldXYPlane(),dblLt3)

arrInt = Rhino.CurveCurveIntersection(strTempCirc1,strTempCirc2)
Call Rhino.DeleteObject(strTempCirc1)
Call Rhino.DeleteObject(strTempCirc2)

If IsArray(arrInt) Then

arrIntPt0 = arrInt(0,1)
arrIntPt1 = arrInt(1,1)

strDotP2a = Rhino.AddTextDot(“P2a”,arrIntPt0)
strDotP2b = Rhino.AddTextDot(“P2b”,arrIntPt1)

Call Rhino.ZoomExtents(,True)
strChoice = Rhino.GetString(“Point P2a[A] or point P2b[B]?”,”A”, Array(“A”,”B”))

If strChoice = “A” Then

Call Rhino.DeleteObject(strDotP2b)
Call Rhino.DeleteObject(strDotP2a)
strDotP2 = Rhino.AddTextDot(“P2”,arrIntPt0)
strLn1 = Rhino.AddLine(Rhino.CurveEndPoint(strLn0),arrIntPt0)
strLn2 = Rhino.AddLine(arrIntPt0,Rhino.CurveStartPoint(strLn0))

ElseIf strChoice = “B” Then

Call Rhino.DeleteObject(strDotP2a)
Call Rhino.DeleteObject(strDotP2b)
strDotP2 = Rhino.AddTextDot(“P2”,arrIntPt1)
strLn1 = Rhino.AddLine(Rhino.CurveEndPoint(strLn0),arrIntPt1)
strLn2 = Rhino.AddLine(arrIntPt1,Rhino.CurveStartPoint(strLn0))

End If

Triangle = Array(strDotP0,strDotP1,strDotP2)
ReDim arrLines(2)
arrLines(0) = strLn0
arrLines(1) = strLn1
arrLines(2) = strLn2
blnLoop = 1

Else

Call Rhino.DeleteObject(strLn0)
Call Rhino.DeleteObject(strDotP0)
Call Rhino.DeleteObject(strDotP1)
Call Rhino.MessageBox(“The member lengths can not be triangulated. Please try a different set of members.”)

End If

Loop

End Function

Function Sort(arrTxtDot)

Dim strMin, blnSwap
Dim i, j, k

Do

blnSwap = False
For i = 1 To UBound(arrTxtDot)

If Rhino.TextDotText(arrTxtDot(i-1)) > Rhino.TextDotText(arrTxtDot(i)) Then

strMin = arrTxtDot(i)
arrTxtDot(i) = arrTxtDot(i-1)
arrTxtDot(i-1) = strMin
blnSwap = True

End If

Next

Loop While blnSwap = True

Sort = arrTxtDot

End Function

Function Tetrahedron(arrTxtDots, ByRef arrLines)

ReDim arrInPts(2)
ReDim arrTempDots(2)
ReDim arrInLts(2)
ReDim arrTempSphs(2)
Dim arrIntSrf, strJoinCrv, arrIntCrvSrf
ReDim arrIntDots(1)
Dim strChoice, arrIntPt
Dim i, j
Dim blnLoop
Dim intPtNum
Dim intCGChoice
ReDim arrTempLines(2)
Dim intLineCount
Dim blnGoal, arrGoalPt

blnLoop = 0

Do While blnLoop = 0

blnGoal = Rhino.GetString(“Select a goal point?”,,Array(“Y”,”N”))

If blnGoal = “Y” Then

arrGoalPt = Rhino.GetPoint(“Select goal point”)
Call GoalPoint(arrTxtDots,arrGoalPt)

End If

For i = 0 To 2

arrInPts(i) = Rhino.GetPoint(“Select point #”&CStr(i+1))
Call Rhino.UnselectAllObjects
arrTempDots(i) = Rhino.AddTextDot(CStr(i+1),arrInPts(i))
Call Rhino.SelectObject(arrTempDots(i))

arrInLts(i) = Rhino.GetReal(“Enter member length at this node:”)
arrTempSphs(i) = Rhino.AddSphere(arrInPts(i),arrInLts(i))
Call Rhino.ZoomExtents(,True)

If i = 1 Then

arrIntSrf = Rhino.SurfaceSurfaceIntersection(arrTempSphs(0),arrTempSphs(1),,True)

If IsArray(arrIntSrf) Then

If UBound(arrIntSrf,1)>0 Then

strJoinCrv = JoinCurve(arrIntSrf)

Else

strJoinCrv = arrIntSrf(0,1)

End If

Else

Call Rhino.DeleteObject(arrTempDots(0))
Call Rhino.DeleteObject(arrTempDots(1))
Call Rhino.DeleteObject(arrTempSphs(0))
Call Rhino.DeleteObject(arrTempSphs(1))
blnLoop = 0
Call Rhino.MessageBox(“The member lengths can not be triangulated. Please try a different set of members.”)
Exit For

End If

ElseIf i = 2 Then

arrIntCrvSrf = Rhino.CurveSurfaceIntersection(strJoinCrv,arrTempSphs(2))

If IsArray(arrIntCrvSrf) Then

blnLoop = 1
arrIntDots(0) = Rhino.AddTextDot(“IntA”,arrIntCrvSrf(0,1))
arrIntDots(1) = Rhino.AddTextDot(“IntB”,arrIntCrvSrf(1,1))
Call Rhino.SelectObjects(arrIntDots)

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)

End If

Else

Call Rhino.DeleteObjects(arrTempDots)
Call Rhino.DeleteObjects(arrTempSphs)
Call Rhino.DeleteObject(strJoinCrv)
blnLoop = 0
Call Rhino.MessageBox(“The member lengths can not be triangulated. Please try a different set of members.”)
Exit For

End If

End If

Next

Loop

Call Rhino.DeleteObjects(arrIntDots)
Call Rhino.DeleteObjects(arrTempSphs)
Call Rhino.DeleteObjects(arrTempDots)
Call Rhino.DeleteObject(strJoinCrv)

For i = 0 To 2

arrTempLines(i) = Rhino.AddLine(arrInPts(i),arrIntPt)

Next

intLineCount = UBound(arrLines)
ReDim Preserve arrLines(intLineCount+3)
arrLines(intLineCount+1) = arrTempLines(0)
arrLines(intLineCount+2) = arrTempLines(1)
arrLines(intLineCount+3) = arrTempLines(2)

intPtNum = UBound(arrTxtDots)
ReDim Preserve arrTxtDots(intPtNum+1)
arrTxtDots(intPtNum+1) = Rhino.AddTextDot(“P”&CStr(intPtNum+1),arrIntPt)

intCGChoice = CG(arrTxtDots,arrLines)

If intCGChoice = 7 Then

Call Rhino.DeleteObjects(arrTempLines)
Call Rhino.DeleteObject(arrTxtDots(intPtNum+1))
ReDim Preserve arrTxtDots(intPtNum)
ReDim Preserve arrLines(intLineCount)

End If

Tetrahedron = arrTxtDots

End Function

Function JoinCurve(arrCrvs)
‘takes the two dimensional array resulting from a SurfaceSurfaceIntersection command and returns the string identifier of the joined intersection segments

Dim intSegments, arrJoin
Dim i

intSegments = UBound(arrCrvs,1)

ReDim arrJoinCrvs(intSegments)

For i = 0 To intSegments

arrJoinCrvs(i) = arrCrvs(i,1)

Next

arrJoin = Rhino.JoinCurves(arrJoinCrvs, True)
JoinCurve = arrJoin(0)

End Function

Function Triangulate(ByRef arrLines, arrTxtDots)

Dim arrInPt1, arrInPt2, strTempDot1, strTempDot2, strTempLine
Dim intMsg, intLineCount, intCGChoice

arrInPt1 = Rhino.GetPoint(“Select first point”)
strTempDot1 = Rhino.AddTextDot(“1”,arrInPt1)
Call Rhino.SelectObject(strTempDot1)

arrInPt2 = Rhino.GetPoint(“Select second point”)
strTempDot2 = Rhino.AddTextDot(“2”,arrInPt2)
Call Rhino.SelectObject(strTempDot2)

intMsg = Rhino.MessageBox(“The member length required between these points is “&CStr(Rhino.Distance(arrInPt1,arrInPt2)),4)

If intMsg = 6 Then

Call Rhino.AddLayer(“cut_members”, RGB(255,0,0))
Call Rhino.CurrentLayer(“cut_members”)
intLineCount = UBound(arrLines)
ReDim Preserve arrLines(intLineCount+1)
arrLines(intLineCount+1) = Rhino.AddLine(arrInPt1,arrInPt2)
Call Rhino.CurrentLayer(“uncut_members”)

End If

intCGChoice = CG(arrTxtDots,arrLines)

If intCGChoice = 7 Then

Call Rhino.DeleteObject(arrLines(intLineCount+1))
ReDim Preserve arrLines(intLineCount)

End If

Call Rhino.DeleteObject(strTempDot1)
Call Rhino.DeleteObject(strTempDot2)

End Function

Function Panelize

Dim strStart
Dim strDot1, strDot2, strDot3
ReDim arrPts(2)
Dim strSrf
ReDim arrEdges(2)
ReDim arrDgs(2)
Dim arrTempDiv
ReDim strDots(2)
Dim intMsg, arrFlat, arrFlatOrPt, arrBox

strDot1 = Rhino.GetObject(“Select first point”,8192)
Call Rhino.SelectObject(strDot1)

strDot2 = Rhino.GetObject(“Select second point”,8192)
Call Rhino.SelectObject(strDot2)

strDot3 = Rhino.GetObject(“Select third point”,8192)
Call Rhino.SelectObject(strDot3)

arrPts(0) = Rhino.TextDotPoint(strDot1)
arrPts(1) = Rhino.TextDotPoint(strDot2)
arrPts(2) = Rhino.TextDotPoint(strDot3)

strSrf = Rhino.AddSrfPt(arrPts)

arrEdges(0) = Rhino.AddLine(arrPts(0),arrPts(1))
arrEdges(1) = Rhino.AddLine(arrPts(1),arrPts(2))
arrEdges(2) = Rhino.AddLine(arrPts(2),arrPts(0))

arrDgs(0) = Rhino.AddLine(arrPts(0),Rhino.CurveMidPoint(arrEdges(1)))
arrDgs(1) = Rhino.AddLine(arrPts(1),Rhino.CurveMidPoint(arrEdges(2)))
arrDgs(2) = Rhino.AddLine(arrPts(2),Rhino.CurveMidPoint(arrEdges(0)))

arrTempDiv = Rhino.DivideCurve(arrDgs(0),4)
strDots(0) = Rhino.CopyObject(strDot1,arrPts(0),arrTempDiv(1))

arrTempDiv = Rhino.DivideCurve(arrDgs(1),4)
strDots(1) = Rhino.CopyObject(strDot2,arrPts(1),arrTempDiv(1))

arrTempDiv = Rhino.DivideCurve(arrDgs(2),4)
strDots(2) = Rhino.CopyObject(strDot3,arrPts(02),arrTempDiv(1))

Call Rhino.DeleteObjects(arrEdges)
Call Rhino.DeleteObjects(arrDgs)
Call Rhino.UnselectAllObjects()

intMsg = Rhino.MessageBox(“Flatten this panel?”,4)

If intMsg = 7 Then

Call Rhino.DeleteObject(strSrf)
Call Rhino.DeleteObjects(strDots)

ElseIf intMsg = 6 Then

If Not IsArray(arrFlatOrPt) Then

arrFlatOrPt = Rhino.GetPoint(“Select origin point for unroll”)

End If

arrFlat = RhinoUnrollSurface(strSrf,strDots,False,False)
arrFlat = Rhino.MoveObjects(arrFlat,Array(0,0,0),arrFlatOrPt)
arrBox = Rhino.BoundingBox(arrFlat)
arrFlatOrPt = arrBox(1)
Call Rhino.DeleteObjects(strDots)

End If

End Function

Function RhinoUnrollSurface(strSurface, arrCurves, blnExplode, blnLabels)

‘ Default return value
RhinoUnrollSurface = Null

‘ For speed, turn of screen redrawing
Call Rhino.EnableRedraw(False)

‘ Save any selected objects
Dim arrSaved : arrSaved = Rhino.SelectedObjects

‘ Unselect all objects
Rhino.UnSelectAllObjects

‘ Select the surface to unroll
Rhino.SelectObject strSurface

‘ 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)
Next
strCurves = strCurves & ” _Enter”
End If

‘ 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
Rhino.UnSelectAllObjects

‘ 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
Call Rhino.EnableRedraw(True)

End Function

Function CG(arrDots, ByRef arrLines)

ReDim arrDotPts(UBound(arrDots))
Dim dblSumLength, arrMidPt
Dim dblX, dblY, dblZ, dblLength
Dim i
ReDim arrMemCGPt(2)
ReDim arrJtCGPt(2)
ReDim arrCGPt(2)
Dim strTempCGPt, strTempCGLine, intCount
intCount = 0
ReDim arrBasePts(intCount)
Dim arrSortBasePts, strBaseCrv, intInside, arrCGBasePt
Dim intChoice

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

For i = 0 To UBound(arrLines)

dblSumLength = dblSumLength+Rhino.CurveLength(arrLines(i))

Next

For i = 0 To UBound(arrLines)

arrMidPt = Rhino.CurveMidPoint(arrLines(i))
dblLength = Rhino.CurveLength(arrLines(i))
dblX = dblX+((arrMidPt(0))*(Rhino.CurveLength(arrLines(i))))
dblY = dblY+((arrMidPt(1))*(Rhino.CurveLength(arrLines(i))))
dblZ = dblZ+((arrMidPt(2))*(Rhino.CurveLength(arrLines(i))))

Next

arrMemCGPt(0) = dblX/dblSumLength
arrMemCGPt(1) = dblY/dblSumLength
arrMemCGPt(2) = dblZ/dblSumLength

dblX = 0
dblY = 0
dblZ = 0

For i = 0 To UBound(arrDots)

arrDotPts(i) = Rhino.TextDotPoint(arrDots(i))

dblX = dblX+arrDotPts(i)(0)
dblY = dblY+arrDotPts(i)(1)
dblZ = dblZ+arrDotPts(i)(2)

Next

arrJtCGPt(0) = dblX/i
arrJtCGPt(1) = dblY/i
arrJtCGPt(2) = dblZ/i

arrCGPt(0) = ((dblMemDens*dblSumLength*arrMemCGPt(0))+(dblJtWt*i*arrJtCGPt(0)))/((dblMemDens*dblSumLength)+(dblJtWt*i))
arrCGPt(1) = ((dblMemDens*dblSumLength*arrMemCGPt(1))+(dblJtWt*i*arrJtCGPt(1)))/((dblMemDens*dblSumLength)+(dblJtWt*i))
arrCGPt(2) = ((dblMemDens*dblSumLength*arrMemCGPt(2))+(dblJtWt*i*arrJtCGPt(2)))/((dblMemDens*dblSumLength)+(dblJtWt*i))

strTempCGPt = Rhino.AddPoint(arrCGPt)
strBaseCrv = Base(arrDotPts)

arrCGBasePt = arrCGPt
arrCGBasePt(2) = 0
strTempCGLine = Rhino.AddLine(arrCGPt,arrCGBasePt)
intInside = Rhino.PointInPlanarClosedCurve(arrCGBasePt,strBaseCrv)

Call Rhino.DeleteObject(strBaseCrv)

If intInside <> 1 Then

intChoice = Rhino.MessageBox(“The addition of this point will cause the structure to topple. Carry on anyway?”,4)

Else

intChoice = Rhino.MessageBox(“The addition of this point will not cause the structure to topple”)

End If

Call Rhino.DeleteObject(strTempCGPt)
Call Rhino.DeleteObject(strTempCGLine)
CG = intChoice

End Function

Function Base(arrAllPts)

Dim intPolyCount, intPtCount, intInOut
Dim i, j
Dim arrTempPoly, strTempPoly
Dim dblDist, dblMinDist, intMinPt, bolMin
Dim dblParam, arrClsPt
Dim arrTempPts
Dim arrJoin
intPtCount = 0
intPolyCount = 2
bolMin = 0
ReDim arrPts(intPtCount)
ReDim arrBasePts(intPolyCount)
ReDim arrBaseLns(intPolyCount)

For i = 0 To UBound(arrAllPts)

If arrAllPts(i)(2) = 0 Then

arrPts(intPtCount) = arrAllPts(i)
intPtCount = intPtCount+1
ReDim Preserve arrPts(intPtCount)

End If

Next

intPtCount = intPtCount-1
ReDim Preserve arrPts(intPtCount)

arrBasePts(0) = arrPts(0)
arrBasePts(1) = arrPts(1)
arrBasePts(2) = arrPts(2)

arrBaseLns(0) = Rhino.AddLine(arrBasePts(0),arrBasePts(1))
arrBaseLns(1) = Rhino.AddLine(arrBasePts(1),arrBasePts(2))
arrBaseLns(2) = Rhino.AddLine(arrBasePts(2),arrBasePts(0))

For i = 3 To intPtCount

arrTempPoly = Rhino.JoinCurves(arrBaseLns)
strTempPoly = arrTempPoly(0)

intInOut = Rhino.PointInPlanarClosedCurve(arrPts(i),strTempPoly)

Call Rhino.DeleteObject(strTempPoly)

If intInOut = 0 Then

For j = 0 To intPolyCount

dblDist = Rhino.Distance(arrBasePts(j),arrPts(i))

If j = 0 Then

dblMinDist = dblDist
intMinPt = j
bolMin = 0

Else

If dblDist < dblMinDist Then

dblMinDist = dblDist
intMinPt = j
bolMin = 0

End If

End If

Next

For j = 0 To intPolyCount

dblParam = Rhino.CurveClosestPoint(arrBaseLns(j),arrPts(i))
arrClsPt = Rhino.EvaluateCurve(arrBaseLns(j),dblParam)
dblDist = Rhino.Distance(arrClsPt,arrPts(i))

If dblDist < dblMinDist Then

dblMinDist = dblDist
intMinPt = j
bolMin = 1

End If

Next

If bolMin = 0 Then

arrBasePts(intMinPt) = arrPts(i)

Call Rhino.DeleteObjects(arrBaseLns)

For j = 0 To intPolyCount-1

arrBaseLns(j) = Rhino.AddLine(arrBasePts(j),arrBasePts(j+1))

Next

arrBaseLns(intPolyCount) = Rhino.AddLine(arrBasePts(intPolyCount),arrBasePts(0))

ElseIf bolMin = 1 Then

arrTempPts = arrBasePts
intPolyCount = intPolyCount+1
ReDim Preserve arrBasePts(intPolyCount)

arrBasePts(intMinPt+1) = arrPts(i)

For j = intMinPt+2 To intPolyCount

arrBasePts(j) = arrTempPts(j-1)

Next

Call Rhino.DeleteObjects(arrBaseLns)
ReDim Preserve arrBaseLns(intPolyCount)

For j = 0 To intPolyCount-1

arrBaseLns(j) = Rhino.AddLine(arrBasePts(j),arrBasePts(j+1))

Next

arrBaseLns(intPolyCount) = Rhino.AddLine(arrBasePts(intPolyCount),arrBasePts(0))

End If

End If

Next

arrJoin = Rhino.JoinCurves(arrBaseLns,True)
Base = arrJoin(0)

End Function

Function GoalPoint(arrTextDots,arrGoalPt)

Dim strMin, blnSwap
Dim i, j, k

ReDim arrDist(UBound(arrTextDots))

Do

blnSwap = False
For i = 1 To UBound(arrTextDots)

If Rhino.Distance(Rhino.TextDotPoint(arrTextDots(i-1)),arrGoalPt) > Rhino.Distance(Rhino.TextDotPoint(arrTextDots(i)),arrGoalPt) Then

strMin = arrTextDots(i)
arrTextDots(i) = arrTextDots(i-1)
arrTextDots(i-1) = strMin
blnSwap = True

End If

Next

Loop While blnSwap = True

Call Rhino.SelectObject(arrTextDots(0))
Call Rhino.MessageBox(“The closest node to the goal point has been selected”)

End Function

Article Published in Int|AR – Journal of the RISD Department of Interior Architecture

An article I co-authored with members of Kamath Design Studio on the planning, design and construction of an Interpretation Centre for a black buck sanctuary in Churu District, in Rajasthan was published in Int|AR – the RISD Department of Interior Architecture’s journal on adaptive re-use. My personal involvement in the project had been in the site documentation and context analysis stages way back in 2007 so seeing the final design and constructed buildings and working on the paper was a very satisfying experience. Though this project has nothing to do with digital design and fabrication, it showcases the contemporary use of indigenous craft skills and building systems that I seek to integrate with digital design work-flows. Here is a link to the article.

A Photograph of a Nearby Settlement from the Context Documentation

Digital Design and the Future of the Small Architectural Firm

Like a lot of people of my generation, I was introduced to computers around middle and senior school. This was before Windows, Macintosh, Linux or Android. If we wanted to interact with the computer we had to programme it to do exactly what we wanted it to do. In today’s terms, we had to write our own software and create our own apps. Computers have come a long way since then.

BBC Micro computers similar to the ones I first used in school (Photo: Dom Walton, Flickr.com)

We have seen the rise of the graphical user interface (GUI) increasing the opacity of the inner workings of computers. You don’t need to know how to write code any more. Using computers is no longer about creating but consuming. We now use what software we get off the shelf rather than create our own.

Apps (Source: http://www.geek.com/articles/apple/apple-app-store-subscriptions-20110215/)

As the enforcement of anti-software piracy laws has increased in India, architects have become increasingly invested in specific proprietary software packages (ask any architect about the police raids that checked for pirated CAD software in their studios). Being tied to an expensive piece of software means that a designer is forced to use that software for as many tasks as possible to achieve a return on investment. Architects do not have the flexibility to select a piece of software that is ideally suited to a design task. As an analogy, if each app for your smart phone cost a lot of money, you’d probably just use a general purpose browser to search for the cricket score rather than buy an app made specifically to give you score updates.

The nature of a small architectural firm is that it provides customised design solutions to a limited clientele. If small firms are to use digital design tools to their full potential, and fully integrate them into their work flow, then a standardised software package cannot be the solution. For a small firm to fully embrace what digital design has to offer, it needs the ability to customise design software to provide customised design solutions.

The trajectory taken by architectural software has been in the opposite direction to the needs of the small firm. Simple Computer Aided Design (CAD) software which functions like a digital drawing board has now given way to Building Information Modelling (BIM) software that is able to handle all aspects of construction from site surveying to construction supervision. The ability of BIM software to process all kinds of data related to design and construction vastly increases the efficiency and productivity of an architect.

The more data an architect processes using standardised software, the more the architect is restricted to what the software is pre-programmed to do. For a large architectural firm doing commercial projects this is not a significant trade-off, in fact, standardisation across projects is an asset in terms of speed and efficiency. But these very advantages of the software are not only an anathema to small practices but also significantly increase the competitive edge that large firms have over them in an already shrinking professional space.

Unlike CAD, BIM software is not only a design tool but also guides project management and construction. The global standardisation of BIM software results in an overt and/or covert standardisation of building materials and technologies. The kind of software an architect uses influences the form and aesthetic of the buildings they design, the kinds materials used in the buildings, and the kinds of construction techniques required to build the buildings. The implications of this discussion therefore go far beyond the confines of architectural firms and their software to ultimately affect the economics of construction, the environmental impact of buildings, and social issues linked to the value of indigenous local skills and knowledge.

The way a small architectural firm negotiates the use software in their practice will only become more pressing in the future. One way to deal with this can be to use only CAD software for digital drawings and not use BIM in the project work flow at all. This is the way most small practices currently function but it may not be feasible to indefinitely compete with the ever increasing efficiency of large firms using BIM.

Another way a small firm may deal with this can be to introduce BIM into the work flow only after major design decisions have already been taken and use it merely as a tool to coordinate information robustly and efficiently. This would be akin to a writer writing with pencil and paper and only using a word processor like an electronic type writer to create a final draft for printing thus not allowing the software’s spelling and grammar checking (and other automated features) to affect the way in which the writing is conceived. In architectural terms this will make construction management and general coordination more efficient, but it will not allow the small architect to make full use of the possibilities that digital design opens up.

The third way for the small firm is to create a digitally aware practice that approaches software the way we were taught at school – to be creators rather than consumers of software. This does not mean re-inventing the wheel and making one’s own version of general purpose commercial BIM software. Rather, the digitally aware small firm must be able to quickly and efficiently create unique pieces of simple code that are tailored to perform the unique tasks that are required to create unique designs. These pieces of code cannot be sophisticated software but rough and ready tools for one-off deployment. The use of software here adds value to the creative process and is much more than an office automation tool or information database. Such code will not do away with the need for a CAD or BIM package but will augment it and overcome its limitations, acting as a bridge between the architect’s creative design process and standardised software tools. In real terms it may even function as a script that runs within a software package and makes the most of its pre-programmed functions. Such a small firm will be a savvy consumer and tinkerer of software with the goal of being a creator of unique and customised architecture.

Weaving and Linear Measurement in Digitally Guided Construction

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.

Source: http://www.thecarvingpath.net/forum/index.php?showtopic=1278

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.

The skinning of the plywood framework with strips of flexible luaun.
A Surface
A Divided Surface
The Boundaries Of The Divisions Form A 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.

A surface woven from digitally derived linear fabrication data.
The first bamboo Parametric Pavilion. Kamath Design Studio, New Delhi, 2010.

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.

Digital Design and (Manual) Fabrication

In most academic and scholarly settings the phrase ‘Digital Design and Fabrication’ is used almost like a single word. In fact I was associated with the Digital Design and Fabrication Group at MIT’s Department of Architecture for a large part of my SMArchS programme. However, I wonder if Digital Design must go together with Digital Fabrication, and what happens if they do not? Are we, as designers living in an age where we have access to both digital and non-digital methods of design and fabrication, missing out on opportunities by bundling Digital Design with Digital Fabrication? A vast majority of building construction in both industrialised and non-industrialised contexts still primarily uses manual, non-digital methods of construction. Does this mean that methods of  ‘Digital Design’ can not be used in such contexts? (Digital Design being “a self contained way of designing exclusively within a computational environment” (Sass, Lawrence, and Oxman, Rivka. (2006). Materializing design: theimplications of rapid prototyping in digital design. Design Studies, 27, (3), p. 333)).


A 'Contractor' with a CAD Drawing at a Site Using Manual Construction Techniques (http://architectureideas.info/wp-content/uploads/2008/08/contractor1.jpg&t=1)
The Ideal Digital Design and Fabrication Work Flow (http://mit.edu/yourhouse/images/Onsite%20Fabrication%20copy.jpg)

The main argument against being able to use Digital Design without Digital Fabrication is that the formal complexity of the resulting designs is impossible to achieve without the accuracy and versatility of Digital Fabrication technology. Once adopted, Digital Design and Fabrication also offers many conveniences such as the seamless transition from CAD model to fabrication data for CNC machines and the ability to make use of rapid prototyping in the design process. (Sass, Lawrence, and Oxman, Rivka. (2006). Materializing design: the implications of rapid prototyping in digital design. Design Studies, 27, (3), 325-55.) Digital Fabrication also offers advantages such as very high levels of accuracy in building components that increase pre-fabrication and reduce on-site assembly (Kieran, Stephen, and Timberlake, James. (2004). Refabricating architecture: how manufacturing methodologies are poised to transform building construction. New York: McGraw Hill.)

The use of digital fabrication using data from a CAD model means that under ideal conditions designers and fabricators do not have to deal with measurements and calculations while building. Since parts are CNC manufactured, they are highly accurate and their dimensions do not need to be verified before assembly – until and unless there is a mistake and something doesn’t fit. In a manual construction, however, measurement is an integral part of construction. The data from the design is read off dimensioned drawings and used by a construction worker to build a part of the building. The actual dimensions and orientation of the part then need to be checked against those in the drawing. This process of the construction worker having to follow dimensions given in a drawing issued by the designer has its origin in the Renaissance in the West.

Prior to that (and outside the West) the boundary between the designer and the maker was not as well defined and exact dimensions for a building were not completely specified prior to construction. Instead, construction would proceed by a process of Cutting and Fitting whereby a part would first be made and its dimensions would be measured subsequently in order to determine the dimensions of new parts that were dependent on the dimensions of the original part. (McGee, David. (1999). From Craftsmanship to draftsmanship: naval architecture and the three traditions of early modern design. Technology and Culture, Vol. 40, No. 2 (Apr., 1999), pp. 209-236).

Given the extremes of Digital Fabrication and Cutting and Fitting, and all methods of manufacture in between, can we devise efficient means of executing Digital Designs without the use of Digital Fabrication?

Santa Monica Cradle: Reflections on Craft and Computation

While it does not strictly follow the Sensing-Evaluating-Shaping design methodology I developed in my SMArchS thesis (Integrating Digital Design and Fabrication with Craft Production), the Cradle sculpture by Ball-Nogues Studio in Santa Monica illustrates many of the issues addressed therein.

My thesis examined if methods of manual craft production can be utilised to overcome the indeterminacies of physical materials and processes that hinder Digital Design and Fabrication. The Cradle sculpture consists of a number of stainless steel spheres that are tangent to a complex curved surface as well as to each other.

The Cradle Sculpture Seen as Spheres Tangent to a Complex Curved Surface and to Each Other

I developed a script which is able to place spheres one at a time on a surface in such a manner. However, if one attempts to physically replicate the the results of the script (say, by placing balls in a bowl)  one will quickly encounter a number of discrepancies between the digital and the physical.

Balls in a Bowl

One of these discrepancies is the effect of gravity on the tangent spheres which will alter the positions of all the spheres every time a new tangent sphere is added. However, this can be overcome if each ball that is added is glued in place before the next one is added.

Another discrepancy which is much harder to overcome arises from the ‘imperfections’ of physical materials. The geometric nature of the system of tangencies between the surface and the spheres and between the spheres themselves means that the displacement of any one sphere or any modification of the surface will cause a displacement of all the spheres in the system. This means that the slightest discrepancy in form between the digital model of the surface and its physical counterpart, or any deviation of the balls from perfect sphereicality, will cause a mismatch between the digital model created by the script and a physical model.

One way to overcome this issue would be to build in a tolerance between all the components of the system (the surface and the spheres). However, this would have two drawbacks – firstly, it would mean that no two spheres in the physical model will actually be touching due to the tolerance between them, and it could be argued that this would unacceptably compromise the visual perception of the sculpture. Secondly, it would require a sophisticated joint at each point of tangency to absorb the tolerance built into the system which would increase the cost of the project significantly considering that there are approximately three hundred and fifty balls in the sculpture.

Instead, in this project, we chose to allow a deviation between the digital model and the physical artefact. The script was thus used only as a guide in the project to visualise the project through renderings, to estimate material costs and quantities, and to perform structural analysis.  This enabled the surface of the form-work to be constructed cheaply and rapidly without the pressure of having to conform to the digital model to a high level of accuracy and to have a very simple welded joint between spheres. The final configuration of balls in the project was guided by the digital model developed using the sphere packing script and also a result of the incomputable, indeterminable characteristics of the physical materials and processes of fabrication and subjective human design responses to these unique conditions. Proof of this idea lies in the impossibility of duplicating the exact placement of balls if one were to repeat this project once again.

The Surface of the Form-Work Fabricated with Two Layers of Curved Lauan
Welded Joints Between Spheres

Oltrarno, Florence – The Future of Craft

Florence is world renowned for its heritage.  Its buildings and works of art mark key milestones in the development of Western civilization. However, this heritage is viewed as belonging to the past and having nothing to do with the present.

Historically, craft as an activity  has tied the residents of neighbourhood of Oltrarno to their built environment – from window shutters and door knobs to street lights and bicycle stands. The practise of craft in the present maintains a connection with the past. Just as the crafts of Oltrarno are an invaluable resource to the neighbourhood they are equally relevant in the context of the city of Florence and the whole world.

This slideshow requires JavaScript.

In order to halt the decline of crafts in Oltrarno, people need to be made aware of the significance of craft as a living connection between the past and the present. The practise of craft needs to be kept financially and logistically viable in the face of the changes taking place in the neighbourhood. Avenues for the development and evolution of crafts to ensure their sustainability in the future and prevent them from being mere relics from the past. Ways must be found to make craft more productive so that it can cater to the many needs of the common citizen and remain relevant to their lives.

I wrote this report as part of a study on Digital Placemaking by the Digital City Design Workshop MIT, in 2007. This study was commissioned by the City of Florence and presented to the representatives of the city in 2009.

SMArchS (Design Computation) Thesis

The following is the abstract of my masters thesis for the SMArchS(Design Computation) degree at MIT. A downloadable PDF of my thesis can be found here.

Thesis Title: Integrating Digital Design and Fabrication with Craft Production

Abstract

This thesis examines if methods of manual craft production can be utilised to overcome the indeterminacies of physical materials and processes that hinder Digital Design and Fabrication (DDF). Indeterminacies in physical materials and processes are considered to be errors that prevent DDF from achieving its stated goal of a seamless transition from digital model to physical artefact. One of the definitions of craft, by contrast, is “(potentially) error through and through… [where error is]… an incomputable deviation from the norm” (Dutta, p. 211, 2007).

This concept of error as being “incomputable” is analysed using theories from computation, systems theory and sociology to formulate a definition of material craft production for this thesis. Material craft production is then compared to the concept of digital craft and it is argued that digital craft is limited in its capacity to negotiate physical materials and processes.

Tools from systems theory are then used to propose a model describing material craft production. This model is called the Sensing-Evaluating-Shaping (SES) model. The validity of the SES model is tested through case studies of material craft production.

The SES model is analysed using systems analysis tools and a role for DDF is proposed within the SES model,  giving rise to digital SES production. The ability of digital SES production to negotiate indeterminacies in physical  materials and processes is tested through the fabrication of a series of increasingly complex physical artefacts.