NATURAL SYSTEMS STUDIOTHE UNIVERSITY OF MELBOURNE 2012

JOHN MCILDOWIE

technical exercises\1

growth\2 parabol\3swarm\4

reaction\5

1

// TECHNICAL EXERCISES //

fieldstectonics

orbit

1

The initial task of the studio was to learn the language of Processing. The following

studies in this chapter are brief graphic explorations, which represent the sequential

learning process undertaken. In engaging with the fundamental concept of the studio

all the follow technical exercises are conceptually driven by natural systems. While

this was only used to inform the graphic quality of the work, it provides a framework

for future more dynamic and emergent sketches of natural systems.

Stan Allen explored the notion of the field as an architectural condition,

particularly in contrast to that of the architectural object where the collective

is considered over the individual. He argues that field conditions offer a

tentative opening in architecture to address the dynamics of use, behaviour

of crowds and the complex geometries of masses in motion1. Indeed it

provides a useful model for the analysis of cities too, as well, as it is a

unifying concept, recognising both the whole and its parts. Importantly the

whole emerges from these constituent parts, which will be the basis for all

the work in this journal.

1 Allen S, 1997, From Object to Field, Architectural Design, Vol 67, No 5-6, p.30

f i e l d s

Fields are a formal or spatial matrix capable of unifying diverse elements

while respecting the identity of each. This is a bottom-up phenomenon;

defined not by overarching geometries but by intricate local connections,

see Image 2, Mondrian's Composition 10. In this sketch I have created

a field of varying sized circles which overlap so as to imply some sort of

relationship. This represents the starting point in terms of technical ability

and should act as a reference point in the continued development of my

work.

1. The Cat's Eye Nebula

2. Composition 10 - Piet Mondrian

3. Glaucocystis Cell

1 32

This sketch began with no real intention however the exercise turned into a kind of drawing machine that produced interesting graphic results, which then became the basis for a more rigorous exploration. In this a series of lines are drawn from a central point in various controlled directions, which I began to see as a convergence of mass, a tectonic collision.

Code Sample: void draw() { if (mousePressed && mouseButton == LEFT) { if (random(0,100) > 50) { sat = random(0,255); bright = random(0,127); noFill(); stroke(hue, sat, bright, 10); strokeWeight(.8); float x = random(-width,width*2); float y = random(-height,height*2); line(x, y, mouseX, mouseY); for (float w=0.5; w < 3; w += 0.1) { float lDist = 0.8 + (w * 0.2/3); stroke(hue,sat,bright,10); strokeWeight(w); line (mouseX,mouseY,random(1000),random(1000));

1. Tectonic Collision - Mountain Range

2. Fractured Landscape - Jean Pierre

Hebert, a generative artwork produced

entirely from code and drawn by a mechani-

cal plotter

3. BanQ Restaurant - Office dA Architects

t e c t o n i c s

1 32

These four images were drawn

o r b i t

Code Sample:

class Attractor{ float mass; PVector locationA; float G; Attractor(){ locationA = new PVector(width/2+40,height/2+40); mass = 20; G = 0.2; } PVector attract(Walker w){ //what is the force’s direction PVector force = PVector.sub(locationA,w.locationW); float distance = force.mag(); //constrain distance to attractor distance = constrain(distance,4,50); force.normalize(); //whats the forces magnitude float strength = (G*mass*w.massW)/(distance*distance); force.mult(strength); //return the force so it can be applied return force; }

This sketch is a simulation of the gravitational path of an object around a point in space. This sketch represents a slight departure from the technical exercises seen previously, as it aims to actively mimic a natural system to produce some kind of emergent pattern. In this case a particle moves through space while gravitational forces, positioned as a central point, are applied in order to manipulate the path of the particle. This leads to the emergence of a orbit, just like atomic orbit or the orbit of planets, but on a two-dimensional plane.

e m e r g e n c e A system exhibits emergence when there are coherent emergents (property, behaviour, structure ...) at the macro level that dynamically arise from interactions between parts at the micro level.

De Wolf + Holvoet 2005

1. Space

2. Atomic Orbit

3. Jet stream of fighter planes

Orbit after an hourOrbit after 10 minutes

Orbit after 30 minutes

2 // GROWTH //

diffusion limited aggregation

Systems with emergent properties are often a parallel collection of similar units, a complex set made up of relatively simple components which when changed can produce vastly different outcomes. These processes are abundant in nature and work to form much of what we know. Almost all biological systems contain self-similar units produced through recursive processes, while many physical systems contain some form of self-similarity1. Importantly the role of the singular is fundamental to that of the collective, consider a termite mound or a coral reef, where the interplay of local agency and environmental stimulus actively construct these systems.

So can we use these models of nature to further the discipline of architecture? Can we examine architecture as an emergent social, material and spatial system? Can architecture become an adaptive and evolving organism?

Research into this field of emergence is working to develop new models for architecture as an adaptive, emergent system. Theodore Spyropoulos, director of the Architectural Association Design Research Lab, believes "architecture can construct machines that are generative, evolving relationships that engage new forms of spatial organisation and fabrication.2" These ideas have also been explored in the physical realm of design, particularly by Skylar Tibbits, whose has produced a number of self-organising small scale structures. His DeciBot (fig 1) is a family of programmable folding chains, which fold and rotate to form new three dimensional arrangements. So by

1 Flake G W, 1998, The Computational Beauty of Nature, MIT

Press, Massachusetts p. 4 2 Spyropoulos T, 2009, Evolving Patterns: Correlated Systems of

Interaction, Architectural Design Vol. 79, Iss. 6, p.87

embedding information in the materials or form, the system can build and rebuild itself, just as DNA and proteins do within the body. Indeed this is a powerful example of the potential for architecture, however there still remain a number of problems, particularly in relation to scale. Importantly, however, this research into natural systems is only now fully able to be realised.

Architecture has always been concerned with using nature as a source of inspiration, but it is only now with the aid of computers that we can engage with both the aesthetic and functional properties of natural systems in a wholistic and meaningful way.

Figure 1 - DeciBot - Skylar Tibbits

During our exploration of a simple random movement phenomenon, the random walker, my research led me to diffusion limited aggregation, which is a process where particles undergoing a random walk cluster together to form aggregates of such particles. This theory was first proposed by Witten + Sander in 1981 and is a model which simulates certain types of aggregation, like metal ions diffusing through a fluid and sticking to a charged electrode. This type of organic growth is recursive and is in many ways similar to the Lindenmayer system, which produces

“architecture is the continuation of nature in her constructive activity”

Karl Friedrich Schinkelr e s e a r c h

1 2

3 4

5 6

7

1. Crab Nebula

2. Snowflake

3. River delta

4. Electrodeposition - Diffusion limited

aggregation - Ions to electrode

5. Tree branches

6. Aggregation 4 - Andy Lomas

7. Audi Urban Futures Competition - Jurgen

Mayer

g r o w t h Diffusion limited aggregation is a process where particles move through space using a random walk, whereby the movement of the particle is decided by choosing a random direction and moving a short distance in that direction. When the particle moves it checks to see if any other particles have collided with it. If they have, the particles stop and clusters together to form this branching growth.

This theory was first developed by Witten + Sander in 1981 and is in many ways similar to the Lindenmayer system, which also uses recursion to produce fractal like branching forms and patterns of growth. The process is a natural phenomenon, which can be observed in snowflakes and electrodeposition and may have even played a role in the formation of planets1.

1 http://classes.yale.edu/fractals/panorama/physics/dla/dla.html

Emergence is a consolidation of a profound change in knowledge and materialisation that has made significant changes to science and technology and to the way in which we think of architecture and the way we produce it. Emergence provides an explanation of how natural systems have evolved and maintained themselves, and a set of models and processes for the design and fabrication of architectural forms that exhibit complex behaviour, and perhaps even real intelligence. Hensel, Menges + Weinstock

Code Sample:

// test if something is nextdoor if (!alone()) { stuck = true; edge[y * width + x] = true; } } } // returns true if no neighboring pixels boolean alone() { int cx = x;// get positions int lx = cx-1; int rx = cx+1; int ty = cy-1; int by = cy+1;

if (cx <= 0 || cx >= width || lx <= 0 || lx >= width || rx <= 0 || rx >= width || cy <= 0 || cy >= height || ty <= 0 || ty >= height || by <= 0 || by >= height) return true;

// pre multiply the ys cy *= width; by *= width; ty *= width; // N, W, E, S if (edge[cx + ty] || edge[lx + cy] || edge[rx + cy] || edge[cx + by]) return false; // NW, NE, SW, SE

if (edge[lx + ty] || edge[lx + by] || edge[rx + ty] || edge[rx + by]) return false;

Growth pattern over time

Fractal qualities of the growth

By adding seeds in different locations

we begin to see a system of parts

acting against each other, intersection

and forming a new more complex

system of similar components.

3

3 // PARABOL //

drawing with particles

p a r a b o l

This sketch explore the physical and visual relationship of a number of independent particles. Particles are distributed, either randomly or from a specific axis and they move freely within the bounds of the screen. A line is then drawn between particles that come within a certain distance of each other, see Figure 1 & 2. The closer particles are to each other, the darker the lines become. Throuh these series of straight lines emerges a pattern of parabolic type

Code Sample:

class Ball{ Vec3D loc = new Vec3D(0,0,0); Vec3D speed = new Vec3D (random(-1,1),random(-1,1),0); Vec3D acc = new Vec3D(); Ball(Vec3D _loc){ loc = _loc; }void run(){ mover(); bounce(); display(); lineBetween();}void mover(){ speed.addSelf(acc); speed.limit(2); loc.addSelf(speed); acc.clear();//reset acceleration}void bounce(){ if (loc.y <0) loc.y = height; if (loc.y > height) loc.y =0; if (loc.x <0) loc.x = width;

if (loc.x > width) loc.x =0;

}void display(){ pushMatrix(); noStroke(); noFill(); ellipse(loc.x,loc.y,2,2); popMatrix(); }void lineBetween(){ for (int i = 0; i < ballCollection.size(); i++){ Ball other = (Ball) ballCollection.get(i); float distance = loc.distanceTo(other.loc); if (distance <= (1/3)*distBalls){ strokeWeight(4); stroke(0,20); } else if (distance<=(2/3)*distBalls){ strokeWeight(2); stroke(150,10);} else { strokeWeight(3); stroke(255,10); line(loc.x,loc.y,other.loc.x,other.loc.y);

} } }}

Top: Tripartite of sequential images with

particles distributed randomly

Bottom: Process

Above: Sequential Images with particles

distributed from a central x-axis

Opposite: Iterations with varying minimum

distance required to draw the line and

varying time constraints

4 // SWARM //

flock / swarm behavior dissolving typologies

In his book Emergence: The Connected Lives of Ants, Cities and software Steven Johnson explores the city as a form of emergence. The city works like a pattern in time, a dynamic adaptive system based on a bottom up collective intelligence that is significantly more sophisticated than the behaviour of its parts, much like that of an ant colony or a flock of birds. For Johnson the city operates through a kind of swarm intelligence1.

'Emergence' has been a very popular term in the recent architectural discourse, but it is important to note that this idea of emergence is not limited to the current digital design trends. Ancient African settlements have been seen to have exhibited emergent properties as do the favela's of Brazil. In respect to my agent in this book, however, it will be more useful to explore its meaningfulness in response to the digital discourse of architecture.

How might we make use of digital technologies to model the city? Or to influence its evolution?

If we accept the city to be an emergent organism, then surely these digital models of emergence can be useful. Firstly it must be clear that any attempt to model a system as complex as the city will inevitably fall well short of any sort of urban reality. Nonetheless emergent models whereby there is a fundamental interrelationship between agents and an ability to respond intrinsically to environment do provide a platform whereby the city can be viewed as a more widely interconnected matrix, a web of sweeping relationships.

The use of swarm intelligence in computation has been explored in a number of different ways. Manuel

1 Steven Johnson, Emergence: The Connected Lives of Ants, Cities andSoftware, Scribner (New York), 2002.

DeLanda outlines a model of agent-based behaviour that could be developed to understand the decision-making processes within an actual city. These agents should be seen as individual agents that embody the collective intelligence of an entire society2.

Kokkugia also explore the potential of swarm intelligence, however their aim is not to simulate actual populations or their occupation of architecture, but rather to devise a flexible system embodying a collective self-organising urban intelligence: "An application of swarm logic to urbanism enablesa shift from notions of the master-plan to that of master-algorithm as an urban design tool. This shift changes the conception of urban design from a sequential set of decisions at reducing scales, to asimultaneous process in which a set of micro or local decisions interact to generate a complex urban system. Rather than designing an urban plan that meets a finite set of criteria, urban imperatives areprogrammed into a set of agents which are able to self-organise3."

Should our cities be modelled on swarm intelligence, just because the two have be seen to exhibit similar properties?

Perhaps not, but at the same time, exploring new models of organisation is a good way to further the discourse. These explorations are a way of giving some kind of meaning to the architectural process, to distance oneself from the arbitrary and to produce new, spatially interesting and diverse outcomes.

2 Leach, N. (2009), Swarm Urbanism. Archit Design, 79: 56–63. doi: 10.1002/ad.918

3 www.kokkugia.com

r e s e a r c h

1

3 4

5 6

7

2

1. Slime Mould

2. Tree - Angkow Wat Temple, Cambodia

3. Birds flocking

4. Schooling fish

5. Boston Centre for the Arts Bridge Proposal

Xefirotarch

6. Sci-arc graduate thesis - Steven Ma

7. Fibrous Tower - Kokkugia Architects

This sketch is based on a flocking algorithm, first developed in the 1980's by artificial theorist Craig Reynolds, which places a number of agents into an on-screen environment. These agents are then programmed to follow three simple rules; the maintain a certain distance from other agents in the environment; to math the velocities of other agents in their immediate neighbourhood; and finally to move towards the perceived centre of the mass of agents in its neighbourhood.1

In my sketch this can be explained as three simple functions; separate, align and cohesion. The particles leave trails so as to express their previous path and to expose a tentacle like graphic quality in the work.

1 Allen S, 1997, From Object to Field, Architectural Design, Vol 67, No 5-6, p.30

Code Sample:

void flock() { separate(separation); align(alignment); cohes(cohesion); }

void cohes(float magnitude) { Vec3D sum = new Vec3D(); int count=0; for (int i=0; i< ballCollection.size(); i++) { Ball other = (Ball) ballCollection.get(i); float distance = loc.distanceTo(other.loc); if(distance >0 && distance <20){ sum.addSelf(other.loc); // point addition of neighbours count++; } } if (count>0) { sum.scaleSelf(1.0/count); // calculate mid-point of neighbours } Vec3D steer = sum.sub(loc); // vector from current location to midpoint steer.scaleSelf(magnitude); // scale vector by magnitude acc.addSelf(steer); // add steering to acceleration }

void align (float magnitude) { Vec3D steer = new Vec3D (); int count =0; for (int i=0; i<ballCollection.size();i++) { Ball other = (Ball) ballCollection.get(i);

float distance = loc.distanceTo(other.loc); if (distance >0 && distance < 10) { steer.addSelf(other.speed); count++; } } if (count > 0) { steer.scaleSelf(1.0/count); } steer.scaleSelf(magnitude); acc.addSelf(steer); }

void separate(float magnitude) { Vec3D steer = new Vec3D(); int count =0; for (int i=0; i<ballCollection.size(); i++) { Ball other = (Ball) ballCollection.get(i); float distance = loc.distanceTo(other.loc); if (distance >0 && distance <10) { Vec3D diff = loc.sub(other.loc); diff.normalizeTo(1.0/distance); steer.addSelf(diff); count++; } } if (count>0) { steer.scaleSelf(1.0/count); } steer.scaleSelf(magnitude); acc.addSelf(steer); }

Code based on a tutorial from Jose Sanchez -http://www.plethora-project.com/2012/01/26/process-

s w a r m

Separation - 6

Cohesion - 0.2

Alignment - .4

Spawn - Randomly

along middle axis

1200 Agents

Separation - 100

Cohesion - 1

Alignment - 0.4

Spawn - Centre

1200 Agents

Separation - 100

Cohesion - 1

Alignment - 0.4

Spawn - Randomly

along middle axis

1200 Agents

Code Sample:

// ATTRACT - within Boid class void attract(){ Attractor closestAtt = new Attractor(); float mindist = Float.MAX_VALUE; for(int i = 0; i < attractors.size(); i++){ Attractor a = (Attractor) attractors.get(i); float d = PVector.dist(a.loc, this.loc); if(d<mindist){ closestAtt = a; mindist = d; } } arrive(closestAtt.loc); }

Separation - 3

Cohesion - 0.2

Alignment - 1

Field of Vision - 40

750 Agents

Code Sample:

// DISPLAY MESH void renderMesh(){ stroke(parent.c, map(neighbors.size(), 0, 5, 150, 255)); //fill(parent.c, map(neighbors.size(), 0, 5, 150, 255)); //noStroke(); for(int i = 0;i < neighbors.size(); i++){ Boid other = (Boid) neighbors.get(i); float d = PVector.dist(this.loc, other.loc); if(d<parent.clusterDistance) { line(other.loc.x, other.loc.y, other.loc.z, loc.x, loc.y, loc.z); } } }// CHECK FOR CLUSTERS void clusterCheck(){ for(int i = 0;i < parent.boids.size(); i++){ Boid other = (Boid) parent.boids.get(i); float d = PVector.dist(other.loc, loc); //println("dead fuck " + d); if((d < parent.clusterDistance)&&(d > 0)){ this.dead = true; this.vel = new PVector(0,0,0); neighbors.add(other); GLOBAL_DEAD++; } }

Separation - 3

Cohesion - 0.2

Alignment - 1

Field of Vision - 40

750 Agents

Cluster Distance - 30

Separation - 1 - 4

Cohesion - 4.5 - 1

Alignment - 3

Field of Vision - 30

750 Agents

Attractors Off

Separation - 1 - 4

Cohesion - 4.5 - 1

Alignment - 3

Field of Vision - 30

750 Agents

Attractors On

Separation - 1 - 3

Cohesion - 4 - 1

Alignment - .5

Spawn - Random

750 Agents

Attractors On

Separation - 1 - 3

Cohesion - 4 - 1

Alignment - .5

Cluster dist - 50

Spawn - Random

750 Agents

Attractors On

Separation - 1 - 3

Cohesion - 4 - 1

Alignment - .5

Cluster dist - 50

Spawn - Random

750 Agents

Attractors On

Separation - 1

Cohesion - 3

Alignment - 1.5

1500 Agents

Field of Vision - 30

Separation - 3

Cohesion - 0.2

Alignment - 1

1500 Agents

Field of Vision - 60

Separation - 6

Cohesion - 1

Alignment - 0.3

1500 Agents

Field of Vision - 60

Separation - 2

Cohesion - 0.2

Alignment - 0.3

1500 Agents

Field of Vision - 30

re-imagining flagstaff gardens

Separation - 2.5

Cohesion - 2

Alignment - 4

Cluster dist - 30

750 Agents

Attractors On

Separation - 4

Cohesion - 2

Alignment - 5

750 Agents

Attractors On

Separation - 10

Cohesion - 2

Alignment - 2

750 Agents

Attractors On

Separation - 1 - 5

Cohesion - 5

Alignment - 0.5

750 Agents

Attractors On

This is a brief visual exploration of swarm intelligence in an architectural context. I have placed a series of attractors within and directly around the site as a way of manipulating the path of the agents and establishing some kind of plan logic that has a human context. Above are a number of iterations based on manipulating the variables associated with the code. The main image on the opposite page is an overlay of a series of different iterations, as a way of achieving spatial diversity.

d i s o l v i n g t y p o l o g y

These types of emergent systems produce a new kind of logic, a logic which dissolves the traditional language of architecture. This idea has been explored by architects without the use of emergence, for example UN Studio use the diagram as a tool to free them from an architectural tradition and typology. In many ways these sketches are diagrams. Diagram of the erosion of the city into an emergent field.

Code Sample:

//check the environment around the object void checkWorld(){ //create a temp vector to keep track of the direction of the best condition PVector toBest = new PVector(); float maxV = 0; //loop through pixels for (int i = -searchRad; i<=searchRad;i++){ for (int j = -searchRad; j<=searchRad;j++){ if(!(i==0 && j==0)){ //checks for edges int x = floor(location.x)+i; x = constrain(x,0,width-1); int y = floor(location.y)+j; y = constrain(y,0,height-1);

//check to see if this is the smallest current value //scale by the distance to the value float v = world.getAt(x,y); PVector toV = new PVector(i,j)

//limit the angle of vision if(PVector.angleBetween(toV,velocity)<PI/2){ //check to see if the current value is larger than //the current best if((v)>maxV){ //reset all our variables that keep track of the best option float d = toV.mag(); toV.mult(1/d); toBest = toV; maxV = v;

Melbourne - Grid 1

Grid 1

Grid 2

Melbourne - Grid 2

Search Rad - 5

Max Speed - 3

Search Rad - 3

Max Speed - 3

Berlin - Perimeter Block

Barcelona - Roman Village

Search Rad - 5

Max Speed - 3

Barcelona - Roman Village

Search Rad - 3

Max Speed - 2

Berlin - Perimeter Block

Barcelona - Roman Village

5

1 2

3

4 5

1. BZ Reaction

2. Coral off Tukanh Besi Laman - Indonesia

3. Giant pufferfish skin pattern

4. Untitled - John Mccabe

5. Voxel - Michael Hensmeyer

6. Taichung Metropolitan Opera House - Toyo

Ito6

// REACTION //

BZ Reaction5

The Belousov-Zhabotinsky reaction is an example of a temporally oscillating chemical reaction. An unusual and interesting feature of the reaction is that as it progresses on a two dimensional plate, self-organized spirals are formed. The oscillation occurs only so long as the system is out of equilibrium and is important in chemistry because it shows that chemical reactions do not have to be dominated by equilibrium thermodynamics behaviour. Oscillating chemical reactions have been used as an explanation for the patterning apparent in animal markings, as noted by D'Arcy Thompson1. In this sketch instead of using set states, as is the norm in BZ reactions, the quantities of three chemicals is represented with floating point values, which approaches a reaction diffusion model, however the diffusion will be transferred in a traditional cellular automata manner, through the states of surrounding cells.

1 Ball, P. (2012), Pattern Formation in Nature: Physical Constraints and Self-Organising Characteristics. Archit Design, 82: 22–27. doi: 10.1002/

ad.1375

Code Sample:

// Belousov-Zhabotinsky reaction// Algorithm defined by Alasdair Turner// http://discovery.ucl.ac.uk/17241/1/17241.pdf

void draw (){ for (int x = 0; x < width ; x ++) { for (int y = 0; y < height ; y ++) { float c_a = 0.0; float c_b = 0.0; float c_c = 0.0;// the amount of A, B and C is averaged for each cell and its neighbours before the reaction // equations above are applied (cellular automata) c_a /= 9.0; c_b /= 9.0; c_c /= 9.0; //reaction equations // A + B = 2A - creation of A is autocatalyzed intil B expires // B + C = 2B - B can be created but only with a quantity of C // C + A = 2C - C can be created but only with a quantity of A //Constrain values to the range 0 to 1 for HUE color display a[x ][ y ][ q] = constrain ( c_a + c_a * (rateA*c_b - rateC*c_c ), 0, 1); b[x ][ y ][ q] = constrain ( c_b + c_b * (rateB*c_c - rateA*c_a ), 0, 1); c[x ][ y ][ q] = constrain ( c_c + c_c * (rateC*c_a - rateB*c_b ), 0, 1); set (x, y, color (.5, 0.9, a[x ][ y ][ q ])); } } if (p == 0) { p = 1; q = 0; } else { p = 0; q = 1;

r e a c t i o n

Top: Tripartite of sequential reaction

images

Bottom: Tripartite of sequential reaction

images with the rate of reaction sped up

rateA = 0.7

rateB = 1

rateC = 1

rateA = 0.7

rateB = 0.7

rateC = 1

rateA = 1.5

rateB = 1

rateC = 0.5

rateA = 1.5

rateB = 1

rateC = 0.5

rateA = 1.5

rateB = 0.75

rateC = 1

rateA = 0.5

rateB = 0.5

rateC = 0.5

rateA = 1

rateB = 1

rateC = 1

rateA = 0.6

rateB = 1

rateC = 1

Elevations of model from Amira.

I exported a RAW data file from processing and created an IsoSurface in Amira, however the results were not as I expected. The surface

should be fluid, like the reaction, however Amira has connected the points with lines and while it produces some interesting graphic results

I will need to refine this further in order to achieve right results

Elevations of model from Amira.