Page 1


Wooden Furoshiki

ETH Zurich Institute for Technology in Architecture Chair of Computer Aided Architectural Design Prof. Dr. Ludger Hovestadt MAS Thesis February 2014 Yuko Ishizu Evdoxia Xexaki

Contents Introduction










This thesis was conducted as a final project after a one year MAS program at the chair of CAAD at the ETH Zurich under the direction of Professor Lunger Hovestadt. “Wooden Furoshiki� is the final product of a collaborative research in the fields of materiality, fabrication and information technology. Team: Yuko Ishizu Evdoxia Xexaki Tutoring and Supervision: Prof. Dr. Ludger Hovestadt Dr. Phil. Vera Buhlmann Mathias Bernhard Benjamin Dillenburger External support: Christoph Schindler 5



This project concerns of a research on materiality, construction and information technology. It relies on our interest in materials and assumptions about them and concerns a research on giving new properties and meanings to already existed materials, having as a given material under investigation, a kind of wood, yew tree. The aim of this research is to give answers to questions such as “Can a hard material be soft?”, “Can it be transformable” or “Can wood acquire properties of a textile?”

Construction and Information Technology

With yew tree as a starting point and these questions in mind, our objective is to design and construct 3d objects which are flexible and transformable and can function as furniture and interior space products.

From the tectonic points of view, only thing differentiating human being from any other could be the notion of standardisation in construction. Standardization was a modern material production placing importance on efficiently producing uniform, homogeneous artefacts from natural, irregular materials. With the aid of contemporary design techniques however, it is now possible to have material design make use of, and even feature explicitly, the imperfections of natural materials with minimal impact on production efficiency. Through the use of digital scanning and robotic fabrication, proposes to take material irregularities as design input, to distinguish and create meaningful order from material ‘noise’. Instead of materials adapting to production processes, it is an inversion: construction adapting to materials, from top-bottom design to bottom-up design.

Potentiality in architecture Architecture changes and adapts depending on culture and era. The current period, the growing speed of cultural change imposes the seeking of new ways of thinking and conceptualizing, as well as designing and producing. Traditionally, architects focus on the final form of the architectural piece of work. Nowadays, a shift from the final product to the process from which the architectural form emerges is required. When based on types and certain rules, architecture repeats itself, elements are copied and preexisted forms are imitated, while, on the other side, the repetition of the process, and not the final form, does not represent the same, but integrates the difference. The process is repeated, so that the innovation emerges and a field of varied forms comes as a result. The ideas of possibility, alteration, potentiality, interdependence, temporality and performance, coexist now with the ideas of form, substance, permanence and language. The understanding of the design process as an open field of possibilities leads to a more flexible and adaptive architecture.


Construction is not only about the taking of whatever materials at hand and building of whatever one wants, but also about making the most use of materials and coming up with smart use of them within specific duration and cost. Therefore, we need to negotiate with these constraints in construction and search for ways to maximize materials, construction processes and design solutions

Through this project, we manage to combine computational design (algorithmic design) and craftsmanship. Algorithmic design integrates the potential for unpredictable patterns, as well as technology enhances our ‘hands on’ approach and enables a unique way of using materials.


Materiality Wood + resin: natural raw material + artificial chemical material


Wood (Yew tree) The yew is a small- to medium-sized evergreen tree, growing 10–20 metres tall, with a trunk of diameter of up to 2 meters wide, but usually 20-40 cm. It is relatively slow growing, and can be very long-lived, with the maximum recorded trunk diameter of 4 metres probably only being reached in about 2’000 years. Today European yew is widely used in landscaping and ornamental horticulture. Due to its dense, dark green, mature foliage, and its tolerance of even very severe pruning, it is used especially for formal hedges and topiary. Its relatively slow growth rate means that in such situations it needs to be clipped only once per year. The slow growth is also fatal to the yew. The young trees are chewed by deer which are immune to the poison. Therefore the yew is a protected tree that is almost extinct in the forest. The yew tree is a special tree with a local background. At Zurich’s Uetliberg thrives the last great refuge of 80’000 European yew (as much as throughout Germany). While in most parts of Europe yew is almost extinct and strictly protected, yew from Uetliberg is available at a reasonable price. But as yew dropped out of the international wood market, there is no domain for this highly capable wood – it is used for securing the Uetliberg infrastructure (e.g. poles, stairs, timbering), but not in construction or carpentry. Yew tree has the following special characteristics: • • • • • • • 12

toxic (except the bright red aril surrounding the seed) slow growth and longevity “wood defects”: knotty and twisted heartwood resists compression, sapwood resists stretching extreme colour difference between heartwood and sapwood decay resistant local in Zurich

Using yew tree as the basic material, we explore the potential of using a material with specific special characteristics in an architectural context and making the most out of its irregularities.


Epoxy resin Epoxy is the cured end product of epoxy resins, as well as a colloquial name for the epoxide functional group. Epoxy resins, also known as polyepoxides are a class of reactive prepolymers and polymers which contain epoxide groups. Epoxy resins may be reacted (crosslinked) either with themselves through catalytic homopolymerisation, or with a wide range of co-reactants including polyfunctional amines, acids (and acid anhydrides), phenols, alcohols, and thiols. These co-reactants are often referred to as hardeners or curatives, and the cross-linking reaction is commonly referred to as curing. Reaction of polyepoxides with themselves or with polyfunctional hardeners forms a thermosetting polymer, often with strong mechanical properties as well as high temperature and chemical resistance. Epoxy has a wide range of applications, including metal coatings, use in electronics / electrical components, high tension electrical insulators, fiber-reinforced plastic materials, and structural adhesives. Epoxy resin is employed to bind gutta percha in some root canal procedures.

applications where high strength bonds are required. Epoxy adhesives can be developed to suit almost any application. They can be used as adhesives for wood, metal, glass, stone, and some plastics. They can be made flexible or rigid, transparent or opaque / colored, fast setting or slow setting. Epoxy adhesives are better in heat and chemical resistance than other common adhesives. In general, epoxy adhesives cured with heat will be more heat- and chemical-resistant than those cured at room temperature. The strength of epoxy adhesives is degraded at temperatures above 350 °F (177 °C).[7] Resin is used to fix the cracks of the wood, while at the same time makes the wood much stronger and resistant to forces. In purpose, we used resin of high viscosity and high transparency, in order to reach and cure even the smallest cracks of the wood and to have a result which comes in contrast to the solid wood’s appearance.

Applications The applications for epoxy-based materials are extensive and include coatings, adhesives and resin matrices for composite materials such as those using carbon fiber and fiberglass reinforcements (although polyester, vinyl ester, and other thermosetting resins are also used for glass-reinforced plastic). The chemistry of epoxies and the range of commercially available variations allows cure polymers to be produced with a very broad range of properties. In general, epoxies are known for their excellent adhesion, chemical and heat resistance, good-to-excellent mechanical properties and very good electrical insulating properties. Adhesives Epoxy adhesives are a major part of the class of adhesives called “structural adhesives” or “engineering adhesives” (that includes polyurethane, acrylic, cyanoacrylate, and other chemistries.) These high-performance adhesives are used in the construction of aircraft, automobiles, bicycles, boats, golf clubs, skis, snowboards, and other 14








Alternative approach of design Architecture is creating phenomena, which allow people to give a new perspective. Just one piece of cloth could be Architecture, if it would cause (trigger on) some activities to happen. Design is not only making physical objects but also an abstract trigger giving people the incentive to gather and interact, as well as creating new special properties. We understand the design process as an open field of possibilities. Through design process, new ideas about the living space may derive and the potential for the unexpected and the surprise always exists.

Furoshiki Furoshiki (風呂敷) is a type of traditional Japanese wrapping cloth traditionally used to transport clothes, gifts, or other goods. It began to be used in the mid-Nara Era, in traditional Japanese baths (Onsen), to not confuse or mix the clothes. Before becoming associated with public baths, furoshiki were known as hirazutsumi (平包み), or flat folded bundle. Eventually, the furoshiki’s usage extended to serve as a means for merchants to transport their wares or to protect and decorate a gift. Currently Furoshikis are made of different fabrics, including silk, cotton, rayon and nylon. And though this art remains popular in Japan, its use has declined due today high demand for plastic bags. In recent years the use of Furoshiki is promoted again, to ensure environment protection in Japan and worldwide. This project has the intention of giving a new perspective to the wood material. Our aim is to create a foldable surface out of wood, a ‘Wooden Furoshiki’.


The project consists of wooden pieces which compose a flexible surface which can perform in different three-dimensional shapes. The material ranges between hard and soft, seating and curtain, blurring relationships between furniture and textiles. What is particular is that we cut each trunk into horizontal sections, in contrast to what is usually done. Moreover, we don’t cut the wood in a predefined geometrical shape, but always by following the natural grain already designed on the trunk’s section during the tree’s growing. This way, we end up with irregular pieces which can be connected in many, different and not directly predictable ways. ‘Folding ability’ relies on the way the pieces are connected to each other. Behaviour differentiates in several parts of the surface, due to the size and density of the pieces, as wells as the way in which the pieces are connected to each other. The inherent properties of each separate piece have no meaning when it is disconnected from the whole. The properties of the pieces of the structure are only defined through the relationships which are developed between them and their environment. The relations which are developed between the wooden elements have immediate effect to the whole of the structure. While, in reverse, any change on the whole has effects on its different parts. Also it is crucial to aim for a closer relationship between subject and object. Due to its flexibility and changeability, interaction between the user and the object is keenly promoted in the case of ‘Wooden Furoshiki’. The user can fold it, unfold and fold in a different way, giving to the object different functions according to his needs. When transformed, ‘Wooden Furoshiki’ can acquire different functions, from a piece of furniture lying on the ground to a hanging object functioning as a chandelier or a curtain. The light and shadows of the object can create a very interesting atmosphere in the interior of a space.


Experimentation on cloth behaviour simulation







Experimentation on circle mesh simulation









Test model _ 1

Test model _ 3

Test model _ 4

Test model _ 2

Test model _ 5

Experimentation both with models out of cardboard and with the material itself in order to test the folding ability of a surface depending on the size of the modules and the distance between them, as well as the strength of the yew as material. Testing the flexibility depending on different distances between the modules 38

Test model _ 6 39



Process We take advantage of the great colour and the special flower-shaped section of the yew tree. We focus on the grain its section has, trying to expose it on our design.















The process we followed at the fabrication phase is the following: 1. 2. 3. 4. 5.

6. 7. 8. 9. 10. 11.

Collection of trunks of wood Slicing the trunks in slices of the desired thickness (2 mm) Sanding the wooden slices Taking photos or scanning of the slices and creating an archive Tracing through the grain of each slice in order to create a variety of wooden rings (different shape, different size, different thickness) Milling the slices according to the grain tracing and collecting the varied rings produced Fill with resin the cracks wherever needed Selecting the desired pattern Packing the rings according to the pattern selected Preparation for connecting the pieces to each other (drilling of the holes and production of the joints) Connect each piece with its neighboring pieces (ball joint or wire joint)

This way, we manage to have a variety of rings of different size and shape, while using most of the wood provided. Each ring produced is similar, but unique. There is no pair of same rings. The final pattern is completely dependent on the provided rings and can never be the same. As well as, the same pieces can produce a variety of different patterns.




Connections The joints are specially designed for the needs of this project. There are two types of joints which are used, ball joints and wire joints.

Ball joints Ball joints are made out of steel and can reach an angle of 45 degrees. They are located between the pieces along the edges and the middle line, creating the backbone of the structure. They can be locked on any position in the range of their moving ability, this way stabilising the structure on the desired form. In addition, ball joints are located on specific positions on the edge pieces, functioning as connectors of different parts of the surface, also helping on the stability of a specific form.

Wire joints

Ball joints

The rest of the joints of the surface are made of wire and metal sticks. They are thus designed, so that the wire forms a sheath on both sides. Each of these sheaths enters the wood piece through a hole and stays put there by a piece of metal stick which enters vertically from the other side of the wood. These joints keep the pieces connected and in some distance between them (around 4mm), thus allowing a freedom of movement on the surface. Wire joints





7.00 15.50




9.24 6.46 4.00

13.00 15.00

10.00 15.00



7.20 4.00



3.84 1.66


22.00 15.63


째 30.00

21.00 15.00

6.46 2.88

2.50 3.00


6.46 9.24

13.00 15.00

4.00 10.00

8.00 10.00





Detail of the ball joint 48

Detail of the wire joint 49

Assebly diagrams 50

Ball joints’ position 51

Wire joints’position 52

Wood rings’ position 53

Tools Very important role for the completion of this project played the use of proper tools. -

Polygon-packing algorithm

Algorithm is a productive design tool. The use of algorithm in design process leads to a dynamic design process, a machine of form production. It defines the organizational principles from which a form can derive and not the form itself. Is not a specific form produced, but a field of virtual forms. The result adapts and changes according to the required point of view.

- CNC milling machine _ for cutting through the grain - CNC lathe _ for producing the metal ball joints - Drilling machine _ for making holes on the wooden pieces in order to connect them to each other - Sanding machine _ for sanding the wood - Scroll saw machine _ for slicing the wood

polygon packing algotithm 54








Environmental extent: waste into production Cutting the log into slabs is not the only method that can be involved in the process of the production of a wood product. Cutting the log into slabs is the traditional and most common method of transforming a tree into a wood product. Nevertheless, it is not the only method that can be involved in the process of the production of a wood product. As through the procedure of making lumber, there is a lot of wood waste produced at the forestry, our proposal involves the possibility of transforming the wood waste into products by computational design and digital fabrication approaches. This can be achieved either by the optimization of reducing wood waste or the use of wood waste from the forestry. This approach can be applied to different forestry so that the wood waste can be reduced.









polygon packing algorithm:

setObstacle(); setObstacle1(); importPolygons(); importGuide();

opimization by fitness of color mapping import java.awt.geom.*; Polygon[] polygons; PGraphics fitPG; ArrayList<Polygon> visiblePolygons; ArrayList<float[]> visibleParams; //String[] ptsLines; //String[] polyline; float[]transX; float[]transY; float[]rots; boolean[][] grid; boolean[][] obstacle; boolean[][] obstacle1; boolean[][] obstacle2; float fitness; int minArea, maxArea; float resolution=0.3; int nX=150;int nY=120; float scale =15.5;//rhino float s =8;// public void setup() { size(int(s*nX), int(s*nY)); nX=int(nX*resolution); nY=int(nY*resolution); scale=scale/resolution; s=s/resolution; grid=new boolean[nX][nY]; /* ptsLines = loadStrings(“pts.txt”); for(int i=0; i<ptsLines.length; i++){ String[] polylineParams = split(ptsLines[i],’|’); polyline = split(polylineParams[1],’_’); } */ 70


nest(); fitness=fitness4();

public void draw() { for (int i=0;i<5;i++) { evolve(); } //println(“using: “+visiblePolygons.size()+”/”+polygons.length+” polygons , fitness: “+fitness+”%”); nest(); background(255); }


void drawElements(){ scale(s); noStroke(); fill(250,200,200); rectMode(CORNER); rect(0,0,nX,nY); ////draw frame String[] ptsLines = loadStrings(“pts_frame.txt”); for(int i=0; i<ptsLines.length; i++){ String[] polyline = split(ptsLines[i],’_’); fill(255,150,150); noStroke(); beginShape(); for(int n=0; n<polyline.length; n++){ float[] ptCoord =float(split(polyline[n],’,’)); vertex(ptCoord[0]/scale,ptCoord[1]/scale); } endShape(CLOSE); 71

} fill(200); stroke(0); strokeWeight(0.2f); ////draw polygons noramlly //println(polygons.length + “,”+visiblePolygons.size()); for (int i=0;i<visiblePolygons.size();i++) { Polygon poly=visiblePolygons.get(i).copy(); poly.rotate(visibleParams.get(i)[0]); pushMatrix(); translate(visibleParams.get(i)[1], visibleParams.get(i)[2]); poly.display(g); popMatrix(); } /* ////draw polygons in raster mode rectMode(CENTER); fill(255,0,0); for (int i=0;i<visiblePolygons.size();i++) { Polygon poly=visiblePolygons.get(i).copy(); poly.calculateRasterShape(); pushMatrix(); translate(visibleParams.get(i)[1]+poly.x1, visibleParams.get(i) [2]+poly.y1); poly.displayRasterShape(g); popMatrix(); } */ } void importGuide(){ PImage img = loadImage(“bw.png”); img.resize(nX,nY); img.loadPixels(); fitPG = createGraphics(img.width,img.height); fitPG.beginDraw(); for(int i=0; i<img.pixels.length; i++){ 72

fitPG.stroke(brightness(img.pixels[i])); fitPG.point(i%img.width,floor(i/img.width));

} fitPG.loadPixels(); fitPG.endDraw();

} /** *filling strategy: *find the lowest position for each piece, test different rotations */ public void nest() { for (int x=0;x<grid.length;x++) { for (int y=0;y<grid[x].length;y++) { grid[x][y]=false; } } visiblePolygons = new ArrayList<Polygon>(); visibleParams = new ArrayList<float[]>(); for (int i=0;i<polygons.length;i++) { Polygon polygon=polygons[i]; int minY=Integer.MAX_VALUE; //int minR=0; float rotDiv = 1; boolean fitting = false; for (int j=0;j<rotDiv;j++) { //int fitCount = 0; Polygon poly=polygon.copy(); float angle=2*PI*j/rotDiv; poly.rotate(angle); poly.calculateRasterShape(); for (int y=0;y<nY;y++) { for (int x=0;x<nX;x++) { if (fit(poly.gridShape, (int)( x+poly.x1), (int)(y+poly. y1),poly.area)) { //fitCount++; int cY=0; if (cY<minY) { minY=cY; //minR=j; transX[i]=x; transY[i]=y; 73

rots[i]=angle; fitting = true;



} y=nY; x=nX;

} } if(fitting){ Polygon poly=polygon.copy(); poly.rotate(rots[i]); poly.calculateRasterShape(); place(poly.gridShape, (int)( transX[i]+poly.x1), (int) (transY[i]+poly.y1));




float[] params = new float[3]; params[0] = rots[i]; params[1] = transX[i]; params[2] = transY[i]; visibleParams.add(params); visiblePolygons.add(polygon);

/** *create a random polygon */ public Polygon createRandomPath() { float num = 10; Polygon poly=new Polygon(“�,(int)num); for (int j=0;j<poly.nPoints;j++) { float angle=PI*2f*j/(num+1); float radius=random(3, 6); float cX=cos(angle)*radius; float cY=sin(angle)*radius; poly.setPoint(j, cX, cY); } poly.calculateRasterShape(); return poly; } 74

/** *check if there is any overlap with another piece */ public boolean fit(boolean[][] shape, int x1, int y1, int area) { if (x1<0||y1<0||shape.length+x1>grid.length||shape[0]. length+y1>grid[0].length)return false; for (int x=0;x<shape.length;x++) { for (int y=0;y<shape[0].length;y++) { if (shape[x][y] && grid[x+x1][y+y1]) { return false; } if(shape[x][y]&&obstacle[x+x1][y+y1]){ return false; } if(shape[x][y] && obstacle1[x+x1][y+y1]){ float areaMap = map(area,minArea,maxArea,0,1); if(areaMap<0.5){ return false; }else{ return true; }

} }



return true;

/** *occupy the covered pixels */ public void place(boolean[][] shape, int x1, int y1) { for (int x=0;x<shape.length;x++) { for (int y=0;y<shape[0].length;y++) { if (shape[x][y]) { grid[x+x1][y+y1]=true; } } } } 75

/** *change the sequence of the pieces */ public void swapPolys(int i1, int i2) { Polygon tempPath=polygons[i1]; polygons[i1]=polygons[i2]; polygons[i2]=tempPath; } /** *change the sequence of the pieces *evaluate the new fitness *keep if new version is better */ public void evolve() { int swapCount = 1; int[][] randomIndex = new int[2][swapCount]; for(int i=0; i<swapCount; i++){ int i1=(int)random(polygons.length); randomIndex[0][i] = i1; int i2=(int)random(polygons.length); randomIndex[1][i] = i2; swapPolys(i1, i2); } nest(); float newFitness = fitness4(); if(newFitness>=fitness){ fitness = newFitness; println(fitness); }


else { for(int i=0; i<swapCount; i++){ int i1 = randomIndex[0][i]; int i2 = randomIndex[1][i]; swapPolys(i1, i2); } }

/** *fitness=filled height of the pieces 76

*/ /* public float fitness() { for (int y=grid[0].length-1;y>=0;y--) { for (int x=0;x<grid.length;x++) { if (grid[x][y])return y; } } return 0; } public float fitness2(){ return visiblePolygons.size(); } public float fitness3(){ float polyCount = 0; float boundCount = 0; for(int i=0; i<grid.length; i++){ for(int n=0; n<grid[i].length; n++){ if(grid[i][n]){ polyCount++; } if(!obstacle[i][n]){ boundCount++; } } } float fitRatio = polyCount/boundCount*100; return fitRatio; } */ public float fitness4(){ float fitCount = 0; for(int i=0; i<visiblePolygons.size(); i++){ Polygon poly = visiblePolygons.get(i); float[] params = visibleParams.get(i); int x = floor(params[1]); int y = floor(params[2]); float areaMap = map(poly.area,minArea,maxArea,0,1); 77

float imgMap = map(brightness(fitPG.pixels[y*fitPG. width+x]),0,255,0,1); float fit = (1-abs(areaMap-imgMap))*100/visiblePolygons.size();


fitCount += fit;

return fitCount; } void setObstacle(){ obstacle = new boolean[nX][nY]; PGraphics pg = createGraphics(nX,nY); pg.beginDraw(); pg.background(255); pg.stroke(0); pg.fill(0); /* String[] ptsLines = loadStrings(“pts_frame.txt”); for(int i=0; i<ptsLines.length; i++){ String[] polyline = split(ptsLines[i],’_’); pg.beginShape(); for(int n=0; n<polyline.length; n++){ float[] ptCoord =float(split(polyline[n],’,’)); pg.vertex(ptCoord[0]/scale,ptCoord[1]/scale); } pg.endShape(CLOSE); } pg.loadPixels(); for(int i=0; i<nX; i++){ for(int n=0; n<nY; n++){ color col = pg.pixels[n*nX+i]; if(brightness(col) < 100){ obstacle[i][n] = true; }else{ obstacle[i][n] = false; } } } */ for(int i=0; i<obstacle.length; i++){ 78

} }

for(int n=0; n<obstacle[i].length; n++){ obstacle[i][n] = false; }


void setObstacle1(){ obstacle1 = new boolean[nX][nY]; obstacle2 = new boolean[nX][nY]; PImage img = loadImage(“imageparser9.jpg”); img.resize(nX,nY); img.loadPixels(); fitPG = createGraphics(img.width,img.height); fitPG.beginDraw(); for(int i=0; i<img.pixels.length; i++){ fitPG.stroke(brightness(img.pixels[i])); fitPG.point(i%img.width,floor(i/img.width)); } fitPG.loadPixels(); for(int i=0; i<nX; i++){ for(int n=0; n<nY; n++){ color col = fitPG.pixels[n*nX+i]; if(brightness(col) < 255/2){ obstacle1[i][n] = true; }else{ obstacle1[i][n] = false; } } } fitPG.endDraw(); } class Polygon { String name; float[] xCors; float[] yCors; int nPoints; float x1,y1,x2,y2; boolean[][]gridShape; int area; 79

Polygon(String name, int nPoints) { = name; this.nPoints=nPoints; xCors=new float[nPoints]; yCors=new float[nPoints]; } public void rotate(float rotation){ float cosR=cos(rotation); float sinR=sin(rotation); for (int i=0;i<nPoints;i++){ float xR, yR; xR=xCors[i] * cosR - yCors[i]*sinR; yR=xCors[i] * sinR + yCors[i]*cosR; xCors[i] = xR; yCors[i] = yR; } } Polygon copy() { Polygon copy=new Polygon(name,nPoints); for (int i=0;i<nPoints;i++){ copy.setPoint(i, xCors[i], yCors[i]); } return copy; } void calculateBounds() { x1=Float.MAX_VALUE; y1=Float.MAX_VALUE; x2=-10000000; y2=-10000000; for (int i=0;i<nPoints;i++) { x1=(int)min(x1, xCors[i]); y1=(int)min(y1, yCors[i]); x2=(int)max(x2, xCors[i]); y2=(int)max(y2, yCors[i]); } x1-=1; y1-=1; x2+=1; y2+=1; } 80

void calculateRasterShape() { calculateBounds(); int nX=(int)(x2-x1)+1; int nY=(int)(y2-y1)+1; gridShape=new boolean[nX][nY]; for (int x=0;x<nX;x++) { for (int y=0;y<nY;y++) { if (contains(x+x1, y+y1)) { gridShape[x][y]=true; } } } } void setPoint(int i, float x, float y) { xCors[i]=x; yCors[i]=y; } void display(PGraphics g) { g.fill(200); g.beginShape(); for (int i=0;i<xCors.length;i++) { g.vertex(xCors[i], yCors[i]); } g.endShape(CLOSE); g.fill(0); g.textAlign(CENTER); g.textSize(2*resolution); g.text(name,0,0); } void displayRasterShape(PGraphics g){ for (int x=0;x<gridShape.length;x++){ for (int y=0;y<gridShape[0].length;y++){ if (gridShape[x][y]){ rect(x,y,1,1); } } } } 81

/** * check if inside by counting vertical ray intersections with boundary * equal amount: outside, otherwise outside */ boolean contains(float x, float y) { boolean inside=false; for (int i=0;i<nPoints;i++) { int i2=(i+1)%xCors.length; float x1=xCors[i]; float x2=xCors[i2]; if (x1!=x2) { float y1=yCors[i]; float y2=yCors[i2]; if (x>=x1&&x<x2||x>=x2&&x<x1) { // between if (y<y1&&y<y2) { inside=!inside; } else if (y<y1||y<y2) { double cY=((x-x1)/(x2-x1))*(y2-y1)+y1; if (cY>y)inside=!inside; } } } } return inside; } /** * calculate center point */ PVector center(){ PVector cen = new PVector((x2-x1)/2,(y2-y1)/2); return cen; } /** * calculate area */ void calculateArea(){ 82



area = 0; for(int i=0; i<gridShape.length; i++){ for(int n=0; n<gridShape[i].length; n++){ if(gridShape[i][n]){ area++; } } }

void importPolygons(){ String[] ptsLines = loadStrings(“pts.txt”); polygons=new Polygon[ptsLines.length]; transX=new float[polygons.length]; transY=new float[polygons.length]; rots=new float[polygons.length]; for (int i=0;i<polygons.length;i++) { String[] polylineParams = split(ptsLines[i],’|’); String[] polyline = split(polylineParams[1],’_’); Polygon poly=new Polygon(polylineParams[0],polyline.length); for(int n=0; n<polyline.length; n++){ float[] ptCoord =float(split(polyline[n],’,’)); float cX=ptCoord[0]/scale; float cY=ptCoord[1]/scale; poly.setPoint(n, cX, cY); } polygons[i]=poly; polygons[i].calculateRasterShape(); polygons[i].calculateArea(); } minArea = 99999999; maxArea = -1; for(int i=0; i<polygons.length; i++){ Polygon poly = polygons[i]; if(poly.area > maxArea){ maxArea = poly.area; } if(poly.area < minArea){ minArea = poly.area; } 83

} } void saveScreenshot(){ save(“screenshot.png”); exit(); }

Many thanks to: Werkhofs Albisguetli Mechanical Workshop, Department of Physics, ETH Zurich, HPT C 113, Head: Andreas Stuker Department of Carpentry, ETH Zurich, HIF B 50.1, Oliver Zgraggen, Paul Fischlin Raplab, Department of Architecture, ETH Zurich, HIL B 46 ZHAW Workshop Kaspar Fahrlaender Paul Beuchat Gregory Gregoriadis Achilleas Xydis Togo Takamura For the providing of materials, machinery, tools, time and space in order to have our final product realized. 84


Millions discover their favorite reads on issuu every month.

Give your content the digital home it deserves. Get it to any device in seconds.