Scripted drawings and urban design
Daniel Richards
This section uses algorithmic design processes to explore the organization of urban form. It describes an approach to the design of urban systems and speculates upon ways in which a data-driven design process can be established through the construction of custom scripted design tools. This section is split into three elements which each expand upon the idea of growing urban form from algorithmic processes which respond to various contextual and legislative stimuli.
This case study follows the development of a proposal for Beswick in East Manchester in which emergent architectural and urban traits have evolved in response to existing site conditions and the East Manchester local development plan.
Decentralized networks
The example opposite illustrates how urban infrastructure can be defined using a collection of nodes as design generators and allow local interventions to establish a global network. This network is defined using decentralized control; this means that each node is responsible for creating a piece of surrounding infrastructure based on site-specific (local) relationships which contribute towards a collective (global) network.
The intention of this case study is not to provide software-specific guidance as to how to write a script, but rather to illustrate the generic steps used to create each script. The 12 diagrams (below right) read horizontally as three iterations of the same process to illustrate how the script can apply differently to various situations.
The script comprises several parts:
1 A population of nodes is created whose positions will define the resulting network.
2 All nodes are collected into an array, allowing them to be accessed via a loop function.
3 A first loop is created which subjects each node to the following operations:
4 All other nodes within X distance of the selected node are defined as immediate neighbors and are added to a second array.
5 Vectors are projected between the selected nodes and immediate neighbors and the mid-point coordinates are stored.
6 The mid-point coordinates are sorted by their angle around the selected node and a spline is drawn connecting the sorted mid-points.
The infrastructure that emerges becomes an interference pattern of the initial node positions, thus creating an infrastructure that has grown out of a simple construction algorithm and the local relationships between the nodes. In addition to this example, Voronoi diagrams can also be used to construct optimum networks between a set of points and have been used extensively in urban planning establish zoning and catchment areas.
Network growth through a simulated landscape.
Below are 12 emergent urban networks which are defined by their associated parametric equations that have been, in turn, used to distribute the control nodes. The urban networks all exhibit emergent traits: village greens are created when nodes are arranged in a circular formation [3]; large inner ring roads form in radial networks [4] and suburban areas with decreasing density can been seen on the fringes of most networks. Importantly, complexity has not been given to these networks; their complexity has developed as an emergent property of local interventions.
The script that was used to create the urban networks can also be extended to construct three-dimensional structures. The example below shows a similar process in which a population of nodes create three-dimensional surfaces between neighboring nodes. In the example a secondary script has then been applied to subdivide the surfaces and construct curved elements.
The process of decentralizing the design processes allows for the creation of multiple scripts that can be run sequentially to produce paradoxically controllable, “out of control” structures.
Growing networks
The previous explorations illustrated how algorithmic design can benefit from embracing decentralized control. This example will follow the creation of a script which can grow road networks through a simulated urban landscape.
Network patterns and associated parametric equations.
In 1970, John Conway devised a zero-player game called the “Game of Life”—a mathematical “game” that simulates colonies that grow and perish over time. The game consists of a two-dimensional grid that defines a series of cells. The cells can exist in one of two states: alive or dead and each cells state is defined by its relationship to its neighboring cells. The game then works by iterating very simple rules in which each cell must evaluate its neighboring cells and define the current state. Over generations, the game is able to simulate organic behavior. Conway’s “Game of Life” is the most well known example of a computational technique called cellular automata.
The script used to grow networks requires two elements. First, a landscape must be established and second, a generator for growth must be designed. The landscape becomes defined as a grid of cells (as Conway’s model), providing a space in which networks will be grown and also a mechanism by which cells can communicate using decentralized controls. The generator for growth will be based on the biological phenomenon “Phototropism” which is the tendency for plants to grow towards sources of light. The aim of this script is to establish a cell as the goal point (light source) and a process by which suitable transport routes can be grown through the pixelated landscape to provide a network link.
The script comprises several parts (as shown in the diagram below). Each cell can exist in one of two states: open space or existing building.
1 Each cell has the capacity to communicate with its immediate neighbors only.
2 A target cell is identified.
3 Using an iterative function each cell connects to the neighboring cell closest to the target cell until the target is reached.
4 Cells which are defined as existing buildings form obstacles. Subsequently the next shortest route may need to be taken causing a detour.
5 Cells connections to neighboring cells may not always form a connecting link on first trial. On such an occurrence the network reaches a dead end surrounded by existing buildings.
6 As cells connect to neighboring cells they drop “digital breadcrumbs” that can be retraced upon meeting a dead end. These “breadcrumbs” are stored within a small memory bank within each cell that has been created by assigning each cell a custom attribute.
7 Agents are now able to find their way out of dead ends and dead ends are then filled in to prevent future networks making the same mistake.
The network growth script works by growing connecting networks between assigned target cells and starting cells. The script provides connectivity through any landscape where connection is possible.
The example, below left, illustrates a network being grown through a randomly generated landscape whereby each cell on the top and left sides of the grid are connected to a target cell in the bottom left corner.
The network script can also be formatted to operate within a three-dimensional landscape. The example, below right, shows the emergent network of routes through a three-dimensional maze. The physical model has been printed in gypsum powder using a Zcorp 3D printer.
The resultant networks are highly rational and theoretically predictable. However, the sheer magnitude of calculations required to manually compute these networks make it implausible to complete without the use of computation.
The process of writing scripts to generate form is not difficult. However, for scripted methodologies to become “useful” it is important to develop methods by which resultant forms can be processed and evaluated.
The example, below, shows how the networks grown using the previous script can be subjected to evolutionary pressures using a genetic algorithm to simulate Darwinian natural selection and thus breed fitter urban networks.
The network landscape has been created as a grid where each cell is either open space or existing building, therefore the landscape can be reformatted and stored as binary code with 1 referring to existing building and 0 representing open space. This process requires a function which can examine any landscape and print the landscape’s genetic code to a .txt file which can be used later to upload landscapes and thus associated network phenotypes from binary.
Once the landscapes and thus resulting networks exist as pure binary data they can be easily be subjected to “genetic crossover” to create hybrid urban models which exhibit traits from two or more parent landscapes/networks.
In order to provide points at which beneficial mutations may occur, the potential for copying errors must be introduced to the genetic crossover.
Once the mechanisms for downloading, uploading and crossover with potential mutations have been established we can develop an organic design methodology using a genetic algorithm to evaluate and evolve the network models.
Emergent architectural traits and distribution of programmatic elements.
The diagram, below, illustrates the algorithmic process of evolution. Beginning with an existing urban landscape (Beswick, East Manchester) we download the landscape to binary and upload three offspring landscapes which have been subjected to possible mutation. The network script is then run on each landscape producing a fully connected infrastructure and defining certain cells-specific programs based upon their local relationships. Each networked landscape can then be evaluated for variable features such as: transport route lengths or the amount of new residential space (red cells) allowing each offspring landscape to be assigned a fitness level.
Over a series of iterations, the process of using the “best” landscapes/networks to breed potentially improved versions of the original urban space can lead to optimized urban form with complex emergent characteristics.
The design of urban space using algorithmic tools enables the designer to establish soft topological relationships between spaces, rather than definite physical connections. The act of drawing becomes augmented. Sketching becomes the act of strategizing relationships in code and technical drawing transforms into the writing of architectural scripts used to develop bottom-up generative systems.
Phylogenetic tree of successful urban networks.