Recyceld FaBricK 2.o by Amay Gurkar

Open Thesis Fabrication | Iaac 2011 1

Recycled FaBric(k) 2.0 Open Thesis Fabrication | Iaac - 2011 Vittal Sridharan | Amay Uday Gurkar The concept, design possibilities and technology testing for the project was initialized as a part of the MAA(Masters in Advanced Architecture) course at IaaC in the year 2010-11. Our aim is to take the project to a level so as to perceive it in reality and construct a 1:1 test structure during the OTF (Open Thesis Fabrication) at IaaC. This thesis and experiments would not be possible without the help of our dear friend Guru Prakash (a.k.a gurupagos) The project was conducted under the guidance of (OTF) Open Thesis Fabrication coordinators : Marta Male Alemany Luis Fraguada

2011 Recycled FaBric(k) 2.0 Vittal Sridharan | Amay Gurkar IaaC | Barcelona

Recycled FaBric(k)2.0 Recycling construction waste by means of digital processes to design new emergent architecture.

Preface “Digital materiality evolves through the interplay between digital and material processes in design and construction. The synthesis of two seemingly distinct worlds - the digital and the material - generates new, self-evident realities.” The above text is quoted from the literature “Digital Materiality in Architecture published by Fabio Gramazio and Matthias Kohler” a research conducted within the academic environment of ETH Zurich, Faculty of Architecture, where they identify new methods of designing in relation to the material behaviour and their properties tested during the fabrication process. This digital materiality discussed by the authors was the guideline for our thesis conducted during the Digital Tectonics Studio within the MAA program at the Institute for Advanced Architecture of Catalonia. PREVIOUS RESEARCH : Recycled FaBric(k) is a project about recycling broken bricks from demolished /disaster hit sites; reinstating them as construction materials by using present technologies & computation – tagging the brick for identification,analysing their complex geometry,extracting their inherent parameters, input designer’s parameters and study the possible outcomes which could be assembled on site based on the information from simulation. The process involves scanning the broken bricks with a 3D scanner to reproduce it on a digital platform; tagging and assigning an identification to the bricks using fiducial markers; using computation on Rhinoceros/Grasshopper to analyse its properties and incorporate designer’s input. And finally based on these outcomes, assemble the broken bricks using certain tools/ technologies to assist for precision installation of each brick forming the structure. EVOLUTION CATALOGUES : During the MAA (Masters in Advanced Architecture) program at the Institute for Advanced Architecture of Catalonia (IAAC) the focus wad laid on all three aspect of the process - creating a catalogue of development from the 3D Scanning, fiducial markers and experiments with scaled models for possible emerging structures considering a specific set of broken bricks. In the Digital Tectonics Studio which was conducted over a period of six months, we focused on producing designs specific to the material properties of the broken bricks, and developing the process using various technologies to bring the thesis as close as possible to reality. We developed a catalogue of possible structures (Design Evolution) keeping in mind the process that would be involved in scripting them and automating the methods or logics behind the complex structure that could then be applied to any number of bricks at all possible sites, with any given structure depending on the bricks found at those sites. These design evolution studies formed a set of rules that needed to be fed into the master program such that we could optimise the emerging structure for the specific set of bricks found at the specific site. PROGRAMMING DESIGN RULES: The idea behind the evolution of the experimental design models was to test the process in the time constrain of four months. The procedure otherwise was to automate the process of logic provided by the script to test a physical 1:1 prototype. Once these rules were identified, it was a matter of translating them into codes / scripts, which would channel the next level of complexity wherein the intent of the user/designer would help, strategize the evolving structure.

CONCLUSION : Within the MAA framework, we were able to test and develop Recycled FaBric(k) at every level of the process, bringing out the possibilities it holds for testing on actual sites. For the Open Thesis Fabrication we aim at creating real scale prototypes of the project by making additions/subtraction to the process and applied logics, with the added advantage of the collaborating with professionals / companies.

Recycled FaBric(k)2.0 6

Introduction

Thesis Statement and Objectives

Recycled FaBric(k) 2.0 is the next step towards the implementation of the MAA project into a real scale test structure. Our focus during the Open Thesis Fabrication is towards how each computational logic / rule would generate varied structures from the inherent properties of the broken bricks. As our MAA thesis concluded, it gave rise to specific set of questions, most importantly what were the possible applications and what kind of structures would result out of such a process? During the Phase-1 (developed during the course of the Masters Program MAA) of the project we discussed the various autonomous technologies that were being used to analyse the design possibilities, we then hacked kinect as a 3d scanner, fiducial markers for identification and augmented systems for the assembly. These processes are now taking advantage of the collaborations available during the OTF. The project is conceived as a portable design system which can be executed at any given site immediately with a minimal cost, hence our intention is to work further on and develop it to a state of completion. For the open thesis fabrication we narrowed down on the following companies as partners considering they would provide us with the machines / softwares / technical guidance we will require to bring this thesis to a level that would generate a real scale test structure. METAIO - Augmented Reality System.

Contents 01 | Preface _04 _Previous Research Outline _Evolution Catalogues

02 | Thesis Statement _07 03 | Objectives _07 _Technologies _Partner Companies Collaboration

04 | Hypothesis _11 _Present Research Visualisation

05 | References _13 06 | Process _ MAA Research _15 _ Kinect as a 3D Scanner _21 _ Broken Bricks _31 _ Brick Geometry Simplification _32 _ Brick Matrix _34 _ Brick Parameters _36 _ Design by Code _34 _ Bounding Box + Galapagos _36 _ Sorting Angles + C# _44 _ Differential Thickness + C# _52 _ The Corbelled Arch + C# _66 _ Sequential Evolutionary Solver _80 _ Augmented Reality Assembly _89

(with Metaioâ&#x20AC;&#x2122;s JUNAIO application)

Hypothesis “The beauty of brick structures is that it characteristically highlights its materials as key building components because they form a series of clearly visible pieces that belong to bigger jigsaw of the architecture.” - Lorraine Farrelly (Construction + material) Brick is one of the oldest construction material known to man. And most of the conventional construction waste recycling methods known to man include heavy consumption of energy (physical and resources), thus not leading to a sustainable solution. Broken bricks have a characteristic shape, which if analysed and simplified, could be used to generate emergent design forms. This process is the purest example in the lines of “Digital Materiality”. These bricks found abandoned / discarded for their irregular shape can actually be potentiated as a new strong design language in architectural terms. Through the design evolution catalogues, we derived many useful structures that directly relate to different site conditions and accordingly optimise the structure against insulation (wall thickness where required) wind breakers, (to chanelise the wind in desired directions) retaining walls (as the structures are not fitted with mortar, the gaps in-between them lead to ease off(?) pressure for the soil behind the retaining walls) etc. Our aim during the open thesis fabrication was to generate a new design strategy in re-using the broken bricks found at abandoned sites with the help of the digital tools and technologies highlighted earlier. Through this entire process, architecture becomes increasingly rich and diversified. Variation emerges as it becomes possible to design large number of structures in distinguishable ways (as the parameters of broken bricks differ) using digital means. Within the research paper of “Fabio Gramazio and Matthias Kohler - Digital Materiality” they very clearly describe the designing processes - “Digital Materiality leads us from the design of static forms to the design of material processes. In doing so we give up geometry, whether drawn or modelled, as architecture’s actual building plan and its primary basis for design decisions. Instead, we design the relationships and sequences that inhabit architecture and that emerge as its physical manifestation. But once we begin to invent such material processes , a new way of thinking about architecture reveals itself. It is a conceptual way of designing with architectural parameters, conditions, relationships, and degrees of freedom. “ Architecture that uses these digital technologies interests us because it take a bottom up approach, where not every form is directly translated from the ideas of the designer, but also through the material parameters / relationships. This leads to a new associative and tangible way to think, build and experience architecture. Recycled FaBric(k) 2.0 would translate these issues of a bottom-up approach and develop prototypes at a 1:1 scale to test the entire process to be applied within the architectural design realm.

09 12

References 01 | The Smart Scrap _Ball State University _methods to digitse complex geometries 02 | MOStack - on the verge of collapse _simulation of blocks for stable outcomes 03 | Architecture of Machu Picchu _study of historical example on dry wall construction 04 | Structures by Eladio Dieste _innovations in brick construction _techniques to create complex structures 05 | Structures by Solano Benitez _innovations in brick construction _techniques to create complex structures 06 | The Programmed Wall _ETH Zurich, Faculty of Architecture _digital and robotic precision systems 07 | Freeform Catalan Thin-tile Vaults _Phillip Block Reasearch Group _techniques for compression only structures _RhinoVAULT plugin to design funicular forms 08 | Reactable Surfaces _University of Pompe Fabra _fiducial markers for tagging id to bricks 09 | Digital Materiality _reference to research paper _ETH Zurich, Faculty of Architecture 10 | Softwares Involved _Rhinoceros _Grasshopper _Processing _Sketchy Physics

Chapter 01 14

Recycled FaBric(k) Process Brief Introduction of the process :

Step 01|Collect all the material (broken bricks) either site found or from other sources. Step 02|Place the broken bricks into the portable 3D scanner (hacked microsoft kinect) translating physical data of the bricks into digital information. Step 03|Tagging the scanned bricks with their unique fiducial markers linking physical and the digital. Step 04|Extracting geometric properties, sorting, comparing geometries for similarities to develop a design based on parameters. Step 05|Real time construction evaluation, as a feed back loop between design and execution. Step 06|Rectification based on feedback.

Brief Introduction of the process The focus of our thesis was more on the process than the resultant outcome. The initial experimental material chosen was broken/used bricks - the most commonly used material for construction and also the largest amongst construction waste. Broken bricks have a characteristic shape, which if analysed and simplified could lead to emergent design forms. This process is the purest example in the lines of digital materiality. Ideally this process is meant to be applied with all construction waste materials. This thesis explores the possibilities that emerge from broken properties of the bricks using mechanic and computational intelligence. The process involves applying day to day technologies, parametric and scripting tools along with open sourced arduino platform boards well interlinked to generate a closed recurring loop (non linear system). Technologies used in the project include - microsoft kinect, fiducial markers, webcams, smartphones all inter-connected by laptops and their sophisticated softwares such as processing, rhinoceros, grasshopper and reactivision. The different technologies used within the processes are regular home entertainment devices costing around 500 - 1000/- Euros as a one time investment for the project. Floating costs including power consumptions and transportation cost which are marginal as most materials and technologies are locally available. DIGTAL CONTROL| Recycled Fabric(k) directs these tools (delete extra space) into a process where digital control creates new designs possibilities. Digital Control in the project helps in two aspects - analysing and simplifying the complex geometry of the broken bricks. The digitally reproduced models of the bricks are analysed of all its properties during this phase of the project - like the centre of gravity, number of faces, shapes , sizes of brick, etc. The second aspect integrates the parameters derived from the bricks into various design possibilities by generating scripts which can apply designer controlled parameters during the design development. This helps in visualising multiple outcomes by changing and combining various parameters. By extracting these multiple parameters a requisite design with these bricks can be simulated and studied of its precision, interlocking, mortar / binding material required to assemble them. Digital Control also helps in analysing the contour of the terrain in which the design is executed and the hence the design can accommodate the site conditions and lead to a more stable outcome. The flexibility of modifying and simulating the design gives the designer an opportunity to update his final outcome and construct the most preferred outcome.

DIGITAL CONTROL : While architects have employed computer-aided drafting (CAD) systems since a couple of decades, only recently have two distinct and potent design sensibilities, parametric and algorithmic design have emerged. Nurtured by early architectural researchers and programmers operating in practice, these methodologies are now gaining widespread professional and academic acceptance. | Neil Leach

Brief Introduction of the process DESIGN APPLICATION| Can Valldaura is a historical mountain villa which is a part of the green FabLab Barcelona. At Q Valldaura each student and researcher will be self-sufficient while coexisting with various natural, social, economic, and knowledge networks. Food will be produced on site in organic gardens, by farms animals, through an active agricultural system and within biocultures. Production within the Green Fab Lab will use local resources such as wood, fibers, or sensors, based on a network shared knowledge within the natural environment. Each person will contribute to the creation of energy for Q Valldaura to operate through all activities. Each of these interactions create the â&#x20AC;&#x153;Self-Net Manâ&#x20AC;? who is learning, adapting and sharing their knowledge with local and global communities. IaaC (Institute for Advanced Architecture of Catalunya) , Barcelona had organized a voluntary program to recover the recyclable materials like wood, bricks and stones to reuse them for the development of new structures at this heritage site. We as students participated in this program and managed to recover a lot of bricks which were in good condition to be reused in construction. Taking cues from this exercise we decided to experiment our project at this site and contribute to the design and development of possible structures at this site. FOOD | Activate agricultural system on the old terraces. Can Valldaura has been constructed over a mountain and there are many terraces created for landscaping and micro agriculture pockets. Broken brick walls could form retaining walls which can flow along the contour lines instead of forming hard lines and creating rigid terraces. These fluid terraces would follow the lines of the contours thus reacting and behaving in tandem with the site FABRICATION | Production with new technologies, connected to the world. Enclosure walls for the fabrication lab which has been proposed by the institute could be constructed with broken bricks. The advantage is these bricks could create interesting patterns instead of mundane walls and also accommodate climatic factors like light and ventilation based on the orientation of these walls to the sun. SHELTER | ENTERTAINMENT | Free standing kiosks and seatings designed from broken bricks can be installed at site. Can Valldaura often organizes various parties and outings for the students visiting IaaC, Barcelona. These structures could act as semi enclosures as well as small zones demarcating various activities like plantations, kennels, seating alcoves etc.

Chapter 02 20

OTF Process

Kinect as a 3d Scanner

SCANNING (in electronics) _to move a finely focused beam of light or electrons in a systematic pattern over a surface in order to reproduce and subsequently transmit an image.

3D SCANNING _is a process that analyses a real-world object or environ-

ment to collect data on its shape and possibly its appearance (i.e.colour, texture). The collected data can be used to construct digital, three dimensional models.

KINECT _is a device mainly for the xbox gaming console, which interprets movement by different users and translates that motion within the games. But ever since its release people have widely hacked it to be used as a real time 3D scanning device.

Kinect as a 3d Scanner With over 8 million units sold within the first 2 months of its official launch, kinect is the fastest selling consumer electronic device. Through the open source community, the kinect hardware was reverse engineered to work on PC within days of its release.

INTRODUCTION : Kinect is based on software technology developed internally by Rare, a subsidiary of Microsoft Game Studios owned by Microsoft and on range camera technology by Israeli developer PrimeSense, which interprets 3D scene information from a continuously projected infrared structured light. Thus kinect has the ability to translate the regular RGB image captured by the camera and translate them with the depth sensors to successfully generate a 3D of the captured view. Although there are many available 3d scanners within the market they all have many drawbacks, including costs, scanning time, resolution, portability, etc the kinect was the most optimum solution to be tested for the Recycled FaBric(k) 2.0 process. Kinect as far as we know is the fastest available 3d scanning hardware with capabilities to generate 3D in real-time. Now that we know the basics of how the kinect functions, let us explore the process that lead us to code the device to construct 3d digital models of our broken bricks. CONNECTING TO THE PC : As the kinect was officially launched for the Xbox gaming console, microsoft had not released the drivers required to successfully connect it to a PC. But the official developers (Open NI and PrimeSense) released the drivers for hackers to control the device. Even though at present Microsoft has released the official SDK for the device, most programming tools such as the one we have applied for this thesis (processing) rely on the developer drivers. Hence it is necessary to instal all the drivers that are needed through the websites of the individual developers. Once we achieve this step, the kinect is recognised by the PC and can now be accessed by processing. PROCESSING LIBRARIES : Libraries are meant to extend the capabilities of processing beyond just graphics and images, they are intended to enable audio, video and communication features with other devices. The library suited for our thesis is called SimpleOpenNI available on their website, it is simple OpenNI and NITE wrapper built for processing. Therefore not all functions of OpenNI are supported, its meant more to deliver a simple access to the functionality of the device. The library allows to generate a pointcloud using all the depth sensor features from the kinect. Through this chapter we will explore how the code functions and the necessary additions to build a 3d scanner using the kinect. SCRIPTING DETAIL : The SimpleOpenNI library is an easy to hack interface for the kinect. The sample code available just displays the depth information captured by the kinect sensor and display within the processing window as a set of points. In order to generate a complete 360 degree scan of the brick, we introduced new sets of arrayLists which can contain the depth information individually and later compile them all as set of points rotated around the centre of the scanned brick. The script also has user control sliders, accessing the scanning distance, render detail, rgb scan and other export functions.

What is processing ? Processing is an open source programming language and environment for people who want to create images, animations, and interactions. Initially developed to serve as a software sketchbook and to teach fundamentals of computer programming within a visual context, Processing also has evolved into a tool for generating finished professional work.

Kinect as a 3d Scanner RFB2 Scanbrick Script

class Scanner { //----------------------------------------------------------CLASS VARIABLES float depth = 900; float minDepth = 400; int detail = 8; int distance = 620; int counter; PVector a, b, c, d; PrintWriter Print1, Print2, Print3, Print4; ArrayList<PVector> scan1 = new ArrayList<PVector>(); ArrayList<PVector> scan2 = new ArrayList<PVector>(); ArrayList<PVector> scan3 = new ArrayList<PVector>(); ArrayList<PVector> scan4 = new ArrayList<PVector>(); //----------------------------------------------------------KINECT CALIBRATION void calibrate() { translate(0, 0, 0); rotateX(PI); rotateY(0); scale(0.5f); counter++; for (int y=0; y < kinect.depthHeight(); y+=detail) { for (int x=0; x < kinect.depthWidth(); x+=detail) { int[] depthMap = kinect.depthMap(); PVector[] realWorldMap = kinect.depthMapRealWorld(); int index = x + y * kinect.depthWidth(); int rawDepth = depthMap[index]; PVector v = realWorldMap[index]; if (rawDepth < depth) { if (rawDepth > minDepth) { //stroke(255, 255, 255); //point(v.x, v.y, v.z); scan1.add(v);

}

for (int i=counter; i == 6; i++) { scan1.add(v); } for (int i=counter; i == 160; i++) { //ptCld1.clear(); scan2.add(v); } for (int i=counter; i == 260; i++) { //ptCld1.clear(); scan3.add(v); } for (int i=counter; i == 380; i++) { //ptCld1.clear(); scan4.add(v); } }

} }//never delete

//----------------------------------------------------------DISPLAY FUNCTION void display() { pushMatrix(); translate(0, 0, -distance); for (int i=0; i<scan1.size(); i++) { a = scan1.get(i); stroke(#FC0D00); point(a.x, a.y, a.z); //Print1.println( “Counter:” + counter + “ “ + a.x + “,” +” “ + a.y + “,” + “ “ + a.z + “;”); } popMatrix(); pushMatrix(); translate(-distance, 0, 0); rotateY(radians(90)); for (int i=0; i<scan2.size(); i++) { b = scan2.get(i); stroke(#FCD700); point(b.x, b.y, b.z); //Print2.println( “Counter:” + counter + “ “ + b.x + “,” +” “ + b.y + “,” + “ “ + b.z + “;”); } popMatrix(); pushMatrix(); translate(0, 0, distance); rotateY(radians(180)); for (int i=0; i<scan3.size(); i++) { c = scan3.get(i); stroke(#03FC57); point(c.x, c.y, c.z); //Print3.println( “Counter:” + counter + “ “ + c.x + “,” +” “ + c.y + “,” + “ “ + c.z + “;”); } popMatrix(); pushMatrix(); translate(distance, 0, 0); rotateY(radians(270)); for (int i=0; i<scan4.size(); i++) { d = scan4.get(i); stroke(#008AFF); point(d.x, d.y, d.z); //Print3.println( “Counter:” + counter + “ “ + d.x + “,” +” “ + d.y + “,” + “ “ + d.z + “;”); } popMatrix(); println(“count: “ + counter); println(“number of points within the arrayList pointCloud: “ + scan1.size()); //println(“number of points within the arrayList pointCloud2: “ + scan2.size()); //println(“number of points within the arrayList pointCloud3: “ + scan3.size()); //println(“number of points within the arrayList pointCloud3: “ + scan4.size()); }//never delete

These are a few functions written in processing to access the raw depth datas from the kinect and compiled together using arrayLists to generate a 360 scan of the brick. The main aspects of the code are shown as sample above and on the adjacent page where the kinect calibration is executed and later the display functions draws the 3d of the brick as a pointcloud.

Kinect as a 3d Scanner RESOLUTION OF THE SCAN : The point cloud model as generated from processing, is then exported into Rhinoceros to construct a mesh. There are many methods for exporting the point cloud from processing, printing .txt files of the co-ordinates of all the points, exporting as known CAD formats such as .cad, .rvb, .skp, ply etc, or directly sending the x,y,z co-ordinates of the points through the udp protocol. Sending the list of data via udp requires a simple message script similar to the one written for a .txt file. Once the point cloud is translated to rhino we use the rhino resurf plugin to construct a mesh from the selected point cloud. Images on the following page compares the brick, the point cloud generated and the final mesh / digital model of the broken brick. The comparison shows the loss in data which is the loss in the fineness of the 3d model generated. The final 3d of the brick is not entirely constructed for various reasons and requires a lot more depth of calibration. For this purpose we explore the quality of using a kinect v/s using a very expensive 3d scanner which the collaborating company ZCorp would let us demonstrate. The procedure of exporting the point cloud data is briefly explained in the following paragraph. UDP PROTOCOL :

The User Datagram Protocol (UDP) is one of the core members of the Internet Protocol Suite, the set of network protocols used for the Internet. With UDP, computer applications can send messages, in this case referred to as datagrams, to other hosts on an Internet Protocol (IP) network without requiring prior communications to set up special transmission channels or data paths. This is a library for processing which can

send messages containing data of the point clouds to other hosts. The message is recieved by grasshopper using the gHowl plugin. The gHowl plugin acts as a receiver for the udp message, in this case the co-ordinates of the points. The message as written in processing has to be broken down and the list of numbers which represent the x, y, z co-ordinates is then extracted, later connected with a simple pointXYZ component in grasshopper to build the complete point cloud of the brick. The advantage of using the udp protocol is that it can receive the data in real time and can be updated with the new co-ordinate changes. MESH FROM POINTS : This is one of the simplest steps for generating the 3d model of the scanned brick. With the use of the Rhino Resurf plugin we only select the points or the point cloud and click on generate to develop the mesh. The method of converting a point cloud into a mesh uses a particular triangulation program and individually leads to the quality of the mesh.

Comparison between the real brick, the point cloud generated from our script on processing with renderDetail set as 10 (so every 10 points are skipped) and the mesh constructed using the point cloud. This was the outcome in the first attempt, tweaking with the calibrations will result with a more cleaner mesh and a complete 3D Brick.

Kinect as a 3d Scanner DRAWBACKS : Using the kinect as a 3d scanner has one major drawback, i.e. the resolution of the pointcloud / final mesh of the broken brick. As the kinect is hacked to work with the PC, there are no softwares or applications that can directly generate a 3d object, as a result it requires us to rely on programming tools such as processing. The other drawback involve the lighting condition during the process of scanning. Since the kinect uses a Infrared camera and sensor the object cannot be scanned within broad daylight. This is a similar to most of the 3d scanners available, as lighting condition facilitated the scanning process directly. CONCLUSION : As a conclusion the kienct is the most optimum scanner for the recycled fabrick process. Even though the resolution need a lot of calibration, the cost difference make it readily available within all countries. With a few more months of calibrating the kinect the end result if not better, would be as good as the ones from the expensive 3d scanners.

Chapter 03 30

OTF Process Broken Bricks

BROKEN BRICKS

This Chapter highlights the simplification used for all the broken bricks inorder to evaluate them further using rhinoceros and grasshopper. Since bricks are broken in an uneven complex geometry, it is necessary to simplify their geometry to extract the important parameters.

Broken Bricks Geometry Simplification BRICK GEOMETRY : process directly. Usually most bricks sourced from disaster / demolished sites are broken in an angular section with 3 parallel surfaces. According to a few tests carried out by us, most bricks break in the middle section of the brick. This is due to the bonding between the bricks in the wall. Some bricks sourced are also in their whole, i.e. they are not broken or chipped and can be reused as a whole brick. SIMPLIFICATION : The broken bricks when scanned by the kinect form an undulated surface with a tolerance of 2 - 3 mm. This is not favourable or necessary while digitally assembling structures. For this reason, we simplify the bricks by the parameters extracted. We consider a bounding box retaining the shape of each surface, only flattening and removing unnecessary points from the scanned mesh. An important factor to consider while simplifying the geometry is that the broken face is follows a convex curve. It would have to be divided into 2 faces, while a concave face can be considered as 1 face and the remaining empty gap could be filled.

The above image shows the difference in geometry after 3d scanning the broken brick with the kinect. At the far left is the 3d scan of the brick and towards the right is the final brep extracted from the scan to be considered for all the codes.

The above image represents the simplification carried out for analysing the geometry in rhino. The geometry generated at the end is a planar bounding box extracting only the necessary parameters of the original brick, without considering the deformations, and gaps.

Broken Bricks Matrix of Bricks

MATRIX OF BROKEN BRICKS :

The image below displays the matrix of the 100 broken bricks that were evaluated for generating structures using the various scripts, codes, algorithms. The parameters extracted are overlaid onto the image, their vectors, angles, faces, vertices, all of which help in providing assembly logics.

Broken Bricks Parameter Extraction EXPLODED BRICKS : With the help of the kinect we achieved to generate a complete 3d scan of the broken brick, which is further simplified for the ease of analysis, and data extraction. There is some loss of data within this process, but this does not result in any loss of intelligence for the assemblies. After simplifying the bricks into a more cleaner faced brep, all the necessary information is extracted in the form of lists. These lists consist of the unique data provided by the unique parameters of every broken brick. All the logics or intelligence needed for the assemblies that are unique to these sets of broken bricks are extracted with this method. This is the guideline provided to every script to analyse, evaluate, re-evaluate, and compare within the brick sets. This is the most essential part for all assemblies, each of which is highlighted or given importance for the rules of emergence.

EXTRACTION LISTS : The diagram and number charts on the adjacent page represent the lists consisting of the different parameters extracted from each brick to analyse and compare between them for all the scripted assemblies. The above image shows the different components applied to extract the various datas

BRICK ID { _ } Number of Edges

BRICK ID { _ } Edge Lengths

BRICK ID { _ } Number of Faces

BRICK ID { _ } Face Angles

0. Line-like Curve 1. Line-like Curve 2. Line-like Curve 3. Line-like Curve 4. Line-like Curve 5. Line-like Curve 6. Line-like Curve 7. Line-like Curve 8. Line-like Curve 9. Line-like Curve 10. Line-like Curve 11. Line-like Curve

0. 206.37 1. 75.00 2. 206.37 3. 115.0 4. 154.39 5. 126.20 6. 115.0 7. 154.39 8. 126.20 9. 75.0 10. 75.0 11. 75.0

0. Trimmed Surface 1. Untrimmed Surface 2. Trimmed Surface 3. Untrimmed Surface 4. Untrimmed Surface 5. Untrimmed Surface

0. 1. 2. 3.

BRICK ID { _ } Total Volume 0. 1.55582 mm3

BRICK ID { _ } List of Vertices 0. {2472.368015, 2578.117787, 0.0}

1. 2. 3. 4. 5. 6. 7.

{2472.368015, 2578.117787, 75.0} {2587.368015, 2578.117787, 0.0} {2587.368015, 2423.725188, 0.0} {2472.368015, 2371.740425, 0.0} {2587.368015, 2578.117787, 75.0} {2587.368015, 2423.725188, 75.0} {2472.368015, 2371.740425, 75.0}

0.00 90.00 90.00 24.32

Broken Bricks Parameter Extraction

EXTRACTION LISTS :

Some other types of broken bricks where the planes of their broken faces are within the XZ or YZ planes. These bricks have broken faces inclined in the Z direction, useful to change the normal vectors of the possible growth of structures.

Chapter 04 40

OTF Process

Design by Code

SortingAngles_BrokenFace

SCRIPTING _ The apparent primacy of these codes opens up the possibility

of modelling systems through digital means, and with it the possibility of using digital means to breed structures. We are witnessing a fresh and highly innovative vocabulary of architectural forms, generated by the algorithmic potential of the computer – from the proliferating logic of cellular aggregation, to the adaptive, parametric behaviour of distributive systems mutating across a landscape. ‘Scripting’ – the manipulation of digital code – Neal Leach

Design by Code INTRODUCTION : How has design changed through the use of computers? Is it still valid to assume that a designer is in control of a design concept? What if there is a lack of predictability over what was intended by the designer and what came out on the computerâ&#x20AC;&#x2122;s screen? Is computer programming necessary in design today? This chapter highlights the methods where digital computational power is explored to create designs, test them via simulation softwares as well as thinking about the assemblies. EMERGENCE : The phenomenon, whereby a simple rule set at a low level creates organized complexity on a higher level, is called emergence. In a nutshell, emergence is the observation of how complex and coherent patterns can arise from a large number of small, very simple interactions. This is the principle we will be trying to harness in the next few chapters. When you create a large number of small agents (Broken Bricks) with simple behaviors (assemblies/ logics), collectively they can become capable of producing a more complex, emergent, structure on the macro level. THINK LOCALLY, ACT LOCALLY: The scripts developed for this project explores the parameters extracted from the broken bricks to help aseemble structures form the idea of emergence. With the application of grasshopper, C# scripting, and external plugins such as galapagos we develop methods where each brick behaves to a simple local relationship to the adjacent bricks.

Design by Code Bounding Box + Genetic Algorithm INTRODUCTION : The first definition to generate structures out of broken bricks is inspired from the logics of emergence, the idea where we control the self assemblies of broken bricks by adding simple rules of interaction / behaviours with their adjacent bricks. Each broken brick is brought closer to each other by controlling the bound box around all the bricks. For this definition we considered 3 broken bricks, to help optimise the process as fast as possible. Through this chapter we shall progress from the basic definition for getting the bricks together, detecting the collisions with each other to adding more and more rules of interactions between the bricks. LOGIC (EMERGENCE) : Bounding Box provides us with combined volume of all the three bricks which can be optimised to be least bringing the bricks as close as possible. By doing this we also need to specify the least distance between each bricks so that they do not penetrate eachother. This is where collision detection definition helps the algorithm to control penetration. Each broken brick is given the freedom to rotate around the xy plane from the centre of the brick. EVOLUTIONARY SOLVER (GALAPAGOS) : Evolutionary problem solving mimics the theory of evolution employing the same trial-and-error methods that nature uses in order to arrive at an optimised result. When automated for specific parameters and results, this technique becomes an effective way to computationally drive controlled results within the iterative design process â&#x20AC;&#x201C; allowing designers to produce optimised parameters resulting in a form, graphic or piece of data that best meets design criteria. What we achieve by this component is the best optimised result of the movement and the rotation of each brick to assemble in the most compact volume. Through the next few pages we will see the results of self assembling bricks by adding onto the basic evolutionary solver for the most compact volume.

At the bottom of each assembled structure, we represent textually the grasshopper definition which brought us to that particular evolutionary solution.

Positions of broken bricks before running the evolutionary solver to optimise the resultant assembly based on the compactness of their bounding box volume.

Broken Bricks

XY-Rotation 180 X- Movement Y- Movement

Control / Computation Bounding Box - Volume Collision Detector

Galapagos Solver

Minimise Fitness Value Volume of Bounding Box

Design by Code

Bounding Box + Genetic Algorithm

Self assembly for the same set of 3 broken bricks, with the most compact bounding box volume by maintaining minimum distances between the centroids of each brick.

LOGIC : First addition to the previous script of getting the broken bricks to self-assemble, is to minimise the distance between the centroids of each brick. The definition does not provide the solver any particular orientation or faces to assemble with. As the solver through each generation moves and rotates the brick to self-assemble, it cross checks the distances between their centroids and maintains minimum distances between each of them. OBSERVATION : Galapagos assembles the bricks in a compact bounding box, which results into a square shaped box, since its volume would be the least compared to a more rectangular box. As well as the distances forms a triangle with nearly the same distance between each centroid.

Broken Bricks

XY-Rotation 180 X- Movement Y- Movement

Control / Computation Bounding Box - Volume Collision Detector Centroid Distances

Galapagos Solver

Minimise Fitness Value Volume of Bounding Box Centroid Distance

Self assembly for the same set of 3 broken bricks, with the most compact bounding box volume by maintaining minimum distances between selected face vertices and forming a rectangular bounding box.

LOGIC : Another addition to the previous script of getting the broken bricks to selfassemble, is to minimise the distance between the vertices of selected faces of each brick. Here the user can assign the face vertices to which the adjacent bricks need to have minimum distance. As the solver through each generation moves and rotates the brick to self-assemble, it re-evaluates the distances between the vertices, and displays the optimum fitness. Also for this definition we assign a relationship between the lengths of the bounding box, hence it shifts out of the square shaped to form a rectangular box. OBSERVATION : This definition starts to form a more linear relationship between the assemblies of the bricks. This would lead to a wall like assembly.

Broken Bricks

XY-Rotation 180 X- Movement Y- Movement

Control / Computation Bounding Box - Volume Collision Detector Face Vertice distance

Galapagos Solver

Minimise Fitness Value Volume of Bounding Box Vertice Distances

Design by Code

Bounding Box + Genetic Algorithm

Self assembly for the same set of 3 broken bricks, with the most compact rectangular bounding box volume by maintaining the least angles and minimum distance between the centroids.

LOGIC : This definition also maintains a relation of the bounding box lengths to form a more rectangular box, and while doing so also maintain the angles and distances between the centroids of each brick to be the least. The definition does not provide the solver any particular orientation or faces to assemble with. As the solver through each generation moves and rotates the brick to self-assemble, it cross checks the vector angles constructed form the centroid and maintains minimum distances between each of them. OBSERVATION : As we add more and more rules to analyse the assembly, although it takes more time to optimise but the results tend to work better. By this i mean, galapagos optimises the best orientations for the simple rules given to it.

Broken Bricks

XY-Rotation 180 X- Movement Y- Movement

Control / Computation Bounding Box - Volume Collision Detector Centroid Distances Centroid Angle Vectors

Galapagos Solver

Minimise Fitness Value Volume of Bounding Box Centroid Distance and Angles

Self assembly for the same set of 3 broken bricks, with the most compact rectangular bounding box volume by maintaining the least angles and equal distances between the centroids.

LOGIC : With this definition we finally get to achieve what looks like the least possible volume of the rectangular bounding box, and hence forming a straight line of growth for the broken bricks. Here we assign the rules for least variations between vector angles and distances from the centroids of each broken brick. OBSERVATION : This definition starts to form a more linear relationship between the assemblies of the bricks. This would lead to a wall like assembly, where the growth for the next set of bricks would be linear as well. The most optimum result computated by galapagos between all other definitions.

Broken Bricks

XY-Rotation 180 X- Movement Y- Movement

Control / Computation Bounding Box - Volume Collision Detector Centroid Distances Centroid Angle Vectors

Galapagos Solver

Minimise Fitness Value Volume of Bounding Box Centroid Angles and Distances

Design by Code

Bounding Box + Genetic Algorithm DRAWBACKS : The only drawback and the major one from these sets of grasshopper definitions would be the time taken to solve by galapagos. For the sets of rules as shown in the previous few pages, the time taken by galapagos would range somewhere between 15 - 30 mins. This maybe be due to the face that it has to compute each generation the intersections of the bricks, as well as the added rules. CONCLUSION : Evolutionary Solving using the Galapagos component within grasshopper, leads us with interesting results and observations. By providing simple rules and letting the solver optimise and evaluate the best possible assembly could be the simples t and most straight forward methods to start our investigation in finding forms by recycling broken bricks.

Chapter 05 51

Design by Code Sorting Broken Face Angles + Scripting C# INTRODUCTION : Extracting the parameters from the set of 50 broken bricks as shown in the earlier pages, the unique character for all the bricks is the angle at which the bricks are broken. For these few definitions, we have simplified the geometry of the broken faces so as to arrive at a simpler 3d digital object. Applying the think locally, act locally principle, we derive few definitions where by the bricks have to align to their adjacent bricks at particular selected vertices. This brings about interesting assemblies where the back faces of every brick are aligned to form a straight wall, whereas the front faces give the wall a twisted character. LOGIC (For Loops) : The parameter under control for these definitions are the angles of the broken faces. Once we extract the list of all the angles, its a matter of sorting them either ascending or descending, to control the positions of the bricks. The positions are decided by the sorting, after which the user controls the length, height of the required wall to place the new sorted list of bricks to generate a twisted pattern wall. Here the logic is a simple for loop, to move all the bricks to their respective position based on the broken face angles. PROGRAMMING WITH C# : Since this definition once sorts the bricks based on their angles, it has to simple translate the bricks to generate the desired assembly, the translate component needs to be dynamic. Dynamic in this sense means it need to translate all the bricks to their new positions no matter how many bricks are fed into the definition. In order to make this dynamic for any number of broken bricks, we introducing programming. Using C#, we generate a for loop, where all the items in the loop (broken bricks) are translated to their new positions (vertices of the previous brick).

Broken Bricks

XY-Rotation Broken Faces and their Angles

Control / Computation

Sorting Angles Sorting All Bricks Dispatch each brick course

C# Scripting

Translate to Vertice of the Previous Brick within the List

50 broken bricks, assembled based on their sorted broken face angles, to generate a wall of 10 layers (brick courses). Sorted from biggest angle to the least, hence the upper most layer consist of bricks with all parallel faces.

Design by Code Sorting Broken Face Angles + Scripting C#

50 broken bricks, assembled based on their sorted broken face angles, to generate a wall of 07 layers (brick courses). Sorted from biggest angle to the least, hence the extreme right layer consist of bricks with all parallel faces.

LOGIC : Sorting the bricks according to their broken face angle vectors, actually decides the locations for every brick in the assembly. Hence sorting plays the major controlling factor for these assemblies. The only limiting factor within this, is that the list can be sorted either in ascending or descending orders. But we could split or dispatch every alternate brick into new lists which is explored in the above assembly. Here the bricks are sorted and split such that each layer/ course of the wall has the least to highest angle.

50 broken bricks, assembled based on their sorted broken face angles, to generate a wall of 07 layers (brick courses). Sorted from least angle to the biggest, hence the extreme left layer consist of bricks with all parallel faces.

LOGIC : As mentioned in the previous example, the importance of sorting and dispatching to reshuffle the sequence of the bricks, here that list is reversed. This leads us to a small issue where the bricks penetrate within each other if moved to only the vertice of the previous brick. This issue is tackled by finding the offset distance from the edge using the C# script. The result is highlighted on the outward curvature of the wall, rather than the inward curvature of the previous list.

Design by Code Sorting Broken Face Angles + Scripting C# VARIATIONS + COMBINATIONS : Using the same definitions, we could combine or multiply them to sets of same number of bricks to form walls, enclosures which are emerged from the characteristics of the broken bricks. Every evolution would derive out a new sequence for the assembly . Here the user also have the added function of reversing the sorting sequence or flipping the broken bricks on a desired plane to extend the curvatures of the assembly. Eventually we would end up with walls with emerging curvatures with the inner space as smooth as a straight course brick wall. C# SCRIPT : A simple for loop translating the positions of the sourced bricks to the vertice of the previous bricks. Input parameters required for this script are the bricks dispatched as per the desired brick course and a starting point for the wall assembly. Within the script we extract the vertice from the previous brick and translating the brick to that vertice using a vector. As the loop is assigned till Bricks.Count, any number of bricks we put in the component, it will be assembled. private void RunScript(List<Brep> Bricks, Vector3d Point, ref object A) { //----------------------------------------Global Variables Vector3d v1; Point3d p1; Point3d[] p = new Point3d[8]; //----------------------------------------Move first Brick to Start Point Bricks[0].Translate(Point); //Move rest of the Bricks to a vertice from the previous Bricks for (int i = 1; i < Bricks.Count; i++){ p = Bricks[i - 1].DuplicateVertices(); p1 = p[4]; v1 = new Vector3d(p1); Bricks[i].Translate(v1); } //----------------------------------------Display all Bricks A = Bricks; }

Design by Code Sorting Broken Face Angles + Scripting C# CONCLUSION : Although the level of scripting required for such an aseembly of broken bricks, is not very evolutionary or complex. but it is dynamic enough to sort N number of broken bricks as and when found. This definition could be added with more parameters to shuffle the bricks without loosing the overall form, where we can re-evaluate the assembly based on its stability, volume, centre of gravity, etc. For us, it was more interesting to display varied potential assemblies with the same set of bricks, hence we derived more definitions highlighting the unique characters of the bricks. But we would consider reevaluations to scripts in the chapters yet to come.

Chapter 06 59

Design by Code Differential Thickness + Attractors INTRODUCTION : Recycling bricks from existing buildings or disaster sites provides us with a unique set of broken bricks, each having their own parameters. In this definition we extract the longest edge length to sort the bricks based on their thickness. The assembly is run with a simple logic of placing the broken bricks to control the thickness of the overall wall. The broken bricks are all oriented in the same direction, as the definition is meant to be applied part by part to construct the entire structure. If needed they can be oriented in their reverse angels to have a more aesthetic configuration. LOGIC (Attractor Point) : The logic or intelligence is extracted from the lengths, and we assembly the wall to give it a differential thickness. Now we introduce an attractor point which re-evaluats the positions of the brick to converge the shorter length around it. By this we have the control on which parts or regions of the assembly need to be the least thick or vice-versa. The attractor point calculates the distance between all the origin points of t he bricks to the location of the attractor and translates these distances into a new sorting order for the bricks, overloading the previous sorting order. Now the C# script just translates the bricks to the vertice of the previous brick.

Broken Bricks BrickVolume Longest Edge Length

Control / Computation Sorting Lengths Sorting All Bricks Dispatch each course Attractor Point

C# Scripting

Translate to Vertice of the Previous Brick within the List

50 broken bricks, assembled based on their longest edge length, to generate a wall of 10 layers (brick courses). Sorted from longest lengths at the base of the wall to the shortest length at the top.

Design by Code Differential Thickness + Attractors

50 broken bricks, assembled based on their longest edge length, to generate a wall of 10 layers (brick courses). Sorted from longest to the shortest length derived by the attractor point.

VARIATIONS + COMBINATIONS : Here the sorting for the broken bricks are based on the lengths of the largest face, the intelligence to control their positions is driven by a control point. Think of this control point as an attractor, which pulls together all the broken bricks within the list with the least length. By adding the attractor the user / designer can control points or regions of the wall where the thickness needs to be maximum or minimum.

50 broken bricks, assembled based on their longest edge length to generate a wall of 10 layers (brick courses). The image on the left represents the lengths sorted and the image on the right superimposes the attractor point guiding the overall assembly.

C# SCRIPT : The intelligence for the positions of the bricks comes from the control point. A simple for loop translating the positions of the sourced bricks to the vertice of the previous bricks. Input parameters required for this script are the bricks sorted based on the attractor point lengths and dispatched as per the desired brick course and a starting point for the wall assembly. Within the script we extract the vertice from the previous brick and translating the brick to that vertice using a vector.

Design by Code Differential Thickness + Attractors CONCLUSION : The assembly emerging from this definition, is more practically suited. The varied thickness provides us with regions where lesser insulation is required and vice-versa. Through this grasshopper definition, we evaluated a new method of sorting the broken bricks, where the attractor defines the locations of bricks. This attractor could be derived from solar, radiance analysis for the desired structure, and simultaneously sort the bricks in order of assembly.

Chapter 07 65

Design by Code Scripting the Corbelled Arch INTRODUCTION : In architecture a corbel is a piece of stone jutting out of a wall to carry any superincumbent weight. A corbel arch (or corbeled / corbelled arch) is an arch-like construction method that uses the architectural technique of corbelling to span a space or void in a structure, such as an entrance way in a wall or as the span of a bridge. A corbel vault uses this technique to support the superstructure of a buildingâ&#x20AC;&#x2122;s roof. PRINCIPLES OF CORBELLING : A corbel arch is constructed by offsetting successive courses of stone at the springline of the walls so that they project towards the archwayâ&#x20AC;&#x2122;s centre from each supporting side, until the courses meet at the apex of the archway (often capped with flat stones). For a corbeled vault covering the technique is extended in three dimensions along the lengths of two opposing walls. Corbel arches and vaults require significantly thickened walls and an abutment of other stone or fill to counteract the effects of gravity, which otherwise would tend to collapse each side of the archway inwards. Could these arches be achieved by broken bricks ? Our investigation led us to explore the corbel arch by aligning the bricks by their broken faces in the Z - axis. Since the bricks are all broke at different angles the corbel brings forth the smooth curvature of an arch.

Stone corbelled arches at Borobodur in Java, Indonesia. In this example we can observe that the corbel is perpendicular to the wall to span the corridor. The centre key stone has been carved in a T - shape, to balance the forces of the corbels.

Design by Code Scripting the Corbelled Arch LOGIC (Stability) : Now that we understand the basic principles of an corbelled arch, translating the methods to broken bricks, we derive corbels with a smoothened edge surface, which generates a arch like curvature. The logic is very simple to stack bricks one above another with an offset, but in the case of broken bricks the offset is derived from within the parameters of the bricks broken faces. The grasshopper definitions derived for this assembly runs through many loops, as this assembly relies on a very important factor, i.e. the factor of stability. At first all the sourced bricks are sorted according to their volumes, which is used to remove / cull bricks which are lesser volume than the desired tolerance . This is necessary to avoid very small bricks which cannot support the above offsets. Now the remaining bricks are sorted according to the angles of their broken face vectors, this results in a list of sorted bricks with minimum to maximum angles sent as input to the C# translate component. The C# component just places the bricks in the same order as fed to a Z-vertice of the previous brick. As we move ahead with this definitions, there would be more evaluations and components added to the simple one curvature corbelled arch. We would eventually derive corbelled arches that have double curvatures, the inner and the outer with central filler gaps to be filled by the culled / removed bricks or other insulating material. The scripts would also analyse the relations between the inner and the outer curvatures for the overall stability of the arch.

Broken Bricks BrickVolume Broken Face Angle

Control / Computation Sorting Angles Cull Straight Bricks Cull Bricks least Volume Sorting All Bricks Dispatch each course

C# Scripting

Translate brick SET A to Vertice of the Previous Brick within the List Translate brick SET B to end face Plane of SET A

The above image is meant to represent the number of variations possible with a set of 50 broken bricks. Every arch within the image has the same number of input bricks the variations are made possible with the Dispatch or Cull items components in grasshopper. Some have a double layered inner and outer curvature.

Inner Curvature 10 Outer Curvature 07

Inner Curvature 09 Outer Curvature 06

Inner Curvature 08 Outer Curvature 05

Inner Curvature 07 Outer Curvature 04

Inner Curvature 06 Outer Curvature 03

Inner Curvature 05 Outer Curvature 02

Inner Curvature 04

Inner Curvature 03

Inner Curvature 02

Inner Curvature 01 Outer Curvature 01

Design by Code Scripting the Corbelled Arch

Inner Curvature 01 Brick id | angle 28.0 7.0 9.0 12.0 0.0 23.0 32.0 10.0 19.0 24.0 1.0 6.0 18.0 11.0 5.0 30.0 29.0 33.0 22.0 17.0 31.0

32.79 30.49 24.75 24.32 23.97 23.41 22.71 18.04 17.82 15.46 15.23 14.99 13.53 13.34 10.24 9.82 9.48 9.44 8.61 8.12 7.39

Inner Curvature 05 Brick id | angle 15.0 17.0 1.0 47.0 10.0 16.0 8.0 13.0 34.0 44.0 35.0 20.0

32.28 28.80 23.97 22.71 18.90 16.52 14.99 13.34 10.34 9.82 8.61 6.40

Inner Curvature 09 Brick id | angle 11.0 33.0 8.0 7.0 45.0

24.75 21.32 14.99 10.24 7.39

Inner Curvature 02 Brick id | angle 28.0 7.0 9.0 12.0 0.0 32.0 8.0 10.0 19.0 24.0 6.0 18.0 11.0 27.0 5.0 29.0 33.0 22.0 17.0 31.0

28.0 7.0 9.0 0.0 23.0 32.0 10.0 19.0 24.0 6.0 18.0 11.0 5.0 30.0 29.0 22.0 17.0 31.0

32.79 30.49 24.75 24.32 23.97 22.71 18.90 18.04 17.82 15.46 14.99 13.53 13.34 12.66 10.24 9.48 9.44 8.61 8.12 7.39

Inner Curvature 06 Brick id | angle 9.0 14.0 47.0 12.0 2.0 13.0 7.0 49.0 20.0

Inner Curvature 03 Brick id | angle 32.79 30.49 24.75 23.97 23.41 22.71 18.04 17.82 15.46 14.99 13.53 13.34 10.24 9.82 9.48 8.61 8.12 7.39

Inner Curvature 07 Brick id | angle 32.0 48.0 10.0 2.0 27.0 44.0 45.0

30.49 24.32 22.71 18.04 15.23 13.34 10.24 9.44 6.40

29.83 23.76 18.90 15.23 13.02 9.82 7.39

Inner Curvature 04 Brick id | angle 28.0 7.0 12.0 0.0 32.0 8.0 19.0 24.0 6.0 18.0 27.0 5.0 29.0 33.0 17.0 31.0

32.79 30.49 24.32 23.97 22.71 18.90 17.82 15.46 14.99 13.53 12.66 10.24 9.48 9.44 8.12 7.39

Inner Curvature 08 Brick id | angle 17.0 47.0 16.0 13.0 44.0 20.0

28.80 22.71 16.52 13.34 9.82 6.40

Inner Curvature 10 Brick id | angle 14.0 12.0 13.0 49.0

24.32 18.04 13.34 9.44

The diagram on the adjacent page represents the different curvatures achieved from the same set of 50 bricks, by just controlling the sorting of the broken bricks, This is achieved by using a dispatch pattern or by culling certain items from the list of sorted broken bricks. Above is the list of bricks sorted in the order of the broken face angles to generate the emerging curvature.

Design by Code Scripting the Corbelled Arch SCRIPTING THE ARCH : The script for generating the arch is a step forward from the earlier scripts of translating the bricks to a vertice of the previous brick. According to the principles of corbelling, it requires a necessary amount of counter load to balance the offsets produced to span the opening. This counter balance is achieved by adding another layer of bricks, at the end plane of the first set of bricks. Now the second layer of bricks when aligned to their broken faces vertices, form another curvature on the outside. This curvature in a major controlling factor for the counterbalance of the entire corbel. We shall look at the possible variations of the two curves in the following pages. C# SCRIPT in GRASSHOPPER : private void RunScript (List<Brep> b, Vector3d v, List<Brep> b1, Plane xz, Plane yz, ref object A, ref object B) { //--------------Global Variables Vector3d v1; Point3d p1; Point3d[] p = new Point3d[8]; Point3d[] pb1 = new Point3d[8]; //--------------Move first Brick to Start Point b[0].Translate(v); //Move rest of the Bricks to a vertice from the previous Bricks for (int i = 1; i < b.Count; i++){ p = b[i - 1].DuplicateVertices(); p1 = p[3]; v1 = new Vector3d(p1); b[i].Translate(v1); } //--------------Mirror the Second List of bricks around the xz - yz plane for (int i = 0; i < b1.Count; i++){ b1[i].Transform(Transform.Mirror(xz)); b1[i].Transform(Transform.Mirror(yz)); } for (int i = 0; i < b1.Count; i++){ Point3d[] VertTar = b[b.Count - i - 1].DuplicateVertices(); Point3d[] VertRef = b1[i].DuplicateVertices(); Plane PlaneRef = new Plane(VertRef[2], VertRef[0], VertRef[5]); Plane PlaneTar = new Plane(VertTar[0], VertTar[2], VertTar[1]); }

b1[i].Transform(Transform.PlaneToPlane(PlaneRef, PlaneTar));

//--------------Display both sets of Broken Bricks A = b; B = b1; }

The first image diagram A, represents the output from the C# Script Translating both SETs of bricks. The second image diagram B, translates the SET B of bricks to form an outer curvature. With the same translation script, the third diagram C is a reverse placement of the same SET B bricks. This brought us to a conclusion of controlling both curvatures, to test the most stable corbel arch. The resulting hollow spaces from this assembly is considered as a filler space using the culled bricks at the start of this definition.

Design by Code Scripting the Corbelled Arch

The images shown on both pages are the explorations done with the corbel arches in progression in one axis. Both have different curvatures meant to counter balance for stability. These variations are a glimpse of the possibilities with a set of about 200 broken bricks using the corbel arch script in grasshopper.

Design by Code Scripting the Corbelled Arch

iii

xiii

xii

viii

vii

xiv

TOP DOWN APPROACH : Finding the right bricks to the user designed curves. Within this definition, a very small one, the user can control the curve of the assembly as desired. The grasshopper definition scans through all the broken bricks after initial culling based on volume, and finds the best brick to fit to the referenced curve. SCRIPT : The script divides the reference curve based on the standard height of the broken bricks, and finds the brick with the required angle for the assembly. This process is based on a top down approach, where the designer controls the overall form. This script is highly useful when we consider more complex bricks, with double curved faces, so that the next aligned course could evolve from the first course. C# is used in two parts for this definition, once to find the lengths between the divided referenced curve points, this is used to compare with the lengths of the broken faces and the other to translate the bricks to form the desired curvature. Script A : Calculate the Lengths.

private void RunScript(List<Point3d> x, ref object A) { List<double> d0 = new List<double>(8);

}

for (int i = 1; i < x.Count; i++){ double d = x[i - 1].DistanceTo(x[i]); d0.Add(d); //A = d[i]; } A = d0;

Broken Bricks BrickVolume Broken Face Angle

Reference Curve Divide Curve

Control / Computation Sorting Angles Cull Straight Bricks Cull Bricks least Volume Locate Bricks Curve Lengths

C# Scripting

Translate brick SET A to Vertice of the Previous Brick within the List. Find similar member

Design by Code Scripting the Corbelled Arch CONCLUSION : Stability for these assemblies is essential, but through the growth of this particular definition, we arrived to a more realistic approach where we start to consider the tolerance of broken bricks. Which bricks should be used, which can be used, removing straight bricks for the formation of the curves, and later input them as structural fillers. Although most of these curves cannot stand by itself the secondary curvature, provides it with the thickness necessary to stand erect. This was tested through digital simulations using sketchy physics 3.2, for Sketch Up 8.0.

Chapter 08 79

Design by Code Sequential Brick Optimization INTRODUCTION : This definition to generate structures out of broken bricks similar to the first tests with the galapagos evolutionary solver, is inspired from the logics of emergence, the idea where we control the self assemblies of broken bricks by adding simple rules of interaction / behaviours with their adjacent bricks. Here we test the locations of every brick sequentially to best fit or align to a user defined curve. For every position the solver places each brick within the input list and cross-examines the closest and best brick to follow the curve. LOGIC (EMERGENCE) : The logics or rules that are needed to run this definition for optimization are simply the orientations of each brick around the start brick to follow the fed curvature growth. Each brick is defined to orient to every vertice of the two short faces, this is achieved by assigning the vector to orient against. EVOLUTIONARY SOLVER (GALAPAGOS) : The script for this design requires two basic parameters - the set of bricks and the design curve. The bricks are sorted based on their volume and the largest brick is moved to the start of the curve. For positioning the second brick to the face of the first brick three basic rules are tested to find the most suitable brick 1. orienting the face of the second brick to the first brick with the outer lower vertex matching that of the first brick 2. four such orientations of the second brick are formed on the above logic 3. the lower our vertex of the opposite face(non- connecting) of the second brick should have the least distance from the desired curve.This helps in maintaining the growth of the formation along the curve. 4 the plane of the opposite face of the second brick should form the least possible angle to the plane formed perpendicular to the vector of the point on curve. The solver uses these rules to find out the best possible connecting brick along the desired curve. Looping this technique for a multitude of curves enclosures can be formed. The design curves could is later altered by a genetic algorithm model to push the cantilevering of the different layers to attain a stable standing structure.

Broken Bricks

Brick Vertices. Broken Face Angle Planes. Brick Orientations User defined Curve

Control / Computation Sorting Volume Closest Point to curve Angle of the planes to planes of curve

Evolutionary Solver

Optimising the locations for each brick sequentially. Testing the vertices and plane angles closest to the curve.

RULE 01 _orienting the two faces. Using vectors to align the two faces with a reference of the outer vertices of the bricks

RULE 02 _all possible orientations of the second brick to the first brick, with reference of different vertice vectors.

RULE 03 _testing the closest point to user defined curve and least difference in angle to the perpendicular plane on the curve.

Design by Code Sequential Brick Optimization

Perspective views of the curves for which the evolutionary solver finds the optimum broken brick positions.

Plan view of the curves overlayed on the generated structure.

Structure generated from a set of curves transforming from a circle to a jagged star shaoe testing different degrees of curves as a guide for the assembly. The evolutionary solver, finds the best possible brick to fit the input curves at each level. Although the formation do not exactly fit to the curve the overall form is an outcome of the particular set of brick and will have slight variations for every new set of broken bricks.

Design by Code Sequential Brick Optimization

ALternate optimisation of curves with displacement in the Y - axis

Elevational view of the optimsed curve structure for which the evolutionary solver displacing in the Z - axis.

Perspective view of the optimsed curve structure for which the evolutionary solver displacing in the Z - axis.

The images on the adjacent page explores the same difination, but with the Brick type B and C where the broken faces are in the XZ / YZ planes and some have 2 broken faces in different planes. This allows galapagos (evolutionary solver) to follow curves that are in the X, Y, and Z planes. The bottom 2 images on the adjacent page, applies this logic into the X and Z axis, where the sequential growth is pulled upwards in the Z axis, The image at the top of the adjacent page shows the similar displacement but on the Y axis to have a dynamic curved wall.

Design by Code Sequential Brick Optimization CONCLUSION : Design process using evolutionary solvers helps forming emergent free standing structures which are a result of the designers input( the desired curves for the alignment, a site with its inherent contours) and the inherent property of the bricks ( the formation based on the shape of the bricks). A bottom up design process of this sort respects and accomodates all the parameters of design - the construction material, the site and the designers idea thus creating a balanced design system.

Chapter 09 88

OTF Process

Augmented Reality Construction

AUGMENTED REALITY :

Augmented reality (AR) is a live, direct or indirect, view of a physical, realworld environment whose elements are augmented by computer-generated sensory input such as sound, video, graphics or GPS data. With the help of advanced AR technology (e.g. adding computer vision and object recognition) the information about the surrounding real world of the user becomes interactive and digitally manipulable. Artificial information about the environment and its objects can be overlaid on the real world.

METAIO :

As a world-wide leader in Augmented Reality technology, metaio develops software products for visual interactive and information solutions between t he real and the virtual world.

Augmented Reality Construction Junaio Application METAIO : Metaio has attained a leading international role in the burgeoning technology segment of Augmented Reality with the development of its metaio software platform. It offers an open architecture and is designed for ease of use by integrators from various fields and backgrounds. Clients and partners can create their own applications, sell their solutions in specific markets increasing their brand awareness and revenues or lowering their costs. Whether it is an advertising campaign, an OEM integration or a completely new product - AR is finding its way into everyday life. JUNAIO APPLICATION : junaio® is the world’s most advanced augmented reality (AR) browser and open development platform with the most diverse array of capabilities. 2D image recognition and tracking, QR code reading, barcode reading, navigational and GPS overlays, indoor navigation and now, also 3D object recognition. With junaio® you can easily augment magazines, newspapers, television, product packaging, and point-of-sale displays. junaio® can be used to overlay a camera view with geo-tagged information describing one’s immediate surroundings. You can use the SCAN function to instantly launch any AR content from an image in the junaio® database. The images on the adjacent page, show the very easy to operate process of uploading the model on the junaio creators website (www.creator.junaio.com) and testing the application on the iPod. The target image for this experiment is the cover of this book, RFB2. This express the fact that we don’t need to have a specific marker, QR tag, or fiducial to track an object. Also the model for now is a static md2 model, which could be animated to show the orientation of the brick.

Using the free web creator for the junaio glue based channel application, we have tested a model of dice displaying on top of the cover of this book. The above image shows the interface on the web where we upload the tracking image, which could be only a text, and uploading a md2 model on that image. There are extensive controls for animating, positioning and orientation of the model for the AR experience.

Augmented Reality Construction Junaio Application CONCLUSION : Junaio provides us with a very easy and fast workflow for the assembly of the complex brick structures. With the help of augmented reality the user can be guided for placing and orienting each brick with relation to the previous using a simple text based tracker id. The test conducted was compiled within an hour. With the latest version releasing within a weeks time, we wouldnâ&#x20AC;&#x2122;t need a tracking image as juanio can detect objects and assign AR models on top of it.