Content uploaded by Torsten Ullrich

Author content

All content in this area was uploaded by Torsten Ullrich on Dec 29, 2015

Content may be subject to copyright.

Know the Rules

Tutorial on Procedural Modeling

Know the Rules

– Tutorial on Procedural Modeling –

Christoph Schinko, Ulrich Krispel, Torsten Ullrich

?

Visual Computing, Fraunhofer Austria Research GmbH

Graz University of Technology, Austria

Abstract

This tutorial introduces the concepts and techniques of procedural & generative modeling. It starts

with some introductory examples to motivate the main idea: to describe a shape using an algorithm.

After the explanation of technical terms, the second Section focuses on technical details of algorithm

descriptions, programming languages, grammars and compiler construction, which play an important

role in generative modeling. The purely geometric aspects are covered by the third Section. It

comprehends the concepts of geometric building blocks and advanced modeling operations. Notes on

semantic modeling aspects – i.e. the meaning of a shape – complete this Section and introduce the

inverse problem. What is the perfect procedural description for a real object? The answer to this

question is discussed in the fourth Section while its application is shown (among other applications

of generative and inverse-generative modeling) in the ﬁfth Section. The discussion of open research

questions concludes this tutorial.

keywords:

geometry processing; generative, procedural modeling; inverse modeling;

modeling applications; shape description; language design

This handout is based on:

@Article{KSU2014,

Title = {The Rules Behind -- Tutorial on Generative Modeling},

Author = {Krispel, Ulrich and Schinko, Christoph and Ullrich, Torsten},

Journal = {Proceedings of Symposium on Geometry Processing / Graduate School},

Year = {2014},

Pages = {2:1--2:49},

Volume = {12}

}

?

corresponding author:

mail: torsten.ullrich@fraunhofer.at

www: www.cgv.tugraz.at & www.fraunhofer.at

About the Authors

Christoph Schinko

Christoph Schinko, born in 1982, studied Telematics at Graz University of Tech-

nology. He received his Master’s degree in June 2009 and worked as a researcher

in the FIT-IT project MetaDesigner at the Institute of Computer Graphics and

Knowledge Visualization (CGV) at Graz University of Technology. His research

focuses on generative modeling, rapid prototyping and 3D Web technologies. Since

March 2013 he works for Fraunhofer Austria Research GmbH, Visual Computing.

Ulrich Krispel

Ulrich Krispel received his Master’s degree in Telematics in 2008 from Graz Uni-

versity of Technology, Austria. He has been a research assistant at the Institute

of Computer Graphics and Knowledge Visualization (CGV), Graz University of

Technology, and at Interactive Graphics Systems Group (GRIS), TU Darmstadt.

Currently, he is a research assistant at Fraunhofer Austria Research GmbH. His

ﬁelds of interest cover geometry processing for procedural descriptions and (inverse)

procedural modeling with a focus on shape grammars.

Torsten Ullrich (presenter)

Dr. Torsten Ullrich studied mathematics with a focus on computer science at the

University of Karlsruhe (TH) and received his doctorate in 2011 with his work “Re-

constructive Geometry” on the subject of reverse engineering at the Graz University

of Technology. Since 2005 he has been involved in the establishment of the newly

formed “Fraunhofer Austria Research GmbH”. He coordinates research projects in

the ﬁeld of “Visual Decision Support”, “Virtual Engineering” and “Digital Society”

and is Deputy Head of the business area Visual Computing in Graz. His research in

the ﬁeld of generative modeling languages and geometrical optimization has received

several international awards.

Contact information: torsten.ullrich@fraunhofer.at

Contents

1 Introduction to “Generative Modeling” 7

1.1 Ruler and Compass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.2 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

1.3 Civil Engineering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

1.4 Natural Patterns . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1.5 Entertainment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1.6 Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2 Languages & Grammars 15

2.1 Language Processing & Compiler Construction . . . . . . . . . . . . . . . . . . . . . . . . 15

2.2 Scripting Languages for Generative Modeling . . . . . . . . . . . . . . . . . . . . . . . . . 18

3 Modeling by Programming 23

3.1 Building Blocks & Elementary Data Structures . . . . . . . . . . . . . . . . . . . . . . . . 23

3.2 Advanced Techniques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

3.3 Semantic Modeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

4 Inverse Modeling 31

4.1 Problem Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

4.2 Overview on Current Approaches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

5 Applications 35

5.1 Procedural Shape Modeling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

5.2 Semantic Enrichment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

5.3 Form Follows Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

6 Open Questions 45

C. Schinko, U. Krispel & T. Ullrich, 2015 7

1 Introduction to “Generative Modeling”

Generative modeling has been developed in order to generate highly complex objects based on a set of

formal construction rules. This modeling paradigm describes a shape by a sequence of processing steps,

rather than just the end result of applied operations: Shape design becomes rule design. This approach

is very general and it can be applied to any domain and to any shape representation that provides a set

of generating functions.

1.1 Ruler and Compass

The ruler-and-compass construction is the construction of lengths, angles, and other geometric ﬁgures

using only an idealized ruler and compass. Geometry from the days of the ancient Greeks placed great

emphasis on problems of constructing various geometric ﬁgures using only a ruler without markings (to

draw lines) and a compass (to draw circles). All ruler-and-compass constructions consist of repeated

application of ﬁve basic constructions based on Euclid’s axioms [48] using the points, lines and circles

that have already been constructed. Based on these geometric primitives and a ﬁxed set of operations, the

ruler-and-compass constructions – such as illustrated in Figure 1 – are the ﬁrst algorithmic descriptions

of generative models.

O

A

B

C

D

E

F

G

Construction of a pentagon:

1. Draw a circle in which to inscribe

the pentagon and mark the center

point O.

2. Construct a pair of perpendicu-

lar lines which intersect in O and

mark their intersection with the

circle A and B.

3. Let D be the midpoint of BO.

The circle with center D and ra-

dius | DA | intersects the line de-

ﬁned by the points B and O.

Mark the intersection point as F .

4. The length of section AF is equal

to the edge length AG of an in-

scribed pentagon (red).

Figure 1: The construction of a pentagon can be performed using compass and a straightedge only. The con-

struction algorithm is based on Euclid’s axioms [48].

Because of the prominent place Greek geometric constructions held in Euclid’s Elements [48], these

constructions are sometimes also known as Euclidean constructions. Such constructions lay at the heart

of the geometric problems of antiquity of circle squaring, cube duplication, and angle trisection. The

Greeks were unable to solve these problems, but constructions for regular triangles, squares, pentagons,

and their derivatives had been given by Euclid.

It turns out that all constructions possible with a compass and straightedge can be done with a

compass alone, as long as a line is considered constructed when its two endpoints are located [149]. The

reverse is also true, since Jacob Steiner showed that all constructions possible with straightedge and

compass can be done using only a straightedge, as long as a ﬁxed circle and its center have been drawn

beforehand. Such a construction is known as a Steiner construction.

8 Know the Rules – Tutorial on Procedural Modeling

Figure 2: Compass and ruler operations have long been used in interactive procedural modeling. This Gothic win-

dow construction was created in the framework presented by Wolfgang Thaller et al. using direct manipulation

without any code or graph editing [126].

The long history of geometric constructions [71] is also reﬂected in the history of civil engineering and

architecture [79]. For example, Gothic architecture and especially window tracery exhibits quite complex

geometric shape conﬁgurations. But this complexity is achieved by combining only a few basic geometric

patterns. Sven Havemann and Dieter W. Fellner present some principles of this long-standing

domain, together with some delicate details, and show how the constructions of some prototypic Gothic

windows can be formalized using our generative modeling techniques [44]. Using modularization, so that

complex conﬁgurations can be obtained from combining elementary constructions, diﬀerent combinations

of speciﬁc parametric features can be grouped together, which leads to the concept of styles. They

permit to diﬀerentiate between the basic shape and its appearance, i.e., in a particular ornamental

decoration [126]. This leads to an extremely compact representation for a whole class of shapes [15].

1.2 Architecture

Generative modeling techniques have rapidly gained attention throughout the past few years. Many

researchers enforced the creation of generative models due to its many advantages. All objects with

well-organized structures and repetitive forms can be described procedurally. In these cases, generative

modeling is superior to conventional approaches.

A big advantage of procedural modeling techniques is the included expert knowledge within an object

description [135], e.g., classiﬁcation schemes used in architecture, archaeology, civil engineering, etc. can

be mapped to procedures. For a speciﬁc object, only its type and its instantiation parameters have to be

identiﬁed [138]; the generative building blocks themselves are ﬁxed and do no change. As a consequence,

only their evaluation parameters have to be speciﬁed: Figure 3 illustrates variations of the same building

blocks.

The usage of generative modeling techniques in architecture is not limited to buildings of the past.

Over the last few decades, progressive architects have used a new class of design tools that support

generative design. Generative modeling software extends the design abilities of architects by harnessing

computing power in new ways. Computers, of course, have long been used to capture and implement

the design ideas of architects by means of CAD and, more recently, 3D modeling. But generative design

actually helps architects design by using computers to extend human abilities.

An impressive example is the Helix Bridge in Singapore (see Figure 4). The 280 m bridge is made

up of three 65 m spans and two 45 m end spans. The major and minor helices, which spiral in opposite

directions, have an overall diameter of 10.8 m and 9.4 m respectively. The outer helix is formed from

six tubes which are set equidistant from one another, whereas the inner helix consists of ﬁve tubes.

C. Schinko, U. Krispel & T. Ullrich, 2015 9

Figure 3: Gothic architecture ﬂourished during the high and late medieval period. It is deﬁned by strict rules with

its characteristics: pointed arcs, the ribbed vaults, and the ﬂying buttresses. These building blocks have been com-

bined in various ways to create great churches and cathedrals all over Europe. The generative description of Gothic

cathedrals encodes these building blocks and the rules on how to combine them. The result is an algorithm that takes

a few high-level parameters. By modifying these parameters, it is easy to generate a family of Gothic examples (left,

middle, right). The building blocks have been created by Michael Curry, http://www.thingiverse.com/thing:2030.

10 Know the Rules – Tutorial on Procedural Modeling

Figure 4: The Helix Bridge is a pedestrian bridge in the Marina Bay area in Singapore. Its generative design

has been optimized numerically. Furthermore, the bridge was fully modeled in order to visualize its form and

geometrical compatibility, as well as to visualize the pedestrian experience on the bridge.

The bridge design is the product of inseparable collaboration between architects (Cox Architecture and

Architects 61) and civil engineers (Arup Consultant). For its 280 meter length, the dual helix structure

of the bridge utilizes 5 times less steel than a conventional box girder bridge. This fact enabled the client

to direct the structure to be constructed entirely of stainless steel for its longevity.

1.3 Civil Engineering

The generative modeling approach is very general. It can be applied to any domain and is not restricted

to shape representations [25]. Nevertheless, this tutorial focuses on shape design, computer-aided design

and 3D modeling.

Figure 5: The design of ascent assemblies for oﬀshore cranes (colored in red) results in high eﬀorts and con-

tributes a major part of the overall engineering costs of a crane. In case of repetitive and nearly identical design

processes, the product development processes can be optimized by software driven design automation: the reduction

of engineering eﬀorts by modeling design knowledge [38].

C. Schinko, U. Krispel & T. Ullrich, 2015 11

In the context of 3D computer-aided design (CAD), each design process that involves repetitive tasks is

perfectly suited for a generative approach. Engineering processes can be diﬀerentiated in repetitive and

creative processes. In contrast to creative processes, repetitive ones consist of nearly identical tasks and

are therefore independent of creative decisions. This condition is necessary for modeling them in a system

of rules as demonstrated by Gerald Frank [39]: Liebherr manufactures and sells an extensive range of

products including ship-, oﬀshore and harbor mobile cranes as well as hydraulic duty cycle crawler cranes

and lift cranes. Due to customers’ needs each crane has to be partially or fully engineered, but the design

process of ascent assemblies is based on repetitive tasks based on a set of invariant rules that can be

modeled and stored. In numerous interviews with engineering experts at Liebherr the repetitive design

processes have been analyzed and a generative model has been designed. Integrated into the existing

CAD pipeline, a construction engineer now only has to determine the deﬁning parameters of an assembly

and ﬁll out the corresponding input ﬁelds in a user interface. The engineering of ascent assemblies of an

oﬀshore crane required up to 150 hours. Using the procedural approach, the eﬀorts have been reduced

down to 10%.

1.4 Natural Patterns

In today’s procedural modeling systems, scripting languages and grammars are often used as a set of rules

to achieve a description. Early systems based on grammars were Lindenmayer systems [99] (L-systems)

named after Aristid Lindenmayer. They were successfully applied to model plants. Given a set of

string rewriting rules, complex strings are created by applying these rules to simpler strings. Starting with

an initial string the predeﬁned set of rules form a new, possibly larger string. The L-systems approach

reﬂects a biological motivation. In order to use L-systems to model geometry an interpretation of the

generated strings is necessary.

The modeling power of these early geometric interpretations of L-systems was limited to creating

fractals and plant-like branching structures (see Figure 6). This lead to the introduction of parametric

L-systems. The idea is to associate numerical parameters with L-system symbols to address continuous

phenomena which were not covered satisfactorily by L-systems alone.

L-System:

Axiom: F X

Angle: 28

◦

Rules:

F 7→ C

0

F F −[C

1

−F +F ]+[C

2

+F −F ]

X 7→ C

0

F F + [C

1

+ F ] + [C

3

− F ]

whereas F denotes “draw forward” and +/−

denote “turn left”/“turn right”. The square

bracket [ corresponds to saving the current

values for position and angle, which are re-

stored when the corresponding square bracket

] is executed. C

0

, C

1

, C

2

switch colors and X

does not correspond to any drawing action.

This example can be executed online by

Kevin Roast’s L-Systems-Demo:

http://www.kevs3d.co.uk/dev/lsystems/

Figure 6: Lindenmayer systems are a simple but elegant “turtle rendering” platform. The recursive nature of

L-system rules lead to self-similarity and thereby fractal-like forms. Plant models and natural-looking organic

forms “grow” and become more complex by increasing the iteration level i.e. the number of substitutions.

12 Know the Rules – Tutorial on Procedural Modeling

Combined with additional 3D modeling techniques, Lindenmayer systems can be used to generate complex

geometry [129], [130]. In order to generate models of plants, terrains, and other natural phenomena that

are convincing at all diﬀerent scales, Robert F. Tobler et al. introduce a combination of subdivision

surfaces, fractal surfaces, and parametrized L-systems, which makes it possible to choose which of them

should be used at each level of resolution. Since the whole description of such multi-resolution models

is procedural, their representation is very compact and can be exploited by level-of-detail renderers that

only generate surface details that are visible.

This kind of data ampliﬁcation can be found in various ﬁelds of computer graphics. E.g. curved

surfaces speciﬁed by a few control points are tessellated directly on the GPU. This results in low storage

costs and allows generating the complex model only when needed, while also reducing memory transfer

overheads. Although L-systems are parallel rewriting systems, derivation through rewriting leads to very

uneven workloads. Furthermore, the interpretation of an L-system is an inherently serial process. Thus,

L-systems are not straightforwardly amenable to parallel implementation. In 2010, Markus Lipp et al.

presented a solution to this algorithmic challenge [68].

1.5 Entertainment

The demoscene is a computer related subculture that specializes in producing demos, which are pro-

grams that perform audio-visual presentations. The scene has been active since the advent of personal

computers, for a brief history we refer to the book of Tomas Polgar [98].

The creation of such programs is often tied to various constraints, as memory and general hardware

capabilities of the early personal computers were quite limited. Nowadays, these constraints are mostly

of self-imposed nature, e.g. creating a demo using only a ﬁlesize of 4096 bytes (or 4kB). Naturally, these

constraints facilitate the usage of procedural methods for any type of presentation content: 3D geometry

(meshes), textures [32], sound, etc.

Even without these limitations, content creation [133] has always been the main ﬁeld of applica-

tion for procedural techniques: from game design [5], [27], [57], [97], [132], and virtual worlds [104], to

non-geometry aspects such as story-telling and drama management [85], camera movements [60] and

player [131] / artiﬁcial intelligence modeling [9], [54].

From a historical point of view, although procedural methods arose in the ﬁeld of early video game

development, their use was not common in the special eﬀects and feature animation community.

While computer-generated content made ﬁrst appearance in movies in the late 70s, it was not until

the 90s, most notably with the movies Terminator 2 and Jurassic Park, that the ﬁlm industry started

using 3D computer graphics for content authoring and animation. Nowadays, procedural eﬀects for 3D

games are similar to procedural eﬀects for movie productions. Diﬀerences can be found in the degree of

visual ﬁdelity, but these are mainly caused by the real-time demands of 3D games.

Visual artists use 3D animation tools to create procedural eﬀects (see Table 2). Several talks at

Siggraph 2014 [116] underly the relevance of the topic for the ﬁlm industry:

Daniel Heckenberg et al. presented a procedural approach to create, animate and render repet-

itive geometric features such as scales or cobblestones developed for the movie Walking With Di-

nosaurs 3D. These tools were used to realize hundreds of diﬀerent dinosaur characters from nine

diﬀerent species.

An algorithm to create procedural tentacle bundles for an alien creature in the movie Edge of

Tomorrow was presented by Dan Sheerin. It allows an entire tentacle bundle to be deﬁned by a

base curve and a list of parameters.

Francesco Giordana et al. presented a hybrid CPU/GPU, fully procedural node based frame-

work for fur animation. Each node can be GPU accelerated with the option to falling back to CPU

computation in case of errors at any point in the graph.

C. Schinko, U. Krispel & T. Ullrich, 2015 13

1.6 Applications

Procedural Generation of

Road [40]

Interactive Architectural

Modeling with Procedural

Extrusions [58]

Procedural Modeling of

Interconnected Structures

[62]

Interactive Modeling of

City Layouts using Layers

of Procedural Content [66]

Interactive Visual Editing

of Grammars for Procedu-

ral Architecture [67]

Model Synthesis: A Gen-

eral Procedural Modeling

Algorithm [76]

Computer-generated res-

idential building layouts

[77]

Interactive Furniture Lay-

out Using Interior Design

Guidelines [78]

Interactive Coherence-

Based Facade Modeling

[83]

Procedural Modeling of

Cities [92]

Modeling Procedural

Knowledge – a genera-

tive modeler for cultural

heritage [106]

Scripting Technology for

Generative Modeling [107]

Procedural Descriptions

for Analyzing Digitized

Artifacts [138]

Modelling the Appear-

ance and Behaviour of Ur-

ban Spaces [144]

Procedural Design of Ex-

terior Lighting for Build-

ings with Complex Con-

straints [111]

Terrain Generation Using

Procedural Models Based

on Hydrology [41]

Generating and Explor-

ing Good Building Lay-

outs [12]

Procedural Facade Varia-

tions from a Single Layout

[11]

Table 1: Currently architecture, urban design and civil engineering are the predominant ﬁelds of applications for

generative modeling, although the main concept can be applied to any domain.

14 Know the Rules – Tutorial on Procedural Modeling

C. Schinko, U. Krispel & T. Ullrich, 2015 15

2 Languages & Grammars

Originally, scripting languages have been designed for a special purpose, e.g., to be used for client-side

scripting in a web browser. Nowadays, the applications of scripting languages are manifold. JavaScript,

for example, is used to animate 2D and 3D graphics in VRML [23] and X3D [13] ﬁles. It checks user

forms in PDF ﬁles [22], controls game engines [31], conﬁgures applications, deﬁnes 3D shapes [107], and

performs many more tasks. According to John K. Ousterhout scripting languages use a higher level

of abstraction compared to system programming languages as they are often typeless and interpreted

to emphasize the rapid application development purpose [90]. Whereas system programming languages

are designed for creating algorithms and data structures based on low-level data types and memory

operations. As a consequence, graphics libraries [88], graphics shaders [86] and scene graph systems [102],

[146] are usually written in C/C++ dialects [33], and procedural modeling frameworks use scripting

languages such as Lua, JavaScript, etc.

2.1 Language Processing & Compiler Construction

The evaluation of procedural descriptions typically utilizes techniques used for description of formal

languages and compiler construction [93]. The range of diﬀerent concepts of languages to describe a

shape is very wide and comprehends all kinds of linguistic concepts [26]. The main categories to describe

a shape are

rule-based: using substitutions and substitution rules to build complex structures out of simple

starting structures [91], [63], [82], [118].

imperative and scripting-based: using a scripting engine and techniques used in predominant pro-

gramming languages [43], [107], [62], or

GUI and dataﬂow-based: using new graphical user interfaces (GUI) and intelligent GUIs to detect

structures in modeling tasks, which can be mapped onto formal descriptions [67], [125].

Nevertheless, the general principles of formal descriptions and compiler construction are in all cases the

same – independent of ahead-of-time compilation, just-in-time compilation or interpretation [109]. The

basic steps are illustrated in Figures 7 and 8. They outline the compilation process and show the main data

structures – especially the abstract source tree (AST): In the ﬁrst stage the input source code is passed

to lexer and parser. A ﬁrst step is to convert a sequence of characters into a sequence of tokens, which is

done by special grammar rules forming the lexical analysis. For instance, in some languages only a limited

number of characters is allowed for an identiﬁer: all characters A-Z, a-z, digits 0-9 and the underscore

are allowed with the condition that an identiﬁer must not begin with a digit or an underscore. Such lexer

rules are embedded in another set of rules – the parser rules. They are analyzing the resulting sequence

of tokens to determine their grammatical structure. The complete grammar consists of a hierarchical

structure of rules for analyzing all possible statements and expressions that can be formed in a language,

thus forming the syntactic analysis.

For each language construct available a set of rules is validating syntactic correctness. At the same

time actions within these rules create the intermediate AST structure that represents the input source

code. The resulting AST is the main data structure for the next stage: semantic analysis. Once all

statements and expressions of the input source code are collected in the AST, a tree walker analyzes their

semantic relationships, i.e., errors and warnings are generated, for instance, when symbols are used but

not deﬁned, or deﬁned but not used.

Having performed all compile-time checks, a translator uses the AST to generate platform-speciﬁc

ﬁles. In other words, this task involves complete and accurate mapping of the AST to constructs of the

target platform.

The example in Figures 7 and 8 shows a compilation process of JavaScript. In JavaScript, the top-level

rule of an AST is always a simple list of statements – no enclosing class structures, no package declaration,

no inclusion instructions, etc. Each statement contains all included substatements and expressions as

well as associated comments. During the validation step, this tree structure is extended by reference and

occurrence links; e.g., each method call references the method’s deﬁnition and each variable deﬁnition

links to all its occurrences. Having assured that all compile-time checks are carried out, symbols are

stored in a so called namespace. During validation, this data structure is used to detect name collisions

(e.g. redeﬁnition of variables) and undeﬁned references (e.g. usage of undeclared variables).

16 Know the Rules – Tutorial on Procedural Modeling

var pi = 3.14159 ; function circle_area

( radius ) { return pi * radius *

radius ; } for ( var i = 1 ; i

< 10 ; ++ i ) { var radius = 10

+ 2 * i ; var area = circle_area

( radius ) ; var text = "circle #"

+ i + ": " + "r = " + radius +

" cm, " + "A = " + area + " cm^2." ;

IO . print ( text ) ; }

= ;

( ) {

* * ;

}

( = ; < ; ++ ) {

= + * ;

= ( );

= + +

+ + +

+ + + ;

. ( );

}

var

function

return

for var

var

var

var

pi

circle_area radius

pi radius radius

i i i

radius i

area circle_area radius

text i

radius

area

IO print text

3.14159

1 10

10 2

"circle #" ": "

"r = " " cm, "

"A = " " cm^2."

1. The ﬁrst step in a compiler

pipeline is performed by a lexi-

cal analyzer. It converts source

code (top left) into a sequence

of tokens, i.e. a string of one

or more characters that is sig-

niﬁcant as a group. Tokens are

identiﬁed based on speciﬁc rules

of the lexer.

2. The stream of to-

kens (middle right) is pro-

cessed by the syntactic an-

alyzer based on the gram-

mar rules of the language

to parse. This example is

written in JavaScript. Its

entry point into the gram-

mar rules is a statement-

rule.

3. The result of the parsing step is an abstract

source tree (AST) (see Figure 8 right). Af-

terwards, the sematic analyzer constructs the

table of symbols (see Figure 8 left) and gen-

erates all references needed to resolve names

(see Figure 8 red pointers).

4. In an optional step, an optimizer may per-

form changes in the AST in order to speed

up the ﬁnal code; in this example, the vari-

able pi and the function circle area are only

assigned once. Therefore, they might be re-

solved and inlined in order to reduce the num-

ber of look-ups and function calls.

5. In the ﬁnal step a code generator produces

object code of the target platform.

Figure 7: A compiler consists of three main components: a front-end reads in the source code and constructs

a language-independent representation – a so-called abstract source tree (AST). The middleware performs nor-

malization and optimization steps on the AST. Finally, the back-end generates platform-speciﬁc object code, i.e.

executables, libraries, etc.

C. Schinko, U. Krispel & T. Ullrich, 2015 17

variable declaration

name: value:

pi 3.14159

function declaration

name:

circle_area

parameters:

radius

body:

{

return

value:pi * radius * radius

}

for-loop

declared iterator: value:

i 1.0

conditional

expression:

increment expression:

i < 10.0 ++ i

body:

{

variable declaration

name: value:

radius 10.0 + 2.0 * i

variable declaration

name: value:

area circle_area(radius)

variable declaration

name: value:

text "circle #" + i +

": " + "r = " +

radius + " cm, "

+ "A = " + area +

" cm^2."

expression

IO.print(text)

}

Table of symbols:

GLOBAL .IO

[. . . ]

GLOBAL .area

[. . . ]

GLOBAL .circle area

[. . . ]

GLOBAL .circle area.msg

[. . . ]

GLOBAL .circle area.radius

[. . . ]

GLOBAL .i

[. . . ]

GLOBAL .pi

declaration statement:

var pi = 3.14159;

declaration ﬁle & line:

example.ecs:1

references:

1. example.ecs:1

var pi = 3.14159;

2. example.ecs:4

return pi * radius * radius;

GLOBAL .radius

[. . . ]

GLOBAL .text

[. . . ]

Figure 8: The most important data structure within a compiler (suite) is the abstract source tree (AST), which

represents the input source code in a language-independent way. It consists of a tree structure to encode the

hierarchical, nested statements (right) enriched by references to resolve symbols (visualized in red). Additional

data structures – such as a table of symbols (left) – simplify the work performed by the compiler’s middleware.

18 Know the Rules – Tutorial on Procedural Modeling

From a historical point of view, the ﬁrst procedural modeling systems were Lindenmayer systems [99],

or L-systems for short. These early systems, based on grammars, provided the means for modeling plants.

The idea behind it is to start with simple strings and create more complex strings by using a set of string

rewriting rules. The modeling power of these early geometric interpretations of L-systems was limited to

creating fractals and plant-like branching structures.

Later on, L-systems are used in combination with shape grammars to model cities [92]. Yogi Parish

and Pascal M

¨

uller presented a system that generates a street map including geometry for buildings

given a number of image maps as input. The resulting framework is known as CityEngine – a modeling

environment for CGA Shape. Also based on CGA Shape, Markus Lipp et al. presented another modeling

approach [67] following the notation of Pascal M

¨

uller [82]. It deals with the aspects of more direct local

control of the underlying grammar by introducing visual editing. Principles of semantic and geometric

selection are combined as well as functionality to store local changes persistently over global modiﬁcations.

Sven Havemann takes a diﬀerent approach to generative modeling. He proposes a stack based

language called Generative Modeling Language (GML) [43]. The postﬁx notation of the language is very

similar to that of Adobe Postscript.

Generative modeling inherits methodologies of 3D modeling and programming [136], which leads

to drawbacks in usability and productivity. The need to learn and use a programming language is

a signiﬁcant inhibition threshold especially for archaeologists, cultural heritage experts, etc., who are

seldom experts in computer science and programming. The choice of the scripting language has a huge

inﬂuence on how easy it is to get along with procedural modeling. Processing is a good example of how

an interactive, easy to use, yet powerful, development environment can open up new user groups. It has

been initially created to serve as a software sketchbook and to teach students fundamentals of computer

programming. It quickly developed into a tool that is used for creating visual arts [101].

Processing is basically a Java-like interpreter oﬀering new graphics and utility functions together

with some usability simpliﬁcations. A large community behind the tool produced libraries to facilitate

computer vision, data visualization, music, networking, and electronics. Oﬀering an easy access to pro-

gramming languages that are diﬃcult to approach directly reduces the inhibition threshold dramatically.

Especially in non-computer science contexts, easy-to-use scripting languages are more preferable than

complex programming paradigms that need profound knowledge of computer science. The success of

Processing is based on two factors: the simplicity of the programming language on the one hand and the

interactive experience on the other hand. The instant feedback of scripting environments allow the user

to program via “trial and error”. In order to oﬀer our users this kind of experience, we enhanced our

already existing compiler to an interactive environment for rapid application development.

2.2 Scripting Languages for Generative Modeling

There exists a broad variety of tools and techniques for procedural modeling. We provide an overview of

a collection of generative modeling techniques (see Table 2) under the following aspects:

application domain: Generative modeling tools often incorporate prior knowledge of a speciﬁc applica-

tion domain, e.g. generative modeling of architecture [122], or modeling of organic structures [69],

[99], which is reﬂected in this aspect.

programming category: Some methods are built on top of conventional programming languages, or

scripting languages. On the contrary, some techniques are built using proprietary languages, such

as rule-based systems for buildings [151], or [82] for urban modeling. Some systems can be used

even without any scripting, e.g. graph-based languages [126], or the visual interactive editing of

split grammars [67].

environment: This aspect covers the tool set that provides geometric entities and operations, for ex-

ample the geometry kernel of a 3d modeling software, e.g. the open source modeling suite blender

or a proprietary system such as shape grammars on convex polyhedra [127].

C. Schinko, U. Krispel & T. Ullrich, 2015 19

Tool Name Application Domain Programming Category Environment

Blender Scripting general purpose model-

ing

python scripting open source modeling

software blender

CityEngine [82] urban modeling CGA shape commercial integrated

development environ-

ment CityEngine

Generalized Grammar

G

2

[63]

scientiﬁc python scripting commercial modeling

software Houdini

Generative Modeling

Language (GML) [43]

CAD postscript dialect proprietary, integrated

development environ-

ment for polygonal and

subdivision modeling

Grasshopper 3D visual arts, rapid proto-

typing, architecture

visual programming

based on dataﬂow

graphs, Microsoft .NET

family of languages

commercial modeling

software Rhinoceros3D

HyperFun [94] scientiﬁc specialized high-level

programming language

proprietary geometry

kernel FRep (Function

Representation)

Maya Scripting general purpose model-

ing

Maya Embedded Lan-

guage (MEL) and

python scripting

commercial modeling

software Autodesk Maya

OpenSCAD CAD OpenSCAD language open source, based on

CGAL geometry kernel

PLaSM scientiﬁc python scripting, Func-

tion Level scripting

integrated development

environment Xplode

Processing visual arts, rapid proto-

typing

Java dialect open source, integrated

development environ-

ment Processing

PythonOCC general purpose model-

ing and CAD

python scripting Open CASCADE Tech-

nology

Revit Scripting architecture Microsoft .NET family of

languages

commercial modeling

software Autodesk Revit

siteplan [58] rapid prototyping, archi-

tecture

interactive GUI-based

modeler

open source, integrated

development environ-

ment siteplan

Sketchup Scripting architecture, urban mod-

eling and CAD

Ruby scripting commercial modeling

software SketchUp

Skyline Engine [95] urban modeling visual programming

based on dataﬂow

graphs, python scripting

commercial modeling

software Houdini

speedtree plants/trees interactive GUI-based

modeler, SDK for C++

standalone modeler and

integration into various

game engines

Terragen landscape modeling interactive GUI-based

modeler

free and commercial,

integrated development

environment Terragen

XFrog [30] plants/trees interactive GUI-based

modeler

integrated development

environment, standalone

and plugins for Maya

and Cinema4D

Table 2: Overview on generative / procedural 3D modeling tools and approaches.

20 Know the Rules – Tutorial on Procedural Modeling

There are many diﬀerent programming paradigms in software development. Therefore, they also apply

to the ﬁeld of generative modeling, where some paradigms emerged to be useful for speciﬁc domains.

imperative: In many cases, generative modeling is carried out using classical programming paradigms:

A programming language is used to issue the commands that generate a speciﬁc object using a

library that utilizes some sort of geometry representation and operations to perform changes. An

example are compass and ruler systems used by an imperative language. Furthermore, any modeling

software that is scriptable by an imperative language or provides some sort of API falls into this

category. Note that the resulting geometry is often produced as side eﬀects.

dataﬂow based: The program is represented as a directed graph of the data ﬂowing between operations.

The graph representation also allows for a graphical representation; Visual Programming Languages

(VPL) allow to create a program by linking and modifying visual elements, many VPL’s are based

on the dataﬂow paradigm. Examples in the domain of generative modeling are the Grasshopper3D

plug-in for the Rhinoceros3D modeling suite, or the work of Gustova Patow et al. [95] built on

top of the procedural modeler Houdini.

rule based systems: Another diﬀerent representation that proved useful for generative modeling are

rule-based systems. Such systems provide a declarative description of the construction behavior of a

model by a set of rules. An example are L-Systems, as described in the Introduction. Furthermore,

the seminal work of George Stiny and James Gips [122] introduced shape grammars, as a formal

description of capturing the design of paintings and sculptures, in the sense of “design is calculating”.

Similar to formal grammars, shape grammars are based on rule replacement.

shape grammars In the classical deﬁnition [122], a shape grammar is the 4-tuple SG = (V

T

, V

M

, R, I),

where V

T

a set of shapes, V

T

∗

denotes the set of the shapes of V

T

with any scale or rotation. V

M

is

a ﬁnite set of non-terminal shapes (markers) such that V

T

∗

∩ V

M

= ∅. R denotes the set of rules,

which consists of pairs (u, v), such that u = (s, m) consists of a shape s ∈ V

T

∗

combined with a

marker of m ∈ V

M

, and v is a shape consisting of either

v = s

v = (s, ˜m) with ˜m ∈ V

M

v = (s ∪ ˜s, ˜m with ˜s ∈ V

T

∗

and ˜m ∈ V

M

Elements of the set V

T

∗

that appear in and rules of R are called terminal shapes. I is called the

initial shape, and typically contains an u ∈ (u, v) ∈ R. The ﬁnal shape is generated from the shape

grammar by starting with the initial shape and applying matching rules from R: for an input shape

and a rule (u, v) whose u matches a subset of the input, the resulting shape is another shape that

consists of the input shape with the right side of the rule substituted in the matching subset of

the input. The matching identiﬁes a geometric transformation (scale, translation, rotation, mirror)

such that u matches the subset of the input shape and applies it to the right side of the rule. The

language deﬁned by a shape grammar SG is the set of shapes that will be generated by SG that

do not contain any elements of V

M

.

split grammars The work of Peter Wonka et al. [151] applied the concepts of shape grammars

to derive a system for generative modeling of architectural models. This system uses a combination

of a spatial grammar system (split grammar) to control the spatial design and a control grammar,

which distributes the design ideas spatially (e.g. set diﬀerent attributes for the ﬁrst ﬂoor of a

building). Both of these grammars consist of rules with attributes that steer the derivation process.

The grammar consists of two types of rules: split and convert. The split rule is a partition operation

which replaces a shape by an arrangement of smaller shapes that ﬁt in the boundary of the original

shape. The convert rule replaces a shape by a diﬀerent shape that also ﬁts in the boundary of the

original shape. A simple example is shown in Figure 9.

This system has further been extended by the work of Pascal M

¨

uller et al. [82], which introduced

a component split to extend the split paradigm to arbitrary 3d meshes, as well as occlusion queries

and snap lines to model non-local inﬂuences of rules. For example, two wall segments that intersect

each other should not produce windows such that the window of one wall coincides with the other

wall, therefore occlusion queries are used to decide if a window should be placed or not.

C. Schinko, U. Krispel & T. Ullrich, 2015 21

The derivation of a split grammar, starting from an initial shape, yields a tree structure, which

suggests that the derivation can be speed up by a parallel implementation, which has been shown

by Jean-Eudes Marvie et al.[72]. Parallel generation is especially useful in an urban context,

with scenes with high complexity and detail. The work of Lars Krecklau et al. [61] used gpu

accelerated generation in the context of generating and rendering high detailed building fa¸cades; the

work of Zhengzheng Kuang et al. [64] proposes a memory-eﬃcient procedural representation of

urban buildings for real-time visualization.

With more advanced shape grammar systems, the non-local inﬂuences are a problem because

they introduce dependencies between arbitrary nodes of the derivation tree. Recent work by

Markus Steinberger et al. [120] shows how to overcome this problem in an GPU implemen-

tation. Furthermore, the same authors presented methods to interactively generate and render only

the visible part of a procedural scene using procedural occlusion culling and level of detail [121]

Figure 9: The tiles of a ﬂoor that contains windows with decorative elements (keystones) are generated by a

split grammar. The set of rules (left) will yield the ﬁnal instance of the ﬂoor if applied to a start image (right).

The derivation process is guided by an additional control grammar (e.g. which keystone is selected), which is not

shown in this ﬁgure [151].

22 Know the Rules – Tutorial on Procedural Modeling

C. Schinko, U. Krispel & T. Ullrich, 2015 23

3 Modeling by Programming

3D objects, which consist of organized structures and repetitive forms, are well suited for procedural

description, e.g. by the combination of building blocks or by using shape grammars. We discuss the

problems in conjunction with the deﬁnition of a shape:

What is a suitable interface for a building block?

Especially within a pipeline of diﬀerent tools, this question is gaining in importance.

Figure 10: In this Figure, three diﬀerent data structures are used to represent a mug. A polygonal mesh is shown

in the left image. The image in the middle shows a subdivision surface with the corresponding control mesh. On

the right hand side, the mug is represented by a 64 × 64 × 64 grid of voxels.

3.1 Building Blocks & Elementary Data Structures

Several elementary data structures are commonly used in computer graphics (see Figure 10).

Figure 11: The quality of the polygonal approximation of a cylinder highly depends on the number of primitives.

By increasing the number of primitives a better approximation of a cylinder can be created. In our case we have

n-gonal prisms, where n is 4 (left), 8 (middle), 64 (right). Once the approximation is selected and saved as a

mesh, the semantic information: “This is a cylinder.‘” is lost.

Polygonal Meshes A polygonal mesh representation is well-suited for real-time computer graphics.

Their inherent structure consisting of vertices, edges and faces can be – more or less – directly

mapped onto consumer graphics cards. Due to numerical problems with ﬂoating point numbers,

modeling with polygons can lead to undesirable results. During many mesh operations, even within

a simple intersection routine, the trade-oﬀ between range and precision may cause inaccuracies.

Another drawback of polygonal meshes can be seen when trying to model free-form shapes. The

quality of the approximation of an object’s surface with polygons highly depends on the number

of primitives and the modeling operations used. Once an approximation is found, all information

about the approximated surface is often lost, see Figure 11.

24 Know the Rules – Tutorial on Procedural Modeling

Apart from approximation problems, all operations are well-deﬁned, e.g. boolean mesh operations

always yield a polygonal mesh. However, important questions remain unanswered: How does an

interface for binary mesh operations on polygonal meshes look like? Are half-edges in this context

a suitable interface?

Non-Uniform Rational B-Splines This problem gets worse when modeling with non-uniform rational

B-splines (NURBS). Even the question for a simple intersection of two NURBS curves is not easy

to answer. Apart from the cases where two curves do not intersect or are identical, there can be

at most 9 intersection points, when looking at cubic curves. Calculating the intersection leads to

numerical issues. The problems get worse when intersecting two NURBS surfaces. There can be

various intersection components such as curve segments, points, loops and singular points. These

components are approximated with respect to given tolerances. Given the intersection curve, how

are the two surfaces stitched together? An interface for this operation has to deal with all these

aspects.

Subdivision Surfaces Subdivision surfaces are deﬁned recursively starting with a given polygonal mesh

(typically a quadrilateral, or a triangle mesh), as illustrated in Figure 10 (middle). A reﬁnement

scheme is applied to this mesh creating new vertices and faces converging to the limit subdivision

surface (which is the surface produced by applying the reﬁnement scheme inﬁnitely many times).

Intersection operations are often carried out on a per-facet basis. Therefore, the surfaces are

subdivided into a great number of facets and the intersection of surfaces is approximated by the

intersection of the facet pairs. Although, the stitching problem remains and undesired artifacts

around the intersection curve may occur.

For ensuring manufacturability, additional constraints have to be considered. For 3D printing

purposes, the geometry has to be water-tight and free of self-intersections. The former can, for

example, be ensured by using topology preserving Euler operators for mesh creation. They operate

on the connection graph of the mesh representation and obtain a valid boundary. The latter

property can be ensured by careful use of modeling operations.

Convex Polyhedra However there are data structures that do not have these problems. Shapes can be

deﬁned by the intersection of half-spaces. In general, the intersection of arbitrary half-spaces need

not be bounded. So called convex polyhedra can be deﬁned algebraically as the set of bounded

solutions to a system of linear inequalities. An important topological property is that convex

polyhedra are homeomorphic to a closed ball. All operations are well-deﬁned, leaving the problem

with the ﬁnite precision of ﬂoating point numbers.

Voxel Representations A voxel represents a data point on a regular, three-dimensional grid – similar to

a pixel in an image. Depending on the area of application, the data point can be multi-dimensional,

e.g. a vector of density and color. Due to the fact that position and size of a voxel are pre-

deﬁned, voxels are good at representing regularly sampled spaces. The approximation of free-form

shapes suﬀers from this inherent property, as can be seen in Figure 10 (right). Nevertheless, voxel

representations do not suﬀer from numerical instabilities as they are typically deﬁned on an integer

grid.

Implicit Surfaces Implicit surfaces are deﬁned as isosurfaces by a function R

3

→ R. Therefore, similar

to voxels, a surface is only indirectly speciﬁed. Also, with a function it is hard to describe sharp

features and it is diﬃcult to enumerate points on a surface. However, this representation has

several advantages. There is an eﬃcient check, whether a point is inside a shape, or not. Surface

intersections as well as binary operations can be implemented eﬃciently. Since the surface is not

represented explicitly, topology changes are easily possible.

C. Schinko, U. Krispel & T. Ullrich, 2015 25

Creating shapes with the presented elementary data structures requires the deﬁnition of modeling opera-

tions. Depending on the underlying representation, certain modeling operations are diﬃcult or impossible

to implement. The selection of operations for these data structures are manifold and can be grouped as

follows:

Instantiation are operations for creating new shapes.

Binary Creations are operations involving two shapes such as constructive solid geometry (CSG)

operations.

Deformations and Manipulations stand for all deforming and modifying operations like morphing

or displacing.

Also building blocks can be regarded as modeling operations. Complex shapes typically consist of subparts

– so called building blocks. We have already mentioned the open problem of deﬁning a suitable interface on

a data structure level. This problem still exists when describing shapes on a more abstract level. When

creating an algorithmic description of a shape, one has to identify inherent properties and repetitive

forms. These properties must be accounted for in the structure of the description. Identiﬁed subparts

or repetitive forms are best mapped to functions in order to be reusable. However, the true power of an

algorithmic description becomes obvious when parameters are introduced for these functions. As little as

the possibility to position a subpart at a diﬀerent location using input parameters makes the diﬀerence.

From that point on, the algorithmic description no longer stands for a single object, but for a whole

object family.

Within a composition of modeling functions, where each function is attached via its parameters to

topological entities deﬁned in previous states of the model, another problem occurs. Referenced entities

must then be named in a persistent way in order to be able to reevaluate the model in a consistent

manner. In particular, when a reevaluation leads to topological modiﬁcations, references between entities

used during the design process are frequently reevaluated in an erroneous way, giving results diﬀerent

from those expected. This problem is known as “persistent naming problem” [70].

3.2 Advanced Techniques

Besides classical, geometric operations – such as CSG – procedural and functional descriptions oﬀer novel,

additional possibilities to describe a shape.

Architectural Modeling with Procedural Extrusions This method utilizes the paradigm of foot-

print extrusion to automatically derive geometry from a coarse description. Input to this system are

polygons whose segments can be associated with an extrusion proﬁle polygon. The system utilizes the

weighted straight skeleton method [7] to calculate the resulting geometry. Examples can be seen in Fig-

ure 12. An implementation is available under the name siteplan, see also the tools section and Table 2.

While the growing demand for new building models contained in virtual worlds, games, and movies,

makes the easy and fast creation of modiﬁable models more and more important, 3D modeling of buildings

can be a tedious task due to their sometimes complex geometry. For historic buildings, especially the

roofs can be challenging. Johannes Edelsbrunner et al. present a new method of combining simple

building solids to form more complex buildings, and give an emphasis on the blending of roof faces.

This can be integrated in common pipelines for procedural modeling of buildings and will bring more

expressiveness than existing methods [34].

Deformation Aware Shape Grammars Generative models based on shape and split grammar sys-

tems often exhibit planar structures. This is the case because these systems are based on planar primitives

and planar splits. There are many geometric tools available in modeling software to transform planar

objects into curved ones, e.g. free-form deformation [112]. Applying such a transformation as a post-

processing step might yield undesirable results. For example, if we bend a planar facade of a building

into a curved shape, the windows inside the fa¸cade will have a curved surface as well. Another possibly

unwanted property arises when an object is deformed by scaling, e.g. the windows on a fa¸cade would

have diﬀerent appearances. Therefore, Ren

´

e Zmugg et al. introduced deformation aware shape gram-

mars [156], which integrate deformation information into grammar rules. The system still uses established

26 Know the Rules – Tutorial on Procedural Modeling

Figure 12: The work of Tom Kelly and Peter Wonka [58] oﬀers a framework to specify the geometry of a

building by extrusion proﬁles. The segments of footprint polygons (e.g. c) are associated with extrusion proﬁles,

e.g. the green segments are associated to the proﬁle a, the purple segments to the proﬁle b. The resulting geometry

can be seen in d.

methods utilizing planar primitives and splits, however, measurements that determine the available space

for rules are performed in deformed space. In this way, deformed splits can be carried out, the deforma-

tion can be baked at any point to allow for straight splits in deformed geometry. An example is shown

in Figure 13.

Variance Analysis Analyzing and visualizing diﬀerences of similar objects is important in many re-

search areas: scan alignment, nominal/actual value comparison, and surface reconstruction to name a

few. In computer graphics, for example, diﬀerences of surfaces are used to validate reconstruction and

ﬁtting results of laser scanned surfaces. Scanned representations are used for documentation as well as

analysis of ancient objects revealing smallest changes and damages. Analyzing and documentation tasks

are also important in the context of engineering and manufacturing to check the quality of productions.

Christoph Schinko et al. [110] contribute a comparison of a reference / nominal surface with an ac-

tual, laser-scanned data set. The reference surface is a procedural model whose accuracy and systematics

describe the semantic properties of an object, whereas the laser-scanned object is a real-world data set

without any additional semantic information. The ﬁrst step of the process is to register a generative

model (including its free parameters) to a laser scan. Then, the diﬀerence between the generative model

and the laser scan is stored in a texture, which can be applied to all instances of the same shape family

as illustrated in Figure 14.

As generative models represent an ideal object rather than a real one, the combination of noisy 3D

data with an ideal description enhances the range of potential applications. This bridge between both

C. Schinko, U. Krispel & T. Ullrich, 2015 27

Figure 13: Deformation aware shape grammars allow the integration of free-form deformation into a grammar-

based system that is based on planar primitives and splits. Measurement about the available space for placing

objects are taken in deformed space while splits are carried out in undeformed space. An undeformed building

with rooms (left image) is deformed using two diﬀerent deformations (middle, right). It can be observed that the

amount of windows and rooms adapts automatically to the available space [156].

the generative and the explicit geometry description is very important: it combines the accuracy and

systematics of generative models with the realism and the irregularity of real-world data as pointed out

by David Arnold [6]. Once the procedural description is registered to a real-world artifact, we can use

the ﬁtted procedural model to modify a 3D shape. In this way we can design both low-level details and

high-level shape parameters at the same time.

3.3 Semantic Modeling

In some application domains, e.g. in the context of digital libraries, semantic meta data plays an important

role. It provides semantic information that makes up the basis for digital library services: indexing,

archival, and retrieval. Depending on the ﬁeld of application, meta data can be classiﬁed according to

the following criteria [139]:

Data Type The data type of the object can be of any elementary data structure (e.g. Polygons, NURBS,

Subdivision Surfaces, . . . ).

Scale of Semantic Information This property describes, whether meta data is added for the entire

data set or only for a sub part of the object.

Type of Semantic Information The type of meta data can be descriptive (describing the content),

administrative (providing information regarding creation, storing, provenance, etc.) or structural

(describing the hierarchical structure).

Type of creation The creation of the semantic information for an object can be done manually (by a

domain expert) or automatically (e.g. using a generative description).

Data organization The two basic concepts of storing meta data are storing the information within the

original object (e.g. EXIF data for images), or storing it separately (e.g. using a database).

Information comprehensiveness The comprehensiveness of the semantic information can be declared

varying from low to high in any gradation.

An important aspect of semantic enrichment are standards. Many concepts for encoding semantic

information can be applied to 3D data, unfortunately only a few 3D data formats support semantic

markup [114]:

Collada The XML-based Collada format allows storing meta data like title, author, revision etc. not

only on a global scale but also for parts of the scene. This ﬁle format can be found in Google

Warehouse where meta data is, for example, used for geo-referencing objects.

PDF 3D PDF 3D allows to store annotations separated from the 3D data even allowing annotating the

annotations. An advantage is that the viewer application is widely spread and PDF documents are

the quasi standard for textual documents.

28 Know the Rules – Tutorial on Procedural Modeling

Figure 14: This ﬁgure shows the scanned model (top left), the procedural reference model (top middle), as well

as the output of the combined representation (top right). The combined version consists of a static instance of

the procedural model with details stored in a texture. The details are applied to the procedural base geometry via

shaders. The procedural reference model has been deﬁned by a set of parameters obtained in a ﬁtting process

applied on the scanned model. Having modiﬁed the procedural parameters, new procedural cups can be generated

(bottom middle). If one of these new cups is combined with an already existing texture, previously captured details

can be transferred (bottom right).

Due to the persistent naming problem, a modiﬁcation of the 3D model can break the integrity of the

semantic information. Any change of the geometry can cause the referenced part of the model to no

longer exist or being changed.

There are a lot of examples for semantic modeling in various contexts [42], [128], [143], [153], [20].

Here, one representative from the ﬁeld of geospatial modeling is selected to illustrate the topic:

Input parameters for a generative description can be either artiﬁcial or derived from real-world mea-

surements, like survey or satellite images. In the domain of geospatial modeling, data exported from

geospatial databases is used. The two ﬁle formats GeographyML (www.opengeospatial.org) and CityGML

(www.citygml.org) are wide-spread. Erick Mendez et al. [74] generate models using data exported from

geospatial databases, typically available in a vector format, to transcode it into 3D models suitable for

standard rendering engines. The transcoding process involves information loss, therefore the right point in

the pipeline has to be found to perform transcoding – this is called transcoding trade-oﬀ. Their modeling

framework lets developers optimize the transcoding trade-oﬀ to create 3D interactive visualizations. The

example augmented reality application shown in Figure 15 displays underground infrastructure created

out of geographic information systems (GIS) data.

30 Know the Rules – Tutorial on Procedural Modeling

C. Schinko, U. Krispel & T. Ullrich, 2015 31

4 Inverse Modeling

4.1 Problem Description

In order to use the full potential of generative techniques, the inverse problem has to be solved; i.e. what

is the best generative description of one or several given instances of an object class? This problem can

be interpreted in several ways. The simplest way to create a generative model out of a given 3D object

is to store it in the geometry deﬁnition ﬁle format called OBJ. A simple cube may result in a ﬁle with

content:

# definition of vertices

v 1.0 -1.0 -1.0

v 1.0 -1.0 1.0

v -1.0 -1.0 1.0

v -1.0 -1.0 -1.0

v 1.0 1.0 -1.0

v 1.0 1.0 1.0

v -1.0 1.0 1.0

v -1.0 1.0 -1.0

# definition of faces

f 1 2 3 4

f 5 8 7 6

f 1 5 6 2

f 2 6 7 3

f 3 7 8 4

f 5 1 4 8

This ﬁle format structure can be interpreted as a simple language in Polish preﬁx notation. Preﬁx

notation is a form of notation for logic, arithmetic, and algebra. Its distinguishing feature is that it places

operators (v, f, . . . ) to the left of their operands / parameters. Obviously, this is not the desired result

as the generative model can only represent a shape families, which are composed of only one member.

4.2 Overview on Current Approaches

Parsing shape grammars Shape grammars can be used to describe the design space of a class of

buildings / fa¸cades . An interesting application is therefore: given a set of rules and measurements of a

building, typically photographs or range scans, which application of rules yields the measurements? In

this context, the applied rules can also be seen as parse tree of a given input.

The work of Hayko Riemenschneider et al. [103] utilizes shape grammars to enhance the results of a

machine learning classiﬁer that is pre-trained to classify pixels of an orthophoto of a fa¸cade into categories

like windows, walls, doors and sky. The system applies techniques from formal language parsing, a variant

of the CYK algorithm, to parse a two-dimensional split grammar that consists of horizontal and vertical

splits, as well as repetition and symmetry operations. In order to reduce the search space, an irregular

grid is derived from the classiﬁcations, and the parsing algorithm is applied to yield the most probable

application of rules that yields a classiﬁcation label per grid cell. Such a parse tree can easily be converted

into a procedural model, as can be seen in Figure 16.

Fuzhang Wu et al. [152] also address the problem of how to generate a meaningful split grammar

explaining a given facade layout. Given a segmented facade image, the system uses an approximate

dynamic programming framework to evaluate if a grammar is a meaningful description. However, the

work does not contribute to the problem of facade image segmentation.

Model synthesis The work of Paul Merell and Dinesh Manocha [75] is set in the context of

automatic generation of a variation of models. The task is that given an exemplaric object (i.e. a mesh)

and constraints, derive a locally similar object. The method was inspired by texture synthesis methods.

These methods generate a large two-dimensional texture from a small input sample, where the result

is locally similar to the input texture, but should not contain visible regularities or repetitions. The

method computes a set of acceptable states, according to several types of constraints, and constructs a

set of parallel planes that correspond to faces orientations of the input model. Intersections of these planes

yield possible vertex positions in the output model. The system proceeds by assigning an acceptable state

32 Know the Rules – Tutorial on Procedural Modeling

(a) orthophoto (b) classiﬁcation result (c) irregular grid

(d) parsed structure (e) 3d rendering (f) reconstruction

Figure 16: A building fa¸cade (a) is classiﬁed into pre-trained categories using a machine learning classiﬁer (b).

From these classiﬁcations, a irregular grid is derived (c), and a two-dimensional split grammar is parsed (d). It

can be seen that the system was able to detect horizontally repeated columns (red rectangles) and two side parts,

symmetric around the middle part (connected blue rectangles). The resulting parse tree can be transformed to

a generative description, which can be evaluated to geometry for rendering (e). Parts of the city of Graz were

reconstructed from photographs and range scans using this technique (f).

(a) input model (b) parallel lines (c) acceptable output shape

(d) input model (e) generated variation

Figure 17: The work of Paul Merell and Dinesh Manocha [75] uses a mesh with constraints as input (a).

The input model is analyzed, and a set of identical lines is identiﬁed. Parallel translation of these lines yields a

discretization of space (b), from which a new model is synthesized that locally satisﬁes the constraints of the input

model (c). The bottom row shows an example in 3D, where many complex buildings (e) are generated from four

simple ones (d). The output contains vertices that have been constrained to intersect in four faces, some of them

are circled in red.

C. Schinko, U. Krispel & T. Ullrich, 2015 33

(a) procedural tree model

(b) input model and variations generated from the procedural model

Figure 18: The method of Ondrej Stava et al. [119] utilizes a statistical growth model of trees that is able

to generate a variety of diﬀerent tree species, as can be seen in the top row (a). The system uses a statistical

optimization method to ﬁnd the parameters of the model, given an input exemplar. The bottom row shows an

input model and three variations generated from the procedural model using the parameters that resulted from the

optimization process.

to a vertex and remove incompatible states in its neighborhood. The system terminates, if every vertex

has been assigned a state. This process is illustrated in Figure 17.

Inverse procedural modeling of trees The work of Ondrej Stava et al. [119] proposes a method

that estimates the parameters of a stochastic tree model, given polygonal input tree models, such that the

stochastic model produces trees similar to the input. Finding such a set of parameters is a complex task.

The parameters are estimated using Markov Chain Monte Carlo (MCMC) optimization techniques. The

method uses a statistical growth model that consists of 24 geometrical and environmental parameters.

The authors propose a similarity measure between the statistical model and a given input mesh that

consists of three parts: shape distance, which measures the overall shape discrepancy, geometric distance,

which reﬂects the statistics of geometry of its branches, and structural distance, which encodes the cost

of transforming a graph representation of the statistical tree model into a graph representation of the

input tree model. For some examples see Figure 18.

The MCMC method has also been applied by other methods to ﬁnd parameters of a statistical

generative model: [124], [145], [154].

Parameter Fitting and Shape Recognition The approach presented by Torsten Ullrich and

Dieter W. Fellner uses generative modeling techniques to describe a class of objects and to identify

objects in real-world data e.g. laser scans [135]. The input data sets of the algorithm are a point cloud

P and a generative model M. Then, the algorithm answers the questions

1. whether the point cloud can be described by the generative model and if so,

2. what are the input parameters x

0

such that M (x

0

) is a good description of P .

The implementation uses a hierarchical optimization routine based on fuzzy geometry and a diﬀerentiating

compiler; i.e. the complete generative model description M (x

1

, . . . , x

k

) (including all possibly called

subroutines) is diﬀerentiated with respect to the input parameters. This diﬀerentiating compiler oﬀers

the possibility to use gradient-based optimization routines in the ﬁrst place. Without partial derivatives

many numerical optimization routines cannot be used at all or in a limited way.

34 Know the Rules – Tutorial on Procedural Modeling

Figure 19: The scanned cup (rendered in semi-transparent gray) have been identiﬁed as instances of the gener-

ative cup description.In these cases the cups’ properties (position, orientation, radius, height, handle shape) are

determined successfully.

The example data set shown in Figure 19 consists of laser-scanned cups and a generative cup descrip-

tion. The algorithm is able to detect an instance of the generative cup. In these cases the cups’ properties

(position, orientation, radius, height, handle shape) are determined with only a small error.

C. Schinko, U. Krispel & T. Ullrich, 2015 35

5 Applications

Real-world applications demonstrate the power and versatility of generative modeling techniques.

5.1 Procedural Shape Modeling

First, we demonstrate the eﬀectiveness of procedural shape modeling for mass customization of consumer

products [16]. A generative description composed of a few well-deﬁned procedures can generate a large

variety of shapes. Furthermore, it covers most of the design space deﬁned by an existing collection of

designs – in this case wedding rings, see Figure 20. The challenge is whether it is actually possible to

ﬁnd a suitably general generative description.

Figure 20: The challenge: Samples from the JohannKaiser wedding ring design space. This is the input for

the creation of a generative description, which is both an abstraction and a generalization of the given individual

designs.

Careful analysis of the existing collection of designs reveals that the basic shape of most rings can be

deﬁned using the following parameters:

1. a proﬁle polygon,

2. the angular step size deﬁned by the number of supporting proﬁles to be placed around the ring’s

center,

3. the radius, and

4. a vertex transformation function.

The idea is to decompose the design variations into a set of transformation functions. Each function

transforms selected in a certain way. Eﬀects can be combined by calling a sequence of diﬀerent transfor-

mations. Figure 21a shows an example of a proﬁle polygon, copies of which are placed radially around

the origin (Figure 21b). These polygons are ﬁrst converted to double-sided faces. Then, corresponding

back and front sides are connected (Figure 21c) and a subdivision surface is created (Figure 21d). The

proﬁle polygon, the rotation angle, and a set of custom parameters are the input to this transformation

function (Figure 21f). In a post-processing step selected faces can be colored diﬀerently (Figure 21h).

The creation of the basic shape is separated from optional steps to create engravings, change materials,

or add gems. Engravings are implemented as per-vertex displacements (to maintain the option for 3D-

printing) and can be applied on quadrilateral parts of the ring’s mesh using half-edges to specify position

and spatial extend, or projectively by using a parametric cylindrical projection.

Typically noble materials like gold, silver, and platinum are used for wedding rings. Their surfaces

can be treated with various ﬁnishing techniques like polishing, brushing, or hammering. In order to

account for these eﬀects, a per-pixel shading model using an approximation of the Fresnel reﬂection term

36 Know the Rules – Tutorial on Procedural Modeling

(a) (b) (c) (d)

(e) (f) (g) (h)

Figure 21: Parametric wedding ring construction: n copies of the the proﬁle polygon (a) are radially placed

around the center (b). Consecutive proﬁles are connected using a newly-designed operator to form a control

mesh (c) that has a simple toroidal structure. It deﬁnes a subdivision surface forming the actual ring shape (d).

Switching the proﬁle transformation function from identity (e) to a selective sine transformation (f) creates a

decorative wave on the surface (g). Using a post-processing step the wave faces can be colored diﬀerently (h).

is used to model anisotropic highlights. Additionally, a cube map is deployed to create visually appealing

reﬂections. Predeﬁned surface ﬁnishes can be applied using normal mapping techniques.

The gem model is of the round brilliant cut type. The mathematical model consists of a convex

polyhedron representing the surface of the gem. Only ﬁve parameters are needed to deﬁne the shape.

Procedural gem instances can be placed by specifying the apex point, an upvector, and a scale factor.

The presented approch is used in a hardware accelerated server-side rendering framework [105], which

has been included in an online system called REx by JohannKaiser. It addresses specialist retailers like

jewelers and wedding ring studios and oﬀers an intuitive web interface for conﬁguring and visualizing

wedding rings (Figure 22). The rendering is done on a dedicated server greatly reducing the hardware

requirements on the client-side. This approach is feasible for a small number of clients oﬀering the

advantage of intellectual property protection, because rendering on the client-side is reduced to displaying

images (renderings coming from the server) and proxy geometry for interaction purposes. The actual 3D

content and its generative description is not transferred to the client.

This work demonstrates the eﬃciency of procedural shape modeling for the mass customization of

wedding rings. The presented generative description is able to produce a large variety of wedding rings.

Figure 23 shows a few results of the parametric toolkit. The approach is considered to be used for

visualization, information purposes only.

C. Schinko, U. Krispel & T. Ullrich, 2015 37

Figure 22: The REx wedding ring conﬁgurator: The user can specify the various parameters of the wedding rings

like proﬁle of the ring, placement and number of diamonds, etc. The interactive 3D rendering gives an immediate

feedback to the user how the choices will inﬂuence the ﬁnal appearance.

Figure 23: The presented generative description is able to produce a large variety of wedding rings. Features like

engravings, recesses, diﬀerent materials, unusal forms and gems can be created and customized.

38 Know the Rules – Tutorial on Procedural Modeling

5.2 Semantic Enrichment

With increasing number of (3D) documents, digital library services become more and more important. A

digital library provides markup, indexing, and retrieval services based on metadata. In the simplest case,

metadata is of the Dublin Core type [55] (title, creator/author, time of creation, etc). This is insuﬃcient

for large databases with a huge number of 3D objects, because of their versatility and rich structure.

Scanned models are used in raw data collections, for documentation archival, virtual reconstruction,

historical data analysis, and for high-quality visualization for dissemination purposes [115]. Navigation

and browsing through the geometric models should be possible not only in 3D, but also on the semantic

level. This requires higher-level semantic information. Semantic questions (“How many windows does

this facade have?”, “How many steps do these stairs have?”, etc.) cannot be answered, if the library

simply treats 3D objects as binary large objects (BLOB). The need for semantic information becomes

immediately clear in the context of electronic data exchange, storage and retrieval [35], [37]. The problem

of 3D semantic enrichment is closely related to the shape description problem [73]:

How to describe a shape and its structure on a higher, more abstract level?

The traditional way of classifying objects, pursued both in mathematics and, in a less formal manner, in

dictionaries, is to deﬁne a class of objects by listing their distinctive properties:

cup – a small, open container made of china, glass, metal, etc., usually having a handle and

used chieﬂy as a receptable from which to drink tea, soup, etc.

http://dictionary.reference.com

This approach is hardly realizable because of the fact that deﬁnitions cannot be self-contained. They

depend on other deﬁnitions (e.g., container, handle, receptable, . . . ), which leads to circular dependencies

that cannot be resolved automatically by strict reasoning, but rely on intuitive understanding at some

point.

An alternative, non-recursive approach for describing shape uses examples. Each entry in a picture

dictionary is illustrated with a photo or a drawing. This approach is widely used, for example in biology

for plant taxonomy. It avoids listing an exhaustive list of required properties for each entry. However,

it requires some notion of similarity, simply because the decision whether object x belongs to class A

or B requires measuring the closeness of x to the exemplars a ∈ A resp. b ∈ B. This decision can be

reached by a classiﬁer using statistics and machine learning [18], [142]. A good survey on content-based

3D object retrieval is provided by Benjamin Bustos et al. [24]. Statistical approaches clearly have their

strength in discriminating object classes. However, feature-based object detection, e.g., of rectangular

shapes, does not yield object parameters: width and height of a detected rectangle must typically be

computed separately.

To describe a shape and its construction process, its inner structure must be known. Structural

decomposition is well in line with human perception. In general, shapes are recognized and coded mentally

in terms of relevant parts and their spatial conﬁguration or structure [59]. One idea to operationalize this

concept was proposed, among others, by Masaki Hilaga [51], who introduces the Multiresolution Reeb

Graph, to represent the skeletal and topological structure of a 3D shape at various levels of resolution.

Structure recognition is a very active branch in the ﬁeld of geometry processing. The detection of shape

regularities [96], self-similarities [19] and symmetries [80], [81] is important to understand a 3D shape.

To summarize, structural decomposition proceeds by postulating that a certain type of general regularity

or structure exists in a class of shapes. This approach clearly comes to its limits when very speciﬁc

structures are to be detected, i.e., complicated constructions with many parameter interdependencies.

A possibility to describe a shape is realized by the generative modeling paradigm [91], [137]. The

key idea is to encode a shape with a sequence of shape-generating operations, and not just with a list

of low-level geometric primitives. In its practical consequence, every shape needs to be represented

by a program, i.e., encoded in some form of programming language, shape grammar [82], modeling

language [43] or modeling script [8].

The implementation of the “deﬁnition by algorithm” approach is based on a scripting language [135]:

Each class of objects is represented by one algorithm M. Furthermore, each described object is a set

C. Schinko, U. Krispel & T. Ullrich, 2015 39

of high-level parameters x, which reproduces the object, if an interpreter evaluates M (x). As this kind

of modeling resembles programming rather than “designing”, it is obvious to use software engineering

techniques such as versioning and annotations. In this way, model M may contain a human-readable

description of the object class it represents.

This encoding of semantic information can be used to enrich 3D objects semantically: the algorithm

starts with a point cloud P and a generative model M. Without user interaction it determines a pa-

rameter set x

0

, which minimizes the geometrical distance between P and M(x

0

). This distance d can be

interpreted as a multidimensional error function of a global optimization problem. Therefore, standard

techniques of function minimization can be used. Having found the global minimum x

0

, the geometric

distance d(P, M(x

0

)) can be interpreted. A low value corresponds to a perfect match; i.e. the point cloud

P is (at least partly) similar to M (x), whereas a high value indicates no similarity. Consequently, the

algorithm is able to semantically recognize instances of generative objects in real data sets.

As the computational complexity of global optimization depends on the dimensions of the error func-

tion, Torsten Ullrich et al. use a hierarchical optimization strategy with coarse model descriptions

and few parameters at the beginning and detailed model descriptions at the end. This multi-step op-

timization determines free parameters successively, ﬁxes them and introduces new parameters. This

process stops, if the end of the hierarchy is reached, or if high error values indicate no object similarity.

In contrast to other related techniques using ﬁtting algorithms, such as “Creating Generative Models

from Range Images” by Ravi Ramamoorthi and James Arvo [100], the approach by Torsten Ullrich

et al. can classify data semantically. Although Ravi Ramamoorthi and James Arvo also use genera-

tive models to ﬁt point clouds, they modify the generative description during the ﬁtting process. As a

consequence the optimization can be performed locally with a computational complexity, which is sig-

niﬁcantly reduced. But starting with the same generative description to ﬁt a spoon as well as a banana

does not allow to generate or preserve semantic data.

An example illustrates this process. The generative model to describe a vase takes 13 parameters:

R(r

x

, r

y

, r

z

) is the base reference point of the vase in 3D and T (t

x

, t

y

, t

z

) is its top-most point. The points

R and T deﬁne an axis of rotational symmetry. The remaining seven parameters deﬁne the distances

d

0

, . . . , d

6

of equally distributed B´ezier vertices to the axis of rotation (see Figure 24). The resulting 2D

B´ezier curve deﬁnes a surface of revolution – the generative vase.

In our example, the result of the registration step is a particular generative vase out of a family

of vases. A small selection of vases is shown in Figure 25 to demonstrate the versatility of the shape

template. It is the best generative vase to describe the digitized artifact it has been registered to. Figure

26 illustrates this result. Please note, the registration algorithm can only modify the input parameters

of the generative description. It cannot modify the description itself. As a consequence, features, which

cannot be generated by the script, cannot be included in the generative result.

40 Know the Rules – Tutorial on Procedural Modeling

R(r

x

, r

y

, r

z

)

T (t

x

, t

y

, t

z

)

d

0

d

1

d

2

d

3

d

4

d

5

d

6

Figure 24: A digitized artifact is often represented by a list of triangles with additional information such as

textures (to describe the visual appearance) and meta data (to describe its context); e.g. the vase on the left

hand side is a digitized artifact of the “Museum Eggenberg” collection. It consists of 364 774 vertices and 727 898

triangles.

A generative model describes a 3D shape by an algorithm and a set of high-level parameters. This example of a

procedural shape on the right hand side takes two points R and T in 3D and some distance values, which deﬁne

the control vertices of a B´ezier curve. The result is a surface of revolution to describe a vase.

Figure 25: The generative vase is deﬁned by two reference points of an axis of rotation (top and bottom) and

seven distances d

0

, . . . , d

6

, which deﬁne a surface of revolution. Changing only the parameters d

0

, . . . , d

6

, keeps

the vases’ height ﬁxed and modiﬁes the outer shape.

Figure 26: The digitized artifact (left) has been registered to a generative description of a vase. The result is

the best-ﬁtting vase of the complete family of vases deﬁned by the generative description – i.e. the generative vase

(right; rendered in red) is very similar to the digitized artifact (right; rendered in beige).

C. Schinko, U. Krispel & T. Ullrich, 2015 41

5.3 Form Follows Function

The last application involves design procedures and optimization methods used in inverse modeling as

well as civil engineering techniques – namely thermal analysis.

The adjustment of architectural forms to local and speciﬁc solar radiation conditions is a fundamental

study. When discussing energy consumption and solar power harness in buildings, important aspects

have to be taken into account, e.g., the relation between a building form and its energy behavior, and the

local weather conditions on an all-year basis. Several studies were published so far, trying to answer these

questions. “Form follows energy” has become an omnipresent dogma in architecture, but its realization is

diﬃcult. The manual analysis of the various relations between form, volume, and energy consumption has

to face many – not only numerical – problems. Christina R. Lemke points out these diﬃculties [65].

Already existing, common building forms (64 diﬀerent shapes in total) are analyzed and discussed.

In “Impact of building shape on thermal performance of oﬃce buildings in Kuwait” [4] a simpliﬁed

analysis method to estimate the impact of the building shape on energy eﬃciency of oﬃce buildings

is presented. This method is based on results obtained from a comprehensive whole building energy

simulation analysis. The simpliﬁed method, presented in the form of a correlation equation, is, according

to the authors, suitable for architects during preliminary design phase in order to assess the impact of

shape on the energy eﬃciency of oﬃce buildings. Although a building’s shape has a signiﬁcant impact

on the energy costs, and although these maintenance costs surpass the initial costs in several orders of

magnitude, no general guidelines are available for architects on the impact of a building’s shape on its

energy eﬃciency.

Several studies try to reduce the complex relationship of “Form follows Energy” to a few equations.

Naresh K. Bansal and Amitabh Bhattacharya[10] as well as Ramzi Ourghi et al. [89] derived

simpliﬁed analysis methods. Although some simpliﬁcations are acceptable for special scenarios, all of them

may introduce a signiﬁcant, systematic error as discussed by Patrick Depecker et al. [29]. According

to them many parameters are often missing, such as orientation or climate in order to produce reliable

results. The climate aspects are usually simpliﬁed to the season with the harshest weather, often forgetting

that temperatures in cities at certain latitudes can drop below thermal comfort limits in winter and that

temperatures in cities at other latitudes often raise above thermal comfort limits in summer [87].

Similar to our example, Veerparkash P. Sethi analyzes ﬁve of the most commonly used single

span shapes of greenhouses (even-span, uneven-span, vinery, modiﬁed arch and Quonset types) [113].

Hence, in this study an attempt has been made to select the most suitable shape and orientation of a

greenhouse for diﬀerent climatic zones (latitudes) on the basis of total solar radiation availability and its

subsequent eﬀect on the greenhouse air temperature. From this study important conclusions were taken

regarding greenhouse shapes and their relation to maximum solar radiation extraction by using several

diﬀerent simulations.

Using generative modeling techniques we perform an optimization within a conﬁguration space of a

complete family of buildings. The numerical optimization routine used in “Generative Modeling and

Numerical Optimization for Energy-Eﬃcient Buildings” [141] has to tackle several problems which occur

in many complex, nonlinear optimization tasks: the choice of initial values and the problem of local min-

ima. Both problems are addressed by a modiﬁed diﬀerential evolution method. Diﬀerential evolution is

a heuristic approach for minimizing nonlinear, non diﬀerentiable space functions. It is described in “Dif-

ferential Evolution: A simple and eﬃcient heuristic for global optimization over continuous spaces” [123],

[21]. The diﬀerential evolution method for minimizing continuous space functions can also handle discrete

problems by embedding the discrete parameter domain in a continuous domain. It converges quite fast

and is inherently parallel, which allows an execution on a cluster of computers.

The greenhouse to optimize is based on an extruded, quartic B´ezier curve: the ﬁrst and the last

control point have distance width, which may vary from 3m to 50m. The second control point is located

directly above the ﬁrst one at a ﬁxed height of 2m. Symmetrically, the second to last control point is

directly above the last one. The third control point can be chosen freely. It is parameterized by its

absolute height height ∈ [4m − 75m] and its relative position ratio ∈ [0, 1]. Finally, the greenhouse has a

geographical orientation α ∈ [0

◦

− 180

◦

] measured towards northern direction. These parameters deﬁne

the upright projection and the vertical section as illustrated in Figure 27.

42 Know the Rules – Tutorial on Procedural Modeling

control point height

length (dependent)

width

control point ratio

orientation

Figure 27: This greenhouse is deﬁned by four parameters: its width, a free control point of a B´ezier curve (with

two free coordinates), and an overall orientation within its environment. This image sketches the construction

process and shows the optimization result at the same time – the optimal solution according to energy needs.

The surface area under the deﬁned B´ezier curve has been calculated analytically. Its symbolic represen-

tation is included as a function in the scripted model in order to determine the greenhouse’s length –

a non-free parameter. If the length were a free parameter, the minimization would set it to zero. The

resulting greenhouse would have no volume and no energy need. To exclude such trivial solutions the

volume has to be a constant.

Having scripted the construction process our framework generates a population of parameter vectors

x

1,1

, . . . , x

1,n

, evaluates the script with each parameter and passes the corresponding geometry to Au-

todesk Ecotect

(TM)

, which performs an energy-eﬃciency analysis. This analysis returns an approximation

for the greenhouse’s annual energy needs – the back coupling for a gradient-free optimization method.

The outcome of the numerical optimization process is the best building (within the family of buildings

described by its script) concerning energy-eﬃciency.

The generative models are scripted in a JavaScript dialect. The geometry is encoded in a simple mesh

structure, which contains additional, semantic information and markup. For example, each polygon is

annotated with

its meaning (ﬂoor, roof, wall, window, etc.),

its material (a reference name of the material data base of Autodesk Ecotect

(TM)

: concrete, glass,

etc.), and

its hierarchy level (e.g. each window references its surrounding wall).

Furthermore, the generative model contains global meta data about energy respectively heat sources;

especially

its location (a geographically referenced climate data ﬁle in WEA format according to Drury B.

Crawley [28]) in order to include solar energy eﬀects and the building’s environment as well as

occupancy and activity data to include waste heat into the energy eﬃciency calculation.

Each trial vector of a new generation x

?

k+1,i

has to be </