recycled fabrick 2.0

Open Thesis Fabrication | Iaac 2011

Recycled FaBric(k) 2.0 Open Thesis Fabrication | Iaac - 2011Vittal 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.

The project was conducted under the guidance of (OTF) Open Thesis Fabrication co-ordintators :Marta Male Alemany Luis Fraguada

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

RecycledFaBric(k)2.0Recycling construction waste by means of digital processes to design new emer-gent architecture.

Preface“Digital materiality evovles through the interplay between digital and materi-al 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 Architec-ture published by Fabio Gramazio and Matthias Kohler” a research conduct-ed within the academic environment of ETH Zurich, Faculty of Architecture, where they identify new methods of designing in relation to the material be-haviour and their properties tested during the fabrication process. This digital materiality discussed by the authors was the guideline for our thesis conduct-ed during the Digital Tecotnics Studio within the MAA program at the Institure 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,analyzing 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 analyze 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 instal-lation of each brick forming the structure.

EVOLUTION CATALOGUES :During the MAA (Masters in Advanced Architecture) program at the Insti-tute 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, fidiucial 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 pos-sible 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 optimize the emerging struc-ture 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.

RecycledFaBric(k)2.0

Thesis Statement and Objectives

Introduction

FaBric(k)2.0

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 collabora-tions 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 compa-nies as partners considering they would provide us with the machines / soft-wares / technical guidance we will require to bring this thesis to a level that would generate a real scale test structure.METAIO - Augmented Reality System.

Contents01 | Preface _04 _Previous Research Outline _Evolution Catalogues

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

04 | Hypothesis _11 _Present Research Visualisation

05 | References _13

06 | Process _ MAA Research _15 _ Kinect as a Scanner _21 _ Design by Code _31 _ Brick Matrix _34 _ Bounding Box + Galapagos _36 _ Sorting Angles + C# _44 _ Differential Thicness + C# _52 _ The Corbelled Arch + C#

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 piec-es 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 ana-lysed 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 po-tentiated as a new strong design language in achitectural terms.

Through the design evolution catalogues, we derived many useful structures that directly relate to diffrent site conditions and accordingly optimize 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 inbetween them lead to ease off(?) pressure for the soil behind the retaining walls) etc. Our aim during the open thesis fab-rication was to generate a new design strategy in re-using the broken bricks found at abondoned sites with the help of the digital tools and technologies highlighted earlier.

Through this entire process, architecture becomes increasingly rich and di-versified. Variation emerges as it becomes possible to design large number of structures in distinguishable ways (as the parameters of broken bricks dif-fer) using digital means. Within the research paper of “Fabio Gramazio and Matthias Kohler - Digital Materiality” they very clearly describe the design-ing 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 modeled, 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 ar-chitecture reveals itself. It is a conceptual way of designing with architectural paramters, 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 / relation-ships. 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.

01

02

03

04

05

06

07

08

09

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

References

Chapter 01

Recycled FaBric(k) ProcessBrief 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 thier unique fiducial markers linking physical and the digital. Step 04|Extracting geometric properties, sorting, comparing geometries for similarities to de-velop 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 feed-back.

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 ana-lysed 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 possibilites that emerge from broken properties of the bricks using mechanic and computational intelligence. The process involves applying day to day technologies, parametric and scritping tools along with open sourced ar-duino 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 sophisti-cated softwares such as processing, rhinoceros, grasshopper and reactivi-sion. The different technologies used within the processes are regular home entertainment devices costing around 500 - 1000/- Euros as a one time in-vestment 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 geom-etry 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 visual-ising 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 accomodate 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 “Self-Net Man” 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 struc-tures 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 experi-ment 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 |Producition 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 cre-ate interesting patterns instead of mundane walls and also accomodate 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 in-stalled 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 planta-tions, kennels, seating alcoves etc.

Chapter 02

Kinect as a 3d ScannerOTF Process

SCANNING (in electronics) _to move a finely focused beam of light or elec-trons in a systematic pattern over a surface in order to reproduce and subse-quently 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 appearence (i.e.colour, texture). The collected data can be used to construct digital, three dimen-sional models.

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

Kinect as a 3d Scanner

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 sucessfully gener-ate 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, portabli-ty, etc the kinect was the most optimum soltuion to be tested for the Recy-cled FaBric(k) 2.0 process. Kinect as far as we know is the fastest avaible 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, micro-soft had not released the drivers required to successfully conect 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 re-leased the official SDK for the device, most programming tools such as the one we have applied for this thesis (processing) rely on the developer driv-ers. 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 capabilites of processing beyond just graphics and images, they are intended to enable audio, video and com-munication features with other devices. The library suited for our thesis is called SimpleOpenNI avialable 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 scan-ning distance, render detail, rgb scan and other export functions.

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.

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.

RFB2 Scanbrick ScriptKinect as a 3d Scanner

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.


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 proto-col. 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 constuct 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 com-parision 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 vari-ous 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 scan-ner which the collaborating company ZCorp would let us demonstrate. The procedure of exporting the point cloud data is briefly explained in the fol-lowing 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 applica-tions 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 mes-sage is recieved by grasshopper using the gHowl plugin. The gHowl plugin acts as a reciever for the udp message, in this case the co-ordinates of the points. The message as wriiten 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 pro-tocol is that it can recieve the data in real time and can be updated with the new co-ordinate changes.

MESH FROM POINTS :This is one of the simplet stepd 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 pro-gram and individually leads to the quality of the mesh.

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


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 lighing 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 lightin condition fecilitated 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 callibration, the cost difference make it readily availble 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

Broken BricksOTF Process

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

Broken BricksGeometry Simplification

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.

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 theie 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 digital-ly assembling structures. For this reason, we simplify the bricks by the param-eters extracted. We consider a bounding box retaining the shape of each surface, only flatening 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 remain-ing empty gap could be filled.

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 BricksMatrix of Bricks

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

Broken BricksParameter 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 etracted in the form of lists. These lists consist of the unique data provided by the unique paramters 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 guidline provided to every script to analyse, evaluate, re-evaluate, and compare within the brick sets. This is the most essentail 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 scriptsed assemblies. The above image shows the different components applied to extract the various datas

BRICK ID { _ }Number of Faces

0. Trimmed Surface1. Untrimmed Surface2. Trimmed Surface3. Untrimmed Surface4. Untrimmed Surface5. Untrimmed Surface

BRICK ID { _ }List of Vertices

0. {2472.368015, 2578.117787, 0.0}1. {2472.368015, 2578.117787, 75.0}2. {2587.368015, 2578.117787, 0.0}3. {2587.368015, 2423.725188, 0.0}4. {2472.368015, 2371.740425, 0.0}5. {2587.368015, 2578.117787, 75.0}6. {2587.368015, 2423.725188, 75.0}7. {2472.368015, 2371.740425, 75.0}

BRICK ID { _ }Face Angles

0. 0.001. 90.002. 90.003. 24.32

BRICK ID { _ }Total Volume

0. 1.55582 mm3

BRICK ID { _ }Number of Edges

0. Line-like Curve1. Line-like Curve2. Line-like Curve3. Line-like Curve4. Line-like Curve5. Line-like Curve6. Line-like Curve7. Line-like Curve8. Line-like Curve9. Line-like Curve10. Line-like Curve11. Line-like Curve

BRICK ID { _ }Edge Lengths

0. 206.371. 75.002. 206.373. 115.04. 154.395. 126.206. 115.07. 154.398. 126.209. 75.010. 75.011. 75.0

Chapter 04

Design by CodeOTF Process

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 inno-vative vocabulary of architectural forms, generated by the algorithmic po-tential 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 CodeINTRODUCTION :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’s screen? Is computer programming necessary in design today? This chapter highlights the methods where digital compu-tational power is explored to create designs, test them via simulation soft-wares as well as thinking about the assemblies.

EMERGENCE :The phenomenon, whereby a simple rule set at a low level creates organ-ized complexity on a higher level, is called emergence. In a nutshell, emer-gence is the observation of how complex and coherent patterns can arisefrom 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 largenumber of small agents (Broken Bricks) with simple behaviors (assemblies/ logics), collectively they can become capable of producing a more com-plex, 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 emer-gence. With the application of grasshopper, C# scripting, and external pl-ugins such as galapagos we develop methods where each brick behaves to a simple local relationship to the adjacent bricks.

Bounding Box + Genetic AlgorithmDesign by Code

INTRODUCTION :The first defination to generate structures out of broken bricks is inspired from the logics of emergence, the idea where we control the self assem-blies of broken bricks by adding simple rules of interaction / behaviours with their adjacent bricks. Each broken brick is brought closer to each other by controling the bound box around all the bricks. For this defination we con-sidered 3 broken bricks, to help optimize the process as fast as possible. Through this chapter we shall progress from the basic defination for getting the bricks together, detecting the collsions 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 optimized 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 de-tection defination 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 op-timized result. When automated for specific parameters and results, this technique becomes an effective way to computationally drive controlled results within the iterative design process – allowing designers to produce optimized parameters resulting in a form, graphic or piece of data that best meets design criteria. What we achieve by this component is the best op-timised 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 grass-hopper defination which brought us to that particular evolutionary solution.

Broken BricksXY-Rotation 180X- MovementY- Movement

Control / ComputationBounding Box - VolumeCollision Dectector

Galapagos SolverMinimise Fitness ValueVolume of Bounding Box

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


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


Control / ComputationBounding Box - VolumeCollision DectectorCentroid Distances

Galapagos SolverMinimise Fitness ValueVolume of Bounding BoxCentroid Distance

LOGIC :First addition to the previous script of getting the broken bricks to self-assem-ble, is to minimise the distance between the centroids of each brick. The defination 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 cen-troids and maintins 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.


Control / ComputationBounding Box - VolumeCollision DectectorFace Vertice distance

Galapagos SolverMinimise Fitness ValueVolume of Bounding BoxVertice Distances

Self assembly for the same set of 3 broken bricks, with the most compact bounding box volume by mainting 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 self-assemble, is to minimise the distance between the vertices of selected fac-es of each brick. Here the user can assign the face vertices to which the ad-jacent 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 defination we assign a relationship between the lengths of the bound-ing box, hence it shifts out of the square shaped to form a rectangular box.

OBSERVATION :This defination starts to form a more linear relationship between the assem-blies of the bricks. This would lead to a wall like assembly.



Control / ComputationBounding Box - VolumeCollision DectectorCentroid DistancesCentroid Angle Vectors

Galapagos SolverMinimise Fitness ValueVolume of Bounding BoxCentroid Distance and Angles

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

LOGIC :This defination also maintins a relation of the bounding box lengths to form a more rectangular box, and while doing so also maintain the angles and dis-tances between the centroids of each brick to be the least. The defination 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 vecgtor angles constructed form the cen-troid and maintins minimum distances between each of them.

OBSERVATION :As we add more and more rules to analyse the assembly, although it takes more time to optimize but the results tend to work better. By this i mean, galapagos optimises the best orientations for the simple rules given to it.


Control / ComputationBounding Box - VolumeCollision DectectorCentoid Distances Centroid Angle Vectors

Galapagos SolverMinimise Fitness ValueVolume of Bounding BoxCentroid Angles and Distances

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

LOGIC :With this defination we finally get to achieve what looks like th 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 defination starts to form a more linear relationship between the assem-blies 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 definations.


DRAWBACKS :The only drawback and the major one from these sets of grasshopper defi-nations 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 :Evolutionar Solving using the Galapagos component within grasshopper, leads us with interesting results and observations. By providing simple rules and letting the solver optimise and evaulate the best possible assemby could be the simples t and most straight forward methos to start our investi-gation in finding forms by recycling broken bricks.

Chapter 05

Design by CodeSorting Broken Face Angles + Scripting C#

INTRODUCTION :Extracting the parameters from the set of 50 broken bricks as shown in the earlier pages, the uniqe character for all the bricks is the angle at which the bricks are broken. For these few definations, we have simplified the geom-etry of the broken faces so as to arrive at a simpler 3d digital object. Apply-ing the think locally, act locally principle, we derive few definations where by the bricks have to allign to their adjacent bricks at particular selected vertices. This brings about interesting assemblies where the back faces of every brick are alligned to form a straight wall, whereas the front faces give the wall a twisted character.

LOGIC (For Loops) :The parametr under control for these definations are the angles of the bro-ken 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 defination 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 defination. 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 BricksXY-Rotation Broken Facesand their Angles

Control / ComputationSorting AnglesSorting All Bricks Dispatch each brick course

C# ScriptingTranslate 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 up-per most layer consitis of bricks with all parallel faces.


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 consitis of bricks with all parallel faces.

LOGIC :Sorting the bricks according to their broken face angle vectors, actually de-cides the locations for every brick in the assembly. Hence sorting plays the major controling 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 ex-plored in the above assembly. Here the bricks are sorted and slipt 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 consitis of bricks with all parallel faces.

LOGIC :As mentioned in the previous example, the importance of sorting and dis-patching to reshuffle the sequence of the bricks, here that list is reversed. This leads us to a small issue where the bricks penetrate within eachother 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 innward curvature of the previous list.


VARIATIONS + COMBINATIONS :Using the same definations, we could combine or multiply them to sets of same number of bricks to form walls, enclosures which are emerged from the charcteristics of the broken bricks. Every evolution would derive out a new sequence for the assembly . Here the user also have the added func-tion of reversing the sorting sequence or fliping the broken bricks on a de-sired plane to extend the curvatures of the assembly. Eventually we would end up with walls with emereging 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 dipatched 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 usnig a vector. As the loop is as-signed 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 VariablesVector3d v1;Point3d p1;Point3d[] p = new Point3d[8];

//----------------------------------------Move first Brick to Start PointBricks[0].Translate(Point);

//Move rest of the Bricks to a vertice from the previous Bricksfor (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 BricksA = Bricks;

}

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 consitis of bricks with all parallel faces.

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 consitis of bricks with all parallel faces.


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 defination 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 poten-tial assemblies with the same set of bricks, hence we derived more defina-tions highlighting the unique charaters of the bricks. But we weould consider re-evaluations to scripts in the chapters yet to come.

Chapter 06

Design by CodeDifferential 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 defi-nation 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 defination is menat to be applied part by part to construct the entire structure. If needed they can be oriented in ther re-verse angels to have a more aestheic 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 poistions of the brick to converge the shorter length around it. By this we have the control on which parts or regions of the as-sembly 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 BricksBrickVolumeLongest Edge Length

Control / ComputationSorting LengthsSorting All Bricks Dispatch each courseAtrractor Point

C# ScriptingTranslate 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.


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). Sorted from longest to the shortest length derived by the attractor point.

C# SCRIPT :The intelignece 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 dipatched as per the de-sired 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 usnig a vector.

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


CONCLUSION :The assemby emerging from this defination, is more practically suited. The varied thicness provides us with regions where lesser insulation is required and vice-versa. Through this grasshopper defination, we evaulated a new method of sorting the broken bricks, where the attractor defines the loca-tions of bricks. This attractor could be derived from solar, radiance analysis for the desired structure, and simultaneously sort the bricks in order of as-sembly.

Chapter 07

Design by CodeScritping the Corbelled Arch

INTRODUCTION :n 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 cor-beling to span a space or void in a structure, such as an entranceway in a wall or as the span of a bridge. A corbel vault uses this technique to support the superstructure of a building’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’s cent-er 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 oppos-ing walls.

Corbel arches and vaults require significantly thickened walls and an abut-ment of other stone or fill to counteract the effects of gravity, which other-wise 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 ob-serve that the corbel is prependicaular 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.


LOGIC (Stability) :Now that we understand the basic principles of an corbelled arch, trans-lating the methods to broken bricks, we derive corbels with a smotthened 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 definations 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 alll the sourced bricks are sorted according to their volumes, which is used to remove / cull bricks which are lesser volume than the desired toler-ance . This is neccesary 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 definations, there would more evautaions 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 anaylse the rela-tions between the inner and the outer curvatures for the overall stability of the arch.

Broken BricksBrickVolumeBroken Face Angle

Control / ComputationSorting AnglesCull Straight BricksCull Bricks least VolumeSorting All Bricks Dispatch each course

C# ScriptingTranslate brick SET A to Vertice of the Previous Brick within the ListTranslate 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 grasshop-per. Some have a double layered inner and outer curvature.


Inne

r Cur

vtat

ure

01O

uter

Cur

vatu

re 0

1

Inne

r Cur

vtat

ure

02

Inne

r Cur

vtat

ure

03

Inne

r Cur

vtat

ure

04

Inne

r Cur

vtat

ure

05O

uter

Cur

vatu

re 0

2

Inne

r Cur

vtat

ure

06O

uter

Cur

vatu

re 0

3

Inne

r Cur

vtat

ure

07O

uter

Cur

vatu

re 0

4

Inne

r Cur

vtat

ure

08O

uter

Cur

vatu

re 0

5

Inne

r Cur

vtat

ure

09O

uter

Cur

vatu

re 0

6

Inne

r Cur

vtat

ure

10O

uter

Cur

vatu

re 0

7

28.07.09.012.00.023.032.010.019.024.01.06.018.011.05.030.029.033.022.017.031.0

15.017.01.047.010.016.08.013.034.044.035.020.0

11.033.08.07.045.0

28.07.09.012.00.032.08.010.019.024.06.018.011.027.05.029.033.022.017.031.0

9.014.047.012.02.013.07.049.020.0

14.012.013.049.0

28.07.09.00.023.032.010.019.024.06.018.011.05.030.029.022.017.031.0

32.048.010.02.027.044.045.0

28.07.012.00.032.08.019.024.06.018.027.05.029.033.017.031.0

17.047.016.013.044.020.0

Inner Curvature 01Brick id | angle










32.7930.4924.7524.3223.9723.4122.7118.0417.8215.4615.2314.9913.5313.3410.249.829.489.448.618.127.39

32.2828.8023.9722.7118.9016.5214.9913.3410.349.828.616.40

24.7521.3214.9910.247.39

32.7930.4924.7524.3223.9722.7118.9018.0417.8215.4614.9913.5313.3412.6610.249.489.448.618.127.39

30.4924.3222.7118.0415.2313.3410.249.446.40

24.3218.0413.349.44

32.7930.4924.7523.9723.4122.7118.0417.8215.4614.9913.5313.3410.249.829.488.618.127.39

29.8323.7618.9015.2313.029.827.39

32.7930.4924.3223.9722.7118.9017.8215.4614.9913.5312.6610.249.489.448.127.39

28.8022.7116.5213.349.826.40

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.


SCRIPTING THE ARCH :The script for generating the arch is a step forward from the earlier scripts of transalting 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 achievd by adding another layer of bricks, at the end plane of the first set of bricks. Now the second layer of bricks when alligned to thier broken faces vertices, form another curvature on the outside. This curvature in a major controlling factor for the counterbalance of the enitre 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 translationg script, the third diagram C is a reverse placement of the same SET B bricks. This brought us to a concluision of controling 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 defi-nation.

A B C

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


i

vi

Xi

ii

vii

xii

iii viii

xiii

iv

ix

xiv

vx

TOP DOWN APPROACH :Finding the right bricks to the user designed curves. Within this defination, a very small one, the user can control the cuvre of the assembly as desired. The grasshopper defination scans through all the broken bricks after initial culing 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 com-plex 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 defination, once to find the lengths between the divided refenced 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 BricksBrickVolumeBroken Face Angle

Referenc CurveDivide Curve

Control / ComputationSorting AnglesCull Straight BricksCull Bricks least VolumeLocate Bricks Curve Lengths

C# ScriptingTranslate brick SET A to Vertice of the Previous Brick within the List.Find similar member


CONCLUSION :Stability for these assemblies is essential, but through the growth of this par-ticular defination, 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 neces-sary to stand errect. This was tested through digital simulations using sketchy physics 3.2, for Sketch Up 8.0.

Chapter 08

Augmented Reality ConstructionOTF Process

AUGMENTED REALITY :Augmented reality (AR) is a live, direct or indirect, view of a physical, real-world 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 recogni-tion) the information about the surrounding real world of the user becomes interactive and digitally manipulable. Artificial information about the environ-ment 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 soltuions between t he real and the virtual world.

Augmented Reality ConstructionJunaio Application

METAIO :Metaio has attained a leading international role in the burgeoning tech-nology 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 part-ners can create their own applications, sell their solutions in specific mar-kets 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.ju-naio.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 dont 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 th 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 ConstructionJunaio 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 com-piled within an hour. With the lastest version releasing within a weeks time, we wouldnt need a tracking image as juanio can detect objects and assign AR models on top of it.

recycled fabrick 2.0

Documents

open thesis fabrication

digital processes

fabrication process

digital platform

recycling broken bricks

advanced architecture

thesis conduct

literature digital materiality