Thoughts on Procedural...

Tom Kelly (tkelly@dcs.gla.ac.uk)

first year PhD report, Jan 2010

Contents
1 What is Procedural Geometric Modelling? 3

2 Biologically Inspired Morphology 3

2.1 Emergent behaviours . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Growth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 Regulative Development . . . . . . . . . . . . . . . . . . . . . . . 9

3 Commercial uses 12
3.1 Procedural Inc’s CityEngine . . . . . . . . . . . . . . . . . . . . . 13
3.2 Gamr7’s Urban PAD . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.3 Maxis’s Spore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.4 IDV’s SpeedTree . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.5 Bentley’s GenerativeComponents . . . . . . . . . . . . . . . . . . 16

4 Some Research Directions 16

4.1 Flora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.1.1 The Algorithmic Beauty of Plants . . . . . . . . . . . . . 17
4.1.2 Other Reading in Flora . . . . . . . . . . . . . . . . . . . 22
4.2 Urban . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.2.1 Shape Grammars . . . . . . . . . . . . . . . . . . . . . . . 29
4.2.2 Architectural Theory . . . . . . . . . . . . . . . . . . . . . 29
4.2.3 City Modelling . . . . . . . . . . . . . . . . . . . . . . . . 33
4.2.4 Broader Topics . . . . . . . . . . . . . . . . . . . . . . . . 37
4.2.5 Reverse Procedural Techniques . . . . . . . . . . . . . . . 40

5 Straight Skeleton 42
5.1 Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.1.1 Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5.1.2 Data Structure . . . . . . . . . . . . . . . . . . . . . . . . 43
5.1.3 Collisions Between Three Edges . . . . . . . . . . . . . . . 44
5.1.4 Ensuring Collisions Only Occur On Faces . . . . . . . . . 45
5.1.5 Many Edges Colliding . . . . . . . . . . . . . . . . . . . . 49
5.1.6 Horizontal Output Edges . . . . . . . . . . . . . . . . . . 50
5.1.7 Negative edge gradients . . . . . . . . . . . . . . . . . . . 53
5.1.8 Ambiguous Weighted Skeleton . . . . . . . . . . . . . . . 53
5.1.9 Reconstructing Faces . . . . . . . . . . . . . . . . . . . . . 55
5.2 Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

6 Conclusions 56

7 Future Directions 57
7.1 Spectrum of Proceduralizations . . . . . . . . . . . . . . . . . . . 57
7.2 Evaluation of Procedural Systems . . . . . . . . . . . . . . . . . . 58
7.3 Thesis Subject . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
7.4 The Future . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

2
1 What is Procedural Geometric Modelling?
Procedural geometric modelling is the engineering of algorithms that create ge-
ometry.

Whilst a standard 3D work flow allows a user to create a single chair of a

specific height, a procedural work flow might let a user create an algorithm that
produce a chair of any height.

The benefits of procedural content include:

• Removes the restriction that the size of a virtual environment is propor-

tional to the time spent creating it.
• The quality of the environment is consistent at no additional cost.
• In the long term efficient procedural geometry tools could lead to runtime
environment generation. A virtual world would be generated as the user
explores, giving an experience with more variety and less repetition to the
user.
• Procedural methods offers the potential to generate content that reacts
to various stimuli. For example it could respond to current hardware
availability, to users level of expertise or to the length of their attention
span.
• It is easier to for users to create custom content given a procedural model,
rather than starting from scratch.

Before we begin, a few words and phrases that should be defined:

Model An algorithm that produces a (normally geometric)

model
Instance The output of a single invocation of a model.
Morphogen A substance which causes a change in form of an
object.
Morphospace of a model The conceptual space created by all the different pos-
sible instances that a model could output

2 Biologically Inspired Morphology

Several ancient examples of design systems can be found in nature. In general
these techniques are inherently parallel and robust, but have properties that
make it hard for humans to engineer.
Evolution, the modification of organisms to survive in their environment,
gives one view of a procedural system. The controlling algorithm is an evolu-
tionary system that adapts the design of a creature so that it may survive and
reproduce.
Another classical example is organism growth - complex structures are grown
from simple beginnings, often a simple cell.

3
 It is instructive to examine a few of the phenomena that give natural sys-
tems their intricate and compelling morphospace. Biologists are not yet able to
present a complete system for many of these complex systems, however what
they have discovered shows many insights into the properties of complex pro-
cedural systems. While they have been divided into different groups discussing
different properties of natural morphology, many of the examples belong to more
than one group.

2.1 Emergent behaviours

An emergent system shows behaviours that were never directly stated or pro-
grammed. In our case we are interested in behaviours that create novel and
interesting forms.
Perhaps the classic example are cellular automata. These systems manipu-
late a symbolic environment over time. The classic example is Conway’s Game
of Life[22], in which a grid of black and white squares, and some simple rules,
give rise to some quite unexpected behaviours.
The rules allow for cells, represented by black grid squares, to be created or
destroyed, based on their neighbours after the previous iteration. Cells are born
in cells adjacent to three neighbours on the previous iteration. Cells with only
one, or four or more neighbours die, while cells with two or three neighbours on
the previous iteration remain alive.

Figure 1: a) The cycle of a glider pattern in the Game of Life. b) The ”Gosper
glider gun”, a formation that creates a stream of gliders every 30 iterations.

Given just these simple rules and a simple starting arrangement, large and
complex patterns can be produced. There are several patterns that, once they
happen to occur, are self perpetuation, such as the glider in figure 1,a, which
moves through space. Initial conditions have even been discovered that create
a continuous stream of these gliders, such as figure 1,b.
Indeed it was cellular automata like these that caused Doyne Farmer and
Christopher Langton to discuss “life at the edge of Chaos”[32], while investigat-

4
ing the properties of cellular automata. This is generally taken to mean that
computation, and with it interesting form, mostly occurs in situations undergo-
ing phase-transition. That is there are not so many events to make information
storage impossible, but enough interactions to perform computations at all.
My feelings about cellular automata are that, while they produced intricate
patterns, because they were abstract and not founded on physical rules they
weren’t true to biological systems. I also wished to see if it was possible to
engineer successful outcomes. I performed a short experiment using a computer
running a 2D physics simulator[58].
A number of cells were modelled as circles. They are assigned types, repre-
sented as colours, and each diffuses a particular morphogen. These morphogens
disperse over time. Each type of cell changes it’s acceleration beased on the the
other morphogen gradients. For example the green cells may attempt to move
in the direction of the blue morphogen, while avoiding the morphogen that they
themselves emit, as in figure 2.
By changing the response to the morphgen gradient, it was indeed possible
to create quite complex behaviour. For example the cells quickly created the
three-layered objects in figure 2, however the results were dramatically different
every time the simulation was run. In comparision with a pure geometric design,
(where we might have simply stated a center and three radii) it is a difficult
system to work with. However if we didn’t know the volume that the layered
object would be bounded by, the morphogen-gradient method may be preferable.
Indeed the process of evolution itself can be regarded as an emergent be-
haviour of simple proteins. Like the other emergent behaviours, their is no
predefined goal or destination to the morphological forms.
Generally emergent behaviours to have the following properties:
• Robust. Generally the shape and forms that are generated can be broken
up, but will often reform with similar characteristics.
• Variety of output. The unpredictable nature of emergent behaviours tends
to lead to a large variety of results.
• Difficult to Control. Almost by definition, emergent behaviours do some-
thing other than that they were designed for. This makes them difficult
for humans to engineer in a standard graphical workflow.
• Expensive. The phenomena examined here are parallel mechanisms. That
is a set events happen in parallel inside a “simulation”. Because of the
serial von Neumann bottleneck these scenarios are expensive to compute.

2.2 Growth
When two growing bodies compete for space, they subdivide that space. For
example cells within a membrane, such as occurs in an embryonic mammal,
grow and divide, whilst carving the space within the membrane into discrete
regions. Partitioning space in this way turns out to be a useful procedural tool,
figure 3.
In two dimensions, with bodies growing at a constant speed, the result
is very similar to a computational geometry algorithm known as the Voronoi
tessellation[60], figure 4. The tessellation has some useful properties - it will

5
Figure 2: Simulated cells (red, green & blue) following morphogen gradients
(green type morphogen shown in white). Panels 1-4 shown as the simulation
continues.

colonise all the space, that is growth continues until every region belongs to one
cell or another, and it will terminate with as many partitions as specified when
starting.
The Voronoi algorithm classifies all space as being nearest one or another of
the cell centers. Viewed from the perspective of growth, each area is colonised
first by the nearest cell.
There are several algorithms to calculate the Voronoi diagram[60], the edge-
cutting technique was used to create the city street layouts for one of the au-
thor’s earlier projects (figure 5), while Fortune’s algorithm is faster in lower
dimensions[21].
Additionally we may wish to have our objects in 2D grow at different rates,
or to partition space in three or more dimensions. This leads to the weighted
Voronoi diagram[10], as in figure6, and higher dimensional Voronoi diagrams[61]
as in figure 7, respectively.
Using this class of space-subdivision algorithms provides some of the geo-
metric robustness that biological systems have, but remain easily controlled. It
is also requires less computing power, and is entirely deterministic. The straight
skeleton[3] can also be used as a space subdivision technique, I work on the
algorithm in great detail in later chapers.

6
Figure 3: Belousov-Zhabotinsky reaction forming a Voronoi-like pattern because
the boundaries occur where the chemical’s phases collide [2].

Figure 4: A Voronoi tessellation with one million points, from [56]

7
Figure 5: An earlier project that takes sets of points, and uses the Voronoi
tesselation to create city-street-like maps, such as those on the right. To add
realism, randomly selected “plots” are merged with their neighbours.

Figure 6: An additively weighted Voronoi diagram. The points are the cell
centers [28].

8
 Figure 7: Three dimension Voronoi tessellation. Cell centers not show [52].

2.3 Regulative Development

Regulative development is the study of the interactions that cause an egg to
divide and grow. There are several documented[4] techniques for mechanisms
to change the developmental path of one particular cell. While many cells
begin identical, regulative development may cause it to become different types
of tissue, or behave in some specific way.
When certain types of cells are adjacent, new cell-division behaviours can
be turned on. This induction can happen several times to build up layers of
different cells as the adjacency changes, as in figure 8. Because the technique
depends on contact between cells, induction only works locally.
Chemicals which affect cell development paths are known as morphogens.
Based on the concentrations of morphogens, cells can develop in down different
pathways to their eventual form. Additionally, cell age also has an effect, so
that older cells can behave in different ways to new cells.

“in this way the final specification of how a limb cell should behave is built up
combinatorially; first it is supplied with information as whether it is to be a leg
or wing then signals within the growing limb bud specify more fine-grained
components of positional value, reflecting the precise position within the
limb.[4]”

So a programmer might say that values have been curried into the code
for each part of the limb. You can see this in an experiment - if the tip of a
embryonic chicken’s foot is transplanted onto the end of the wing, the result in
an adult is a wing with a toe on the end; that is the tissue has already been
curried (fated) as part of a leg.
As this chicken example shows these fields are robust when dealing with
geometrically changing features (as disrupted the system can re-organise itself

9
Figure 8: Cell Induction. i) two adjacent regions of cells, ii) new cell type
induced by adjacency, iii) additional strata of cells via induction

ignoring inconsistencies) and may well prove to be well suited to procedural

geometry that adapts to new configurations.
Further experiments have shown these principles in practice by taking a fly
egg (Drosphila) and removing some of the fluid containing the morphogens from
the head end leading to a fly without a head. Alternately if some of the critical
morphogenic chemical is removed from the rear of the fly and injected into the
head, a fly with two sets of abdominal segments is produced. Morphogenic fields
certainly solve the problems of symmetry in simple grammars (since diffusion
is equal in all directions). There are several techniques that seem to be used -
differentiating features by field strength or using a combination of fields.
Figure 9 shows how a single cell may have several different morphogenic
fields present. Development in different parts of the cell depends on the relative
concentrations of these chemicals. By detecting the gradient of the morphogen,
some processes can even be orientated. Complex harmonic patterns can even be
built up by releasing a morphogen in response to two other morphogens having
equal concentrations, figure 10.
Another technique is shown by the evaluation of pair-rule genes. For example
Drosphila has a number of genes (hairy, even-skipped, paired, fushi-tarazu) of
different lengths which are activated at intervals of two body segments. Boolean
combinations of these genes allow more complex patterns to be expressed, with-
out any additional input data, as shown in figure 11. This is very similar to
Muller’s 01 paper [47], that uses the union of 1D square wave functions to
positions elements on a building’s facade.
Finally, much later in the embryo’s development cycle, there is a technique
that creates occasional features called lateral inhibition, figure 12. All the cells

10
 Figure 9: A cell with several different morphogenic fields. [4], plate 21-57.

Figure 10: Top:Cell differentiation may depend on the concentration of a mor-

phogen. Bottom: By releasing a third morphogen (3) when two others are equal,
harmonic sequences of morphogens can be built up.

start off emitting the same concentration of signal chemical. Cells near those
with a larger signal stop signalling, the result is an interspersed pattern. In this
example each of the selected cells then becomes a mother cell to a clutch of

11
Figure 11: The different repeating genes (white rectangles) can be combined
using different boolean operators to create a wide range of boolean patterns
(bottom) [4].

hair-cells, while the remaining cells carry on as normal to become skin.

Figure 12: Lateral inhibition is used in the locating of hair follicles. i) The signal
strength starts out the same, ii) random noise ensures that some cells emit a
stronger signal that others. iii) Lateral inhibition causes cells near a large signal
to stop signalling, leaving an interspersed pattern that designates the growth
locations for the follicles. [4]

All these regulative techniques rely on physical phenomena to create mor-

phologies. Emulating these phenomena is computationally expensive, because
there are many events occurring in parallel. These techniques are however very
robust to shape changes, and disruption during growth. I believe that they are
also fairly understandable from a human engineer’s point of view, and can be
engineered to create interesting forms.

3 Commercial uses
Much of the leading work on procedural modelling happens in the commercial
world, and many of the results are never published. I am most of aware of work
in the video gaming communities.

12
 Over the last two decades video games have adapted with Moore’s law to
become increasingly complex. One of the consequences of this is that our games
are more detailed. For example the complexity of each frame has risen from
the tens of polygons in the 1980’s to the tens of millions today [1]. Additional
techniques such as displacement and bump mapping are adding additional detail
beyond polygon meshes.
As figure 13 illustrates, the increasing requirement for detail is visible in the
structure of video game development companies. The majority of the man-years
required to make a modern video game are spent by artists creating models of
the world.
Unfortunately this bottleneck of creating geometry means that it costs more
than ever to create video games. Development costs for the like of Ubisoft’s Far
Cry 2 (2008) are expected in be in the tens of millions of pounds.
Discussions with staff from Frontier Software describe some of the tools used
to accelerate the generation of large urban environments. Because much of this
work remains unpublished, it is worth detailing a few companies that develop
procedural technologies.

Figure 13: Typical staff composition in a Japanese game developer[45].

3.1 Procedural Inc’s CityEngine

This is the accumulation of Pascal Mueller’s research in the form a company.
Their major selling points are:

• Rapid Digital Prototyping

• Shorter Time-to-Market
• Cost Reduction
• High-Quality Content
• Redefine Design
• Flawless Integration

13
 The market cost is $4000, and they seem to be pitching to a wide range of
companies, everything from video games, architecture, archaeology, simulation,
film & TV.
A typical work flow involves selecting a terrain map, and a population map.
From these the application can create a road network from one of several designs.
After this subdivision into lots and buildings occurs. To construct buildings,
shape grammars are used and driven by a domain specific Python-like scripting
language. This final step means that using the package takes considerable train-
ing, but allows complex features such as recursion and responding to changes in
terrain. A complex example is shown in figure 14.

Figure 14: A promotional image from CityEngine.

3.2 Gamr7’s Urban PAD

Like Procedural Inc. Gamr7 have academic roots, but they are concentrating on
the gaming market. The software isn’t able to procedurally generate geometry,
rather instance buildings at multiple location (figure 15). However complex
road networks may be generated by small teams in short periods of time. Their
selling points:

• Automatic Geometric adaptation

• Automatic Height Field adaptation

• Automatic LOD removal of objects
• Exports to Collada for easy mock-ups and visualisation

• Exports to XML for easy integration into pipeline

• Height field Import
• Configurable Forbidden Zone : Water, game play constraint
• Configurable Road Network : Spline, Bridges, Etc.

3.3 Maxis’s Spore

Spore is a video game that allows users to control a creature as it evolves from
a single cell life form, through a land-based stage to an advanced civilisation
with buildings and vehicles. Maxis use procedural technologies to great effect
to allow the user to design a creature, whilst maintaining a worst-case quality

14
 Figure 15: A promotional image Gamr7

threshold. That is, it is difficult to build a creature that doesn’t look like a
creature.
A small set of operations allows the effective creation of the torso and limbs
of a creature. The skeleton of the creature, and the width of the muscles around
the skeleton can be specified by the user. An unknown system then creates a
fitting skin around the skeleton and calculates where the skin should crease as
the creature moves. Finally the user can position pre-made meshes such as eyes
and horns, each of which has a parametrised range of variations.
This very usable domain specific geometry tool borders on a procedural
system. Considering that the game has been designed for young children, it is
quite believable that a simple artificial intellegence could create a large variety
of creatures of good quality.
A procedural animation system is then able to take the data about which
limbs are legs and which are arms to animate the creature. This is impressive
as there may be 0 or more limbs (figure 16).
Spore costs $40.

3.4 IDV’s SpeedTree

SpeedTree is a commercial product that allows artists to design trees and incor-
porate the results into 3D environments, usually video games as in figure 17. The
offering is a suite of software, the most impressive part of which is SpeedTreeRT,
which calculates physical effects and level-of-details in real time for video games.
It is very widely used in the industry as it provides integration with existing
video game engines.
A CAD system provides the artists with an inteface to specify what their
trees will look like. The output from this can be used in real time or, of course,
taken as a mesh and edited further in a 3D editor.
The cost is $8,500 per title released.

15
Figure 16: A user-generated character from EA’s Spore. (“An AVATAR Dire-
horse by CopperLou, from http://bit.ly/7AYJkZ”)

Figure 17: An screen capture of SpeedTree’s trees in the video game Fallout 3,
by Bethesda

3.5 Bentley’s GenerativeComponents

Bentley has produced a CAD application, GenerativeComponents, in which
elements can be procedural. They can be defined by parametric or associative
modelling. An example of the data flow that creates a staircase is shown in
figure 18. This software is important as it is used by architects to accelerate
the design of modern geodesic structures such as the Setun Hills Business Park
(Moscow), and Lansdowne Road Stadium (Dublin).

4 Some Research Directions

Procedural technology has been a long time in maturing. In the geometric
domain we have seen early successes in terrain generation, then flora. Today
we’re starting to see moderate success in urban environments.

16
Figure 18: An example of a staircase from GenerativeComponents. Source:
http://www.aecbytes.com/review/2009/BentleyArchV8i.html

4.1 Flora
The field of procedural botany has a larger, more structured corpus than urban
procedural modelling. The prevalent technology has been the L-system for the
creation of structured branches and leaves. This has been used to great effect
in commercial projects. For example IDV’s Speedtree allows for the procedural
creation of a variety of foliage very quickly (figure 17), and provides an extensive
library of plant models to be customised.
In this chapter I will first review Lindermayer’s work with L-Systems, fol-
lowed by a broader overview of the state of procedural botany.

4.1.1 The Algorithmic Beauty of Plants

Lindenmayer described his (L) systems in 1968 [34] as an attempt to describe
the structure of plants using a formal grammar. The book The Algorithmic
Beauty of Plants[49] (TABOP) gives an introduction to his work, this section
outlines some of its main themes.
To model plant growth convincingly the traditional, sequential replacement
of a Chomsky grammar was discarded in favour of a parallel, generational growth
model. For example, given the non-terminals X & Y, and the terminals + & -,
we might start with the initial string

initial:X

and apply our production rules. For example every instance of an X may be

17
replaced by the string (X → XY), and similarly (Y → -X+Y). This happens to
every symbol, once per iteration.

iteration 1: XY
iteration 2: XY-X+Y
iteration 3: XY-X+Y-XY+-X+Y

We can perform as many iterations as we wish, and observe the length of

the string grow or shrink as the pattern progresses.
Finally the results are fed into a turtle that evaluates the string as a series
of instructions (for example, X might be move forward, and - might be turn
left). This gives a graphical result.
The result from these systems is generally pleasing, and intented to show the
growth and development of a plant as it grows. Each iteration is taken to be
a time step. However the system is limited to repetitive structures, as TABOP
observes:

“However, production application may also depend on the predecessors context.

This effect is useful in simulating interactions between plant parts, due for
example to the flow of nutrients or hormones.[49]”

This context sensitivity is very similar to the biological principle of induction

(figure 8), and echos a move from Chomsky’s type 2 grammar to a type 1.
A notation is introduced to describe context sensitive production rules. For
example to state that a b between an a and a c should be replaced with a d we
would use the notation:

a h b i c → d

Together with the conventions that the number of iterations is n, the angle
that the turtle turns on a + or - symbol is δ, and Fd moves the turtle forward
d units, allows us to evaluate the grammar given in figure 19 to figure 20. The
L-system interpreter was written in Java, and the image rendered to a Scalable
Vector Graphics image.
These basic L-Systems are given various extensions to overcome certain lim-
itations. TABOP gives the following modifications:

• Context sensitive. As described above, symbol replacement can occur

based on the surrounding elements.
• Stochastic. Each production rule is given a corresponding probability with
which it occurs on each iteration.
• 3D. By using a three dimensional turtle, instead of the two dimensional
standard, three dimensional structures can be created.
• Stack operations. Push and pop stack operations, normally represented
by the characters [ and ], save and restore the turtle’s position during

18
 n=40, δ=22.5◦
#ignore:+-F
starting string: F1F1F1
0 h 0 i 0 → 1
0 h 0 i 1 → 1[-F1F1]
0 h 1 i 0 → 1
0 h 1 i 1 → 1
1 h 0 i 0 → 0
1 h 0 i 1 → 1F1
1 h 1 i 0 → 1
? h + i ? → -
? h - i ? → +

Figure 19: example 1.31,b from TABOP, with some small modifications.

Figure 20: A simple L-System I encoded form TABOP[49], example 1.31,b

(figure 19) over 40 iterations.

evaluation. This gives better representation of the hierarchical nature of

tree - when the turtle finishes drawing a flower, it can return to create
more branches.

19
 • Parametric L-systems. Here each symbol is given a set of parameters, and
a replacement can only take place if a logical statement associated with
the parameters is true.

• Table L-systems. These use a different table of production rules to simu-

late changes in the environment, for example one for generating the plant
in a winter (non flowering) state and summer (flowering) state.
• Map L-systems. These are remarkably similar to Stiny’s Shape Gram-
mars [55]. As shown in figure 21 a Map L-System operates on geometric
input and searches for sets of lines that match the production rule, and
then applies one of them. Because this system works directly on geometry
it is unnecessary to use a turtle to evaluate the output of the system.

Figure 21: A Map-L-system from [49]. Using the two production rules (bottom,
yellow), the initial rectangle (top left) can be subdivided into a tiling.

There are many additional extensions to L-systems in the literature [50][9].

The problem with L-systems is that each extension attempts to make up for
some short coming of the previous models. Perhaps this shows L-systems pro-
vide a valid framework, because it is so easily extended. However, from an
software engineering standpoint, when you see a model overloaded continually
it points towards the original system being not sufficiently detailed.
It seems it may be preferable to model the two systems individually; L-
systems seem to work well for the hierarchical structure common in plants, but
are clumsy when simulating growth or environmental interaction. This is a view
shared by Hart in the introduction to [25]:

“The most prominent of these models has been the L-system. In an effort to
make these models produce more realistic results, some have encoded the
environmental influences, such as geotropism (sagging branches), directly into
the L-system. While this allows the genetic model to include more detailed
information about its reaction to external forces, it makes the model much
more complex and difficult to decypher.[25]”

More recent work on L-system in environments have come to similar conclu-

sions, that when representing a building’s facade as an L-System, a lot of work
must be done to change one particular window[35]. L-systems also represent

20
only one hierarchy of components. For example a grid of windows on a facade
is either defined in terms row-major or column-major. In this situation there is
no requirement to specify a hierarchy, but the L-system enforces one.
As Chomsky points out[16], a grammar should reveal some insight into the
structure being examined. By the time several of the above extensions have been
instigated, the language becomes a mess of concepts and corrections (figure 22),
showing little more insight than if if the same structures where specified in any
other programming language.

Figure 22: Five rules from a parametrised, programmable stochastic L-System[9]

TABOP leaves the subject of L-systems, and continues to discuss wider

topics, such as the phenomena of Phyllotaxis in plants. This is an interesting
study in the limits of procedural modelling from form alone. When modelling
natural phenomena better (procedural) models can be built when we better
understand the causes of a given pattern or form.
Phyllotaxis is the name given to the spiral patterns of seeds that grow in a
sunflower’s head, or the needles on a pine cone. Similar patterns occur in dif-
ferent phases. There are several commonly observed modes, alternate, opposite
or spiral, shown in figure 23.
TABOP describes a model for the spiral phenomena, we simply measure the
desired angle of the mode of Phyllotaxis we’re interested in, and use a simple
formula:

21
Figure 23: a) opposite, b) alternate and c) Fibonacci spiral patterns of
Phyllotaxis[9]

for incrementing n for each point

{
φ = n * angle //NB (”correct” angle is 137.5)
radius = c * sqrt(n)
}

This model only manages to represent one mode of Phyllotaxis, and although
there are similar models for the other modes, we cannot gradually change the
parameters to switch the mode of the model, figure 24, without creating an
unobserved pattern.
However, there are biological models [53], that when run as a simulation
correctly produce all known modes of Phyllotaxis by varying one parameter,
figure 25. However these are more expensive to compute than the simple for-
mula.

4.1.2 Other Reading in Flora

There is a wide range research into algorithmic botany. Here I review a sample
of papers from the field.
The seminal paper that brought the realisation that mathematical modelling
of biological phenomena was Turing’s “A Chemical Basis for Morphogenesis”[57].
By a careful treatment of diffusion formula, this paper shows how a feedback
system can create patterns from an originally uniform system, figure 26. These
are chaotic & emergent, examples of form that occurs in systems posed for
phase-change.
However, the impact of this paper on the field of graphics has been slight,
with the emphasis on recreating, rather than understanding geometry.
Much of the work in procedural flora is a re-invention or reformulation of
Lindenmayer Systems [34]. For example Kawaguchi [29] produced vibrant re-
sults in 1982, figure 27, by combining tubes, “tendrils”, and spheres “knots”.
Each chamber in the spiral is constructed as a skew cylindrical prism. These
provide growth in the forward direction and are repeated and scaled by a set

22
Figure 24: A range of different spiral generations with different values for alpha.
Only one of these uses the “correct” angle found in nature - it is the spiral with
the best coverage (second from top, right). Looking at the diagram from a
distance helps this pattern to become obvious. This image was generated from
java code, via an SVG renderer.

Figure 25: The suspected patterns of auxin transport that lead to the phenom-
ena of Phyllotaxis [53].

23
Figure 26: An example of a ’dappled’ pattern as resulting from a morphogen
system.[57]

ratio, a geometric progression. Knots are added to allow the spiral form to ro-
tate and as branches to add additional tendrils. There is an adjustment factor
to move child branches away from the parents. There isn’t a formal grammar
behind this system, rather a successive application of rules. It would be easy
to create these designs using a stochastic, 3D L-System, but this option is not
evaluated.

Figure 27: Tendril plants[29].

The ever prolific Prusinkiewicz provides the backbone to the field of algo-
rithmic research. In [50], a modification to a context sensitive, probabilistic
L-system is presented that creates vegetation of a required shape, as for top-
iary. By backtracking whenever a boundary is reached, figure 28, a realistic
branching structure is created in the interior, and sufficient foliage is shown on
the exterior.
The original premise behind L-systems was that they simulated the biological
process of induction, and growth. However, the backtracking algorithm here
grows plants in a artificial sequence, very different to natural growth.

24
Figure 28: Top: An implicit surface in the shape of a dinosaur, and the corre-
sponding topiary plant. Bottom Left: 2D results pruning to an oval. Bottom
right: The process of exploring space, and returning the active-pointer to the
previous branch[50].

Prusinkiewicz and Měch develop the idea of environment interaction in L-

systems in[43]. Two concurrent systems run in parallel, one for the plant and
another for the environment. The plant receives information from the envi-
ronment, transports the information to the needed location and responds to
this information by changing the form. The environment perceives the plants
actions and simulates the environment (diffusion of chemicals or flow of light)
and gives feedback to the plant. The development of this paper was this two
way communication between model and environment. The results from the the
environmental feedback are returned as parameters to the L-system.
Recently Palubicki et al.[46] presents a accumulation of much of this work
with L-Systems, figure 29. By exploiting the increased computing power avail-
able in modern computers, very complex models can be evaluated.
There is a substantial body of literature describing botany generation with-
out L-systems. These systems are often more elegant and engineered towards the
specific problem being approached. While they could be recast as L-Systems,
they give more insight as domain specific languages.
Greene[24] introduced the quad-tree as an acceleration mechanism to al-
low fast lookups to allow the grown geometry to search for light, figure 30.
Heliotropism (plants tracking the sun) is simulated by finding the brightest

25
Figure 29: L-systems can create complex environments when used on a large
scale[46].

direction, and biasing growth towards that direction.

Figure 30: A model [24] of a house was imported into a voxel grid. The plant
model was then biased to grow with respect to this model so that the branches
followed the roof shape and stayed clear of the doorway.

Once the structure of a plant has been determined by a grammar, it is

necessary to fill in the remaining detail in a consistent and connected way.
Bloomenthal[13] gives an early solution to convert a line representation of a tree
into rendered geometry, figure 31. By fitting spline-controlled surfaces to the
tree a well-fitting trunk mesh can be created. By x-raying tree bark a realistic
bump map was generated, and outlines of leaves are converted to geometrical
objects and attached.
Reffye et al.[17] describe a time-based simulation of tree growth. The al-
gorithm steps through time, adding new objects at the buds of branches, and
simulating growth for existing objects by rescaling them. The discrete simula-
tion method allows for the simulation of disruptive events, such as trauma or
pruning, and forces, such as gravity to be modelled without deviation from the
main algorithm.

26
Figure 31: A model of a maple tree[13], note the close-fitting mesh and tex-
tures, not normally obtainable from L-System’s turtle-based discrete geometric
objects.

Figure 32: A fir tree with trauma evident on the lower branches[17].

Hart et al.[25] continue the theme of physically based simulations for the
modelling of trees. Different trees respond differently to gravity, there are two
main types -

27
 • Gymnosperms (such as Pine or Spruce trees). These trees support their
weight of their branches by adding extra material below the branches, that
is “compression wood”.

• Angiosperms (such as Apple trees). These trees support their weight by

adding additional material above the branches, causing it to be in tension,
hence “tension wood”

These two types of growth produce different shaped branches and this model
simulates that by widening the area of the trunk above/below the branch for
Gymnosperms/Angiosperms respectively.
The algorithm used by Hart consists of

1. Compute mass
2. Compute center of mass
3. Compute photosynthesis

4. Compute growth rates

5. Grow branches
Because there is a conflict between the strength of a tree (proportional to
area of trunk) and it’s weight (proportional to volume) this provides a natural
mechanism for the tree to stop growing.
Turning away from physical simulations, Runions et al.[51] use a sparse set
of attractors to direct a growth system. The attractors are scattered, marking
a preferred density map of the final tree. As the tree’s skeleton gets within a
set proximity for each attractor, the attractor is removed. Once all attractors
have been reached, growth stops.
By positioning the attractors in different ways (uniformly through a volume,
on the surface of a volume) using different volumes (cones, cylinders) a variety
of different plants can be created by an artist.

Figure 33: Space colonisation technique for tree generation. Left: final tree.
Right: A sapling and a set of attractors.

28
4.2 Urban
The body of work on urban procedural modelling is expansive and disjoint.
Unlike the modelling of flora, where the L-System is the key concept, no such
technique has appeared for Urban Modelling. Because urban modelling requires
approximating the designer’s thought processes, it is generally a much more
challenging field, and most of the corpus resorts to “what looks about right”:
“Voronoi points Pv are generated along an axis that approximately splits the
block into two halves. We have observed that for most queries vertices blocks
this axis corresponds closely to the central segments of the medial axis of the
block.[8]”
Parts of this chapter are from my MEng Research.

4.2.1 Shape Grammars

Stiny and Gips created the concept of shape grammars in 1975, during his PhD
at UCLA[55]. These grammars have been used in design systems for urban [54],
and other domains (such as furniture [30]).
A shape grammar consists of a starting state, a set of transformation rules
and some termination rules. A transformation rule specifies a geometrical con-
figuration that is matched against the current state, and a replacement for that
configuration, figure 35. Unlike an L-System, the rules are not applied in paral-
lel, rather in a serial manner reminiscent of Chomsky grammars[16]. Termina-
tion rules ensure that the evaluation terminates when a particular configuration
is achieved.
Another difference between a shape grammar and an L-System is that a
shape grammar is not deterministic, that is it doesn’t always give the same
result. The result depends on the choices of transformation rule made and the
matching sections of geometry to be replaced. For example only one of rules 20
and 21 from Stiny’s shape grammar analysis (figure 35) of Palladian villas[54]
may be applied in one situation. Furthermore a transformation rule may match
an infinite number of situations, such as locating a pillar anywhere along a wall.
This means that shape grammars must be guided through evaluation. In an
ideal grammar, every possible choice leads to a valid outcome.
A large variety of interesting forms can be created using shape grammars.
Generally they are more powerful than L-systems, being able to create compli-
cated forms, figure 34, but require guidance as to which rules should be applied.

4.2.2 Architectural Theory

There is a large body of work in architectural thoery. In general these are not
very helpful because the are not generative, that it is more suited to analysing,
rather than generating geometry. A Pattern Language[5](APL) attempts to give
the rules for building a city, but because of lack of algorithmic detail, is only
able to say whether a particular design complies with it’s theories or not. APL
describes its language as:

“The elements of this language are entities called patterns. Each pattern
describes a problem which occurs over and over again in our environment, and
then describes the core of the solution to that problem, in such a way that you

29
 Figure 34: The complete Palladian villa floor plan [54].

Figure 35: Rules 20 and 21 from Stiny’s analysis of Palladian villas[54]. The
matching case on the left of each example is replaced with the geometry on the
right hand side. In this example the central block can either be lengthened or
shortened. The letter c is used as a marker to match later features.

can use this solution a million times over without ever doing it the same way
twice.[5]”

And procedes to list rules for the construction of a city from the large-scale
to the small:

1. independent regions
2. major city structures

3. self governing community

4. networks between communities
5. neighborhood environment
6. local centres

7. streets or clusters of houses

8. work communities
9. local road and path network

10. public land

30
 11. common land (smaller than public land)
12. social institutions, family houses

13. groups in society

14. local shops and gathering places
15. layout of a group of buildings

16. relation of each building to the environment

17. indoor/outdoor divide for each building
18. paths and spaces between buildings
19. interior floor plan of the house

20. use of home rooms

21. use of office/work rooms
22. rooms for different social groups
23. relationship of the room to the outdoor

24. garden plan

25. features of the room
26. features of walls and stairs

27. curiosities in the rooms

28. materials and building methodology
29. engineering/internal structure of building
30. structure of the the floor and walls

31. building doors and windows

32. other building details
33. materials for indoor finishing

34. outdoor finishing

35. furnishing

It is worth noting that this list does not represent a hierarchy, but rather
groupings of patterns important to architects. Some of the patterns of tangi-
ble/implementable:
“Pattern 159: Light on two sides of every Room...Locate each room so that it
has outdoor space outside it on at least two sides, and then place windows in
these outdoor walls so that natural light falls into every room from more than
one direction.[5]”

31
While others are vague:
“Pattern 10. Magic of the City...Put the magic of the city within reach of
everyone in a metropolitan area. Do this by means of collective regional
policies which restrict the growth of downtown areas so strongly that no one
downtown can grow to serve more than 300,000 people. With this population
base, the downtown’s will be between two and nine miles apart.[5]”
However these patterns do not form a generative system, there is no algorithm,
just a hierarchy of goals. Texts like APL would be most useful when evaluating
a generative procedural system. We can ask an artist - “can you reliably create
Pattern 10 using our procedural system?”.
As Hiller[27] notes, architectural theory books tend towards representing an
idealised view of architecture.

“[With reference to Architectural Theory books]...first, most have been strongly

normative, and weakly analytic, in that they have been too concerned to tell
designers how buildings and environments should be and too little concerned
with how they are.[27]”

Because of this bias, and the lack of generative detail, much of the corpus
of architectural theory books is hard to use for procedural modelling. However
some broad overviews can be useful.
One exception is the book How Buildings Learn[14], in this Bond describes
the way houses age, and how their appearance changes over time; Buildings that
have been used for a while end up looking very different to how they were built.

Figure 36: How Buildings Learn [14], front cover, left: houses New Orleans
1857, right same houses 1993.

In old cities each house in an initially identical row will have had many
different modifications made to it by different owners through the years. Some
houses will have had similar alterations to do with current trends (such as PVC
windows), others will have unique changes by generations of rich or poor owners
(such as telescopes and flag poles). Bond describes numerous examples of how
the floor plan of a house can over time grow.
Bond continues to give a description of the effect of wealth on house devel-
opment. Rich home owners are more likely to make changes to their properties.
Poorer home owners will not alter the appearance of their houses, and this may
preserve many historic features, such as has happened in the older parts of New

32
Orleans, figure 36. The end result is that the old buildings seen in European
cities are a complex mess of features with underlying patterns. There are more
likely to be correlations between buildings close to each other. Such structures
are built to similar plans and similar materials and modifications that are made
to one house are likely to be applied to other local houses. For examples when
conservatories became popular they were added to old and new houses alike.
Because of historic building protection laws uniform appearance is not corre-
lated with the age of the property. This huge variety provides a challenge for
city generation. Again, this book is not generative, and only gives an idea of
what the outcome should be, rather than saying how to achieve it.
Mitchell [39] starts to describe this problem of computability and makes one
of the first attempts at describing a machine learning centric approach to pro-
cedural modelling. He describes the huge potential search space for designing
buildings in real world architecture setting. Many parameters - from local build-
ing codes, to the quantity of light a window would produce must be encoded
and solved to produce a technically correct building. Trickier is the problem of
designing an algorithm with a sense of aesthetic beauty, which complicates this
search space again. For example we may desire that windows across a building
are different sizes in odd and even columns. Formulating a problem that is suf-
ficiently constrained, without over constraining the problem is a tough problem
itself, before solving this massive logic problem is considered. Mitchell suggests
a range of possibilities, from using a computer to design the buildings and hu-
mans to verify them to the opposite as possibilities for making use of computers
in architecture.
In [40] Mitchell describes the kind of first order logic predicates that may be
used to describe architecture. Throughout this lengthy volume many conflicting
approaches for describing architecture in logical form are given. None of these
are concise enough to implement and the NP-complete nature of inferring facts
from logic problems make this approach a little unrealistic. Mitchell does not
combine these different ways of viewing architecture into a single model.

4.2.3 City Modelling

Parish and Müller’s 2001 paper [47] sparked a recent renewed interest in pro-
cedural urban geometry in graphics research, well detailed by [59]. Parish uses
a L-system to generate roads and basic buildings. This work formed the basis
for the foundation of the company Procedural Inc, and one of the few commer-
cial procedural modelling tools, CityEngine. As figure 37 outlines, the system
uses number of processing steps to create a city. Population density and terrain
maps are given as input. Main roads are laid between the population cen-
ters, and a selfsensitive constrained Lsystem builds a tighter network of smaller
roads around these. Between the roads another Lsystem constructed simple
skyscrapers. This paper sees the introduction of mass-modelling, in which basic
primitive shapes are combined to give the outline of a building. Generally the
results, figure 38 were impressive.
By 2006 Müller et al. had advanced their work, replacing these undecorated
models with a sophisticated shape grammar [42], figure 39. The grammar uses L-
system-like production rules to specify the situations in which a transformation

33
 Figure 37: Overview by the author of Procedural modelling of cities[47].

Figure 38: Results of Procedural modelling of cities[47].

rule is applied. However the authors do not describe their algorithim as an

L-system as it contains many other geometric constructs:
“...and it is important to have the possibility to distinguish between absolute
values (values that do not scale) and relative values (values that do
scale). [42]”
By defining methods to subdivide surfaces, and to snap geometry to repeating
locations, a wide range or features can be portrayed. For example a wall can be
divided to accommodate an integer number of windows, and the windows can be
positioned to avoid arbitrary roof lines. A large set of production rules are still
necessary, but a wide range of intricate and realistic geometry can be created.
Examples given involve skyscrapers and a reconstruction of Roman Pompeii.
However the path through the morphospace (design space) is predetermined by
the grammar, only taking into account stochastic choices, or inputs from the
data-maps.
In [63], Wonka et al. introduce an attribute system that allows the design

34
Figure 39: Left: A mass-model of a complex building, Note the way the win-
dows avoid the roof-lines. Right: the corresponding snap-lines used to position
components.

space to be purposefully evaluated. A large library of components and a split

(continuous subdivision) grammar a large design space is possible. A control
grammar runs in parallel and distributes attributes, ready for the next iteration.
For example every element may have a “simplicity” value, and if the user asks
for a “simplistic” building, this can be used to guide the evaluation of the split
grammar. Other elements have attributes that ensure they are only used if
there is sufficient geometric space. When all attributes are taken into account,
there may be a tie-break between several rules. When such an arbitrary choice
has to be made, the choice is ”baked in” until the end of the evaluation of that
particular building. So if a window type is chosen in a particular building, it will
be used in all identical situations in the same building, providing consistancy of
decisions.
A different pair of hierarchies are used by Finkenzeller [20] to describe the
course and fine details of a building, figure 40. The course system starts with
a floor plan - this comprises a concave set of abutting polygons that represents
the main building, a wing or a balcony. The second hierarchy of geometry is
for the style, the finer components, such as wall subdivisions or windows/doors.
Cornices (decorative moulding strips) are extruded from a sequence of paths
and curves. The different components of the windows and door are created by
a multitude of cornice and frame elements.
Another model for the generation of new urban environments is to extrap-
olate existing data. Aliaga et al.[8] generate new areas of aerial photographs
by extrapolating from existing road networks and photographs. To create new
areas of the city (“fragment synthesis”), the road network is filled in in an hier-
archical order of road size, as in [47]. The direction is derived from a statistical
walk between the specified points, based on information from the example data
(average area of blocks in the vicinity, road type/hierarchy or number of roads
at a junction). Styles are attributed to the new points/intersections from a
classification system based on the example model. Groups of similar (types of
road hierarchy in an area, spacial frequency) points are grouped together using
a quadtree to maintain adjacency. The blocks (”parcels”) are then split into
plots using the Voronoi tessellation of points scattered along the longest axis of
the block.
Each block is then filled in by morphing the best-matching block in the

35
Figure 40: Two hierarchies give impressive detail, without exploding the com-
plexity of the grammars [20].

example model to fit the space in the synthesised road network. This is imple-
mented by subdividing the quad and using an affine texture transform. Because
of the large number of blocks in a typical input image, there is likely to be a
good match (so not so much stretch or distortion) in the synthesised image.
However it is a weakness of the system, that it is less suitable for use with small
quantities of input data. The results are convincing for large sets of input data,
figure 41, but largely statistically derived from certain properties of the existing
geometry.

Figure 41: The fragment on the left, and GIS data is applied and extrapolated
to produce the new geometry on the right.[8]

Once a model has produced a building, it is useful if certain elements can

be manually edited, giving artists direct control of the computational output.
As Lipp et al. demonstrate[36] it is possible to add meta-data to an L-system,
to specify exceptions, figure 42. Furthermore, by representing these features as

36
semantic patches that are laid on top of an L-system, the system can be re-
evaluated, and the artist-defined modifications are still present. Two concepts
are defined to help a user edit find the feature desired -
• exact instance locator - the decision path through the underlying gram-
mar is stored. By remembering the element number at each level in the
hierarchy (e.g. the 34th house, 3rd floor, 2nd window) it is fairly robust
to changes.
• semantic instance locator - this is the technique for selecting more abstract
constructions, e.g. columns of windows. Additional meta-data is added to
the grammar, so that split or repeat operations tag each production with
the given semantic property. Between this system, and an intuitive user
interface, editing existing grammars is a faster process, that involves less
programming.

Figure 42: Left: The red controls allow interactive window resizing[36]. Right:
The bricked-up window can be identified in an L-system generated facade.

4.2.4 Broader Topics

There are a large number of scattered topics that are related to urban proce-
dural modelling. Some subjects include castle construction, entire generative
modelling languages, real time rendering of cityscapes and growing cities over
time. Here I will outline a few of these directions.
The subject of stitching different procedural modelling primitives together,
and transferring data between geometric routines is studied by Havemann in [26].
A stack-based Generative Modelling Language (GML) is introduced in which
the output of different geometric, or otherwise, routines can be used as input
to another routine in much the same manner as Postscript. Each transfor-
mation can access the output of any previous stage removing a bottleneck of
strict-procedural systems. The primitives themselves are defined using bound-
ary representation and Euler macros. Sharp faces are just triangulated but
smooth surfaces act as CatmullClark subdivision surfaces.
Geographic Information System (GIS) databases present a standard input
file for working with cartographic data. Rendering large landscapes from these

37
files is approached by [15]. This paper details the task of rendering 3D scenes
in real time from a vector (rather than the normal raster) source. Because the
input data is in vector form, it is easy to define some objects (rivers, roads) as
smooth splines.
An octree stores each patch of land, with larger octs being used for further
away areas. The maps (texture and displacement) for the leaves of the octree
can be stored onto the GPU to increase speed. It’s also possible to edit vectors
on the fly - by only re-processing the elements that change with each edit it’s
possible to edit spline features in real time. Standard techniques like frustum
culling and LOD allow real time rendering of these massive terrains.

Figure 43: Screen captures from the real time display of GIS data [15].

The subject of Weber et al.’s paper [62] is the growth of cities over time. It is
based on simulation for the numerical aspects, rather than the pure estimation
& guesswork for the geometrical aspects. Similar to Müller’s earlier work [47]
the input to this system is a range of maps (height, water, forest...) and an
initial starting state (e.g. a single street). Subdivision occurs in the following
manner:
• Major Streets

• Quarters
• Minor Streets
• Block
• Lots

• Building Envelopes
In contrast to the earlier work, the streets in the simulation are grown for
each time step, and must be generated in chronological order, thus L-systems
cannot be used. This allows the user to influence the street pattern interactively.
Standard traffic and land-use simulating techniques from urban planners are
used to predict the growth of the city. The output of the model is compared
with the real world growth of Las-Vegas. Because the model is interactive,
subtle changes can be made at different points in time to keep the growth on

38
 Figure 44: The growth of a city over time [62].

track. The final result is quite similar to current-day Vegas, with few changes,
given that so much theory is involved, figure 44
Ali et al. address the problem of rendering massive cities, once we’ve pro-
cedurally created them in [6]. Their approach is to use ray casting techniques
against a displacement mapped surface for each wall of each house. To cre-
ate a fast displacement-map intersection mechanism, the orthogonality of the
generated geometry is exploited on the GPU. Cubes can be matched to empty
volumes of space to allow fewer samples when casting each ray. By exploiting
the expected orthogonality, a lossless matrix-based algorithm is presented that
is carefully tailored for facades. The results of these techniques are shown to be
implementable on a GPU.
Gerth et al. present an example [23] of a domain specific tool for non-expert
users to create castles. GML is again used to describe the interactions of the
primitives. Users are able to draw the outlines of buildings and select the points
which walls should be built though. This presents a simple interface that can
create quite complicated castles. The domain specific information about castles
can be embedded in the system, gives good results, figure 45.

Figure 45: GML modelled castle [23].

39
4.2.5 Reverse Procedural Techniques
Reverse engineering a model, or inverse proceduralization is the method of build-
ing a procedural model from a single example. This process gives many insights
as to how a general procedural modelling package could work.
For example, given the polygon mesh of a house, we may want to infer that
the windows are a repeated elements on a certain grid. This lets us compress
the geometry, correct for errors, and build procedural models.
To extract a building grammar from a set of photographs, [7] takes a set
of several photographs and a simple 3D model. The input mesh is manually
constructed, and aligned to the photos using a semi-automatic process. After
orthogonal subdivision the layout of each floor is represented by strings repre-
senting blocks. Analysis on theses strings with a few simple rules can produce
a useful grammar. Then several assumptions are made about the grammar of
a house. For example that there is a single ground floor, a single top floor, and
any floors between the two are repeated when the facade is re-sized. For sim-
ple examples, figure 46, reasonable results are achieved, however the grammar
analysis technique cannot work on more complicated designs.

Figure 46: A photo (left) is converted to a photograph, from which a gram-

mar is extracted, modifications to the floor plan are made, and grammar then
regenerates the building (middle bottom), before being stitched back into the
original photograph (right).

Creating geometry from existing geometry is a hard problem, because you

need to understand the structure of the geometry on many different scales.
Merrell [37] [38] makes a very successful attempt at only copying local features,
using a very similar technique to 2D texture synthesis, figure 47. The input
example geometry is subdivided to blocks. These are analysed to find allowable
neighbours in each axis direction. To evaluate the model a backtracking search
is performed to find configurations of allowable (previously observed) blocks.
As with texture synthesis the output can be constrained to volumes force the
structure to grow in a specific location. There is no gross control of the system
and the stochastic element cannot be controlled, but could be guided by the
likes of a mass model. It can construct unexpected and new features, such as
the arches within arches in figure 47.
Another direction borrowed from research in textures was studied by Cabral
et al. in extending the concept of content aware image resizing [11] to polygon
geometry. A geometric structure is pre-processed to create handles that can be
repositioned in real time to deform the building, figure 48.
An input model is pre-processed into a set of constraints and a solution.
Then the model can be reshaped using a set of point handles, while the con-

40
Figure 47: Top Left: The input models. Right: The result of model synthe-
sis [38]

straints are satisfied to position each vertex in real time. The geometry is
analysed and a set of hard and soft constraints are entered into a matrix and
solved using least-squares. At interactive speeds, the user’s inputs are projected
using the found solution and applied - if the result is degenerate, the users edit
is rejected.
While this method cannot create new geometry, it provides a fast an in-
teractive solution for resizing rectilinear meshes, and infers a model using the
matrix-inverse technique.

Figure 48:

Li et al. examine reverse engineering feature trees from a given model [33].
This paper takes the approach that you have a 3D mesh and want to recreate
the constructive-solid-geometry primitives and operations used to create that
mesh. These operations are presented in a tree (similar to a parse tree) to
specify their inputs, outputs and ordering.
The algorithm identifies recoverable vertices, edges and faces that the origi-
nal mesh hints at. These might be external to the volume defined by the mesh,
or internal and are identified by intersecting existing features, such as edges or
faces.
One of the hardest parts of working with raw-geometry is determining where
symmetries lie. Because there is no construction intent, all symmetry informa-
tion is lost. Mitra et al. [41] recover this data by identifying many pairs of
symmetrical points. The algorithm identifies the prevalent symmetry trans-
forms by sampling many symmetric pairs of points, and clustering the lines of
symmetry to to reveal the strongest patterns. By quickly rejecting pairs biased
on the local features, the number of points to compare is reduced by an order
of magnitude.
Mean shift-clustering is used to merge nearby points. The Euclidean sym-
metry space used is 7 dimensional. Clustering is needed because noisy input

41
mesh is rarely perfectly symmetrical. Each clustered set of points indicates one
possible symmetry in the model.
Convincing results, such as the decimation of the castle mesh, figure 49 to
14% of it’s original size (transparent boxes are removed data) make this an
interesting technique.

Figure 49: The found symmetries in a model of a castle [41]

Mitra later extends his work to find patterns expressed by two combined
transforms [48] by searching for lattices in a transform space. Some of the types
of pattern detected are shown in figure 50.

Figure 50: Different two-transform patterns [48].

5 Straight Skeleton
The straight skeleton is a geometrical construction that I have become interested
in because of it’s applications to urban modelling, but also it’s ability to emulate
the expansion of an arbitrary polygon, in ways very similar to biological growth.
While exploring the possibilities for roof generation I came across a paper [3]
from Franz Aurenhammer explaining the issues generating a typical hatched
roof from an arbitrary floor plan. This problem, finding the straight skeleton,
is more complex than it initially appears. The straight skeleton is a mathemat-
ical structure that is defined by tracing the corners shrinking of a 2D polygon
(figure 51). The best solution found runs sub-quadratic time O(n17/11+e [18],
given n input vertices and an arbitrarily small constant e, which is traded off
for space. While Eppstein and Erickson describe this fast approach, the details
of the algorithm are best described by Felkel and Stepan [19], who provide a
sensible route for implementation.
Laycock and Day’s paper [44] investigates how to use the straight skeleton
to produce different types of roof edges, from Mansard to Gable. By adjusting
the result of the straight skeleton after it has run, they show that it is possi-
ble to produce a wide range of roof styles. My initial implementation of the
skeleton revealed several modifications that might make the skeleton a powerful
procedural primitive:

42
 • A more interesting skeleton may be constructed if each edge is assigned
different slope. This could be used to create gabled ends of roofs without
Laycock and Days messy alteration after the skeleton algorithm has run.
For example the slope of a roof may be changed at any time to create say a
vertical wall, followed by an overhang, followed by a roof. This construct
is known as the weighted straight skeleton (WSS). [18]
• The skeleton can be truncated at any height during its construction, leav-
ing a bevelled object, this may be used as a wall if the edges slope is
near-vertical or for constructing a window or mitered door frame.
• It should be possible to construct skeletons from non-planar polygons. For
example the walls and roof of a house on a hillside.

5.1 Algorithm
In my Masters Thesis I was only able to create a crude straight skeleton imple-
mentation. What follows now is an explanation of a more careful algorithm I
have developed from Felkel’s description to include weights per edge.
It contributes a method for dealing with multiple co-sited split events in a
floating point environment, as well as a resolution strategy for horizontal roof
edges, this leads to a new degenerate case in which the weighted straight skeleton
is ambiguous.
The straight skeleton takes a simple polygon as input and outputs a graph
connecting the input vertices, figure 51. Strictly the skeleton is a two dimen-
sional construction, however here I regard it as a three dimensional “roof” -
given the floorplan of a house, the skeleton is the gutters and crest lines of a
roof when viewed from above.

5.1.1 Overview
The algorithm uses a sweep plane (figure 52) - this is always parallel to the
plane in which in the input polygon is embedded. It starts at height zero
from the input polygon, and ascends towards the top of the roof. Intersections
between edge-planes, or sides of the roof, are considered in height order as the
sweep plane passes them. The edge-planes (sides of the roof) are defined by
the gradient associated with each edge of the input polygon. In the unweighted
case these are all assumed to be the same positive gradient, whose value has no
effect on the output.
There are intersections that occur between faces that aren’t valid, these
must be ignored as in figure 53. After all collisions have been accounted for, the
algorithm is complete and will have output the edges of the WSS.

5.1.2 Data Structure

The primary structure used is a set of corners, figure 54. Each corner has
pointers to:

• the adjacent (next and previous) input edges. I assume a counter clockwise
ordering of points.
• the adjacent corners.

43
Figure 51: An example of the 2D unweighted skeleton (thin black lines) of an
input polygon (thick black lines), and the calculated faces (shades of grey).

Via the normal computer graphics convention, holes are represented by back-
wards (clockwise) loops of corners. There is a separate list of all input edgesEach
edge has:

• a list of corners that reference it.

• a list of the inactive corners that form it’s boundary.

Additionally there are a set of current edges at the height of the sweep plane.
Each edge may be referenced by more than one pair of corners. This happens
in the case that two parallel roof edges exist.
As the algorithm executes there is one loop of corner pointers for every area
in which the roof volume that intersects the current sweep plane. For example
if a skeleton produces a roof with two peaks, there would be two loops of corner
points at some point during execution.

5.1.3 Collisions Between Three Edges

As the sweep plane ascends the edge-planes may collide to a point, and we have
to modify the data structures accordingly. Often we will remove old corners,
insert new corners or add output edges to the polygon. The ways in which edges
can collide are shown in figure 55.
There are also two other important cases to understand. Firstly, where there
is only one plane at a point, it is just a plane(!). Secondly, when there are two,
it forms only a line in space. These aren’t registered as events and no action is
taken. Figure 55 1,2 & 3 covered all possible topologies.

44
Figure 52: An overview of the straight skeleton algorithm processing an input
polygon.

Each edge-plane cannot collide with just any old other edge-plane. Epp-
stein [18], gives more ideas on a fast approach, but concentrating on correctness
we can start by noting that when two planes collide it forms an edge. We need
three planes to collide to form a point; Before three planes can collide, two of
these planes must already be adjacent. Using the above list of possible inter-
sections, we can see we should only be testing for collisions between pairs of
adjacent edges and one other edge.
Figure 56 gives an overview of how the data structure is updated for each
three plane case. These three types of collisions are sufficient to calculate the
straight skeleton of almost all random input polygons. The other cases are
degenerate and are discussed in the next section. It is unfortunate that most
common roof shapes are classified as degenerate as many input edges are parallel
and include symmetrical shapes that cause more than three planes to meet at
a point.

5.1.4 Ensuring Collisions Only Occur On Faces

One way to view the algorithm, is that after the first event, we calculate a new
input polygon at the given height and start again - so we might see the algorithm
as executing on a pile of contours, one for every event, figure 57.
There are two obvious places to perform this check:

45
Figure 53: The intersections between edge-planes bcd and abd should be ignored.

Figure 54: The pointer structure between live corners and edges.

• Store a list of events between polygons - After an event, find new events
and remove old events involving each edge or bisector that’s changed.
• Store a list of events between planes (planes don’t have bounds) and before
evaluating an event, ensure it occurs within all three faces. This is the
simpler method I implemented.

One trick here (as Felkel[19] describes) is to realize that if two adjacent

46
Figure 55: In 1)ab two adjacent edges meet another edge in its centre, 2) shows
three consecutive edges colliding in 3)ab we see a variation where three consec-
utive edges that form a loop collide.

Figure 56: An overview of the data structure manipulation that occurs at each
type of event. See 60 for detailed explanation of the general case.

edges are involved, these two edges overlap and no collision test is needed. These
adjacent edges form Felkel’s[19] bisectors. As Eppstein[18] explains, reduces this

47
Figure 57: So far the collisions have been presented as infinite planes, however
we are really colliding a set of three sided polygons or faces. For example the
back edge (bold, 2) in the above figure changes it’s topology (red, 2) after some
of the events. After event b the face belongs to two volumes, and hence gives two
polygons to collide against. This means that for all of the three faces involved
in a collision we must ensure that a collision occurs within it’s bounds.

to a ray-casting problem against triangles that has very fast known solutions.
Each of the three types of collisions involves one or more pairs of adjacent
edge-planes colliding. The faces that are intersected are sometimes triangles,
but sometimes they are unbounded triangles, akin to quads with infinite areas.
This occurs when the bisectors do not collide.
Floating point calculations sometimes miss collisions that we expect, topo-
logically, to happen. However we can increase the chances of getting a topologi-
cally sound result if we increase the margin (epsilon-error range) until we catch
all collisions. There are two places where we need to be careful - in checking
that a collision really happens on an edge’s face and in finding events that hap-
pen at the same height or in the same place. I use a cylinder shaped volume
to accumulate events that occur at a given height range and within a certain
distance to a centre point58, similar to work in [31].

Figure 58: Given a set of detected collision points (circles), they should be
combined using an robust-epsilon technique for height, δ2 and radius, δ3

48
5.1.5 Many Edges Colliding
In a degenerate case, more than three planes can meet at one point. This
happens in the center of regular polygons, as well as examples such as figure 59,
where five or eight faces meet single points. Here I present a resolution algorithm
that processes pairs of adjacent corners, for any number of edges meeting at a
single point.

Figure 59: Many building’s footprints lead to more than three edge-planes col-
liding at one point. In this example there are two points where 5 and 8 edges
collide at once.

It is important that these occasions are detected and treated correctly, as we

assume that the linked-list of corners and their locations form a simple polygon
(when projected down onto the input plane) at all times. One of my contribu-
tions here is generalising some rules for handling point collisions, whether three
edge-planes, or more, meet at a point.
The collision resolution technique takes a set of planes that meet at a point
as input. It processes these into lists of chains of adjacent corners that reference
these edges. While constructing these chains we perform the face collisions to
determine which (if any) corner references the correct portion of the edge.
Chains consist of a counter-clockwise ordered lists of edges meeting at a
point. If the edges are adjacent during the collision, they are in the same chain.
We then perform the pointer manipulations intra-chain (figure 60) and inter-
cha(figure 61).

49
 In figure 60, a we see the input structure - a chain of edges abc and their
associated corners (dark blue circles). We now process each pair of edges that
are adjacent (orange lines) as in b and c:

• We remove each of these corners from the master-list. (note that inter-
corner pointers, green arrows, don’t need to be adjusted).

• We create output edges to the skeleton.

Then we process the non-adjacent edge pairs as in figure 60, d, adding in a new
input corner and finally adjusting the inter-corner pointers, (cutting out the
internal corners). However non-adjacent edge pairs take a little more thought
as multiple chains can collide at one point.
We then procede to process between the chains, figure 61, that is inter-chain
pointer updates. We still process corners by pairs, but this time we process the
three pairs that are non-adjacent. We order these around the collision point
(in the unweighted case this can be done by the angle any corner on the chain
makes with the collision point, but see later comments on the weighted case),
and process the pair made by first corner in the first chain, with the last corner
of the next.
Then we process the non-adjacent edge pairs as in figure 61 d, adding in a
new input corner and finally adjusting the inter-corner pointers, (cutting out the
internal corners). However non-adjacent edge pairs take a little more thought
as multiple chains can collide at one point.
For each of these pairs we add one additional corner that is adjacent to each
edge. This corner is at the location of the collision, and cuts out the inter-chain
corners from any edge loops.

5.1.6 Horizontal Output Edges

When evaluating rectilinear shapes, such as the cross-shape in figure 59, we often
see horizontal skeleton lines. This is another degenerate case that we often see
at the same time as the > 3 planes at a point case.
We can note that before processing events at one height, there should be no
adjacent edges that form a horizontal edge in the skeleton. We can see that this
is true because there must also be a collision at the other end of the horizontal
edge that should have already been processed and removed the edge. Also that
after processing there should be no such edges.
As all events co-heighted occur simultaneously there is no interaction be-
tween events and the algorithm is deterministic. That is it produces the same
result, whatever order the collisions are in, so we let them occur in an arbitrary
order.
After one event occurs we may be in the situation where two consecutive &
adjacent edges form a horizontal edge. Because this edge has no height, there
is no way to determine which events it causes can occur first, figure 62.
For this reason all face-collision checks for events at one height are performed
before any are evaluated. This is done by caching a list of chains. This brings
with it the problem that the corner used in a chain may have been superseded,
or ”cut off” from it’s intended collision (see figure below) by an earlier event at
the same height.

50
 Figure 60: Intra chain pointer manipulations.

Figure 61: Inter chain pointer manipulations.

The resolution strategy here depends on the chain type. If the chain has
more than one corner in it, it represents the intersection of two faces, so there
will always be a corner lying on this intersection whose adjacencies will lead to
the correct corner. If the chain is of length 1, we must resort to more geometric
calculations to project all referenced corners onto the input edge, and choose
the preceding corner.
As figure 63 shows, this is quite and involved procedure. Faces a,b,c,d and
e collide at point x. We find their positions in the given volumes by locating

51
Figure 62: In the above figure, there is a collision at x, then at the same height,
faces a,b,c &d collide at y. Face a should be rejected because we’re outside the
bisector. However as the edge forms a horizontal skeleton line, the bisector is
poorly defined (green boundaries), so we would have to accept that all four faces
collide, resulting in deformed output.

the corresponding corners. As co-heighted events occur in an arbitrary order,

by the time figure 2 occurs the corners (u & v) are no longer valid.
In the case of u (or any chain with 2+ edges), we can can use the follow-
ing corner’s previous corner to find u’. This is because the corner references
two edges used in a collision, so must take part it (and horizontal events are
independent - they can’t effect each other’s edges or validity).
This trick won’t work to find v’ as it is part of a chain of length 1. We
project all corners that reference the edge onto the collision line. We then use
the point (v’) that is just before the projected collision as the previous corner.
We ignore any points that reference the edge before the found corner. This is
valid as all these points lie on the edge’s plane, and all the points occur at the
same height, so their order is defined by their projection.

52
 Figure 63:

5.1.7 Negative edge gradients

By changing the weight or gradient of an edge, we can drastically change the
output shape. There is even the possibility of giving the edges a negative (out-
wards) gradient, to create “overhangs”.
No modifications are required to the given algorithm to allow these gradients.
It is interesting to note that negating the gradient, figure 64 produces the
same shape as reversing the polarity (loop direction) of the input, but with a
different final meaning - no longer is the result the top of the roof-shape (a
surface whose normals point upwards), it becomes the ceiling of the building
from the inside (a surface whose normals point downwards).
When edges have negative gradients, it becomes much harder to guarantee
termination of the skeleton; That is it may define an infinite volume. Sometimes
it will terminate, others not. Determining which polygons will terminate and
which won’t would be a good future research direction. Of course it is always
possible to specify an arbitrarily high horizontal plane, which terminates the
algorithm.

5.1.8 Ambiguous Weighted Skeleton

If two skeleton edge-planes are parallel and have the same direction, the inter-
section of their planes with a third is no longer a point (it is either a plane, a
line or not an intersection at all). This leaves the WSS ambiguously defined.
This is one of my contributions. This condition can occur in two places:

• the input polygon

53
 Figure 64: The effect of reversing the polarity on a collision.

• when intermediate edges are removed to being two parallel edges together

Figure 65: 1) an event in the construction of a WSS that is ambiguous. 2,3)

alternative resolution strategies that minimise or maximise the enclosed volume.

When two roof-planes of parallel edges collide, they form a horizontal bi-
sector. That is, the line of collision is parallel to the input polygon. If the
two edges have different directions then this is a roof ridge and the algorithm
proceeds as normal, assured that at the opposite end of the ridge the two roof
ridges will collide again. However if the directions are the same then we are
only able to obtain a degenerate bisector, figure 65. The ambiguity arises in not
knowing which surface gives way to which, because we cannot determine using
the horizontal bisector.
This is a mathematical ambiguity arising from a singularity in the weighted
case, and unrelated to issues of robustness.

54
Figure 66: Work done outside my PhD. Two identical bay windows that lead
to the same ambiguous case. The one on the left is resolved using the volume
minimising technique, the one on the right is volume maximising.

Depending on the configuration as the edges approach parallel, the result

is quite different, and so the limiting case is of little help when resolving these
situations. Because of the utility of a robust straight skeleton, this is an impor-
tant situation to define. We resolve the situation by selecting one roof-plane to
replace the others in the corner data structure, as in figure 66. This is the pri-
mary reason for the vertical clustering outlined earlier - we need to know which
ambiguous events must be treated at the same time, to preserve a meaningful
topology.
Aichholzer et al.[3] do not describe the weighted skeleton, and so do not
come across this situation in their text. I’m not aware of a description of the
weighted skeleton that avoids this ambiguity. However Eppstein [12] describes
the equivalent case in three dimensions.

5.1.9 Reconstructing Faces

Once the edges of the skeleton are known, it is desirable to be able to define
faces (we might want to tile our roof). There is one edge for each face. By
keeping a list of which corners are used by which edges, we are able to traverse
reconstruct the face, figure 67. We traverse the edge map once for each input
edge, following the complete graph created by the subset of the output edges
that are associated with an input edge.

5.2 Results
The results here are presented for completeness. They were generated from
work that did not take place under my PhD time quota.
This section has been censored by the Author. In lieu he gives these pretty
pictures (figure 68, 69).

55
Figure 67: Two cases of face reconstruction by following the map of edges, to
corners (orange dots) referenced by the input edge (orange line). The output
polygon (yellow) is another simple, monotonic, polygon.

6 Conclusions
In general Procedural Modelling is still a loosely defined field, it shows much
promise, but no single system of operation has emerged.
Procedural botany is a strong subject with solid commercial uses, meanwhile
procedural urban studies are just starting to make progress, and very little work
has been done towards procedural fauna.
Biologically inspired techniques are robust, but hard to control. They are
also expensive to evaluate. They’ve shown us that attempting to engineering
algorithms that imitate phenomena, such as Phyllotaxis, isn’t as good as un-
derstanding the phenomena directly. However when dealing with man-made
geometry, it is too complicated to model the thought processes and decisions
that are made, so sometimes there are no options, except to pick an algorithm
that gives a close result.
There are some discrete geometric algorithms, such as the straight skele-
ton and Voronoi tessellation that may make it affordable to create biologically
inspired models.
Architectural theory is at best analytical, rather than generative. Little
useful work in generative architectural studies has been performed. The best
generative work is still coming out of the computer science community. However
architectural theory may be useful for evaluating any results. It is easy to check
that a solution satisfies the constraints, even if we cannot generate the solution
from the constraints. (Like all good NP problems).
Generally urban modelling is a multi-scale problem. There are many varying
patterns, with many subtleties, at a wide range of scales. We are just beginning
to find tools to help us build those patters, and we are still a little way away
from giving those tools to artists to use.

56
Figure 68: A range of building styles that can be generated with this technique.
None of these models took longer that a few minutes to create, and all used less
than a second of CPU time on a 2009 machine.

7 Future Directions
Procedural geometry is a subject that is still being defined. Here I outline
some of the many unanswered questions that I have stumbled across, before
summarising some likely final theses for my PhD.

7.1 Spectrum of Proceduralizations

The study of procedural modelling takes place between two extremes, the arbi-
trary and the instance. A general language can describe an infinite number of
arbitrary geometries, while the instance is a single, unchanging object. How-
ever an instance is ready to use, while a language takes a lot of work to create
a model. Furthermore an instance requires no intelligence on the part of the
user and guarantees good results, while a fully general language requires lots of
intelligence and provides no assurances as to the final quality of the geometry.

57
 Figure 69: A haunted house, created in 15 minutes.

In order for procedural geometry to be useful, it must fill a particular need

in this scale. For example an artist may have an instance he wishes to procedu-
ralize, or a town planner may wish to “place some tall building around here”.
Existing packages, such as CityEngine, ask a user to program in a general envi-
ronment and this makes it very difficult for procedural geometry to be used by
the layman.

7.2 Evaluation of Procedural Systems

Like many new uses for computing, the emphasis so far has been on showing that
procedural systems are a viable and useful technology. To be able to judge the
success of a procedural system we need to evaluate it somehow. Given the many
possible uses for procedural technology, there are many different evaluation
criteria.

• Fastest
• Cheapest
• Most believable
• Most diverse

• Ease of use

Whilst the objective criteria can be measured easily enough, the subjective
criteria pose more of a problem. For example, testing the believability of a
procedural, fictional, castle is a subjective, yet critically important aspect of
development. We cannot ask for subjective response on the model, as it would be

58
meaningless to the man on the street. We cannot ask for a subjective response on
a single instance itself, as we must evaluate the procedural model. Attempting
to evaluate a representative sample of instances is quite an involved task.

7.3 Thesis Subject

As we require more detailed geometry, there is a trend towards increasingly
expressive grammars, using context sensitivity at a grammar level and selfsensi-
tivity at a geometric level. Trying to create an intuitive, easily editable language
that provides the required inputs for these systems is difficult and this has led
to procedural techniques being successful only in limited domains. Indeed some
recent systems avoid an intricate grammar in the search for simplicity. Growth
based primitives, such as the straight skeleton, may allow simple grammars to
create more complex shapes. Therefore I propose to study the following thesis:
It is possible to create a wide range of urban geometry using space coloniza-
tion -

• There is a compact growth-oriented representation of many styles of ar-

chitecture.
• This representation is inherently procedural in its nature.
• There exists an user interface to create procedural urban environments
from space colonization primitives.

7.4 The Future

My work over the next few months will be to complete the straight skeleton
project, extending it to work on non flat terrain and allow arbitrary roof-face
insertion. I also hope to have to increase the speed of the algorithm so it may
be used on large scale architectures, such as castles.
A general plan for the next two years follows.
Foreground Work weeks
Finish current skeleton implementation 8
Design 3D skeleton implementation 2
Build 3D Skeleton 8
Prototype control methods for the 3D skeleton (user interface and code) 7
Build lower dimension skeletons and growth generators 8
Investigate overlap between Straight Skeleton and Voronoi tessellation 4
(Maybe implement Voronoi tessellation) 4
Design Interface for Combining Growth Primitives 3
Evaluate design for interface of graph before building 2
Build the interface 4
Short evaluation of the interface 6
Create a wide range of examples with the system 4
Write up the thesis 32
(Holiday over 24 months) 12
Total 104

59
Background Work weeks
Computational graphics algorithms 4
Cellular Automata and Growth 4
Methods of continuous and discrete growth 4
Uses of Growth in Architectural Theory 4
Other uses of growth algorithms 4
Evaluate tools available to current artists 4
Evaluate tools available to current architects and designers (CAD) 4
Methods for combining procedural operators 4
Total 32

60
References
[1] Develop insider. 69.
[2] Reaction oscillante de belousov-zhabotinsky.
[3] O. Aichholzer, F. Aurenhammer, D. Alberts, and B. Grtner. A novel type of
skeleton for polygons. Journal of Universal Computer Science, 1(12):752–
761, 1995.
[4] Bruce Alberts, Alexander Johnson, Peter Walker, Julian Lewis, Martin
Raff, and Keith Roberts. Molecular Biology of the Cell. Garland Publishing,
2008.
[5] Christopher Alexander, Sara Ishikawa, and Murray Silverstein. A Pattern
Language: Towns, Buildings. Oxford University Press, later printing edi-
tion, August 1977.
[6] Saif Ali, Jieping Ye, Anshuman Razdan, and Peter Wonka. Compressed
facade displacement maps. IEEE Transactions on Visualization and Com-
puter Graphics, 15:262–273, 2008.
[7] Daniel G. Aliaga, Paul A. Rosen, and Daniel R. Bekins. Style grammars
for interactive visualization of architecture. IEEE Transactions on Visual-
ization and Computer Graphics, 13(4):786–797, 2007.
[8] Daniel G. Aliaga, Carlos A. Vanegas, and Bedřich Beneš. Interactive
example-based urban layout synthesis. ACM Trans. Graph., 27(5):1–10,
2008.
[9] Fabricio Anastacio, Przemyslaw Prusinkiewicz, and Mario Costa Sousa.
Sketch-based interfaces and modeling (sbim): Sketch-based parameteriza-
tion of l-systems using illustration-inspired construction lines and depth
modulation. Comput. Graph., 33(4):440–451, 2009.
[10] Peter F. Ash1l and Ethan D. Bolker. Generalized dirichlet tessellations.
Geometriae Dedicata, 20:209–243, 1984.
[11] Shai Avidan and Ariel Shamir. Seam carving for content-aware image
resizing. ACM Trans. Graph., 26(3):10, 2007.
[12] Gill Barequet and Amir Vaxman. Straight skeletons of three-dimensional
polyhedra. In SCG ’09: Proceedings of the 25th annual symposium on
Computational geometry, pages 100–101, New York, NY, USA, 2009. ACM.
[13] Jules Bloomenthal. Modeling the mighty maple. SIGGRAPH Comput.
Graph., 19(3):305–311, 1985.
[14] Stewart Brand and Penguin U. S. A. Paper. How Buildings Learn: What
Happens After They’re Built. Penguin Books, October 1995.
[15] Eric Bruneton and Fabrice Neyret. Real-time rendering and editing of
vector-based terrains. In Eurographics, 2008.
[16] N. Chomsky. Three models for the description of language. Information
Theory, IRE Transactions on, 2(3):113–124, January 1956.

61
[17] Phillippe de Reffye, Claude Edelin, Jean Françon, Marc Jaeger, and Claude
Puech. Plant models faithful to botanical structure and development. In
SIGGRAPH ’88: Proceedings of the 15th annual conference on Computer
graphics and interactive techniques, pages 151–158, New York, NY, USA,
1988. ACM.
[18] David Eppstein and Jeff Erickson. Raising roofs, crashing cycles, and play-
ing pool: applications of a data structure for finding pairwise interactions.
In SCG ’98: Proceedings of the fourteenth annual symposium on Compu-
tational geometry, pages 58–67, New York, NY, USA, 1998. ACM.
[19] Petr Felkel and Stepn Obdrzlek. Straight skeleton implementation. In
Proceedings of Spring Conference on Computer Graphics, pages 210–218,
1998.
[20] Dieter Finkenzeller. Detailed building facades. IEEE Computer Graphics
and Applications, 28:58–66, 2008.
[21] S Fortune. A sweepline algorithm for voronoi diagrams. In SCG ’86:
Proceedings of the second annual symposium on Computational geometry,
pages 313–322, New York, NY, USA, 1986. ACM.
[22] M. Gardner. The fantastic combinations of John Conway’s new solitaire
game “life”. Scientific American, 223:120–123, October 1970.
[23] Björn Gerth, René Berndt, Sven Havemann, and Dieter W. Fellner. 3d
modeling for non-expert users with the castle construction kit v0.5. In
VAST 2005: 6th International Symposium on Virtual Reality, Archaeology
and Intelligent Cultural Heritage, pages 49–58, November 2005.
[24] N. Greene. Voxel space automata: modeling with stochastic growth pro-
cesses in voxel space. In SIGGRAPH ’89: Proceedings of the 16th annual
conference on Computer graphics and interactive techniques, pages 175–
184, New York, NY, USA, 1989. ACM.
[25] John C. Hart and Brent Baker. Structural simulation of tree growth and
response. In In: Proceedings International Conference on Shape Modeling
and Applications, pages 7–11. Springer-Verlag, 1996.
[26] Sven Havemann and Dieter Fellner. Generative parametric design of gothic
window tracery. Shape Modeling and Applications, International Confer-
ence on, 0:350–353, 2004.
[27] Bill Hillier and Christian Altmann. Space is the machine, 1996.
[28] M Karavelas and M Yvinec. 2d apollonius graphs (delaunay graphs of
disks).
[29] Yoichiro Kawaguchi. A morphological study of the form of nature. In
SIGGRAPH ’82: Proceedings of the 9th annual conference on Computer
graphics and interactive techniques, pages 223–232, New York, NY, USA,
1982. ACM.
[30] T. W. Knight. The generation of hepplewhite-style chair-back designs.
Environment and Planning B, 7(2):227–238, 1980.

62
[31] Rüdiger Köhling, Jens Reinel, Jan Vahrenhold, Klaus H. Hinrichs, and
Erwin-Josef Speckmann. Spatio-temporal patterns of neuronal activity:
Analysis of optical imaging data using geometric shape matching. Journal
of Neuroscience Methods, 114(1):17–23, 2002.
[32] Chris G. Langton. Computation at the edge of chaos: phase transitions
and emergent computation. Phys. D, 42(1-3):12–37, 1990.
[33] M. Li, F. C. Langbein, and R. R. Martin. Constructing regularity feature
trees for solid models. In Proc. Geometric Modeling and Processing; LNCS,
pages 267–286. Springer, 2006.
[34] Aristid Lindenmayer. Mathematical models for cellular interactions in de-
velopment ii. simple and branching filaments with two-sided inputs. Journal
of Theoretical Biology, 18(3):300–315, March 1968.

[35] Markus Lipp, Peter Wonka, and Michael Wimmer. Interactive visual edit-
ing of grammars for procedural architecture. ACM Transactions on Graph-
ics, 27(3):102:1–10, August 2008. Article No. 102.
[36] Markus Lipp, Peter Wonka, and Michael Wimmer. Interactive visual edit-
ing of grammars for procedural architecture. ACM Trans. Graph., 27(3):1–
10, 2008.
[37] Paul Merrell. Example-based model synthesis. In I3D ’07: Proceedings of
the 2007 symposium on Interactive 3D graphics and games, pages 105–112,
New York, NY, USA, 2007. ACM.

[38] Paul Merrell and Dinesh Manocha. Continuous model synthesis. ACM
Trans. Graph., 27(5):1–7, 2008.
[39] William J. Mitchell. The automated generation of architectural form. In
DAC ’71: Proceedings of the 8th Design Automation Workshop, pages 193–
207, New York, NY, USA, 1971. ACM.

[40] William J. Mitchell. The Logic of Architecture: Design, Computation, and

Cognition. MIT Press, Cambridge, MA, USA, 1990.
[41] N. J. Mitra, L. Guibas, and M. Pauly. Partial and approximate symmetry
detection for 3d geometry. In ACM Transactions on Graphics, volume 25,
pages 560–568, 2006.

[42] Pascal Müller, Peter Wonka, Simon Haegler, Andreas Ulmer, and Luc
Van Gool. Procedural modeling of buildings. ACM Trans. Graph.,
25(3):614–623, 2006.
[43] Radomı́r Měch and Przemyslaw Prusinkiewicz. Visual models of plants
interacting with their environment. In SIGGRAPH ’96: Proceedings of the
23rd annual conference on Computer graphics and interactive techniques,
pages 397–410, New York, NY, USA, 1996. ACM.
[44] Laycock University Of, R. G. Laycock, and A. M. Day. Automatically
generating roof models from building footprints, 2003.

63
[45] Department of Trade and Industry. From exuberant youth to sustainable
maturity. competitiveness analysis of the uk games software sector., 2002.

[46] Wojciech Palubicki, Kipp Horel, Steven Longay, Adam Runions, Brendan
Lane, Radomı́r Měch, and Przemyslaw Prusinkiewicz. Self-organizing tree
models for image synthesis. ACM Trans. Graph., 28(3):1–10, 2009.
[47] Yoav I. H. Parish and Pascal Müller. Procedural modeling of cities. In
SIGGRAPH ’01: Proceedings of the 28th annual conference on Computer
graphics and interactive techniques, pages 301–308, New York, NY, USA,
2001. ACM.
[48] Mark Pauly, Niloy J. Mitra, Johannes Wallner, Helmut Pottmann, and
Leonidas J. Guibas. Discovering structural regularity in 3d geometry. In
SIGGRAPH ’08: ACM SIGGRAPH 2008 papers, pages 1–11, New York,
NY, USA, 2008. ACM.
[49] P. Prusinkiewicz and A. Lindenmayer. The Algorithmic Beauty of Plants.
Springer Verlag, 1991.
[50] Przemyslaw Prusinkiewicz, Mark James, and Radomı́r Měch. Synthetic
topiary. In SIGGRAPH ’94: Proceedings of the 21st annual conference on
Computer graphics and interactive techniques, pages 351–358, New York,
NY, USA, 1994. ACM.
[51] Adam Runions, Brendan Lane, and Przemyslaw Prusinkiewicz. Modeling
trees with a space colonization algorithm. In Eurographics Workshop on
Natural Phenomena, 2007.

[52] A Schlegel. Biological systems, models, and algorithms.

[53] Richard S. Smith, Soazig Guyomarc’h, Therese Mandel, Didier Reinhardt,
Cris Kuhlemeier, and Przemyslaw Prusinkiewicz. A plausible model of
phyllotaxis. Proceedings of the National Academy of Sciences of the United
States of America, 103(5):1301–1306, 2006.

[54] G Stiny and W J Mitchell. The palladian grammar. Environment and

Planning B: Planning and Design, 5(1):5–18, January 1978.
[55] George Nicholas Stiny. Pictorial and formal aspects of shape and shape
grammars and aesthetic systems. PhD thesis, 1975.

[56] K. Sugihara and M. Iri. Construction of the voronoi diagram for ’one
million’ generators in single precision arithmetic. Proc IEEE., 80:1471–
1484, 1992.
[57] A. M. Turing. The chemical basis of morphogenesis. Philosophical Trans-
actions of the Royal Society of London. Series B, Biological Sciences,
237(641):37–72, 1952.
[58] twak. Morphogens Simulation, January 2009. [online] http://www.dcs.
gla.ac.uk/~tkelly/bits/morphogens/launch.jnlp.

64
[59] C Vanegas, D Aliaga, P Müller, P. Waddell, B. , Watson, P. Wonka, and
Tanzima Zerin Islam. Modeling the appearance and behavior of urban
spaces, Nov 2009.

[60] G Voronoi. Nouvelles applications des paramtres continus la thorie des

formes quadratiques. J. reine angew. Math., 133:97–178, 1907.
[61] D. F. Watson. Computing the n-dimensional delaunay tessellation with
application to voronoi polytopes. The Computer Journal, 24(2):167–172,
February 1981.
[62] Basil Weber, Pascal Mueller, Peter Wonka, and Markus Gross. Interactive
geometric simulation of 4d cities. Computer Graphics Forum, April 2009.
[63] Peter Wonka, Michael Wimmer, François Sillion, and William Ribarsky.
Instant architecture. In SIGGRAPH ’03: ACM SIGGRAPH 2003 Papers,
pages 669–677, New York, NY, USA, 2003. ACM.

65