Portfolio_DesignComputation

zhiping liu’s portfolio 2012

design / computation- swarm urbanism

- context-aware revitalization

- design computation studies

- chronology

SWARM URBANISMUtilizing the Central Place Theory as a logic framework within which the multi-layered networks self organize based on local rules & information exchanges and calculations.Each individual place attracts certain urban activities which are simulated by multi-layered agents’ movements which together form into swarm behaviors in a 2D urban context.

Meanwhile, those swarm behaviors trigger the possibility of growth based on the procise calculation of popolarities to agents and densities of places.The dynamic distribution of the multi-layered networks reflects the local logic of how the city of Hong Kong has grown.

“community design”

from the Planning Review by Hong Kong Planning Department

previous master plans:

Rules

(variables)ProposalsSoftwareAssemblage of

“interests”

Swarm TheoryMulti-agent System

Central Place Theory

Logic

TechnologyDistributions of Planning Programs

- Low-order network (Residential, Schools, restaurant...)

Distribution of density

Road system

Land reclaimation

Re-proposal for existing

...

?

?Designer /planner

Rules (variables)

Empty old Kaitak Airport and surrounding communities

low-income neighborhoods

Industry neighborhoods

transportation system

open spaces

school system

traditional streets, sights

waterfront facilities

land reclamation

view to Victoria Bay

a generative system

- agency - high-order urban activity- low-order activity

- high-order urban spot- low-order spot

- two layers network inspired from “Central Place Theory”

- make a decision to grow or not (based on the calculations of the activities it has attracted in a certain period)

- two sub-classes of agents

- be attracted by differentiated spots and swarm movement (seperate, align, steer...)

- grow (or not) add (or not to add) a new same type of spot in a certan range nearby

- behaviors

- structure

- density control find the properate density of the area where the potential new spot could be added effective factors: - number of same sub-class agents around - number of different sub-class agents around - sensitivity to the existing density - threshold - orientation to south

*the program will select a random location for the potential growth, but it still need a "density control" step to make it happen or not to.

the new spot(low-level) will probably be generated within this threshhold

the new spot(high-level) will probablybe generated within this threshhold

*the "density control" step will generate a "minimum distance" between other same level spotsfor the potential spot

this existing spotis too close to thepotential location

there is no same levelspot too close to

the potential location

1. 161. 15

1. 11 1. 131. 12 1. 14

1

2

35

4

7

10

11

96

812

3

24

1

there are more(12) same level spotswithin certain range,*the smaller minimun distancebetween them for the potential spot,**the higher density this area will be.***

there are less(4) same level spotswithin certain range,*the bigger minimun distancebetween them for the potential spot,**the lower density this area will be.***

*70 pixels for low-level spots; 150 pixels for high-level spots (program setting)

**if the random location find another same level spot in the range,there will not be new spot.

***through this "density control" step, the growth responds tothe dynamic context; the level of the sensitivity could be adjustedbased on local information.

note: low-level growth uses same logic but different setting for the sensitivity to context

new spot (high-level)


existing spot (high-level)


process every feedback loop (iteration):

*the program will select a random location for the potential growth, but it still need a "density control" step to make it happen or not to.

the new spot(low-level) will probably be generated within this threshhold

the new spot(high-level) will probablybe generated within this threshhold

*the "density control" step will generate a "minimum distance" between other same level spotsfor the potential spot

this existing spotis too close to thepotential location

there is no same levelspot too close to

the potential location

low-level connection

high-level connection

attraction from closest high-level spot(more sensitivity to high-level agent)

attraction from closest low-level spot(less sensitivity to high-level agent)

attraction from closest low-level spot(more sensitivity to low-level agent)

attraction from closest high-level spot(less sensitivity to high-level agent)

high-level agent(attracted by spots)

low-level agent(attracted by spots)

low-level spot

high-level spot

Low-level spots calculatethe frequency of attracted agentsto get the "popularity" of this spot.

*Each low-level spot calculate how many agents(high-level & low-level) have been attracted by it.

more agents attracted by the spot,more popular the spot is

*This spot has attracted more enoughagents to trigger the emergence of new spot around it.









low-level spot

high-level spot













low-level spot

high-level spot





growth through iterations

* still images from the animation generated by Processing

agents’ behaviors triggering the growth growing

note: part of code in this script is developed contributed by Roland Snooks (seperate, align, cohere within swarm of agents)

low-order network growth + =high-order network growth combined growth

multi-layered growth

saturated condition

high-order network growth combined growth

low-order network growth

massing study

programming

Within the two layers (orders) of network,this program defines every spots into specificcategories: (low-order): - residential - retail (high-order) - commercial - hotel - office building

The “rules” came from the mapping of Hong Kong. For example: the school should be close to where the density of the residential is high; the office should be found where high-order spots dense in themselves; the hotel should be built in the area with high density and the view of the sea.

The result directly came from the software scripted in Processing. Interestingly, one can find that some of residential spots have been distributed close to the sea and some inside of the land which accident-ly match the “rule” of how high-profile residential and affordable residential have been distributed in Hong Kong.

scho

ols

resid

entia

l

com

mer

cial

hote

ls

mapping variables & rules in Processing calculations in Processing

- hotels:

- schools:

- more ...

CONTEXT-AWARE REVITALIZATION Thesis project at USC M.Arch Postporfessional Program 2009This project uses Swarm Urbanism methodology and parametric tools to research/design in an urban context. In temporary cities, the multi-layered networks provide the dynamic armature of urban activities, which simultaneously create the dynamic networks through self-organization based on certain logic and local feedback. At a variety of scales, the self-organizing system of urban behaviors relates to transitions of program and spatial distributions.

BibliographyCity theories

Kevin Lynch, a Theory of Good City Form, 1981;Christopher Alexander, a Pattern Language: Towns, Buildings, Construction, 1977;

City & Urbanism theoriesJohn Kaliski, “the Present City and the Practice of City Design”, 1999; Everyday Urbanism, 1999

The present city must be defined as a place of continuous creation. City design as situational architecture acknowledges that each person and entity is constructing space and place with acts of daily life. The sum of daily transactions is recognized as an evolving material story to which both city designer and dweller must both contribute. … The hidden, ordinary stories of the city are to be rendered more intense and “more visible” by the city designer, who seeks ultimately to weave individual and group narratives together into an “arrangment” negotiated among all interested parties.

David Grahame Shane, Recombinant Urbanism, Wiley Academy, 2005Conceptual modeling since Lynch: such as actor-designers, who look for repetitive patterns and self-organizing systems of relationships in urban processes at a variety of scales. Through positive feedback, actors amplify these new patterns into structures of relationships that support new built forms and spatial distributions of forms.

Mario Gandelsonas, Architecture and the American City, 1999He charts the transformation of the modern, American, monofunctional, residential, postwar suburb into a new form of muiti-functional “suburban city.” What forms is an “X-urban” city – an “out-of-the-city city” – not only along the car-based periphery but also at the old city-core. This core “becomes one more semiautonomous urban ‘village’” in the metropolitan constellation of X-urban centers; that is , the core of the American city disappears as an exclusively business-and-industrial district and reappears as a mixed residential, shopping, and entertainment area (still including some business), all uses also found on the periphery.

Precedents: Cooper and Eckstut: Battery Park City Master Plan, 1979; 42nd Street Special District. The Seven “-ages” of Postmodernism (introduced by David Grahame Shane, Recombi-nant urbanism)

1, Decoupage (Rossi and “analogical city” design)2, Collage City (plus Contexualism and Rationalism)3, Bricolage4, Photomontage5, Montage6, Assemblage7, Rhizomic assemblage (Deleuze and Guattari)

David Grahame Shane, Recombinant Urbanism, 2005Its function is to help maintain the city’s stability as a self-organizing system. In a linear, logical, scientific urban system it helps maintain the dynamic overall balance between the binary poles that define that system (e.g., production and consumption) by handling exceptions; in nonlinear systems, it facilitates dynamic imbalance and rapid shifts between urban paradigms. With Hindsight, we can see the post-structuralists and Deconstructivists were right to describe the city as a chaotic situation of competing systems. We can also see that this chaotic situation has an emergent logic of its own, produced noncentrally by actors designing systems across vast territories without regard for each other’s decision, each adding their own system as a new layer to existing topography, historic structures, and landscapes.

Michael Batty, Cities and Complexity: Understanding Cities with Cellular Automata, Agent-Based Models, and Fractals, the MIT Press, 2005

He argues that bottom-up processes - in which the outcomes are always uncertain -- can combine with new forms of geometry associated with fractal patterns and chaotic dynamics to provide theories that are applicable to highly complex systems such as cities. Batty begins with models based on cellular automata (CA), simulating urban dynamics through the local lactions of automata. He then introduces agent-based models (ABM), in which agents are mobile and move between locations. These models relate to many scales, from the scale of the street to patterns and structure at the scale of the urban region. Finally, Batty develops applications of all these models to specific urban situations, discussing concepts of criticality, threshold, surprise, novelty, and phase transition in the context of spatial developments.

Parametric Architectural DesignBranko Kolarevic, Architecture in the Digital Age: Design and Manufacturing, Taylor & Francis, 2003Michael Meredith, From Control to Design–Parametric/Algorithmic Architecture, Actar, 2008

Architecture requires social engagement; it requires cultural/social relevance. It is not the para-metric, the relentlessness malleability of form, nor is it complexity for its own sake, but rather a complex of complex relationships that produce architecture.The operational paradigm we’re interested in is akin to Pierre Bourdieau’s “field of cultural production,” where form is the playing field within competing vectors within a larger cultural field of forces.

Swarm UrbanismGilles Deleuze and Felix Guattari, a Thousand Plateaus: Capitalism and Schizophrenia, University of Minnesota Press, 1987Steven Johnson, Emergence: The Connected Lives of Ants, Brains, Cities, and Software, Scribner, 2002Manuel DelandaRoland Snook/KokkugiaWalter Christaller, Central Place Theory

Multi-Agent Parametric Technologya, an analysis toolb, a generate toolc, a design tool

Terms:

Basic IdeaThis project uses swarm urbanism methodology and parametric tools to research/design in an urban context. In temporary cities, the multi-layered networks provide the dynamic armature of urban activities, which simultaneously create the dynamic networks through self-organization based on certain logic and local feedback. At a variety of scales, the self-organizing system of urban behaviors relates to transitions of forms and spatial distributions.

Swarm Urbanism“Swarm urbanism” is the notion that, within the city it addresses the role of self-conscious operations which follow the logic of “swarm intelligence”. It takes further of the logic of the city itself as a space of flows and relationships, which produce a dynamic stable entity through incorporations that remain open to further influence by other external forces.

Multi-Agents Parametric MethodologyBy setting simple rules of agents, software programs could be good at simulating the increasingly complex multi-agents behaviors between them and responses to inputs and impulses, as a self-regu-lating system.

Downtown LAAt a macro level, LA is the extreme example in the discourses of urban planning and urban design. However, this research/design explores a way to use certain parametric technique to design buildings in a particular urban context at a micro level. Downtown LA is experiencing its revitalization process after decades of suburbanization. The residents population increased 36.9 from 2006 to 2008, 14,561 residents units have been created under the adaptive reuse ordinance, more business stores and public projects open and a growing transit network creates it more accessible. This project is not to simulate actual populations of people and buildings, but to explore operations that involve autonomous design agents which are capable of self-organizing into emergent forms.

Design/reseach Process

Context & Rules Analysis Urban Programming Massing Study

Scripted in Processing...

class kAttractor {

// states kVec pos; float magnatude, range; int fillcolor, typeId;

kAttractor(kVec _pos, float _range, float _magnatude, int _fillcolor, int _typeId) { pos = _pos; magnatude = _magnatude; range = _range; typeId = _typeId; }

// methods void update(kWorld world) { connectAtt(world.attractors); }

void connectAtt(AttayList attractors) { int count = 0; for (int i = 0; i < attractors.size(); i++) { kAttractor att = (kAttractor)attractors.get(i); kVec attPosition = kVec.clone(att.pos); float attDist = attPosition.distance(pos); int fillcolor = int(att.typeId); if ((attDist < 100) && (attDist > 20) && (abs(att.pos.x - pos.x) > 3) &&(abs(att.pos.z-pos.z) > 3)) { count++; //move pos.y = pos.y - 0.005*count; pos.x = pos.x + 0.001*(att.pos.x - pos.x); pos.z = pos.z + 0.001*(att.pos.z - pos.z); //link if ((attDist < 50) && (attDist > 20)){ kLine ln = new kLine(pos.x, pos.y, pos.z, att.pos.x, att.pos.y, att.pos.z); ln10.setColor(fillcolor*20); } } } kLine ln11 = new kLine(pos.x, pos.y, pos.z, pos.x, pos.y - count*10, pos.z); ln11.setColor(count*10, count*10, count*10); space.append(ln11); } void gather(ArrayList attractors) ...}

program distributionsite programing Survey FAR based on density


generative process the activities 3 classes of agents attracted by 3 types of function spots trigers the growth


design intention design computation


Scripted in RhinoSub Main() Dim contextPts, programPts, rninLength, maxlength, i, ptPos, count Dim arrCPts() arrPPts() Dim springData(), springData(), springDataP(), springC(), springP() minLength = 10 maxLength = 200 count = 0 ‘ contextPts contextPts = Rhino.GetObjects(“select the context points”, 1) For i = 0 To UBound(contextPts) ptPos = Rhino.PointCoordinates(contextPts(i)) ReDim Preserve arrCPts(i) arrCPts(i) = ptPos Next ‘ programPts programPts = Rhino.GetObjects(“select the program points”, 1) For i = 0 To UBound(programPts) ptPos = Rhino.PointCoordinates(programPts(i)) ReDim Preserve arrPPts(i) arrPPts(i) = ptPos Next ‘ add springC and springP springData = addSprings(springC, springP, arrPPts, arrCPts, minLength, maxLength) springDataC = springData(0) springDataP = springData(1) ‘ agents Dim startAgents, iterations, pos, endPt, vel, marvel, maxForce, arrAgents() ‘()-DYNAMIC Dim arrAgentPos(), ptCloud ‘ user input - start vectors of the agents startAgents = Rhino.GetObjects(“select the starting agent vectors”, 4) iterations = Rhino.GetInteger(“how many steps/iterations”, 200) marvel = 10 maxForce = 2 For i = 0 To UBound(startAgents) pos = Rhino.CurveStartPoint(startAgents(i)) endPt = Rhino.CurveEndPoint(startAgents(i)) vet = Rhino.VectorCreate(endPt, pos) ReDim Preserve arrAgents(i) ‘ Preserve NOT TO Erase arrAgents(i) = Array(pos, vel, maxVel, maxForce) Next For i = 0 To iterations-1 Dim acc, vecAli, vecSep, vecCoh, vecAttC, vecAttP, j, springParam, srfCrv For j = 0 To UBound(arrAgents) Dim k ‘ reset acc to 0 ‘ IN EACH STEP acc = Array(0,0,0) ‘ call the behavior functions - align etc vecAli = align(arrAgents(j), arrAgents, 10) vecSep = separate(arrAgents(j), arrAgents, 10) vecCoh = cohesion(arrAgents(j), arrAgents, 20) vecAttC = attSpringC(arrAgents(j), springC; 50) vecAttP = attSpringP(arrAgents(j), springP, 50) ‘ weight - priority verAli = Rhino.VectorScale(vecAli, 5) vecSep = Rhino.VectorScale(vecSep, 1) vecCoh = Rhino.VectorScale(vecCoh, 1) verAttC = Rhino.VectorScale(vecAttC, -1) vecAttP = Rhino.VectorScale(vecAttP, -1)

acc = Rhino.VectorAdd(acc, VecAttP) ‘ add acc to vel vet = Rhino.VectorAdd(arrAgents(j)(1), acc) ‘ limit vet to marvel vet = vectorLimit(vel,arrAgents(j)(2)) ‘ update the array arrAgents(j)(0) = Rhino.VectorAdd(arrAgents(j)(0), vet) ‘ MOVE arrAgents(j)(0) = vet ‘ NEW VEL Next

count = count + 1 For j = 0 To UBound(arrAgents) ReDim Preserve arrAgentPos(j) arrAgentPos(j) = arrAgents(j)(0) Next Rhino.EnableRedraw False

‘ update the point cloud ptCloud = Rhino.AddPointCoud(arrAgentPos)

Rhino.EnableRedraw True ‘ change springC, springP For j = 0 To UBound(springC) Dim spLine, newSpline, p0, p1, pm, distS, newDistS, distToAgent, accSpring Dim ratial, force0, force1, forceSum Dim initialLength spLine = springDataC(j)(0) pol = Rhino.curveStartPoint(startAgents(i)) endPt = Rhino.CurveEndPoint(startAgents(i)) vel = Rhino.VectorCreate(endPt, pos) ReDim Preserve arrAgents(i) arrAgents(i) = Array(pos, vel, maxVel, maxForce)

p0 = Rhino.CurveStartPoint(spLine) p1 = Rhin0.CurveEndpoint(spLine) pm = Rhino.CurveMidPoint(spLine)

For k = 0 To UBound(arrAgents) ‘ if agent within range(such as length) distToAgent = Rhino.Distance(pm, arrAgents(k)(0)) If distToAgent < distS/2 Then force1 = force1 + 0.1 End If Next Next

‘ compare the lengths with initials (got upper lines) initialLength = springC(j)(1) racial = distS/initialLength

‘ ‘ get the acc (within 1/3 to 3 times) If racial > 1 And racial < 3 Then force0 = -0.1*(ratial-1) End If If racial < 1 And racial > 0.3333 Then forced = 0.1*(1/ratial-1) End If ‘ ‘ sum aces together forceSum = force0 + force1 ‘ loop through all springP (Let programPoint End of the springC move With springP)

End Function

...

Function addSprings(springC, springP, arrPPts, arrCPts, minLength, maxLength)

Dim IineC,lineP, lengthC, lengthP pos, contextPos, contextDist, closestDist, closest- CPt, closestPPt, i, j, k, count Dim springs() ‘count = 0 For i = 0 To UBound(arrPPts) ‘connect with contextPts closestCPt = Rhino.PointArrayClosestPoint(arrCPts, arrPPts(i)) contextDist = Rhino.Distance(arrPPts(i), arrCPts(closestCPt)) lineC = Rhino.AddLine(arrPPts(i), arrCPts(closestCPt)) ‘ connect With programPts Dim pPtDist closestDist = 999999 For j = 0 To UBound(arrPPts) pPtDist = Rhino.Distance(arrPPts(j), arrPPts(i)) If pPtDist < closestDist And pPtDist > 0.01 Then closestDist = pPtDist closestPPt = j End If Next lineP = Rhino.AddLine(arrPPts(i), arrPPts(closestPPt)) ‘ add lineC And lineP into array of spring lengthC = contextDist lengthP = closestDist ReDim Preserve springC(i) ReDim Preserve springP(i) springC(i) = Array(lineC, lengthC, minLength, maxLength) springP(i) = Array(lineP, lengthlP, minLength, maxLength) ReDim Preserve springs(i) springs(i) = Array(springC(i), springP(i)) Next addsprings = springsEnd Function

Function addSpringC(arrPPts, arrCPts, minLength, rnaxLength) Dim lineC, lineP, lengthC, lengthP, pos, contextPos, contextDist, closestDist, closestCPt, clos-estPPt, i, j, k, count Dim spC() For i = 0 To UBound(arrPPts) ‘connect with contextPts closestCPt = Rhino.PointArrayClosestPoint(arrCPts, arrPPts(i) contextDist = RhinoxDistance(arrPPts(i), arrCPts(closestCPt)) lineC = Rhino.AddLine(arrPPts(i), arrCPts(closestCPt)) lengths = contextDist ReDim Preserve spC(i) spc(i) = Array(lineC, lengthC) Next addSpringC = spCEnd Function

Function addSpringP(arrPPts, arrCPts, minLength, maxLength) Dim lineC, lineP, lengthC, lengthP, pos, contextPos, contextDist, closestDist, closestCPt, closestPPt, i, j, k, count Dim spP() For i = 0 To UBound(arrPPts) Dim pPtDist closestDist = 999999 For j = 0 To UBound(arrPPts) pPtDist = Rhino.Distance(arrPPts(j), arrPPts(i)) If pPtDist < closestDist And pPtDist > 0.01 Then closestDist = pPtDist closestPPt = j End If Next lineP = Rhino.AddLine(arrPPts(i), arrPPts(closestPPt)) lengthP = closestDist ReDim Preserve spP(i) spP(i) = Array(lineP, lengthP) Next addSpringP = spP()End Function

Function movePts(agent, springData) ‘ move, length, delete Dim i, sumVec sumVec = Array(0,0,0) count = 0 For i = 0 To UBound(springData) Next movePts = sumVecEnd Function

Function attSpringC(agent, springC, rangeOfVis) Dim j, closestPt, dist, sumVec, count, line, vec sumVec = Array(0,0,0)

count = 0 For j = 0 To UBound(springC) line = springC(j)(0) closestPt = Rhino.CurveClosestPoint(line, agent(0)) closestPt = Rhino.EvaluateCurve(line, closestPt) disk = Rhino.Distance(agent(0),closestPt) If disk < rangeOfVis And dist > 0 Then vec = Rhino.VectorCreate(agent(0), closestPt) vec = Rhino.VectorScale(vec, l/dist) sumVec = Rhino.VectorAdd(sumVec,vec) count = count + 1 End If Next If count > 0 Then sumVec = Rhino.vectorDivide(sumVec, count) End If attSpringC = sumVecEnd Function

Function attSpringP(agent, springP, rangeOfVis) Dim j, closestPt, dist, sumVec, count, line, vec sumVec = Array(0,0,0) count = 0 For j = 0 To UBound(springP) line = springP(j)(0) closestPt = Rhino.CurveClosestPoint(line, agent(0)) closestPt = Rhino.EvaluateCurve(line, closestPt) dist = Rhino.Distance(agent(0), closestPt) If disk < rangeOfVis And dist > 0 Then vec = Rhino.VectorCreate(agent(0), closestPt) vec = Rhino.VectorScale(vec, l/dist) sumVec = Rhino.VectorAdd(sumVec, vec) count = count + 1 End If Next If count > 0 Then sumVec = Rhino.VectorDivide(sumVec, count) End IfEnd Function

Function vectorLimit(vec, maxLength) Dim vecLength vecLength = Rhino.vectorLength(vec) If veclLength > maxLength Then ‘ unitize vec = Rhino.VectorUnitize(vec) ‘ scale by maxLength vec = Rhino.VectorScale(vec, maxLength) End If vectorLimit = vec ‘ RETURN THE FUNCTIONEnd Function

Function align(agent, arrAgents, rangeOfVis) Dim j, dist, sumVec, count sumVec = Array(0,0,0) count = 0 For j = 0 To UBound(arrAgents) dist = Rhino.Distance(agent(0), arrAgents(j)(0)) If disk < rangeOfVis And disk > 0 Then sumVec = Rhino.VectorAdd(sumVec, arrAgents(j)(1)) count = count + 1 End If Next ‘ devide sumVec by the number of vectors in the rangeOfVis If count > 0 Then sumVec = Rhino.VectorDivide(sumVec, count) End If ‘ RETURN TO align SCALED align = sumVecEnd Function

Function separate(agent, arrAgents, rangeOfVis) Dim sumVec, count, vec, dist, j ‘ defining a blank vector summer = Array(0,0,0) count = 0 ‘ loop through all the agents For j = 0 To UBound(arrAgents) ‘ get the distance - if less rangeOfVis dist = Rhino.Distance(agent(0), arrAgents(j)(0)) If disk < rangeOfVis And disk > 0 Then ‘ get a vector from the other agent To the current agent - sum vec = Rhino.VecorCreate(agent(0), arrAgents(j)(0)) vec = Rhino.VectorScale(vec, l/dist) sumVec = Rhino.VectorAdd(sumVec, vec) count = count + 1 End If NextEnd Function

Function cohesion(agent, arrAgents, rangeOfVis) Dim sumVec, count, j, dist summer = Array(0,0,0) count = 0 ‘ loop through all the agents For j = 0 To UBound(arrAgents) ‘get the distance to each agent dist = Rhino. Distance(agent(0), arrAgents(j)(0)) ‘if distance is within the rangeOfVision If dist < rangeOfVis And dist > 0 Then ‘ sum positions sumVec = Rhino.VectorAdd(sumVec, arrAgents(j)(0)) count = count + 1 End If Next ‘ divide sum pos by count If count > 0 Then sumVec = Rhino.VectorDivide(sumVec, count) ‘ create a vector from the agent to the average position sumVec = Rhino.VectorCreate(sumVec, agent(0)) ‘ limit by maxForce sumVec = vectorLimit(sumVec, agent(3)) End If ‘ return cohesion = sumVecEnd Function



massing | skin | structure study

external structure

floors connections

skin skin subdivisions


ROAD SELF-ORGANIZATION STUDYIf we assume that a road system can be purely result of self-organized individual paths, what is the rules behind that process? The later raised question would be: what is the intelligence of a road system which needed to be explored. This study utilizes the multi-agent system to mimic the process that individual paths try to interact with its neighbors. From the initial disordered condi-tion, each segment try to find proper neighbors to join and align.

One of the essential techniques in this study is to use two (could be more) agents in the shell of one agent as that a segment has two vertexs a and b which behave individually.

Beginning with been randomly distributed on a flat site, the path segments are gathering and aligning with selected neighbors and forming possibilities of a connected road pattern.

animation can be found in the submitted vedio, or visit Youtube at:

http://youtu.be/TFg1WlsXXasmobile QR-Code link:

a

b

the closest midpoint from point a

the closest midpoint from point b

segment

a

b

enlarged part from move-1

move back towardthe another end

find the closest midpoint from a

point a moves toward that midpoint

get the distance from a to its own midpoint

compare the distance with its original length/2

move to its own midpoint by the difference

find the closest midpoint from b

point b moves toward that midpoint

get the distance from b to its own midpoint

compare the distance with its original length/2

move to its own midpoint by the difference

"gathering" module

"keeping the length"

module

point a point b

one loop

2 vertexs do 2 things to in each step:

Key scripts:“gathering” function:

“seperating” function:

PHEROMONE TRACK SYSTEM STUDY“Ants” moves by exchanging the pheromone signals. This program allows the agent to move by following two simple rules: try to move to the nearby point which has strongest pheromone left by others; try to move along the paths on the map. The pheromone signals left on the trails keeps fading through time.


http://youtu.be/ZhGFPw1S1vAmobile QR-Code link:

3 behaviors in each step:

Possible distributions over a map with existing roads:

Key script: agent generate pheromone signals and moves by doing 3 calculations in each step

3 functions: following the pheromone signals, following the road and keeping distance from each other

PHEROMONE SYSTEM IN 3DThis study only allows “agents” behave by following 2 sumple rules:1, to follow the trails left by others;2, to keep certain distance from others.

The processing scripts could be used as a general library for later studies by adding more rules/behaviors such as been attracted by attracotes, avoiding the obstacles etc.


http://youtu.be/uD18dV6QLd0mobile QR-Code link:

SPRING SYSTEM STUDY (2D)Spring has been used for structural and architectural studies for a long time. This study is inter-ested in using springs to optimize a spacial distribution. All the spots keeps searching for 4 closest neighbors (spots & anchors) and connect them with springs which push or pull those spots. Different than fixed spring-connected structure, this program allows the spots to change its con-nected neighbors by calculating their distance.


http://youtu.be/cxtoNuasVmAmobile QR-Code link:

finding potential neighborsin 2 categories

find the 4 closest "spots" find the 4 closest "anchors"

sort those 8 closest neighbors to find the 4 closest ones

connect those 8 closest neighbors with springs

moved by the force from those springs

one loopsorting distances to find neighbors

spring behaviors

Each agent (nod) does 3 calculations in each step:Key script - calculations and behaviors in each step:

- sorting

- spring behavior

Screen shots:

SPRING SYSTEM (3D)Spring has been used for structural and archi-tectural studies for a long time. This study is interested in using springs to optimize a spacial distribution. All the spots keeps searching for 4 closest neighbors (spots & anchors) and con-nect them with springs which push or pull those spots.

Different than fixed spring-connected structure, this program allows the spots to change its con-nected neighbors by calculating their distance.

Screen shots of the structure at 3 different overal “initial” spring length:

By real-time changing the “initial” length of springs, the structure trys to re-organize and reach dynamic and “balanced” conditions. This feature allows the designer to have more control on this “self-organized” system.

Spring function scripted in Processing:

Program interface:


http://youtu.be/boujkPUDIwcmobile QR-Code link:

Shading Structure DesignKing Abdullah Civic Center, Saudi Arabia

CHRONOLOGY

2010 - present Ai Architecture, Boston

2008 - 2009 USC, Los Angeles

2004 - 2007 ECADI, Shanghai

1999 - 2014 SEU, Nanjing

Raycom (Lenovo) Songzhuang community, Beijing, ChinaDesigner: Beni Arabi, Gary Anderson, Kevin MacNeill

Studio: Studies in Advanced Surface TectonicsTutor: John Enright

East Shanghai MosqueShanghai, ChinaCollaborator: Xiaoai Wang

Studio: University MuseumTutor: Ziyu Tong

Studio: Nanjing Civil CenterWinner, 2002 Jinyi National Student Architectural Design WorkTutor: Ming Ge

Shimao Sheshan Water ParkShanghai, China

China Defence University Beijing, ChinaCollaborator: Xiaoan Wang

Studio: Swarm UrbanismTutor: Neil Leach, Roland SnooksCollaborator: Yue Yang

Studio: Context-aware RevitalizationTutor: Alice Kimm

King Abdullah Civic CenterSoudi ArabiaDesigner: Beni Arabi, Gary Anderson, Kevin MacNeill, Shusak Janpathompong

BCLG Fangshan community clubhouseBeijing, ChinaDesigner: Beni Arabi, Gary Anderson

Documents

Portfolio_DesignComputation