Master thesis pascal_mueller01

1.130 Aufrufe

Veröffentlicht am

0 Kommentare
0 Gefällt mir
Statistik
Notizen
  • Als Erste(r) kommentieren

  • Gehören Sie zu den Ersten, denen das gefällt!

Keine Downloads
Aufrufe
Aufrufe insgesamt
1.130
Auf SlideShare
0
Aus Einbettungen
0
Anzahl an Einbettungen
5
Aktionen
Geteilt
0
Downloads
14
Kommentare
0
Gefällt mir
0
Einbettungen 0
Keine Einbettungen

Keine Notizen für die Folie

Master thesis pascal_mueller01

  1. 1. Abstract Modeling a city poses a number of problems to computer graphics. Every urban area has a transportation network that follows population and environmental influences, and often a superimposed pattern plan. The buildings appearances follow historical, aesthetic and statu- tory rules. To create a virtual city, a roadmap has to be designed and a large number of build- ings need to be generated. We propose a system using a procedural approach based on L-systems to model cities. From various image maps given as input, such as land-water boundaries and population density, our system generates a system of highways and streets, divides the land into lots, and creates the appropriate geometry for the buildings on the respec- tive allotments. For the creation of a city street map, L-systems have been extended with methods that allow the consideration of global goals and local constraints and reduce the com- plexity of the production rules. The final buildings are composed by another L-system, that generates strings of a shape grammar which has been introduced to describe the form of a building.
  2. 2. Eidgenössische Ecole polytechnique fédérale de Zurich Technische Hochschule Politecnico federale di Zurigo Zürich Swiss Federal Institute of Technology Zurich Institut für Wissenschaftliches Rechnen Prof. M. Gross Forschungsgruppe Graphische Datenverarbeitung Diplomarbeit von Herrn Pascal Müller Design und Implementation einer Preprocessing Pipeline zur Visualisierung prozedural erzeugter Stadtmodelle Einleitung Das Softwarepaket CityBuilder besteht aus einer Sammlung von Softwaretools, welche die automatische Generierung von virtuellen Städten aus einfachen 2D Eingabedaten ermöglicht. Grundlage der Erzeugung ist die Verwendung von Lindenmayer-Systemen, die aus einfachen Anfangskonfigurationen und einer Anzahl Regeln prozedural eine Instanz des gewünschten Stadtnetzes herstellen können. Aufgrund dieser Daten können Gebäude und weitere Land- schaftsmerkmale erzeugt und platziert werden. Obwohl für die Generierung des Strassennetzes und eine einfache regelbasierte Geometry- Engine für Gebäude vorhanden sind, fehlen sowohl eine durchgängige Verarbeitung der Daten, sowie die Möglichkeit, die erzeugten virtuellen Städte zu visualisieren. . Aufgabenstellung In dieser Diplomarbeit soll nun eine durchgängige Pipeline implementiert werden, die das bestehende Tool ergänzt und mit deren Hilfe Bilder der so erzeugten Städte einfach generiert werden können. Die Hauptaufgabe besteht darin, eine Preprocessing Pipeline für das Rendern von prozedural erzeugten Städten zu designen und zu implementieren. Ausgehend von der Datenstruktur der Strassen müssen alle zusätzlichen Elemente wie Geometrie und Texturen korrekt plaziert wer- den. Ausgabe dieser Pipeline ist ein Datenformat, das von den meisten kommerziellen Render- ern gelesen werden kann (zB RIB). Die Gesamtarbeit setzt sich aus folgenden Teilaufgaben zusammen: • User Interface für bestehende Software Tools (L-System) - Erweiterung bestehender Soft- ware Tools durch Einführung einfach verständlicher Parameter in das Generierungsmodell • Implementierung einer kompletten Processing Pipeline mit der entspre- chenden Datenkonversion • Geometriezeugung für Gebäude • Integration eines prozeduralen Shaders • Generieren von Beispielen und Anwendungen Diese Arbeit steht unter der Obhut von Prof. Markus Gross und wird von Yoav Parish betreut. Ausgabe: 16. November 1999 Abgabe: 15. März 2000 Prof. M. Gross
  3. 3. 1 Inhaltsverzeichnis 1 Einleitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.1 Verwandte Arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 1.2 Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4 1.3 Übersicht . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 2 Lindenmayer-Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 2.1 Deterministische L-Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 2.2 Verzweigende L-Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 2.3 Stochastische L-Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 2.4 Kontextsensitive L-Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.5 Parametrische L-Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.6 Umgebungssensitive L-Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 2.7 Open L-Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 3 System Architektur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 4 Erzeugung der Strassennetzwerke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 4.1 Das erweiterte L-System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 4.2 Global Goals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 4.2.1 Western Rule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 4.2.2 Grid Rule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 4.2.3 Radial Rule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 4.2.4 Topographical Rule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 4.2.5 Blending . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 4.3 Local Constraints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 4.3.1 Umgebungssensitivität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 4.3.2 Selbstsensitive L-Systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 4.4 Smoothing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 5 Parzellierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 5.1 Subdivision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 5.2 Parameterzuweisung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 6 Prozedurale Gebäudegenerierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 6.1 Computer Aided Architectural Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 6.1.1 Methoden für den Entwurf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 6.1.2 Instrumente für den Entwurf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 6.2 Die Syntax der Shape Grammar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 6.3 Generierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 7 CityEngine User Manual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 7.1 Die Oberfäche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 7.1.1 Workspace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 7.1.2 File-Menu und Preferences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 7.2 Strassennetzwerkerzeugung (LSystem-Modul) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 7.2.1 LSystem-Menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 7.2.2 Timeline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 7.2.3 Parameterpanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 7.2.4 Rule Preferences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 7.3 Strasseneditor (Streets-Modul) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 7.3.1 Streets-Menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
  4. 4. 2 . 7.4 Parzellierung und Gebäudegenerierung (Allotments-Modul) . . . . . . . . . . . . . . . . . 57 7.4.1 Allotments-Menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 7.4.2 Buildings-Menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 8 Resultate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 8.1 Zürich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 8.2 Manhattan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 9 Schlussbemerkungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 9.1 Fazit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 9.1.1 Strassennetzwerkerzeugung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 9.1.2 Gebäudegenerierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 9.1.3 Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 9.2 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 9.2.1 Strassenetzwerkerzeugung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 9.2.2 Gebäudegenerierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 9.3 Danksagungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 A Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 A.1 Programm-Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 A.2 Das Modul Base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 A.3 Das Modul LSystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 A.4 Das Modul Streets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 A.5 Das Modul Allotments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 A.6 Das Modul UI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 B Dateitypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 B.1 Parameterfile (.par) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 B.2 Ruleparameterfile (.rp) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 B.3 Graphfile (.gra) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79 B.4 Blockfile (.p) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 B.5 Lotfile (.p+) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80 B.6 Buildingrulefile (.lsys) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 B.7 Shapestringfile (.str) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 B.8 MEL Code (.mel) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 B.9 Maya Ascii (.ma) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 C Referenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 D Siggraph 2001 Paper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
  5. 5. 1Einleitung Das Modellieren und Visualisieren einer Stadt mit all ihren geschichtlichen, kulturellen und ökonomischen Eigenheiten ist eine grosse Herausforderung in der Computergraphik. Unter- sucht man Bilder einer Grossstadt wie New York City, entdeckt man eine fantastische Vielfalt von Strassenmustern, Gebäuden, Formen und Texturen. Die kontrollierte und schnelle Erzeu- gung solcher virtuellen Umgebungen kann im Entertainment (siehe Abbildung 1.1), in der Architektur oder der Stadtplanung Anwendung finden. Abbildung 1.1: Die Stadt als Filmkulisse. Links: Metropolis (Fritz Lang; Deutsch- land, 1927). Rechts: Final Fantasy (Square Pictures; USA, 2001). Das prozedurale Modellieren grosser und komplexer Systeme hat eine lange Tradition in der Computergraphik. Bisher wurden jedoch nur natürliche Phänomene und Landschaften in proze- duralen Systemen simuliert. Vielen dieser Systeme ist gemeinsam, dass die Gesamtkomplexität in kleinere Elemente zerlegt werden kann, welche wiederum durch einfache Modelle beschrie- ben werden können. Einige dieser Systeme sind: Die Simulation von Erosion [21], mit Partikel- Systemen generierte Wälder [26] und die Modellierung von Wolken [23]. Um Pflanzen- geometrien zu erzeugen, werden in der Computergraphik hauptsächlich Systeme benutzt, die auf Grammatiken basieren, allen voran die L-Systeme. L-Systeme entwickelten sich über die Jahre zu einem sehr mächtigen und raffinierten Werkzeug [18,25] und wurden auch zur Modellierung ganzer Ökosysteme verwendet [6]. 3
  6. 6. 4 1. EINLEITUNG 1.1 Verwandte Arbeiten Aus kalibrierten Luftaufnahmen von Städten werden mit Methoden der Computer Vision Stras- sen und Gebäude extrahiert. Verschiedene Forschungsteams befassen sich mit diesem Ver- fahren (beispielsweise [13]). Diese Computer Vision Systeme rekonstruieren existierende Städte, jedoch können ohne photographische Eingabedaten keine neuen Modelle generiert wer- den. Die Forschungsarbeiten auf dem Gebiet der Visualisierung [4,5,11,27] von Städten befassen sich mit Data Management, Real-Time Visualisierung und Optimierung der Speicher- ausnutzung. Hier ist der Ausgangspunkt zumindest eine vorhandene Stadtgeometrie. Alexander et al. beschreibt in [1] eine Muster-Sprache (Pattern Language) für die Analyse und Planung von Städten, Nachbarschaften, Gebäuden und Räumen. Diese Sprache besteht aus über 250 verschiedenen Patterns, die vor allem semantische Interpretationen von häufig in Bal- lungsgebieten anzutreffenden Phänomenen sind. Sowohl makroskopische wie “Ringstrassen”, als auch mikroskopische Erscheinungen wie “Fugen im Pflaster” werden in verschiedene Pat- terns klassifiziert. Da diese Muster nicht in quantifizierbaren Massen formalisiert sind, können sie nicht in einen automatischen Generierungsprozess integriert werden. Die Space Syntax, entwickelt von Hillier [14], stellt Theorien zur Analyse der Komplexität von sehr grossen Systemen, wie Städten, zur Verfügung. Es wird versucht, menschliche Ver- haltensmodelle im Raum (beispielsweise die Wahl der Route [15,22]) zu erklären. Aber auch diese Methode ist analytisch und benötigt einen bereits existierenden Stadtplan. Aus dem Bereich des Computer Aided Architectural Design ist die Shape Grammar von Stiny erwähnenswert [29]. Diese verwendet Produktionsregeln, die, anstatt auf den zum Beispiel von L-Systemen bekannten Strings, direkt auf der Form operieren. Diese Shape Gram- mar wird zur Generierung von zweidimensionalen, repetitiven Mustern und in interaktiven Design Applikationen verwendet. 1.2 Lösungsansatz In dieser Arbeit wird ein System namens CityEngine vorgestellt, das mit einer vergleichbar kleinen Menge von geographischen und statistischen Eingabedaten eine komplette Stadt modelliert. Wegener unterteilt das Model einer Stadt in verschiedene Subsysteme [30]. Einige dieser Subsysteme sind: Topographie, Transportmedien, Gebäude, Zonenplanung, etc. Diese lassen sich nach verschiedenen Kriterien sortieren, zum Beispiel nach der Geschwindigkeit der Veränderung eines bereits bestehenden Systems. Da sich die Subsysteme Transportnetzwerk, Landnutzung und Unterbringung in einer urbanen Umgebung sehr langsam ändern (d.h. nur über Jahrhunderte), wird die Generierung einer Stadt im CityEngine System auf die Erzeugung von Strassennetzwerken und Gebäuden reduziert. Die Daten zur Landnutzung liefert der Benutzer in Form von Eingabebildern. Die Strassen dienen der urbanen Bevölkerung als ein Transportmedium, das über die ganze Fläche verteilt ist. Weil mit L-Systemen schon erfolgreich ähnliche Transportsysteme modelliert wurden [18], wird in der CityEngine ein L-System zur Erzeugung der Strassen- netzwerke verwendet. Um eine kontrollierte Generierung von Strassennetzwerken mit L-Systemen zu ermöglichen, wird das L-System Modell um hierarchische Mechanismen erwei- tert.
  7. 7. 1.3 ÜBERSICHT 5 Mit verschiedenen Methoden der CAAD können Gebäude beschrieben und erzeugt werden [31,32]. Da diese Methoden oft auf Formengrammatiken und Ersetzungsregeln basieren, wird in der CityEngine ein parametrisches L-System zur Generierung der Gebäude verwendet. 1.3 Übersicht Das Kapitel 2 ist eine Zusammenfassung der wichtigsten Arbeiten über Lindenmayer-Systeme (L-Systeme). Dieses Kapitels soll die Grundlagen der L-Systeme erläutern, wie diese aufgebaut sind und welche Anwendungen sich daraus ergeben. Kapitel 3 beschreibt das Framework der CityEngine Software, deren Pipeline und die verwendeten Datenstrukturen. Im Kapitel 4 wird die Idee der erweiterten L-Systeme vorgestellt. Erweiterte L-Systeme ermöglichen, die Kon- trolle des Wachstums externen, hierarchisch organisierten Funktionen zu überlassen. Anhand der Strassennetzwerkerzeugung wird die Verwendung dieser erweiterten L-Systeme demonstriert. Kapitel 5 beschreibt die Parzellierung der entstandenen Grundstücke. Anschlies- send wird in Kapitel 6 die Shape Grammar präsentiert, mit der Gebäude rekonstruiert und gen- eriert werden können. Das Kapitel 7 enthält die Anleitung zur Benutzung der CityEngine Software und Kapitel 8 zeigt die so erzielten Resultate. Im letzten Kapitel wird das CityEngine System beurteilt und mögliche Erweiterungen werden vorgeschlagen.
  8. 8. 6 1. EINLEITUNG
  9. 9. 2Lindenmayer-Systeme Ein Lindenmayer-System (L-System) ist ein regelbasiertes, paralleles Ersetzungssystem, das komplexe Endprodukte prozedural generieren kann. Mit Hilfe einer Menge von Ersetzungs- regeln (auch Produktionen genannt) ersetzt man sukzessive Teile eines einfachen Initial- objektes und definiert auf diese Weise komplexe Objekte. Als klassisches Beispiel eines graphischen Objektes, das durch Ersetzungsregeln definiert wurde, gilt die Koch-Kurve. Die am meisten erforschten Ersetzungssysteme basieren auf Charakter-Strings. Als Erste erregte in den späten Fünfzigern die Arbeit von Chomsky über formale Grammatiken die Aufmerksamkeit der Forscher. Chomsky wendete das Ersetzungskonzept an, um syntaktische Merkmale natürlicher Sprachen zu beschreiben. Ein paar Jahre später entstand die zu der kontextfreien Klasse der Chomsky-Grammatiken ähnliche Backus-Naur-Form. Ihr Zweck war, die Programmiersprache ALGOL-60 zu veranschaulichen und sie formal definieren zu können. 1968 entwickelte der Biologe Aristid Lindenmayer ein System um Pflanzen und deren Wachs- tum mathematisch zu beschreiben, das ebenfalls auf Ersetzungsstrategien basierte - die L-Systeme waren geboren. Der essentielle Unterschied zwischen Chomsky-Grammatiken und L-Systemen besteht in der Anwendung der Produktionen: In Chomsky-Grammatiken werden die Produktionen sequentiell abgearbeitet, während in L-Systemen - biologisch motiviert - alle Buchstaben eines Wortes parallel und simultan ersetzt werden. In diesem Kapitel werden zuerst die klassischen L-Systeme aus [24] erklärt. Anschliessend werden die beiden Erweiterungen von Prusinkiewicz und Mech namens umgebungssensitve L-Systeme [25] und Open L-Systems [18] beschrieben. Die in dieser Ausarbeitung verwendete L-System-Syntax entspricht derjenigen aus Prusinkiewicz jüngster Arbeit [18]. 2.1 Deterministische L-Systeme In diesem Unterkapitel wird die einfachste Klasse von L-Systemen präsentiert: die Klasse der deterministischen und kontextfreien L-Systeme (D0L-Systeme). Als Einführung ein intuitives Beispiel: Gegeben sind die 2 Buchstaben a und b. Diese können Wörter bzw. Strings bilden, in denen die beiden Buchstaben beliebig oft vorkommen dürfen. Jeder Buchstabe ist mit einer Ersetzungsregel assoziiert: Die Regel a → ab bedeutet, dass der Buchstabe a im nächsten Schritt durch den String ab ersetzt wird. Für den Buchstaben b gilt die Regel b → a, d.h. b wird durch a ersetzt. Um dieses Ersetzungs-Szenario zu starten benötigt man ein Initialwort: das Axiom. Für dieses Beispiel besteht das Axiom nur aus dem 7
  10. 10. 8 2. LINDENMAYER-SYSTEME Buchstaben b. Im ersten Schritt wird das Axiom b durch a ersetzt mittels der Produktion b → a. Im zweiten Schritt tritt die Produktion a → ab in Kraft, d.h. a wird ersetzt durch ab. Im darauf- folgenden Schritt werden nun a und b simultan ersetzt, was im String aba resultiert. Dieser Prozess wird nun beliebig oft fortgesetzt: Der vierte Schritt produziert abaab, der Nächste abaa- baba, daraus folgt abaababaabaab und so weiter. Im folgenden Abschnitt wird nun die formale Definition von D0L-Systemen angegeben. V bezeichnet ein Alphabet, V* ist die Menge aller Wörter über V, und V+ ist die Menge aller nichtleeren Wörter über V. Das leere Wort wird mit ε bezeichnet. Ein String-L-System ist ein geordnetes Tripel G = 〈V, ω, P〉 mit ω als Axiom für das ω ∈ V+ gilt und P bezeichnet die Menge der Produktionen: P ⊂ V × V*. Eine Produktion (a, χ) ∈ P wird geschrieben als id: a → χ. Dabei nennt man den Buchstaben a den Predecessor, das Wort χ Successor und id ist das Label der Produktion. Es wird vorausgesetzt, dass es für jeden Buchstaben a ∈ V mindestens ein Wort χ ∈ V* mit a → χ gibt. Sogenannte Identitätsproduktionen a → a müssen nicht explizit angegeben werden. Ein L-System ist nur dann deterministisch, wenn für jedes a ∈ V genau ein χ ∈ V* mit a → χ existiert. Bezeichnet µ = a1 a2 ... am ein Wort über V, ν = χ1 χ2 ... χm ein Wort über V*, und gilt ai → χi für alle i = 1..m, dann wurde ν aus µ generiert (µ ⇒ ν). Eine Entwicklungs- S equenz der Länge n eines L-Systems sieht demnach folgendermassen aus: µ0 ⇒ µ1 ⇒ .. ⇒ µn mit µ0 = ω und ν = µn. Um mittels L-Systemen graphische Modelle zu generieren, benötigt man eine graphische Interpretation der L-Systeme. Die einfache, intuitive und am meisten verwendete Methode basiert auf der Verwendung der aus LOGO-Programmen bekannten Turtlegeometrie: Ein Tripel (x, y, α) beschreibt die Position (mit kartesischen Koordinaten x und y) und die Richtung (Winkel α) der Turtle. Die folgenden Symbole steuern die Turtle: F Bewege Turtle d Einheiten vorwärts, was in einer Linie der Länge d resultiert (d ist eine globale Variable). Der neue Status (x’, y’, α) der Turtle berechnet sich aus x’ = x + d · cosα und y’ = y + d · sinα. + Drehe Turtle im Gegen-Uhrzeigersinn um den Winkel δ (globale Variable). Der daraus resultierende Status der Turtle ist (x, y, α + δ). - Drehe Turtle im Uhrzeigersinn um den Winkel δ. Der daraus resultierende Zustand der Turtle ist (x, y, α - δ). Zum Zeichnen eines Strings ist der Initialstatus (x0, y0, α0) nötig, und natürlich feste Werte für d und δ. Abbildung 2.1 zeigt ein Beispiel mit folgendem L-System: ω: F-F-F-F p: F→F-F+F+FF-F-F+F Die 4 Bilder entsprechen der graphischen Interpretation von µ0 bis µ3. Der Winkel δ ist immer 90°. Die Länge d wurde jeweils so gewählt, dass die Bilder gleich gross erscheinen, wozu man d jeweils 4 mal kleiner als im vorhergehenden Schritt gewählt hat.
  11. 11. 2.2 VERZWEIGENDE L-SYSTEME 9 Abbildung 2.1: 4 Entwicklungen der quadratischen Koch-Inseln 2.2 Verzweigende L-Systeme Ein Nachteil der L-Systeme ist, dass das Resultat immer eine einzige zusammenhängende Linie ist. Die L-Systeme wurden aber ursprünglich zum Modellieren von Pflanzen entwickelt und diese haben bekanntlich verzweigende Strukturen. Deshalb wurden die L-Systeme um zwei grundlegende Symbole erweitert: [ Der momentane Status der Turtle wird in einem Stack abgespeichert (“push”). ] Der neue Turtle-Status wird vom Stack gelesen (“pop”). Obwohl sich die Posi- tion (und Winkel) verändern, wird keine Linie gezeichnet. Jetzt können die L-Systeme pflanzenähnliche Strukturen erzeugen. Im folgenden Beispiel wird der Buchstabe A (für “Apex”) eingeführt. Er bezeichnet einen neuen Ast, der noch nicht gewachsen ist und folglich von der Turtle beim Zeichnen ignoriert wird (“Node-Rewritting L-System”). ω: A p1: A → F [ + A ] [ - A ] F A p2: F → F F
  12. 12. 10 2. LINDENMAYER-SYSTEME In Abbildung 2.2 ist der 7. Generations-Schritt dargestellt. Der Winkel δ ist 25.7°. Die erste Produktion p1 bewirkt die 3 Verzweigungen und p2 verdoppelt die Länge der schon bestehenden Forward-Linien. Abbildung 2.2: Beispiel einer Pflanzen-ähnlichen Struktur, die mit einem verz- weigten L-System generiert wurde. 2.3 Stochastische L-Systeme Jegliche Pflanzen, die durch dasselbe deterministische L-System generiert wurden, sehen gleich aus. Um dies zu verhindern, wird der Zufall miteingebaut, was individuell verschiedene Resul- tate ermöglicht. Eine Produktion eines stochastischen L-Systems hat nun folgendes Format: id : pred → succ : prob Das Tripel G der Definition eines D0L-Systems wird zu einem Quadrupel Gp = 〈V, ω, π, P〉 für stochastische L-Systeme erweitert. Die Wahrscheinlichkeitsverteilung π: P -> ]0, 1] bildet die Menge der Produktionen auf die Menge der Produktionswahrscheinlichkeiten ab. Für jeden Buchstaben a ∈ V ist die Summe aller Wahrscheinlichkeiten der Produktionen mit Predecessor a gleich eins. Das heisst verschiedene Produktionen mit demselben Predecessor sind möglich. Abbildung 2.3 zeigt mögliche Resultate (5. Schritt) des folgenden stochastischen L-Systems: ω: F p1 : F → F [ + F ] F [ - F] F : 0.33 p2 : F → F [ + F ] F : 0.33 p3 : F → F [ - F] F : 0.34 Abbildung 2.3: Stochastische, verzweigte Strukturen
  13. 13. 2.4 KONTEXTSENSITIVE L-SYSTEME 11 2.4 Kontextsensitive L-Systeme Produktionen in 0L-Systemen sind kontextfrei, d.h. sie werden unabhängig vom Kontext, in dem der Predecessor steht, ausgeführt. Für Pflanzen kann es aber wichtig sein, Interaktionen zwischen einzelnen Pflanzenteilen zu modellieren. Dies war der Grund für die Entstehung der Klasse der kontextsensitiven L-Systeme. Produktionen dieser Klasse von L-Systemen haben folgendes Format: id : lc < pred > rc → succ lc und rc bezeichnen den linken und den rechten Kontext. Die Produktion wird nur dann aus- geführt, wenn der Predecessor in entsprechendem Kontext steht. Obiges Produktionsformat entspricht der Kontext-sensitiven Klasse der 2L-Systeme. Produktionen in 1L-Systemen haben das Format id: lc < pred → succ oder id: pred > rc → succ. 0L-Systeme, 1L-Systeme und 2L-Systeme sind Teile der Oberklasse der IL-Systeme oder (k,l)-Systeme, bei welchen der linke Kontext ein Wort der Länge k und der rechte Kontext ein Wort der Länge l ist. Das folgende Beispiel, ein 1L-System, propagiert mit Hilfe des Kontextes ein Signal durch einen String: ω: baaaaaaa p1 : b<a→b p2 : b→a Dieses L-System erzeugt folgende Strings: µ0 : baaaaaaa µ1 : abaaaaaa µ2 : aabaaaaa µ3 : aaabaaaa ... 2.5 Parametrische L-Systeme Obwohl mit den obigen L-Systemen interessante Objekte wie Fraktale und pflanzenähnliche Strukturen erzeugt wurden, besitzen sie noch Nachteile. Einer davon ist die Tatsache, dass nur Linien möglich sind, deren Länge ganzzahliges Vielfaches der Einheitslänge ist. Deshalb hat Lindenmayer die Erweiterung zu parametrischen L-Systemen vorgeschlagen: Anstelle der Buchstaben werden Module benützt. Ein Modul A(a1, a2, ... , an) besteht aus einem Buchstaben A ∈ V und ist mit den Parametern a1, a2, ... , an assoziert. Zusätzlich wird die Produktion um Bedingungen und arithmetische Operationen erweitert: id : pred : cond → succ Folgendes Beispiel verdeutlicht die Anwendung: ω: B(2) A(4,4) p1 : B(x) : x > 0 → B(x-1) p2 : B(x) : x ≤ 0 → C p3 : A(x, y) : y > 3 → B(x) A(x/y, 0) p4 : A(x, y) : y ≤ 3 → A(2·x, x+y) Mit den Parametern kann man nun Veränderungen während dem Wachstum des Objektes simu- lieren. Einfaches Beispiel im vorhergehenden L-System ist das Modul B(x): Solange x grösser als Null ist, macht es nichts anderes als seinen Parameter zu dekrementieren oder anders aus-
  14. 14. 12 2. LINDENMAYER-SYSTEME gedrückt, auf seinen Einsatz (p2) zu warten. Abbildung 2.4 stellt die Entwicklung des L-Systems dar. Abbildung 2.4: Die ersten 5 Schritte des obigen parametrischen L-Systems. Zusätzlich sind die Steuerbefehle der Turtle zur graphischen Interpretation eines Modul- Strings ausgereifter geworden: F(a) Bewege Turtle einen Schritt der Länge a vorwärts. Der neue Status (x’, y’, α) berechnet sich aus x’ = x + a · cosα und y’ = y + a · sinα. +(a) Drehe Turtle im Gegen-Uhrzeigersinn um Winkel a. Der daraus resultierende Zustand der Turtle: (x, y, α+a). Abbildung 2.5 zeigt ein L-System, indem die Parameter dazu benützt wurden, um die Länge der Äste zu verkürzen. Das L-System mit Winkelinkrement δ = 85° ist durch folgende Gleichungen definiert: #define ratio 1.456 ω : A(1) p1 : A(s) → F(s) [ +A(s/ratio)] [ -A(s/ratio) ] Abbildung 2.5: Verzweigtes, parametrisches L-System
  15. 15. 2.6 UMGEBUNGSSENSITIVE L-SYSTEME 13 Natürlich können parametrische L-Systeme auch kontextsensitiv oder stochastisch sein. Eine mögliche Produktion eines parametrischen 2L-Systems wäre: p: A(x) < B(y) > C(z) : x+y+z > 10 → E(x+y) F(y+z) Auf dem folgenden, allgemeinen Format einer Produktion eines L-Systems mit allen Erweiterungen basieren die meisten neueren L-System Forschungsarbeiten und auch diese Ausarbeitung: id : lc < pred > rc : cond → succ : prob Mit diesen L-Systemen hat Aristid Lindenmayer (1925-1989) wunderbare Modelle von Pflan- zen generiert. Abbildung 2.6 ist ein Beispiel seiner Arbeiten. Abbildung 2.6: Die Blüten eines Flieders - mit einem L-System generiert. 2.6 Umgebungssensitive L-Systeme Umgebungssensitive L-Systeme wurden entwickelt, um die Reaktion einer wachsenden Pflanze auf ihre Umgebung simulieren zu können. Zum Beispiel wächst eine Pflanze Licht entgegen, oder sie stösst während dem Wachstum auf Hindernisse. Um solche Ereignisse zu simulieren, ist vor allem die (absolute) Position der Turtle wichtig. Deshalb wurden Query-Module eingeführt. Jeder Ersetzungsschritt wird genauso wie in den parametrischen L-Systemen aus- geführt, mit der Ausnahme der Query-Module: deren Parameter bleiben undefiniert. Erst nach Beendigung des Ersetzens werden den Query-Modulen Werte zugewiesen, die von der Position
  16. 16. 14 2. LINDENMAYER-SYSTEME und Orientierung der Turtle abhängen. Syntaktisch haben die Query-Module das Format ?A(a1, a2, ... , an). Im folgenden L-System wird das Query-Modul ?P(x, y) dazu benützt, die Position x, y der Turtle abzufragen: ω: A p1 : A → F(1) ?P(x, y) - A p2 : F(k) → F(k+1) Unten sind die resultierenden Strings aufgelistet. Die Strings µ0’, µ1’, µ2’ und µ3’ sind das Axiom und die Resultate der Ersetzung, bevor die Query-Module interpretiert wurden. Das Symbol * entspricht einem undefinierten Parameter und das Symbol - ist eine Drehung um 90° im Uhrzeigersinn (siehe Abbildung 2.7). µ0’: A µ0 : A µ1’: F(1) ?P(*, *) - A µ1 : F(1) ?P(0, 1) - A µ2’: F(2) ?P(*, *) - F(1) ?P(*, *) - A µ2 : F(2) ?P(0, 2) - F(1) ?P(1, 2) - A µ3’: F(3) ?P(*, *) - F(2) ?P(*, *) - F(1) ?P(*, *) - A µ3 : F(3) ?P(0, 3) - F(2) ?P(2, 3) - F(1) ?P(2, 2) - A Abbildung 2.7: Den Query-Modulen zugewiesene Werte. Das nächste Beispiel beschreibt ein 2D-Modell eines Baumes, dessen Äste gestutzt werden, sobald sie über eine gegebene Form hinauswachsen. Biologische Studien zeigen, dass sich während dem normalen Wachstum eines Baumes Knospen bilden, die keine neuen Äste erzeu- gen und unbenutzt bleiben. Diese Knospen können aber zu einem späteren Zeitpunkt wieder aktiviert werden, wenn man die vorderen, erfolgreicheren Knospen und deren produzierte Äste aus dem System entfernt. Im folgenden Modell wird der Extremfall dieser Theorie simuliert: Knospen werden nur dann aktiviert, wenn Äste abgeschnitten werden. ω: F A ?P(x, y) p1 : A > ?P(x, y) : !prune(x, y) → @o /(180) F A p2 : A > ?P(x, y) : prune(x, y) → T % p3 : F>T→S p4 : F>S→SF p5 : S→ε p6 : @o > S → [ + F A ?P(x, y) ]
  17. 17. 2.6 UMGEBUNGSSENSITIVE L-SYSTEME 15 Die vom Benützer definierte Funktion prune(x, y) = (x < -L/2) || (x > L/2) || (y < 0) || (y > L) erzeugt eine quadratische Clipping-Box mit Kantenlänge L - modelliert also die Schnittform des Baumes. Die Produktion p1 beschreibt, wie ein Apex A (noch zu wachsender Ast) eine schlafende Knospe @o und ein Ast F produziert. Das Modul /(180) ist Teil der 3D-Interpreta- tion einer Turtle und bewirkt eine halbe Drehung der Turtle um ihre eigene Achse (entspricht einem “roll”). Damit wird erreicht, dass die Knospen abwechselnd nach links und nach rechts wachsen. Anschliessend wird wieder ein Apex A eingefügt, um das Wachstum weiterhin zu ermöglichen. Die Produktion p1 wird aber nur ausgeführt, wenn die Turtle sich innerhalb der Clipping-Box befindet. Dazu wird der rechte Kontext, das Query-Symbol ?P(x,y), durch die Funktion prune überprüft. Ist die Turtle aber ausserhalb der Clipping-Box, tritt p2 in Kraft: der vorhergehende Ast F muss gestutzt werden, dazu wird er mit dem Abschneide-Symbol T mark- iert. Zusätzlich wird das Symbol % generiert. Letzteres löscht alle Symbole, die rechts davon in dieser Verzweigungsebene liegen (üblicherweise bis zum Symbol ]). Damit wird das Query- Modul (im rechten Kontext) eliminiert. Die Produktion p3 schneidet einen mit T markierten Ast F ab und erzeugt stattdessen das Knospen-aktivierende Symbol S. Dieses wird mit p4 und p5 nach unten propagiert, bis es auf eine schlafende Knospe trifft und diese zum Leben bzw. Wach- sen erweckt (p6). Abbildung 2.8: Einfaches Modell eines wachsenden Baumes, der gestutzt wird. Oberste Reihe: Schritte 6, 7, 8, und 10; Mittlere Reihe: Schritte 12, 13, 14 und 17; Unterste Reihe: Schritte 20, 40, 75 und 94. Die klein- en Kreise stellen schlafende Knospen dar, und die grossen Kreise zeigen die Position des Signals S an. In Abbildung 2.8 sind verschiedene Phasen des Entwicklungsprozesses dargestellt. Im sech- sten Schritt wächst der Ast der Hauptachse über die Clipping-Box hinaus. Im Schritt 7 wird dieser Ast gelöscht und das Knospen-aktivierende Symbol S losgeschickt, worauf prompt die nächste Knospe aktiviert wird. Es entsteht eine neü Verzweigung, die jedoch auch ausserhalb des Quadrates liegt und in Schritt 9 gelöscht wird, was abermals S generiert. Dieses aktiviert in Schritt 10 wieder eine Knospe. Der Prozess setzt sich fort, bis alle schlafenden Knospen aktiv- iert wurden. Mit ähnlichen, aber wesentlich komplizierteren dreidimensionalen L-Systemen

×