Conference PaperPDF Available

A constrained growth method for procedural floor plan generation

Ricardo Lopes1, Tim Tutenel1, Ruben M. Smelik2, Klaas Jan de Kraker2, and Rafael Bidarra1
1Computer Graphics Group, Delft University of Technology, Delft, the Netherlands
2Modelling, Simulation and Gaming Department, TNO, The Hague, the Netherlands
Virtual worlds, procedural modeling, floor plan genera-
Modern games often feature highly detailed urban envi-
ronments. However, buildings are typically represented
only by their fa¸cade, because of the excessive costs it
would entail to manually model all interiors. Although
automated procedural techniques for building interiors
exist, their application is to date limited. One of the rea-
sons for this is because designers have too little control
over the resulting room topology. Also, generated floor
plans do not always adhere to the necessary consistency
constraints, such as reachability and connectivity. In
this paper, we propose a novel and flexible technique for
generating procedural floor plans subject to user-defined
constraints. We demonstrate its versatility, by showing
generated floor plans for different classes of buildings,
some of which consist of several connected floors. It
is concluded that this method results in plausible floor
plans, over which a designer has control by defining func-
tional constraints. Furthermore, the method is efficient
and easy to implement and integrate into the larger
context of procedural modeling of urban environments.
Game worlds increasingly often feature highly detailed
open worlds. Notable recent examples include Assassin’s
Creed, GTA IV and Oblivion, where players can explore
beautiful cities, of which each building has been modeled
by hand. Manual modeling of these city models involves
an enormous amount of effort, putting a huge burden
on the budget for game development companies. In
particular, this is the reason that, in games, city buildings
either have no interior (they consist only of a fa¸cade)
or a fixed set of interiors is repeated all over the city.
Urban environments are therefore one of many areas
where automated procedural generation methods can
excel, by providing a limitless amount of varied content
for a fraction of the cost.
The procedural generation of a city entails a number of
ingredients, each with its specific procedures and genera-
tion techniques: district topology (city center, suburbia),
road network (ring road, streets), division of open space
into parcels (building lots), building fa¸cades, floor plans
(room layouts) and interior furniture (chairs, tables).
In this paper, we focus on an important if somewhat
neglected ingredient: floor plans. We propose a novel
and flexible technique for generating procedural floor
plans subject to user-defined constraints. Using these
constraints, game designers control both the topological
layout of the building (e.g. which room comes next to
which other room) and the areas of the room. Further-
more, the method guarantees reachability of all rooms
and over multiple floors.
The remainder of this paper is structured as follows.
We first survey previous work on procedural modeling
of urban environments, focusing on floor plan genera-
tion. Then we present our constrained growth method
for procedural floor plans. We show several example
building interiors generated by this technique. And last,
we discuss our method advantages and limitations, and
propose future extensions and potential applications.
Procedural modeling techniques have been proposed for
almost every aspect of virtual worlds, ranging from land-
scapes to buildings. An extensive survey of procedural
modeling techniques can be found in Smelik et al. (2009).
Regarding buildings, L-systems, previously applied to
plant models (Prusinkiewicz and Lindenmayer 1990),
were among the first automated techniques used for
building fa¸cades (Parish and M¨uller 2001). In recent
years, more specialized rewriting systems have been pre-
sented for this purpose: the split grammars (Wonka et al.
2003) and shape grammars (M¨uller et al. 2006).
Here, we focus on procedural techniques for building floor
plans, i.e. the creation of a suitable layout of the different
rooms inside a building. Greuter et al. (2003) create a
floor plan as a combination of 2D shapes. However, this
floor plan is only used for extruding building fa¸cades.
Shape grammars, typically applied to building fa¸cades,
can also create floor plans, as shown by Rau-Chaplin
et al. (1996) in their LaHave House project. Their system
generates a library of floor plans, each of which can be
customized and automatically transformed into assembly
drawings. It uses shape grammars to create a plan
schema containing basic room units. Possible groupings
of individual units are recognized to define functional
zones like public, private or semi-private spaces. After
generating the required geometric data, such as the room
unit dimensions and the location of walls, a specific
function is assigned to each room. The rooms are filled
with furniture, by fitting predefined layout tiles from an
extensive library of individual room layouts.
Martin (2006) proposes a graph-based method, in which
nodes represent the rooms and edges correspond to con-
nections between rooms (e.g., a door). This graph is
generated by a user-defined grammar. Starting from the
front door, public rooms are added. Each of these public
rooms is assigned a specific function (dining room, living
room, etc.). Subsequently, private rooms are attached to
the public rooms and, finally, stick-on rooms like closets
or pantries are introduced. This graph is transformed to
a spatial layout, by determining a 2D position for each
room. For each node, depending on the desired size of
the room, a specific amount of ”pressure” is applied to
make it expand and fill up the remaining building space.
Hahn et al. (2006) present a method tailored for generat-
ing office buildings. Starting from the building structure,
they first position all elements that span across multiple
floors, e.g. elevator shafts, staircases. Then, the building
is split up into a number of floors. On each of them a
hallway subdivision is applied, adding straight hallway
segments or rectangular loops. Next, the remaining re-
gions are subdivided into rooms, for which geometry is
created and appropriate objects are placed. A notable
feature of this system is that each step is executed just
in time: based on the player’s position, floors and rooms
are generated or discarded. A discarded room can be re-
stored exactly in its previous state, by re-using the same
random seed in the procedure, followed by re-applying
all changes to its objects, caused by the player.
Marson and Musse (2010) introduce a room subdivision
method based on squarified treemaps. Treemaps recur-
sively subdivide an area into smaller areas, depending
on a specific importance criterion. Squarified treemaps
simultaneously try to maintain a length to width ratio
of 1. Their methods input is the basic 2D shape of the
building and a list of rooms, with desired dimensions
and their functionality, e.g. social area, service area and
private area. First these functionality areas are added
to the treemap. These areas are again subdivided to
create each room. Possible connections between room
types are pre-defined; based on this, doors are placed
between the rooms in the generated floor plan. Using
the A* algorithm, a shortest path is determined, visiting
all rooms that need a connection with the corridor. This
path is transformed into a corridor, and all rooms are
adjusted to make room for it.
Tutenel et al. (2009) applied a generic semantic layout
solving approach to floor plan generation. Every type of
room is mapped to a class in a semantic library. For each
of such semantic classes, relationships can be defined. In
this context, constraints typically define room-to-room
adjacency, however, other constraints can be defined as
well, e.g. place the kitchen next to the garden, or the
garage next to the street. For each room to be placed,
a rectangle of minimum size is positioned at a location
where all defined relation constraints hold, and all these
rooms expanded until they touch other rooms.
A general overview of the application of constraint solv-
ing in procedural generation can be found in (Tutenel
et al. 2008). Particularly, several approaches define the
creation of room layouts as a space planning problem.
Charman (1993) gives an overview of constraint solv-
ing techniques that, although not specifically focused
on space planning, can be applied to these problems.
He compares several space planners and discusses the
efficiency of these solvers. Due to many recent improve-
ments on constraint solving techniques, his efficiency
concerns are no longer relevant. However, the discussed
planners are still suitable for layout solving. For instance,
the planner he proposed (Charman 1993) works on the
basis of axis-aligned 2D rectangles with variable position,
orientation and dimension parameters, for which users
can express geometric constraints, possibly combined
with logical and numerical operators.
These constraint solving techniques create rectangular
shapes, subject to dimension and adjacency constraints.
However, they are typically quite complex and can still be
time consuming. Moreover, many of them cannot handle
irregular shapes, e.g. L-shaped or U-shaped rooms, which
incidentally also holds for many of the other techniques
discussed above. This is one of the main drawbacks of all
these approaches. Our growth-based approach generates
more flexible results, and does that faster than other
constraint solving techniques.
This section discusses a novel method for procedurally
generating floor plans. The problem of generating floor
plans is primarly a problem of generating the appropri-
ate layout for rooms, i.e. their location and area. We
believe that a proper procedural floor plan is one that
follows the same principles (and, as a consequence, the
appearance) of real building architecture. Our method
has drawn its inspiration from real life architectural floor
plans, where geometric grids are used as a canvas for
hand drawing building interiors. Fig. 1 illustrates a real
architectural floor plan example, where a point grid is
visible. Our method uses a grid-based algorithm for
placing and growing rooms within a building layout. We
describe how this algorithm hierarchically creates a floor
plan by generating building zones followed by its room
areas, both of which are constrained by adjacency and
connectivity relationships.
Figure 1: Example of a real architectural floor plan,
using a geometric point grid
Hierarchical layout
The building layout is defined in a hierarchic manner.
Certain types of rooms can be grouped, allowing the
building to be subdivided in zones for these room groups,
followed by subdividing these zones into sub-zones, or
into specific rooms. This approach is similar to the
method of Marson and Musse (2010), which was dis-
cussed above. An example of a simple hierarchic building
layout is shown in Fig. 2. In this example, we subdivide
a house into two zones: a public zone and a private zone.
The public zone is then subdivided into a dining room,
a kitchen and a living room and the private zone into
a hallway, two bedrooms and a bathroom. This entails
that the room generation algorithm is applied twice, once
for each level in the hierarchy. Note that this hierarchy
can of course have more than two levels.
Because of the hierarchic approach, we do not allow
adjacency constraints to be defined between two rooms
from different zones. We can however put adjacency
constraints between a room and a parent zone, e.g. in
the previous example, we can demand that the hallway
from the private zone is adjacent to the public zone to
allow a connection with this public zone through the
Figure 2: This is an example of a hierarchic subdivision
of a building. (a) shows a building subdivided into
two areas, (b) shows these areas subdivided into their
required rooms.
Room placement
Our method uses a grid as the basis for the room place-
ment and expansion process. There are two advantages
in using this representation. Firstly, it maps closely to
the way architects design floor plans. Secondly, it is effi-
cient to traverse and expand in a 2D grid, which allows
our floor plan generation method to execute fast. Our
grid representation (a matrix) does not limit a floor to a
rectangular shape. We fit non-rectangular buildings in a
grid that includes space marked as outdoor.
The method starts with a building footprint polygon,
which we rasterize into the 2D grid. Additional input
the grid cell dimension in meters (e.g. 0.5m);
a list of room areas to generate;
for each room area its corresponding house zone
(public, private, hallway) and its preferred relative
area (or size ratio);
adjacency and connectivity constraints.
The output it produces is a floor plan, consisting in room
areas, interior and exterior walls, and doors.
In the room placement phase, the initial positions for
each room are determined. For this, we create a separate
grid of weights of the same dimensions as the building
grid. Initially, cells inside the building get a weight of
one and cells outside get a weight of zero. Many of the
rooms in a building are preferably placed next to an outer
wall. Therefore, to apply this constraint, the weights
are altered. A straightforward way to do this would be
to set weights of cells not connected to the outside to
zero. However, placing initial positions adjacent to a
wall does not always result in plausible results, as they
tend to cause less regular room shapes. Therefore, we
use a different approach. Based on the size ratio of the
room and the total area of the building, we can estimate
a desired area of the room. Cells positioned at least a
specific distance (based on this estimated area) away
from the walls are assigned a weight of 1. This results
in much more plausible room shapes.
This phase also deals with the defined adjacency con-
straints. The adjacency constraints are always defined
between two rooms, e.g. the bathroom should be next
to the bedroom, the kitchen should be next to the living
room, etc. When selecting the initial position of a room,
we use the adjacency constraints to determine a list of
rooms it should be adjacent to. We check whether these
rooms already have an initial position. If there is, we
alter the weights to high values in the surroundings of
the initial positions of the rooms it should be adjacent to.
This typically results in valid layouts; however there is a
small chance that the algorithm grows another room in
between the rooms that should be adjacent. To handle
this case, we reset the generation process if some of the
adjacency constraints were not met.
Based on these grid weights, one cell is selected to place
a room, and the weights around the selected cell are
set to zero, to avoid several initial positions of different
rooms to be too close to each other.
Room expansion
We use a growth-based method for determining the pre-
cise shape of rooms. Our algorithm gradually grows
rooms from initial room positions until the building inte-
rior is filled. The expansion process is done by appending
adjacent grid cells to rooms.
Algorithm 1 outlines the expansion of rooms in our
method. It starts with a grid
containing the initial
positions of each room. It then picks one
at a time,
selected from a set of available
), and
expands the room shape to the maximum rectangular
space available (
). This is done until no more
rectangular expansions are possible. At this point, the
process resets
to the initial set, but now considers
expansions that lead to L-shaped rooms (
In a final step, the algorithm scans for remaining empty
cells and assigns them to a nearby room (FillGaps).
Algorithm 1: Room expansion algorithm
in : A list of rooms to be placed l
in : A list of room area ratios r
in : A building grid m
out : A floor plan defined in m
rooms BuildRoomSet(l);
while rooms 6=do
room SelectRoom(rooms, r);
canGrow GrowRect(room, m, r[room]);
if ¬canGrow then
rooms \ {room};
rooms BuildRoomSet(l);
while rooms 6=do
room SelectRoom(rooms, r);
canGrow GrowLShape(room, m);
if ¬canGrow then
rooms \ {room};
if HasEmptySpaces(m)then
the next room to be expanded is chosen
on the basis of the defined size ratios
for each room.
The chance for a room to be selected is its ratio relative to
the total sum of ratios, defined in
. With this approach,
variation is ensured, but the selection still respects the
desired ratios of room areas.
The first phase of this algorithm is expanding rooms
to rectangular shapes (
). In Fig. 3 we see an
example of the start situation (a) and end (b) of the
rectangular expansion phase for a building where rooms
black, green and red have size ratios of, respectively, 8, 4
and 2. Starting with rectangular expansion ensures two
characteristics of real life floor plans: (i) a higher priority
is given to obtain rectangular areas and (ii) the growth is
done using the maximum space available, in a linear way.
For this, all empty line intervals in the grid
to which
the selected
can expand to are considered. The
maximum growth, i.e. the longest line interval, which
leads to a rectangular area is picked (randomly, if there
are more than one candidates). A room remains available
for selection until it can not grow more. This happens if
there are no more directions available to grow or, in the
rectangular expansion case, if the room has reached its
maximum size. This condition also prevents starvation
for lower ratio rooms, since size ratios have no relation
with the total building area. In Fig.3 (b), all rooms have
reached their maximum size.
Of course, this first phase does not ensure that all avail-
able space gets assigned to a room. In the second phase,
all rooms are again considered for further expansion,
now allowing for non-rectangular shapes. The maximum
growth line is again selected, in order to maximize ef-
ficient space use, i.e. to avoid narrow L-shaped edges.
In this phase, the maximum size for each room is no
longer considered, since the algorithm attempts to fill all
the remaining empty space. Furthermore we included
mechanisms for preventing U-shaped rooms. Fig. 3 (c)
illustrates the result of the L-shaped growth step on the
previous example. The final phase scans the grid for
remaining empty space; this space is directly assigned
to the room which fills most of the adjacent area.
With the described mechanism, our growth algorithm
generates valid floor plans. Even with all the constraints,
each room layout problem has many valid solutions.
Therefore, there is quite some variation in generated floor
plans. Since our grid-based algorithm is fast enough, we
can collect multiple alternative solutions for each situa-
tion. We execute our growth algorithm N(parametriz-
able) times, obtaining Ndifferent but valid floor plans.
We can either randomly select one of alternatives, or
we can evaluate and rank the solutions (by e.g. prefer-
ence for smaller hallways or the least amount of corners
in room), and pick the best solution. Post-processing
will convert the grid to a geometric representation of
rooms, and ensures the creation of doors and windows
or extrusion of walls.
Room connectivity
Our method ensures connectivity between rooms by pro-
cedurally placing inner doors. This process is more
elaborate than simply making all rooms reachable from
e.g. the entrance of the building. For plausible results,
(a) (b) (c)
Figure 3: Example for the room expansion algorithm: (a) initial room positions (b) rectangular growth (where rooms
reached their maximum size) (c) L-Shape growth.
room connectivity needs to influence and be influenced
by the topology of the building. We achieved this us-
ing connectivity constraints combined with a specialized
connectivity algorithm.
Connectivity constraints, declared as input, state that
two rooms should be directly connected. Stating that
room A should be connected to room B will create a door
that opens from room A to room B. These constraints
influence the room layout, as they are also interpreted
as adjacency constraints. After placement and expan-
sion of rooms, we proceed to a post-processing phase,
in which, among other things, our connectivity algo-
rithm is executed. For this, the grid representation is
no longer appropriate, as it is more natural to consider
inner walls rather than room areas. Therefore, in this
post-processing phase matching inner walls for the rooms
are created first.
The connectivity algorithm places doors in these walls,
influenced by the building topology and connectivity
constraints. It should ensure the common connectivity
principles of a building (e.g. hallway always leads to
adjacent public rooms), while the constraints should only
be used to declare specific cases. Our aim is to emulate
real life architecture in its basic connectivity concepts,
independent of style or type of buildings. Therefore, we
use the notion of private and public rooms to decide on
door placement. The goal is to create full connectivity,
while respecting room privacy.
Our algorithm starts by placing doors between rooms
for which connectivity was explicitly declared. Next,
it connects any hallway to all of its adjacent public
rooms. Unconnected private rooms are then connected,
if possible, to an adjacent public room. Publics rooms
with no connections are connected to an adjacent public
room as well. Finally, our last step is a reachability test.
We examine all rooms and if any is not reachable from
the hallway, we use the adjacency relationships between
rooms to find a path to the unreachable room, and create
the necessary door(s).
With this algorithm, public rooms (and in particular the
hallway) have priority to become focal points, in terms
of connectivity to private rooms. We wanted to bring
about the situation where, for example, two adjacent
private rooms are connected through a common public
room, instead of having a direct door between them. The
hierarchical layout ensures rooms distribution in such a
way that this setup is possible.
The creation of an inner door is implemented in a simple
manner. First, we select a shared wall between the two
rooms to connect, in which the door fits. Next, we
randomly select a segment of that wall and place the
door in its midpoint. Finally, doors are assigned to open
towards the destination room with its hinge towards the
closest corner of the wall.
Living room
Figure 4: Example of a relatively simple floor plan in-
cluding four rooms and a hallway.
This section provides examples of floor plans generated
with our method. The first example is a relatively simple
rectangular building (11 x 9 m), for which no hierarchy is
defined, and which should contain four rooms (a bedroom,
a bathroom, a kitchen and a living room) and a hallway.
We defined a connectivity constraint between the kitchen
and the living room. An example of a generated floor
plan for this building is shown in Fig. 4. Notice that the
connectivity constraint is satisfied, and that all rooms
are reachable. Generating these kind of floor plans takes
less than 100 ms.
Bedroom 2
Bedroom 3
Bathroom 2
Great room
Kitchen and
dining room
Master bedroom
Master bathroom
Bedroom 2 Bedroom 3
Bathroom 2
Great room
Kitchen and dining room
Master bedroom
Master bathroom
Figure 5: Two examples of a more complex floor plan, built up of a public zone with a great room and kitchen and
dining room, a private zone with a master bedroom and walk-in closet, master bathroom and a private zone with a
hallway, a bathroom and two bedrooms.
In our second example, we show more complex floor
plans, inspired from real floor plans of North-American
style villas. The building (which is L-shaped, measuring
17 x 20 m with a top part of 7 x 9.5m and a bottom part
of 17 x 10.5 m) is subdivided into three areas: one public
and two private zones. There are adjacency constraints
defined between the public area and the two private
areas. The public area includes a great room and a room
for a kitchen and a dining area. These rooms have a
connectivity constraint defined. The first private area
includes a master bedroom with an adjacency constraint
to the public area, a master bathroom and a walk-in
closet both connected to the master bedroom. The
second private area includes a hallway with an adjacency
constraint to the public area and three other rooms (a
bathroom and two additional bedrooms), all connected
to this hallway. Two floor plan examples for this building
are shown in Fig. 5.
One clearly notices L-shaped areas not only for the indi-
vidual rooms but also for the different areas within the
floor plan. This creates more varied and less restrictive
results than methods that are limited to rectangular
rooms. Because of the increased complexity these floor
plans take longer to generate: on average around one
second per floor plan.
In our method, we included a simple mechanism for
placing exterior elements, i.e. outer doors and windows.
These wall elements are declared as requirements for
each room. They are placed using the same method as
for inner doors. The results show that these elements
are placed correctly, if there is space available. In the
future, it would be interesting to consider generating
these elements automatically.
Multiple floors are also supported by our method. When
generating the ground floor, a staircase (or elevator)
room is generated. In the subsequent floors, this room
is duplicated, fixed to the same position as the floor be-
low. Adjacency and connectivity constraints for staircase
rooms still hold as in normal rooms. Our results show
that room expansion in higher floors is not affected by
the initial duplication of the staircase. Rooms expand
naturally around the staircase, respecting all constraints.
An example of a two floor house is shown in Fig. 6.
We discussed how our floor plan generation method
is suitable for procedural building generation, since it
provides fast and plausible floor plans. However, there
is some room for improvement. Firstly, our connectivity
algorithm identifies between which two rooms a door
needs to be placed, but the actual location of the door
is at random within the selected wall segment. This
sometimes creates situations where the walk paths inside
the building are not optimal. A smart approach for
positioning these doors would be a helpful extension.
Another potential issue arises from the fact that we
currently can not constrain the dimensions of a specific
room. Our approach often creates L-shaped rooms, which
might not be desirable in some particular cases. An
example of this is a garage, which needs to have specific
dimensions such that a car can be efficiently parked. An
L-shaped garage makes not much sense in that respect.
Constraints on the width-to-height ratio of a particular
room could improve the methods ability for handling
these cases.
Bedroom 1
Bedroom 2
Toilet Staircase Living room
Figure 6: An example floorplan of a two floor house. Downstairs (left of the figure) an entrance, connected to a toilet,
a staircase and a kitchen and living room, upstairs, the staircase is repeated and is connected to a hallway which in
turn is connected to two bedrooms (one of which is connected with a study) and a bathroom.
Since we use a grid-based algorithm, buildings with ar-
bitrary angles are not supported. However, there are
straightforward extensions for such cases as well. As in
the technique used by Greuter et al. (2003), a building’s
outer shape can be created by combining multiple ge-
ometric shapes. If all of these basic shapes would be
constrained to axis-aligned polygons (with an arbitrary
rotation in reference to the buildings orientation), these
parts could be hierarchically subdivided into separate
areas with our approach, and later combined into one
complete building.
We can conclude that the method presented here effi-
ciently generates valid and plausible building floor plans.
We validate it in two ways. First, we visually compared
floor plans generated by our method with many real-
world plans of North-American houses, with which they
typically matched well. However, although the method
is very suitable for generating floor plans of houses, for
highly regular structured spaces, such as some types
of office buildings, more simple and specialized subdi-
vision methods would be more efficient and effective.
Second, we have consulted with architects and other
experts on the output generated, and received valuable
feedback. This has already resulted in further tuning of
the method’s parameters and constraints, for example
on plausible adjacencies and desirable floor topologies.
In the near future, we also expect this feedback to lead
to the introduction of additional consistency tests.
An area which we could improve upon is the scoring
mechanism for rating the set of alternative layouts gener-
ated by the method. This score could be a combination
of the adjacency constraint satisfaction with a number
of heuristics, e.g. minimum amount of internal doors,
minimum amount of internal wall segments, etc.
Our implementation of the method performs well, due
to its low complexity and efficient data structures. Al-
though it is by far not optimized, it is still suitable in the
context of dynamic generation of virtual worlds, where,
e.g., the interior of procedural buildings is generated
within a small frustum around the player.
As future work, we would like to embed this method in
the broader context of generating fully featured procedu-
ral cities. For this, we would have, among other things,
to integrate the method with a fa¸cade generation sys-
tem, resulting in complete buildings. Also, by using our
semantic layout solving approach (Tutenel et al. 2009),
we could fill the procedural interiors with appropriate
In our view, the constrained growth floor plan generation
method is a small but significant step towards the goal
of realistic and full-featured procedural cities.
Philippe Charman. Solving Space Planning Problems
Using Constraint Technology. In Nato ASI Constraint
Programming: Students’ Presentations, TR CS 57/93,
Institute of Cybernetics, Estonian Academy ofSciences,
Tallinn, Estonia, pages 80–96, 1993.
Stefan Greuter, Jeremy Parker, Nigel Stewart, and Geoff
Leach. Real-time Procedural Generation of ‘Pseudo
Infinite’ Cities. In GRAPHITE ’03: Proceedings of
the 1
International Conference on Computer Graph-
ics and Interactive Techniques in Australasia and
South East Asia, pages 87–94, New York, NY, USA,
2003. ACM. doi:
Evan Hahn, Prosenjit Bose, and Anthony Whitehead.
Persistent Realtime Building Interior Generation. In
Sandbox ’06: Proc. of the ACM SIGGRAPH Sympo-
sium on Videogames, pages 179–186, New York, NY,
USA, 2006. ACM. doi:
F. Marson and S.R. Musse. Automatic Generation of
Floor Plans Based on Squarified Treemaps Algorithm.
IJCGT International Journal on Computers Games
Technology, 2010. Accepted for publication.
Jess Martin. Procedural House Generation: a Method for
Dynamically Generating Floor Plans. Research Poster
presented Symposium on Interactive 3D Graphics and
Games, 2006.
Pascal M¨uller, Peter Wonka, Simon Haegler, Andreas
Ulmer, and Luc Van Gool. Procedural Modeling of
Buildings. In SIGGRAPH ’06: Proceedings of the
Annual Conference on Computer Graphics and
Interactive Techniques, pages 614–623, New York, NY,
USA, 2006. ACM.
Yoav I. H. Parish and Pascal M¨uller. Procedural Model-
ing of Cities. In SIGGRAPH ’01: Proceedings of the
Annual Conference on Computer Graphics and
Interactive Techniques, pages 301–308, New York, NY,
USA, 2001. ACM.
P. Prusinkiewicz and Aristid Lindenmayer. The Algo-
rithmic Beauty of Plants. Springer-Verlag, New York,
NY, USA, 1990.
A. Rau-Chaplin, B. Mackay-Lyons, and P. Spierenburg.
The LaHave House Project: Towards an Automated
Architectural Design Service. In Proceedings of the
International Conference on Computer-Aided Design
(CADEX), Hagenberg, Austria, September 1996.
Ruben M. Smelik, Klaas Jan de Kraker, Tim Tutenel,
Rafael Bidarra, and Saskia A. Groenewegen. A Sur-
vey of Procedural Methods for Terrain Modelling. In
Proceedings of the CASA Workshop on 3D Advanced
Media In Gaming And Simulation (3AMIGAS), Ams-
terdam, The Netherlands, June 2009.
T. Tutenel, R. Bidarra, R.M. Smelik, and Klaas Jan de
Kraker. The Role of Sematics in Games and Simula-
tions. ACM Computers in Entertainment, 6:1–35, 2008.
Tim Tutenel, Rafael Bidarra, Ruben M. Smelik, and
Klaas Jan de Kraker. Rule-based Layout Solving and
its Application to Procedural Interior Generation. In
Proceedings of the CASA Workshop on 3D Advanced
Media In Gaming And Simulation (3AMIGAS), Ams-
terdam, The Netherlands, June 2009.
Peter Wonka, Michael Wimmer, Fran¸cois Sillion, and
William Ribarsky. Instant Architecture. In SIG-
GRAPH ’03: Proceedings of the 30
Annual Con-
ference on Computer Graphics and Interactive Tech-
niques, pages 669–677, New York, NY, USA, 2003.
This work was supported in part by the Portuguese
Foundation for Science and Technology under grant
SFRH/BD/62463/2009. This work has also been sup-
ported by the GATE project, funded by the Netherlands
Organization for Scientific Research (NWO) and the
Netherlands ICT Research and Innovation Authority
(ICT Regie).
Ricardo Lopes
is a PhD student from the Delft Univer-
sity of Technology. His current research interests include:
adaptivity in games, player modeling, interpretation
mechanisms for in-game data and (on-line) procedural
generation techniques. Ricardo got his master’s degree
in Information Systems and Computer Engineering at
the Technical University of Lisbon, in Portugal.
Tim Tutenel
is a PhD candidate from Delft Univer-
sity of Technology, participating in a research pro ject
entitled ”Automatic creation of virtual worlds”. His
research focus is on layout solving, object semantics and
object interactions. In particular, he is researching how
semantics can improve procedural generation techniques.
Tim got his master’s degree in Computer Science at the
Hasselt University in Belgium.
Ruben Smelik
is a scientist at the TNO research insti-
tute in The Netherlands. He is a PhD candidate on a
project entitled ”Automatic creation of virtual worlds”,
in close cooperation with Delft University of Technology.
This project aims at developing new tools and techniques
for creating geo-typical virtual worlds for serious games
and simulations. Ruben holds a masters degree in com-
puter science from the University of Twente.
Klaas Jan de Kraker
is a member of the scientific
staff at the TNO research institute. He holds a PhD
in computer science from Delft University of Technol-
ogy. He has a background in computer-aided design
and manufacturing, collaboration applications, software
engineering (methodologies), meta-modeling and data
modeling. Currently he is leading various simulation
projects in the areas of simulation based performance as-
sessment, collective mission simulation, multifunctional
simulation and serious gaming.
Rafael Bidarra
is associate professor Game Technology
at the Faculty of Electrical Engineering, Mathematics
and Computer Science of Delft University of Technology,
The Netherlands. He graduated in electronics engineer-
ing at the University of Coimbra, Portugal, and received
his PhD in computer science from Delft University of
Technology. He leads the research line on game tech-
nology at the Computer Graphics Group. His current
research interests include: procedural and semantic mod-
eling techniques for the specification and generation of
both virtual worlds and game play; serious gaming; se-
mantics of navigation; and interpretation mechanisms
for in-game data. He has published many papers in inter-
national journals, books and conference proceedings, and
has served as member of several program committees.
... Inspired by the growing of crops, growth based arrangement methods start with populating a domain with 'seeds' which are then iteratively grown to the required size. Examples are can be found in Inoue and Takagi (2008), Lopes et al. (2010), Camozzato (2015). A ship design example is ISA (Nick, 2008). ...
... Examples of tools that generate single floor layouts can be found in Baušys and Pankrašovaite (2005), Camozzato (2015), Inoue and Takagi (2008), Marson and Musse (2010). Multi-floor layout plan generators that include vertical connections such as staircases can be found in Guo and Li (2017), Lopes et al. (2010), Merrell et al. (2010). ...
... In the case of Baušys and Pankrašovaite (2005) passageways or halls need to meet a minimum required area requirement. 2. Placing doors according to a topology (Lopes et al., 2010;Guo and Li, 2017). Although in ship design some spaces might be used as a pass-through towards other spaces, in general each space is directly connected to passageways. ...
Generating detailed warship layouts is crucial to check technical feasibility and performance consistent with emergent requirement elucidation during early stage design. However, generating feasible detailed layouts is a complex and time consuming task. Even today, detailed layout plans are often manually drawn using CAD software, taking up to 150 work hours to complete a single feasible layout plan, as found by the Netherlands Defence Materiel Organisation (DMO). As a result, the number of layout variations that can be generated and analysed is limited. This typically means that further detailed layout generation is postponed, increasing the risk of costly sizing and integration issues later in the design process. Therefore, a method that enables rapid insight into layout sizing issues is required. This paper elaborates on the mathematical working mechanisms of the WARship GEneral ARrangement (WARGEAR) tool, that has been developed to support naval architects in detailing ship arrangements to space level in a matter of minutes. Contributions are: (1) a probabilistic staircase placement algorithm, (2) a network-based approach combined with probabilistic selection for allocation of spaces to compartments, (3) the use of cross-correlation to quickly arrange spaces, and (4) a ‘carving’-based approach to ensure connectivity. A representative WARGEAR application case study is presented. This test shows how WARGEAR is able to confirm the feasibility of future warship arrangements at a high level of detail within minutes.
... Tutenel and Bidarra [62] created a rule-based system that uses a semantic database to identify room kinds, and entities can form associations with their near neighbours. The concepts in this research were greatly influenced by Tutenel et al. [63], who tested a restricted rectangular Lgrowth algorithm that generated fully connected rooms for buildings. In a rectangular-growth-based technique, Camozzato et al. [64] procedurally create floor layouts using a hand-drawn building façade as input. ...
... (1) Floor plan generation A basic restricted growth algorithm is used to produce the floor layout. The original inspiration for utilizing this as a floor plan generator came from Tutenel et al.'s [63] Lshaped restricted growth technique. Unlike their technique, this one does not expand in a rectangle pattern, instead using a single block as the natural granular unit in Minecraft. ...
Full-text available
Procedural content generation (PCG) of terrains is one of the main building blocks for creating an automated and real-time virtual world. This study provides and in-depth review of the different tools, algorithms, and engines used for the PCG of terrains for the PCG of digital worlds; we focus especially on terrain generation but address also the main issues related to build structures and characters. It is important to know that the PCG of terrains can be implemented in a multidisciplinary scenario, for instance, modeling of games, simulating industrial maps, urban and rural planning of developments, government, and nongovernmental agency improvement plans. Many problems in current approaches were identified from the literature, where most of the researches studied were merely throwaway prototyping based, i.e., proof of concept-based systems, and were not tested in the real environment. Also, genetic algorithm-based PCG of terrains lack multiple features such as roads and buildings. The virtual cities generated through different engines were lacking a realistic look and feel. Terrain generation through multiobjective evolutionary algorithms (MOEAs) is investigated, and it is deemed the usage was restricted to the gaming domain and not extended to other fields. Findings suggest that the correctness of generated terrain is a big issue in the automatic generation of terrains. Thus, a focus on the automated correctness check is required. Other important content generation in video games such as structure generation and character generation has been extensively studied, and the techniques are analysed in the further sections of this research work.
... Given a room specification, we first employ iterative boundary cutting to obtain an external scene layout (that can range from a simple rectangle to a complex polygon). The recursive layout generation algorithm by Lopes et al. [73] is then used to divide the scene into the desired rooms. Finally, we determine connectivity between rooms using a set of user-defined constraints. ...
... Given a room spec and an interior boundary, we use the algorithm proposed in [73] to divide the interior boundary into rooms. The algorithm recursively subdivides the interior boundary for each subtree in the room spec. ...
Massive datasets and high-capacity models have driven many recent advancements in computer vision and natural language understanding. This work presents a platform to enable similar success stories in Embodied AI. We propose ProcTHOR, a framework for procedural generation of Embodied AI environments. ProcTHOR enables us to sample arbitrarily large datasets of diverse, interactive, customizable, and performant virtual environments to train and evaluate embodied agents across navigation, interaction, and manipulation tasks. We demonstrate the power and potential of ProcTHOR via a sample of 10,000 generated houses and a simple neural model. Models trained using only RGB images on ProcTHOR, with no explicit mapping and no human task supervision produce state-of-the-art results across 6 embodied AI benchmarks for navigation, rearrangement, and arm manipulation, including the presently running Habitat 2022, AI2-THOR Rearrangement 2022, and RoboTHOR challenges. We also demonstrate strong 0-shot results on these benchmarks, via pre-training on ProcTHOR with no fine-tuning on the downstream benchmark, often beating previous state-of-the-art systems that access the downstream training data.
... In the domain of architecture and urban design, space allocation is well-known with numerous applications in the design of building layouts and urban planning schemes (Keller 2006). From prior descriptions of space allocation, (Lopes et. al. 2010;Martin 2006;Shekhawat 2018), we define the space allocation problem (SAP) as a project-specific organization of spaces, constrained by geometry of spaces and relations between activities, hosted by the spaces. Since each design problem is unique, SAP-related geometric and topological constraints vary significantly between design projects ...
Conference Paper
Full-text available
1 DOTs provides an integrated framework of solvers to address a top-down design process from urban planning to site parcella-tion and massing to floor plans. This is illustrated by the study where the proposed solution is used for urban planning. The site is parcellated and a schematic massing is generated. For each mass, the floor plates are extracted and the floor plan is generated. Computable Design Problems and Integrated Framework of Solvers 1 ABSTR ACT Architects and urban designers use space allocation to develop layouts constrained by project-specific attributes of spaces and relations between them. The space allocation problem (SAP) is a general class of computable problems that eluded automation due to combinatorial complexity and diversity of architectural forms. In this paper, we propose a solution to the space allocation problem using reinforcement learning (RL). In RL, an artificial agent interacts with a simulation of the design problem to learn the optimal spatial organization of a layout using a feedback mechanism based on project-specific constraints. Compared to supervised learning, where the scope of the design problem is restricted by the availability of prior samples, we developed a general approach using RL to address novel design problems, represented as SAP. We integrated the proposed solution to SAP with numerous geometry modules, collectively defined as the space allocation techniques (SAT). In this implementation, the optimization and generative modules are decoupled such that designers can connect the modules in various ways to generate layouts with desired geometric and topological attributes. The outcome of this research is a user-friendly, freely accessible Rhino Grasshopper (C#) plugin, namely, the Design Optimization Toolset or DOTs, a compilation of the proposed SAT. DOTs allows designers to interactively develop design alternatives that reconcile project-specific constraints with the geometric complexity of architectural forms. We describe how professional designers have applied DOTs in space planning, site parcellation, massing, and urban design problems that integrate with performance analysis to enable a holistic, semi-automated design exploration.
... The AABB class instantiates an empty cuboidal space that effectively serves as a blank canvas to implement PCG algorithms in. For example, one could implement Perlin noise generation [20], [21] to add water blocks within an AABB made of grass to create a water body, or constrained growth algorithms [22], [23]. AABBs of different types can be defined using mcg by subclassing the AABB class, and can be manipulated, nested, and combined to produce complex structures (see Figure 3). ...
Task environments developed in Minecraft are becoming increasingly popular for artificial intelligence (AI) research. However, most of these are currently constructed manually, thus failing to take advantage of procedural content generation (PCG), a capability unique to virtual task environments. In this paper, we present mcg, an open-source library to facilitate implementing PCG algorithms for voxel-based environments such as Minecraft. The library is designed with human-machine teaming research in mind, and thus takes a 'top-down' approach to generation, simultaneously generating low and high level machine-readable representations that are suitable for empirical research. These can be consumed by downstream AI applications that consider human spatial cognition. The benefits of this approach include rapid, scalable, and efficient development of virtual environments, the ability to control the statistics of the environment at a semantic level, and the ability to generate novel environments in response to player actions in real time.
... In future developments, the width of local hallways will be addressed and made more realistically. (2.2) Space arrangement The space arrangement makes use of the second level PSO and a seed and growth algorithm based on [15]. Each space is assigned an initial grid cell, the 'initial seed placement', from which it is grown to its required minimum size. ...
... These games have become increasingly popular and therefore PCG techniques have been created that aid in the generation of these virtual worlds. For interior environments, there are techniques that can generate entire house or building layouts [10]. These interior levels can then be furnished with other techniques that place objects such as tables, chairs, and even dinner plates and cutlery [11], [12]. ...
Full-text available
This article describes a set of proposed measures for characterizing areas within a virtual terrain in terms of their attributes and their relationships with other areas for incorporating game designers’ intent in gameplay requirement-based terrain generation. Examples of such gameplay elements include vantage point, strongholds, chokepoints and hidden areas. Our measures are constructed on characteristics of an isovist, that is, the volume of visible space at a local area and the connectivity of areas within the terrain. The calculation of these measures is detailed, in particular we introduce two new ways to accurately and efficiently calculate the 3D isovist volume. Unlike previous research that has mainly focused on aesthetic-based terrain generation, the proposed measures address a gap in gameplay requirement-based terrain generation – the need for a flexible mechanism to automatically parameterise specified areas and their associated relationships, capturing semantic knowledge relating to high level user intent associated with specific gameplay elements within the virtual terrain. We demonstrate applications of using the measures in an evolutionary process to automatically generate terrains that include specific gameplay elements as defined by a game designer. This is significant as this shows that the measures can characterize different gameplay elements and allow gameplay elements consistent with the designers’ intents to be generated and positioned in a virtual terrain without the need to specify low-level details at a model or logic level, hence leading to higher productivity and lower cost.
Layout generation is one of the earliest and most effective steps in designing a residential plan because the layout determines the quality and features of the final result. It is critical to consider the maximum match between each solution and the user-defined constraints, instant variations in constraints, comprehensible initial input, and the presentation of a series of solutions to each user. Thus, three objectives are pursued in this study: proposing a generative mechanism in which different user requirements and architectural design constraints play essential roles; recommending an explicit approach based on variables that are comprehensible to both architectures and users; automating some repetitive tasks related to the architectural presentation. This approach provides solutions that are as close to meeting user requirements as possible while keeping the architectural constraints. Accordingly, the final configuration is usable in the real world.
Full-text available
No one discipline or person can encompass all the knowledge necessary to solve complex, ill-defined problems, or problems for which a solution is not immediately obvious. The concept of Concurrent Engineering (CE) – interdisciplinary, but with an engineering focus – was developed to increase the efficiency and effectiveness of the Product Creation Process (PCP) by conducting different phases of a product’s life concurrently. Transdisciplinary Engineering has transcended CE, emphasizing the crucial importance of interdisciplinary openness and collaboration. This book presents the proceedings of the 28th ISTE International Conference on Transdisciplinary Engineering (TE2021). Held online from 5 – 9 July 2021 and entitled ‘Transdisciplinary Engineering for Resilience: Responding to System Disruptions’, this is the second conference in the series held virtually due to the COVID-19 pandemic. The annual TE conference constitutes an important forum for international scientific exchange on transdisciplinary engineering research, advances, and applications, and is attended by researchers, industry experts and students, as well as government representatives. The book contains 58 peer-reviewed papers, selected from more than 80 submissions and ranging from the theoretical and conceptual to strongly pragmatic and addressing industrial best practice. The papers are grouped under 6 headings covering theory; education and training; PD methods and digital TE; industry and society; product systems; and individuals and teams. Providing an overview of the latest research results and knowledge of product creation processes and related methodologies, the book will be of interest to all researchers, design practitioners, and educators working in the field of Transdisciplinary Engineering.
Full-text available
Architectural design greatly influences building energy performance (BEP), and energy-efficient design is therefore often studied. Architectural space layout also can affect BEP. However, only a few of the numerous studies on energy-efficient design considered the effect of space layout. Within these studies, the isolated effect of space layout on the BEP has hardly have been analysed systematically. The framework of Performative Computational Architecture (PCA) had been proven to be effective to improve BEP. PCA includes form generation, performance evaluation, and computational optimisation. With this framework, the building’s geometry and material properties are parametrised, and the performance is assessed for different combinations of design parameters. It aims to find the proper parameters that satisfy the defined objectives. This method can include the generation and assessment of space layouts. However, only a few studies have tried to combine the automatic generation of space layout with energy performance optimisation; nor the systematic analysis of the effects and relations between space layout and energy performance.
Conference Paper
Full-text available
A novel approach to generate virtual building interiors in real-time is presented. The interiors are generated in a top-down fashion using architectural guidelines. Although a building interior in its entirety may be quite large, only the portions that are needed immediately are generated. This lazy generation scheme allows the use of only a fraction of the memory that a model of the entire interior would otherwise require. Our method provides real-time frame rates, making it attractive for realtime interactive applications.Memory is controlled by deleting regions of the interior that are no longer needed. That said, any changes made in these regions will not be lost. We provide a simple and efficient method to allow changes made to the interior to persist past the life time of the regions that contain them. This allows a dynamic, consistent environment and increases control over the content by allowing developers to make changes.
Conference Paper
Full-text available
Procedural methods are a promising but underused alternative to manual content creation. Commonly heard drawbacks are the randomness of and the lack of control over the output and the absence of integrated solutions, although more recent publications increasingly address these issues. This paper surveys procedural methods applied to terrain modelling, evaluating realism of their output, performance and control users can exert over the procedure.
Full-text available
Powerful graphics hardware is enabling strong improvements in both the appearance and the complexity of virtual worlds for games and simulations. However, current practices in the design and development of virtual worlds mostly resemble high-tech variants of traditional handcrafts, resulting in increasingly unbearable design costs. In this article we state that an essential key to overcoming these problems lies in the enrichment of object models with several kinds of semantic data. We discuss numerous and promising uses for semantic information in virtual worlds, and show, for many of them, how previous results of recent research can be successfully applied. We also identify the fundamental challenges in this new cross-disciplinary area, and point out a number of open issues lying ahead, including the need for (i) a suitable way of specifying semantic data, providing a powerful vocabulary that is useful and usable for all disciplines involved in game design and development; (ii) a seamless integration of semantic data integrated with procedural generation techniques, in order to provide designers with a new and powerful generation of tools; and (iii) a consistency maintenance among evolving objects in a changeable environment, for which powerful constraint-solving methods will be instrumental. We conclude that, as the expectancy for future games and simulations steadily shifts from improved graphics and appearance towards improved character behavior, plausible realism and coherent gameplay, embedding the game world and its objects with richer semantics is going to play a crucial role. We can therefore expect that, in the near future, increasing research efforts and influential results will be emerging in this new exciting area.
Conference Paper
Full-text available
Due to the recent advancement in procedural generation techniques, games are presenting players with ever growing cities and terrains to explore. However most sandbox-style games situated in cities, do not allow players to wander into buildings. In past research, space planning techniques have already been utilized to generate suitable layouts for both building floor plans and room layouts. We introduce a novel rule-based layout solving approach, especially suited for use in conjunction with procedural generation methods. We show how this solving approach can be used for procedural generation by providing the solver with a user-defined plan. In this plan, users can specify objects to be placed as instances of classes, which in turn contain rules about how instances should be placed. This approach gives us the opportunity to use our generic solver in different procedural generation scenarios. In this paper, we will illustrate mainly with interior generation examples.
Conference Paper
Full-text available
We present an approach to procedural generation of `pseudo infinite' virtual cities in real-time. The cities contain geometrically varied buildings that are generated as needed. The building generation parameters are created by a pseudo random number generator, seeded with an integer derived from the building's position. The varied building geometries are extruded from a set of floor plans. The floor plans for each building are created by combining randomly generated polygons in an iterative process. A display list caching and frustum filling approach manages the generation of buildings and the use of system resources. This approach has been implemented on commodity PC hardware, resulting in interactive frame rates.
Constraint programming techniques have proven their eeciency in solving high combinatory problems. In this paper, we study the adap-tation, the extension and the limits of those techniques in the space plan-ning problem which consists in the locations and the sizes of sev-eral objects under geometric constraints in a location space. For all that, we deene the formalism of Geometric Constraint Satisfaction Problem (GCSP) with geometric domains for representing the position variables of the objects. We propose in particular an intelligent and geometric back-track based on constraint propagations. Then we present our environment dedicated to problems with rectangles of variable sizes.
Figure 1: Left: Modeled house based on floor plan generated by algorithm. Right: Top-down view of same floor-plan. As the capability to render complex, realistic scenes in real time increases, many applications of computer graphics are hitting the problem of manual model creation. In virtual reality, researchers have found that creating and updating static models is a difficult and time-consuming task [Brooks 1999]. New games require massive amounts of content. Creating such content is such an expensive process that it may drive smaller companies out of business [Wright 2005]. Content creators cannot keep up with the increasing demand for many high-quality models; algorithms will have to be called upon to assist. Procedural methods, algorithms that specify some characteristic of a scene and generate a model [Ebert et al. 2002], are a possible solution to the content creation problem. With such methods, the algorithm, not an artist, determines the detailed attributes of the scene–attributes ranging from color to motion to objects. Recently, procedural methods have been applied to generating man-made artifacts including cities. Parish and Müller used L-systems to generate a city street map and geometry and textures for build-ings within the city [Parish and Müller 2001]. Focusing on city modeling, Greuter et al. describe a procedure to generate build-ings based on vertical extrusion of randomly generated polygons [Greuter et al. 2003]. Lechner et al. use an agent-based simulation to generate a city map but do not attempt buildings [Lechner et al. 2003]. Though some of the buildings appear believable, each of these research efforts focused on the realistic creation of the city rather than the buildings themselves. Wonka et al. focus more on the appearance of the buildings using a "split grammar" to control the external appearance so that it conforms to architectural rules [Wonka et al. 2003].
Conference Paper
Modeling a city poses a number of problems to computer graphics. Every urban area has a transportation network that follows population and environmental influences, and often a superimposed pattern plan. The buildings appearances follow historical, aesthetic and statutory rules. To create a virtual city, a roadmap has to be designed and a large number of buildings need to be generated. We propose a system using a procedural approach based on L-systems to model cities. From various image maps given as input, such as land-water boundaries and population density, our system generates a system of highways and streets, divides the land into lots, and creates the appropriate geometry for the buildings on the respective allotments. For the creation of a city street map, L-systems have been extended with methods that allow the consideration of global goals and local constraints and reduce the complexity of the production rules. An L-system that generates geometry and a texturing system based on texture elements and procedural methods compose the buildings.
1 Graphical modeling using L-systems.- 1.1 Rewriting systems.- 1.2 DOL-systems.- 1.3 Turtle interpretation of strings.- 1.4 Synthesis of DOL-systems.- 1.4.1 Edge rewriting.- 1.4.2 Node rewriting.- 1.4.3 Relationship between edge and node rewriting.- 1.5 Modeling in three dimensions.- 1.6 Branching structures.- 1.6.1 Axial trees.- 1.6.2 Tree OL-systems.- 1.6.3 Bracketed OL-systems.- 1.7 Stochastic L-systems.- 1.8 Context-sensitive L-systems.- 1.9 Growth functions.- 1.10 Parametric L-systems.- 1.10.1 Parametric OL-systems.- 1.10.2 Parametric 2L-systems.- 1.10.3 Turtle interpretation of parametric words.- 2 Modeling of trees.- 3 Developmental models of herbaceous plants.- 3.1 Levels of model specification.- 3.1.1 Partial L-systems.- 3.1.2 Control mechanisms in plants.- 3.1.3 Complete models.- 3.2 Branching patterns.- 3.3 Models of inflorescences.- 3.3.1 Monopodial inflorescences.- 3.3.2 Sympodial inflorescences.- 3.3.3 Polypodial inflorescences.- 3.3.4 Modified racemes.- 4 Phyllotaxis.- 4.1 The planar model.- 4.2 The cylindrical model.- 5 Models of plant organs.- 5.1 Predefined surfaces.- 5.2 Developmental surface models.- 5.3 Models of compound leaves.- 6 Animation of plant development.- 6.1 Timed DOL-systems.- 6.2 Selection of growth functions.- 6.2.1 Development of nonbranching filaments.- 6.2.2 Development of branching structures.- 7 Modeling of cellular layers.- 7.1 Map L-systems.- 7.2 Graphical interpretation of maps.- 7.3 Microsorium linguaeforme.- 7.4 Dryopteris thelypteris.- 7.5 Modeling spherical cell layers.- 7.6 Modeling 3D cellular structures.- 8 Fractal properties of plants.- 8.1 Symmetry and self-similarity.- 8.2 Plant models and iterated function systems.- Epilogue.- Appendix A Software environment for plant modeling.- A.1 A virtual laboratory in botany.- A.2 List of laboratory programs.- Appendix B About the figures.- Turtle interpretation of symbols.