Teil 3: L-Systeme, einfache Verzweigungsmodelle

Struktur-Funktions-Modelle von Pflanzen
- Sommersemester 2015 -
Winfried Kurth
Universität Göttingen, Lehrstuhl Computergrafik und
Ökologische Informatik
3. Vorlesung: 30. 4. 2015
letztes Mal:
• Laden von dtd-Dateien und erste Analysen in GroIMP
• Programmierparadigmen (imperativ, objektorientiert,
regelbasiert)
• Turtle-Geometrie
• deren Ausführung mit GroIMP
Beispiel: Zeichnen eines Dreiecks
protected void init()
[ Axiom ==> RU(30) F(10) RU(120) F(10) RU(120) F(10) ]
siehe Datei sm09_b01.rgg
heute:
• Einfache L-Systeme (Zeichenketten-Ersetzungssysteme)
• ihre Ausführung mit GroIMP
• einfache Verzweigungsmuster, modelliert mit L-Systemen
Dynamische Strukturbeschreibung
L-Systeme (Lindenmayer-Systeme)
Regelsysteme zur Ersetzung von
Zeichenketten
in jedem Ableitungsschritt parallele
Ersetzung aller Zeichen, auf die
eine Regel anwendbar ist
von A. Lindenmayer (Botaniker)
1968 zur Modellierung des
Wachstums von fadenförmigen
Algen eingeführt
Aristid Lindenmayer (1925-1989)
L-Systeme mathematisch:
Ein L-System ist ein Tripel (, , R); darin ist:
 eine Menge von Zeichen, das Alphabet,
 eine Zeichenkette mit Zeichen aus , das Startwort
(auch "Axiom"),
R eine Menge von Regeln der Form
Zeichen  Zeichenkette;
darin sind das Zeichen auf der linken Regelseite und
die Zeichenkette aus  entnommen.
zum Vergleich: Grammatik für natürliche Sprache:
Satz  S P O
S  Max
S  Tina
P  lernt
O  Englisch
O  Französisch
mögliche Ableitungen:
Satz
S
Satz
P
O
Max lernt Französisch
S
P
O
Tina lernt Englisch
Ein Ableitungsschritt (rewriting) einer Zeichenkette besteht
aus der Ersetzung aller ihrer Zeichen, die in linken
Regelseiten vorkommen, durch die entsprechenden
rechten Regelseiten.
Man vereinbart: Zeichen, auf die keine Regeln anwendbar
sind, werden unverändert übernommen.
Ein Ableitungsschritt (rewriting) einer Zeichenkette besteht
aus der Ersetzung aller ihrer Zeichen, die in linken
Regelseiten vorkommen, durch die entsprechenden
rechten Regelseiten.
Man vereinbart: Zeichen, auf die keine Regeln anwendbar
sind, werden unverändert übernommen.
Ergebnis:
Ableitungskette von Zeichenketten, die sich durch
wiederholte Anwendung des Ersetzungsvorgangs aus dem
Startwort ergeben.
  1  2  3  ....
Beispiel:
Alphabet {A, B}, Startwort A
Regelmenge:
AB
B  AB
Beispiel:
Alphabet {A, B}, Startwort A
Regelmenge:
AB
B  AB
A
Beispiel:
Alphabet {A, B}, Startwort A
Regelmenge:
AB
B  AB
B
Beispiel:
Alphabet {A, B}, Startwort A
Regelmenge:
AB
B  AB
AB
parallele Ersetzung
Beispiel:
Alphabet {A, B}, Startwort A
Regelmenge:
AB
B  AB
BAB
Beispiel:
Alphabet {A, B}, Startwort A
Regelmenge:
AB
B  AB
BAB
Beispiel:
Alphabet {A, B}, Startwort A
Regelmenge:
AB
B  AB
ABBAB
Beispiel:
Alphabet {A, B}, Startwort A
Regelmenge:
AB
B  AB
Ableitungskette:
A  B  AB  BAB  ABBAB  BABABBAB
 ABBABBABABBAB  BABABBABABBABBABABBAB
 ...
Beispiel:
Alphabet {A, B}, Startwort A
Regelmenge:
AB
B  AB
Ableitungskette:
A  B  AB  BAB  ABBAB  BABABBAB
 ABBABBABABBAB  BABABBABABBABBABABBAB
 ...
wie lang ist die n-te Zeichenkette in dieser Ableitung?
Beispiel:
Alphabet {A, B}, Startwort A
Regelmenge:
AB
B  AB
Ableitungskette, besser visualisiert:
was für die Modellierung von grafischen und biologischen
Strukturen bisher noch fehlt:
eine geometrische Interpretation
was für die Modellierung von grafischen und biologischen
Strukturen bisher noch fehlt:
eine geometrische Interpretation
Füge also hinzu:
eine Abbildung, die jeder Zeichenkette
eine Teilmenge des 3-dimensionalen Raumes zuordnet
dann: "interpretierte" L-System-Abarbeitung
  1  2  3  ....

S1

S2

S3
....
S1, S2, S3, ... können als Entwicklungsstufen eines Objekts,
einer Szene oder eines Organismus interpretiert werden.
Für die Interpretation der Zeichenketten:
Turtle-Geometrie
Der Turtle-Befehlsvorrat wird zu einer Untermenge der
Zeichenmenge des L-Systems.
Symbole, die nicht Turtle-Befehle sind, werden von der
Turtle ignoriert.
Für die Interpretation der Zeichenketten:
Turtle-Geometrie
Der Turtle-Befehlsvorrat wird zu einer Untermenge der
Zeichenmenge des L-Systems.
Symbole, die nicht Turtle-Befehle sind, werden von der
Turtle ignoriert.
 Verbindung mit dem imperativen Paradigma
Beispiel:
Regeln
A ==> F0 [ RU(45) B ] A ;
B ==> F0 B ;
Startwort A
Interpretation
durch
Turtle-Geometrie
(A und B werden normalerweise nicht geometrisch interpretiert.)
was für eine Struktur liefert das L-System
A
==>
[ LMul(0.25) RU(-45) F0 ] F0 B;
B
==>
[ LMul(0.25) RU(45) F0 ] F0 A;
mit Startwort L(10) A ?
was für eine Struktur liefert das L-System
A
==>
[ LMul(0.25) RU(-45) F0 ] F0 B;
B
==>
[ LMul(0.25) RU(45) F0 ] F0 A;
mit Startwort L(10) A ?
äquivalente Regel:
A ==> [ LMul(0.25) RU(-45) F0 ] F0 RH(180) A;
weiteres Beispiel:
Flächenfüllende Kurve:
Axiom ==> L(10) RU(-45) X RU(-45) F(1) RU(-45) X;
X ==> X F0 X RU(-45) F(1) RU(-45) X F0 X
Flächenfüllende Kurve:
Axiom ==> L(10) RU(-45) X RU(-45) F(1) RU(-45) X;
X ==> X F0 X RU(-45) F(1) RU(-45) X F0 X
Flächenfüllende Kurve:
Axiom ==> L(10) RU(-45) X RU(-45) F(1) RU(-45) X;
X ==> X F0 X RU(-45) F(1) RU(-45) X F0 X
indisches Kolam-Muster
„Anklets of Krishna“
Beispiel für ein Fraktal:
Koch'sche Kurve
Axiom ==> RU(90) F(10);
F(x) ==> F(x/3) RU(-60) F(x/3) RU(120) F(x/3) RU(-60) F(x/3)
Axiom ==> RU(90) F(10);
F(x) ==> F(x/3) RU(-60) F(x/3) RU(120) F(x/3) RU(-60) F(x/3)
Axiom ==> RU(90) F(10);
F(x) ==> F(x/3) RU(-60) F(x/3) RU(120) F(x/3) RU(-60) F(x/3)
Axiom ==> RU(90) F(10);
F(x) ==> F(x/3) RU(-60) F(x/3) RU(120) F(x/3) RU(-60) F(x/3)
Axiom ==> RU(90) F(10);
F(x) ==> F(x/3) RU(-60) F(x/3) RU(120) F(x/3) RU(-60) F(x/3)
Axiom ==> RU(90) F(10);
F(x) ==> F(x/3) RU(-60) F(x/3) RU(120) F(x/3) RU(-60) F(x/3)
Axiom ==> RU(90) F(10);
F(x) ==> F(x/3) RU(-60) F(x/3) RU(120) F(x/3) RU(-60) F(x/3)
.
L-Systeme mit GroIMP
Notation nach Prusinkiewicz &
Lindenmayer:
= 27.5
F
FF[+F]F[-F]F
in der Sprache XL:
protected void init()
[ Axiom ==> L(1) F0; ]
public void run()
[
F0 ==> F0 [ RU(-27.5) F0 ] F0
[ RU(27.5) F0 ] F0;
]
L-Systeme mit GroIMP
Deklaration neuer, eigener
Symbole (Module):
module A;
module B;
protected void init()
[ Axiom ==> A; ]
public void run()
[
A ==> L(1) F0 [ RU(45) B ] A;
B ==> L(1) F0 B;
]
» A und B werden hier nicht
geometrisch interpretiert
L-Systeme mit GroIMP
Deklaration eigener Symbole mit
geometrischer Interpretation:
module A extends Sphere(0.1);
module B extends Sphere(0.08);
protected void init()
[ Axiom ==> P(14) A; ]
public void run()
[
A ==> L(1) F0 [ RU(45) B ] A;
B ==> L(1) F0 B;
]
Beispieldatei sm09_b02.rgg :
geschlossene Koch-Kurve, entwickelt aus Dreieck
protected void init ()
[ Axiom ==> RU(50) F(10) RU(120) F(10) RU(120) F(10); ]
// oeffentliche Methode zur interaktiven Verwendung in GroIMP
// (ueber Button):
public void anwendung ()
// Regeln muessen in []-Klammern gesetzt und mit ; beendet werden
[
// jedes F() wird durch 4 kleinere F() ersetzt
// die Laenge des F auf der linken Regelseite wird
// durch das x auf die rechte Seite mit heruebergenommen
F(x) ==> F(x/3) RU(-60) F(x/3) RU(120) F(x/3) RU(-60) F(x/3);
]
Beispieldatei sm09_b03.rgg :
/* Sie lernen an diesem Beispiel:
- wie Sie ein einfaches Pflanzenmodell (nach dem Architekturmodell Schoute) erstellen
- wie sie Verzweigungen (Subgraphen) mit [ ] angeben */
// Beispiel einer einfachen botanischen Baumstruktur (Architekturmodell Schoute)
//------ Erweiterungen des Standard-Alphabets (Turtle-Kommandos) -------// Shoot() ist eine Erweiterung des Turtle-Kommandos F() und steht fuer einen Jahres// trieb
module Shoot(float len) extends F(len);
// Bud ist eine Erweiterung eines Kugel-Objekts und steht fuer eine Terminalknospe,
// ihre „strength“ kontrolliert die Laenge des im naechsten Schritt erzeugten Triebes
module Bud(float strength) extends Sphere(0.2)
{{ setShader(RED); setTransform(0, 0, 0.3); }};
//----------------------------------------------------------protected void init ()
[ // Startzustand (eine Knospe)
Axiom ==> Bud(5);
]
public void run ()
[
// eckige Klammern [] kennzeichnen einen Seitenzweig (Relation „branch“)
// Rotationen um „upward“-Achse (RU)
// Verminderung der Staerke der Knospe (in jedem Schritt um 20%)
Bud(x) ==> Shoot(x) [ RU(30) Bud(0.8*x) ] [ RU(-30) Bud(0.8*x) ];
]
Verzweigung, alternierende Zweigstellung und Verkürzung:
module A;
Axiom ==> L(10) F0 A;
A ==> LMul(0.5) [ RU(90) F0 ] F0 RH(180) A;
Verzweigung, alternierende Zweigstellung und Verkürzung:
module A;
Axiom ==> L(10) F0 A;
A ==> LMul(0.5) [ RU(90) F0 ] F0 RH(180) A;
welche Struktur liefert
Axiom ==> F(10) A ;
A ==> [ RU(-60) F(6) RH(180) A Sphere(3) ]
[ RU(40) F(10) RH(180) A Sphere(3) ];
Sphere ==> Z; ?
(F(n) liefert Linie der vorgegebenen Länge n,
Sphere(n) eine Kugel mit Radius n)
Erweiterung des Symbol-Konzepts:
Lasse reellwertige Parameter nicht nur bei Turtle-Kommandos
wie "RU(45)" und "F(3)" zu, sondern bei allen Zeichen
 parametrische L-Systeme
beliebig lange, endliche Parameterlisten
Parameter werden bei Regel-Matching mit Werten belegt
Beispiel:
Regel
A(x, y) ==> F(7*x+10) B(y/2)
vorliegendes Zeichen z.B.:
nach der Regelanwendung:
A(2, 6)
F(24) B(3)
Parameter können in Bedingungen abgeprüft werden
(logische Bedingungen mit Java-Syntax):
A(x, y) (x >= 17 && y != 0) ==> ....
Beispiel:
Welche Struktur wird von folgendem L-System erzeugt?
Axiom ==> [ RU(90) M(1) RU(90) A(1) ] A(1);
A(n) ==> F(n) RU(90) A(n+1);
Welche Struktur wird von folgendem L-System erzeugt?
Axiom ==> [ RU(90) M(1) RU(90) A(1) ] A(1);
A(n) ==> F(n) RU(90) A(n+1);
Variante:
in der zweiten Regel "RU(90)" etwa durch "RU(92)"
ersetzen.
Hausaufgaben:
(1) Lesen Sie auf der „Grogra-CD“ im Abschnitt „Grogra“ die
Unterabschnitte
• Turtle
• Rotation
• Verzweigung
Beachten Sie die Unterschiede zwischen der Grogra-Syntax und XL (z.B.
in XL M statt f, LMul statt L* ...); siehe Tabelle der Turtle-Kommandos
(2) Lesen Sie Chapter 1, Section 1.1 – 1.5 (ohne 1.4) im Buch
„The Algorithmic Beauty of Plants“ von P. Prusinkiewicz und A.
Lindenmayer (online verfügbar, siehe Literaturseite zur
Veranstaltung). (= S. 1-21 ohne Abschnitt 1.4).