Einführung in Turtle-Geometrie, L

Regelbasierte Programmierung mit XL
- Sommersemester 2008 -
Winfried Kurth
Reinhard Hemmerling
BTU Cottbus, Lehrstuhl Grafische Systeme
Die Sprache XL
„eXtended L-system language“
imperativ
objektorientiert
Java
regelbasiert
imperativ
objektorientiert
Java
XL
regelbasiert
Der Begriff "Programmierparadigma"
Paradigma:
grundlegende Denkweise,
beispielorientierte Vorstellung
Paradigma:
"Beschreibt eine Menge von Theorien,
Standards und Methoden, die gemeinsam
einen Weg repräsentieren, Wissen zu
organisieren"
Thomas Kuhn 1970: The Structure
of Scientific Revolutions
Paradigma:
"Beschreibt eine Menge von Theorien,
Standards und Methoden, die gemeinsam
einen Weg repräsentieren, Wissen zu
organisieren"
Thomas Kuhn 1970: The Structure
of Scientific Revolutions
Paradigmenwechsel: schwierig.
Revolution im Denken!
wurde aufgegriffen von Robert Floyd 1978:
Turing Award Lecture
"The Paradigms
of Programming"
Robert W. Floyd (1936-2001)
Welche Paradigmen werden nahegelegt
durch Probleme...
... bei der Simulation natürlicher Objekte ?
... in der Grafik ?
Ökologie:
Ökologie:
Organismen
Ökologie:
Organismen
Aufbau beschreiben
Ökologie:
Verhalten
Organismen
Aufbau beschreiben
(unter bestimmten
Bedingungen)
Ökologie:
Verhalten
Organismen
(unter bestimmten
Bedingungen)
Aufbau beschreiben
Gesetzmäßigkeiten
(Regeln) bestimmen
Ökologie:
Verhalten
Organismen
(unter bestimmten
Bedingungen)
Aufbau beschreiben
Prozesse
Gesetzmäßigkeiten
(Regeln) bestimmen
Ökologie:
Verhalten
Organismen
(unter bestimmten
Bedingungen)
Aufbau beschreiben
Prozesse
Ablauf berechnen
Gesetzmäßigkeiten
(Regeln) bestimmen
Grafisches System:
Grafisches System:
Objekte
Grafisches System:
Objekte
(mit Attributen)
Grafisches System:
Objekte
(mit Attributen)
regelmäßige
Strukturen
Grafisches System:
Objekte
(mit Attributen)
regelmäßige
Strukturen
Prozesse
Einige wichtige Programmierparadigmen
- für numerische Simulation von Prozessen:
imperatives Paradigma
Einige wichtige Programmierparadigmen
- für numerische Simulation von Prozessen:
imperatives Paradigma
(auch: von-Neumann-Paradigma,
Kontrollfluss-Paradigma)
John von Neumann (1903-1957)
imperativ:
"Befehls-Programmierung"
Computer = ?
"Befehls-Programmierung"
Computer = Maschine zur Veränderung von Variablenwerten.
"Befehls-Programmierung"
Computer = Maschine zur Veränderung von Variablenwerten (diese Veränderungen können Seiteneffekte haben).
"Befehls-Programmierung"
Computer = Maschine zur Veränderung von Variablenwerten.
Programm = ?
"Befehls-Programmierung"
Computer = Maschine zur Veränderung von Variablenwerten.
Programm = Plan für den Berechnungsprozess mit
Angabe der Befehle und des Kontrollflusses (z.B.
Schleifen).
"Befehls-Programmierung"
Computer = Maschine zur Veränderung von Variablenwerten.
Programm = Plan für den Berechnungsprozess mit
Angabe der Befehle und des Kontrollflusses (z.B.
Schleifen).
Programmfindung: ?
"Befehls-Programmierung"
Computer = Maschine zur Veränderung von Variablenwerten.
Programm = Plan für den Berechnungsprozess mit
Angabe der Befehle und des Kontrollflusses (z.B.
Schleifen).
Programmfindung: Elementare Einzelschritte finden
und in passende, flexible Reihenfolge bringen.
"Befehls-Programmierung"
Computer = Maschine zur Veränderung von Variablenwerten.
Programm = Plan für den Berechnungsprozess mit
Angabe der Befehle und des Kontrollflusses (z.B.
Schleifen).
Programmfindung: Elementare Einzelschritte finden
und in passende, flexible Reihenfolge bringen.
Programmiersprachen, die dieses Paradigma
unterstützen:
Fortran, Pascal, C, ..., Teile von Java, ...
Beispiel:
x = 0;
while (x < 100)
x = x + 1;
Inhalt der Variable x wird verändert
Schleife legt Kontrollfluss fest
Beachte: "=" steht hier nicht für math. Gleichheit,
sondern für Zuweisung (prozesshaft)!
Nachteil des imperativen Paradigmas:
simultane, parallele Zuweisung wird nicht unterstützt
Nachteil des imperativen Paradigmas:
simultane, parallele Zuweisung wird nicht unterstützt
Beispiel (Floyd 1978):
Räuber-Beute-System, beschrieben durch
Rneu = f(R, B),
Bneu = g(R, B)
Anfängerfehler beim Programmieren:
for (i = ... ) {
R = f(R, B);
B = g(R, B);
}
Nachteil des imperativen Paradigmas:
simultane, parallele Zuweisung wird nicht unterstützt
Beispiel (Floyd 1978):
Räuber-Beute-System, beschrieben durch
Rneu = f(R, B),
Bneu = g(R, B)
Anfängerfehler beim Programmieren:
for (i = ... ) {
R = f(R, B);
B = g(R, B);
}
Programmiersprachen, die das imperative Paradigma
unterstützen:
Fortran, Pascal, C, ..., Teile von Java,
Befehlssprache der Turtle-Geometrie
Turtle:
zeichnende Schildkröte, die auf Befehle hört
Turtle:
zeichnende Schildkröte, die auf Befehle hört
F0
F0
F0 RU(90)
F0 RU(90)
F0 RU(90) F0
F0 RU(90) F0
F0 RU(90) F0 RU(90) LMul(0.5) F0
F0 RU(90) F0 RU(90) LMul(0.5) F0
Wiederholung von Abschnitten der Zeichenkette
möglich mit "for"
z.B. for ((1:3))
liefert
( A B C )
A B C A B C A B C
was ist das Ergebnis der Interpretation von
L(10) for ((1:6))
( F0 RU(90) LMul(0.8) )
?
L(10) for ((1:6))
( F0 RU(90) LMul(0.8) )
anderes Beispiel:
for ((1:20)) ( for ((1:36))
( F0 RU(165) F0 RU(165) ) RU(270) )
anderes Beispiel:
for ((1:20)) ( for ((1:36))
( F0 RU(165) F0 RU(165) ) RU(270) )
Turtle geometry ("Schildkrötengeometrie")
befehlsgesteuertes, lokales Navigieren im 2D- oder 3DRaum (Abelson & diSessa 1982; vgl. Programmiersprache "LOGO")
"Turtle": Zeichen- oder Konstruktionsgerät (virtuell)
- speichert (grafische und nicht-grafische) Informationen
- mit einem Zustandsspeicher assoziiert (wichtig für
Verzweigungen)
- aktueller Zustand der Turtle enthält z.B. Information über
aktuelle Liniendicke, Schrittweite, Farbe, weitere
Eigenschaften des als nächstes zu konstruierenden
Objekts
Befehle (Auswahl):
F0
"Forward", mit Konstruktion eines Elements
(Linienstück, Segment, Gebäudetrakt...),
benutzt wird die aktuelle Schrittweite für die Länge
(die Null steht für "keine explizite Längenfestlegung")
M0
forward ohne Konstruktion (Move-Befehl)
L(x) ändere die aktuelle Schrittweite (Länge) zu x
LAdd(x)
inkrementiere die aktuelle Schrittweite um x
LMul(x)
multipliziere die aktuelle Schrittweite mit x
D(x), DAdd(x), DMul(x)
analog für die aktuelle
Dicke
Erweiterung auf 3D-Grafik:
Turtle-Rotationen um 3 Achsen
Erweiterung auf 3D-Grafik:
Turtle-Rotationen um 3 Achsen
left
head
up
Erweiterung auf 3D-Grafik:
Turtle-Rotationen um 3 Achsen
RL
RH
RU
3D-Befehle:
RU(45)
Drehung der turtle um die "up"-Achse um 45°
RL(...), RH(...) analog um "left" und "head"-Achse
up-, left- und head-Achse bilden ein rechtwinkliges, räumliches
Koordinatensystem, das von der turtle mitgeführt wird
RV(x)Rotation "nach unten" mit durch x vorgegebener Stärke
RG
Rotation ganz nach unten (Richtung (0, 0, -1))
Beispiel:
L(100) D(3) RU(-90) F(50) RU(90) M0 RU(90) D(10) F0 F0
D(3) RU(90) F0 F0 RU(90) F(150) RU(90) F(140) RU(90)
M(30) F(30) M(30) F(30) RU(120) M0 Sphere(15)
erzeugt
was ist das Ergebnis der Interpretation der Zeichenkette
L(10) F0 RU(45) F0 RU(45) LMul(0.5) F0 M0 F0 ?
Verzweigungen:
Realisierung mit Speicher-Befehlen
[
lege aktuellen Zustand auf Speicher
("Ablage", Stack)
]
nimm obersten Zustand von der Ablage
und mache diesen zum aktuellen Zustand
(damit: Ende der Verzweigung)
Verzweigungen:
Realisierung mit Speicher-Befehlen
[
lege aktuellen Zustand auf Speicher
("Ablage", Stack)
]
nimm obersten Zustand von der Ablage
und mache diesen zum aktuellen Zustand
(damit: Ende der Verzweigung)
F0 [ RU(-20) F0 ] RU(20) DMul(2) F0
zurück zum Beispiel:
Objekte
(mit Attributen)
Objektorientiertes Paradigma
Computer = Umgebung für virtuelle Objekte
Programm = Auflistung von (Objekt-) Klassen, d.h.
allgemeiner Spezifikationen von Objekten, die zur Laufzeit
des Programms (ggf. mehrfach) erschaffen und wieder
vernichtet werden können und miteinander kommunizieren.
Programmfindung: Spezifikation der Klassen (Daten und
Methoden), die Objektstruktur und -verhalten festlegen.
Programmiersprachen: Smalltalk, Simula, C++, Java, ...
Beispiel:
public class Auto extends Fahrzeug
{
public String marke;
public int plaetze;
public void anzeigen()
{
System.out.println("Das Auto ist ein " + marke);
System.out.println("Es hat " + plaetze + "Sitze.");
}
}
typisch:
Klassen (Auto) mit Daten (marke, plaetze) und
Methoden (anzeigen)
Beispiel:
Vererbung von
Attributen und
Methoden von Oberan Unterklassen
public class Auto extends Fahrzeug
{
public String marke;
public int plaetze;
public void anzeigen()
{
System.out.println("Das Auto ist ein " + marke);
System.out.println("Es hat " + plaetze + "Sitze.");
}
}
typisch:
Klassen (Auto) mit Daten (marke, plaetze) und
Methoden (anzeigen)
regelmäßige
Strukturen
Regelbasiertes Paradigma
Computer = Transformationsmaschine für Strukturen
Es gibt eine aktuelle Struktur, die solange transformiert wird,
wie dies möglich ist.
Regelbasiertes Paradigma
Computer = Transformationsmaschine für Strukturen
Es gibt eine aktuelle Struktur, die solange transformiert wird,
wie dies möglich ist.
Arbeitsprozess: Such- und Anwendungsprozess.
matching: Suchen einer passenden Regel,
rewriting: Anwendung der Regel, um die Struktur umzuschreiben.
Regelbasiertes Paradigma
Computer = Transformationsmaschine für Strukturen
Es gibt eine aktuelle Struktur, die solange transformiert wird,
wie dies möglich ist.
Arbeitsprozess: Such- und Anwendungsprozess.
matching: Suchen einer passenden Regel,
rewriting: Anwendung der Regel, um die Struktur umzuschreiben.
Programm = Menge von Transformationsregeln
Regelbasiertes Paradigma
Computer = Transformationsmaschine für Strukturen
Es gibt eine aktuelle Struktur, die solange transformiert wird,
wie dies möglich ist.
Arbeitsprozess: Such- und Anwendungsprozess.
matching: Suchen einer passenden Regel,
rewriting: Anwendung der Regel, um die Struktur umzuschreiben.
Programm = Menge von Transformationsregeln
Programmfindung: Spezifikation der Regeln
Regelbasiertes Paradigma
Computer = Transformationsmaschine für Strukturen
Es gibt eine aktuelle Struktur, die solange transformiert wird,
wie dies möglich ist.
Arbeitsprozess: Such- und Anwendungsprozess.
matching: Suchen einer passenden Regel,
rewriting: Anwendung der Regel, um die Struktur umzuschreiben.
Programm = Menge von Transformationsregeln
Programmfindung: Spezifikation der Regeln
Programmiersprachen: L-System-Sprachen, KI-Sprachen,
Prolog, ...
Beispiel: L-Systeme (Lindenmayer-Systeme)
Regelsysteme zur Ersetzung von
Zeichenketten
Beispiel: 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:
Chomsky-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 rewriting-Vorgangs 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?
was für die Modellierung von grafischen und biologischen
Strukturen noch fehlt:
eine geometrische Interpretation
was für die Modellierung von grafischen und biologischen
Strukturen 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:
Start ==> 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:
Start ==> 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:
Start ==> 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
Start  RU(90) F(10);
F(x)  F(x/3) RU(-60) F(x/3) RU(120) F(x/3) RU(-60) F(x/3)
.
Verzweigungsbeispiel:
F0  F0 [ RU(25.7) F0 ] F0 [ RU(-25.7) F0 ] F0 ;
Ergebnis nach 7 Schritten:
(Startwort L(10) F0)
Verzweigung, alternierende Zweigstellung und Verkürzung:
  L(10) F0 A ;
A  LMul(0.5) [ RU(90) F0 ] F0 RH(180) A ;
welche Struktur liefert
  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)
Stochastische L-Systeme
Verwendung von Pseudozufallszahlen
Beispiel:
deterministisch
Start ==> L(100) D(5) A;
A ==> F0 LMul(0.7) DMul(0.7)
[ RU(50) A ] [ RU(-10) A ];
Stochastische L-Systeme
Verwendung von Pseudozufallszahlen
Beispiel:
deterministisch
stochastisch
Start ==> L(100) D(5) A;
Start ==> L(100) D(5) A;
A ==> F0 LMul(0.7) DMul(0.7)
[ RU(50) A ] [ RU(-10) A ];
A ==> F0 LMul(0.7) DMul(0.7)
if (probability(0.5))
( [ RU(50) A ] [ RU(-10) A ] )
else
( [ RU(-50) A ] [ RU(10) A ] );
Beispiel: Fichtenmodell in 3D
mit L-System erzeugt
Erzeugung einer Zufallsverteilung in der Ebene:
Axiom ==> D(0.5) for ((1:300))
( [ Translate(random(0, 100), random(0, 100), 0)
F(random(5, 30)) ] );
Ansicht von oben
schräg von der Seite
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)  ....
Welche Struktur wird von folgendem L-System erzeugt?

 [ 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?

 [ 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.
Interpretationsregeln
Einbau einer weiteren Regelanwendung unmittelbar vor der
grafischen Interpretation (ohne Wirkung auf die nächste
Generation)
InterpretationsregelAnwendung
Turtle-Interpretation
Beispiel:
public void run()
{ [
Axiom ==> A;
A ==> Scale(0.3333) for (i:(-1:1))
for (j:(-1:1))
if ((i+1)*(j+1) != 1)
( [ Translate(i, j, 0) A ] );
]
applyInterpretation();
}
public void interpret()
[
A ==> Box;
]
public void run()
{ [
Axiom ==> A;
A ==> Scale(0.3333) for (i:(-1:1))
for (j:(-1:1))
if ((i+1)*(j+1) != 1)
( [ Translate(i, j, 0) A ] );
]
applyInterpretation();
}
(a)
(b)
public void interpret()
[
A ==> Box;
]
A ==> Sphere(0.5);
(c)
A ==> Box(0.1, 0.5, 0.1)
Translate(0.1, 0.25, 0) Sphere(0.2);
was wird durch dieses Beispiel erzeugt?
public void run()
{
[
Axiom ==> [ A(0, 0.5) D(0.7) F(60) ] A(0, 6) F(100);
A(t, speed) ==> A(t+1, speed);
]
applyInterpretation();
}
public void interpret()
[
A(t, speed) ==> RU(speed*t);
]
Kontextsensitivität
Abfrage eines Kontexts, der vorhanden sein muss, damit eine
Regel anwendbar ist
Angabe des Kontexts in (* .... *)
Beispiel:
module A(int age);
module B(super.length, super.color) extends F(length, 3, color);
Axiom ==> A(0);
A(t), (t < 5) ==> B(10, 2) A(t+1);
A(t), (t == 5) ==> B(10, 4);
B(s, 2) (* B(r, 4) *) ==> B(s, 4);
B(s, 4) ==> B(s, 3) [ RH(random(0, 360)) RU(30) F(30, 1, 14) ];
Der Schritt zu relationalen Wachstumsgrammatiken
Nachteil von L-Systemen:
• in L-Systemen mit Verzweigungen (über Turtle-Kommandos)
nur 2 mögliche Relationen zwischen Objekten:
"direkter Nachfolger" und "Verzweigung"
Erweiterungen:
• Zulassen weiterer Relationstypen (beliebig wählbar)
• Zulassen von Zyklen ( Graph-Grammatik)
ebenfalls regelbasierter Mechanismus:
Graph-Grammatiken
ebenfalls regelbasierter Mechanismus:
Graph-Grammatiken
Regel:
ebenfalls regelbasierter Mechanismus:
Graph-Grammatiken
Regel:
Anwendung:
RELATIONALE WACHSTUMSGRAMMATIKEN
(RGG: Relational Growth Grammars, parallele Graph-Gramm.)
Aufbau einer Regel einer RGG:
Kanten-Markierungen repräsentieren verschiedene Arten
von Relationen:
• ist Nachbar von
• enthält
• trägt
• codiert (genetisch)
• ist gepaart mit
• (...)
auch möglich: Darstellung von multiskalierten Strukturen
Standard-Kantentypen:
successor ( > oder blank), branch ( +> oder erste Kante bei
Klammern [...]), refinement ( /> )
RGG als Verallgemeinerungen von L-Systemen:
Zeichenketten entsprechen speziellen Graphen
In Textform schreiben wir allgemeine (selbstdefinierte) Kanten
als -kantensorte->
Kanten des speziellen Typs "Nachfolger" werden meist als Leerzeichen
geschrieben (statt -successor->)
Sonderformen von RGG-Regeln:
Aktualisierungsregeln (Regelpfeil ::> ): es werden nur
Parameter verändert
Beispiel: s:Sphere ::> s[radius] += increment;
Instanzierungsregeln: einzelne Zeichen werden in
Substrukturen aufgelöst, ohne Einfluss auf den nächsten
Entwicklungsschritt
(Regel muss dann direkt in der Moduldeklaration stehen)
Beispiel:
module S(float value) extends Null ==>
{ float x = value;}
Sphere(0.1).(setShader(new RGBAShader(1,1-x,1-x)));
• Grammatik modifiziert direkt den Graphen, Umweg über StringCodierung entfällt (bzw. wird nur noch für Regel-Input gebraucht)
außerdem Nachteil der Turtle-Interpretation von L-Systemen: Segmente sind nur Zylinder,
keine Objekte im Sinne der OOP
 Erweiterungen:
• Knoten des Graphen können beliebige Objekte sein (auch Grafikobjekte)
• Einbettung von Code einer höheren, imperativen oder objektorientierten
Programmiersprache in die Regeln (für uns: Java)
Zusammenfassung:
Programmierparadigmen
Zusammenfassung:
Programmierparadigmen
● imperativ
Zusammenfassung:
Programmierparadigmen
● imperativ
- Veränderung von Variablen
- Turtle-Geometrie
Zusammenfassung:
Programmierparadigmen
● imperativ
- Veränderung von Variablen
- Turtle-Geometrie
● objektorientiert
Zusammenfassung:
Programmierparadigmen
● imperativ
- Veränderung von Variablen
- Turtle-Geometrie
● objektorientiert
● regelbasiert
Zusammenfassung:
Programmierparadigmen
● imperativ
- Veränderung von Variablen
- Turtle-Geometrie
● objektorientiert
● regelbasiert
- L-Systeme
- Graph-Grammatiken
Zusammenfassung:
Programmierparadigmen
● imperativ
- Veränderung von Variablen
- Turtle-Geometrie
● objektorientiert
● regelbasiert
- L-Systeme
- Graph-Grammatiken
● weitere: funktional; nebenläufig; chemisch ...
Synthese: Die Sprache XL
„eXtended L-system language“
Programmiersprache, die parallele GraphGrammatiken (RGG) einfach verfügbar macht
imperativ
objektorientiert
Java
XL
regelbasiert
Die Sprache XL
Sprachspezifikation: Kniemeyer (2007/08)
(Dissertation erscheint in Kürze)
 Erweiterung von Java
 erlaubt zugleich Spezifikation von L-Systemen und RGG
in intuitiv verständlicher Regelschreibweise
prozedurale Blöcke, ähnlich Java: { ... }
regelorientierte Blöcke (RGG-Teil): [ ... ]
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
Beispiel: XL-Programm für die Koch‘sche Kurve
public void derivation()
[
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);
]
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
Beispiel: XL-Programm für die Koch‘sche Kurve
public void derivation()
[
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);
]
Knoten des
Graphen
Kanten (Typ „Nachfolger“)
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
Spezielle Knoten:
Geometrieobjekte
Box, Sphere, Cylinder, Cone, Frustum, Parallelogram...
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
Spezielle Knoten:
Geometrieobjekte
Box, Sphere, Cylinder, Cone, Frustum, Parallelogram...
Zugriff auf Properties über Parameterliste (Konstruktor):
Box(x, y, z)
oder mit setter-Methoden:
Box(...).(setColor(0x007700))
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
Spezielle Knoten:
Geometrieobjekte
Box, Sphere, Cylinder, Cone, Frustum, Parallelogram...
Transformationsknoten
Translate(x, y, z), Scale(cx, cy, cz), Scale(c),
Rotate(a, b, c), RU(a), RL(a), RH(a), RV(c), RG,
...
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
Spezielle Knoten:
Geometrieobjekte
Box, Sphere, Cylinder, Cone, Frustum, Parallelogram...
Transformationsknoten
Translate(x, y, z), Scale(cx, cy, cz), Scale(c),
Rotate(a, b, c), RU(a), RL(a), RH(a), RV(c), RG,
...
Lichtquellen
PointLight, DirectionalLight, SpotLight, AmbientLight
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
● Regeln in Blöcken [...] organisierbar, Steuerung der Anwendung
durch Kontrollstrukturen
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
● Regeln in Blöcken [...] organisierbar, Steuerung der Anwendung
durch Kontrollstrukturen
Beispiel: Regeln für den stochastischen Baum
Start ==> L(100) D(5) A;
A ==> F0 LMul(0.7) DMul(0.7)
if (probability(0.5))
( [ RU(50) A ] [ RU(-10) A ] )
else
( [ RU(-50) A ] [ RU(10) A ] );
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
● Regeln in Blöcken [...] organisierbar, Steuerung der Anwendung
durch Kontrollstrukturen
● parallele Regelanwendung
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
● Regeln in Blöcken [...] organisierbar, Steuerung der Anwendung
durch Kontrollstrukturen
● parallele Regelanwendung
● parallele Ausführung von Zuweisungen möglich
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
● Regeln in Blöcken [...] organisierbar, Steuerung der Anwendung
durch Kontrollstrukturen
● parallele Regelanwendung
● parallele Ausführung von Zuweisungen möglich
nochmal das Beispiel von Floyd:
Räuber-Beute-System, beschrieben durch
Rneu = f(R, B),
Bneu = g(R, B)
in XL korrekt:
R := f(R, B);
B := g(R, B);
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
● Regeln in Blöcken [...] organisierbar, Steuerung der Anwendung
durch Kontrollstrukturen
● parallele Regelanwendung
● parallele Ausführung von Zuweisungen möglich
● Operatorüberladung (z.B. „+“ für Zahlen wie für Vektoren)
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
● Regeln in Blöcken [...] organisierbar, Steuerung der Anwendung
durch Kontrollstrukturen
● parallele Regelanwendung
● parallele Ausführung von Zuweisungen möglich
● Operatorüberladung (z.B. „+“ für Zahlen wie für Vektoren)
● mengenwertige Ausdrücke (genauer: Producer statt Mengen)
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
● Regeln in Blöcken [...] organisierbar, Steuerung der Anwendung
durch Kontrollstrukturen
● parallele Regelanwendung
● parallele Ausführung von Zuweisungen möglich
● Operatorüberladung (z.B. „+“ für Zahlen wie für Vektoren)
● mengenwertige Ausdrücke (genauer: Producer statt Mengen)
● Graph-Abfragen (queries) zur Analyse der aktuellen Struktur
Beispiel für Graph-query:
Binärer Baum, Wachstum soll nur erfolgen, wenn genügender
Abstand zu anderen F-Objekten
Axiom ==> F(100) [ RU(-30) A(70) ] RU(30) A(100);
a:A(s) ==> if ( forall(distance(a, (* F *)) > 60) )
( RH(180) F(s) [ RU(-30) A(70) ] RU(30) A(100) )
ohne die if-Bedingung
mit der if-Bedingung
Eigenschaften der Sprache XL:
● Knoten der Graphen sind Java-Objekte, auch Geometrie-Objekte
● Regeln in Blöcken [...] organisierbar, Steuerung der Anwendung
durch Kontrollstrukturen
● parallele Regelanwendung
● parallele Ausführung von Zuweisungen möglich
● Operatorüberladung (z.B. „+“ für Zahlen wie für Vektoren)
● mengenwertige Ausdrücke (genauer: Producer statt Mengen)
● Graph-Abfragen (queries) zur Analyse der aktuellen Struktur
● aggregierende Operatoren (z.B. „sum“, „mean“, „forall“,
„selectWhereMin“)
Anfragen (queries) in den erzeugten Graphen
Möglichkeit der Verbindung von Struktur und
Funktion
Beispiel: suche alle Blätter, die Nachfolger des Knotens c
sind, und summiere deren Fläche
Anfragen (queries) in den erzeugten Graphen
Möglichkeit der Verbindung von Struktur und
Funktion
Beispiel: suche alle Blätter, die Nachfolger des Knotens c
sind, und summiere deren Fläche
transitive Hüllenbildung
Aggregationsoperator
Anfragen (queries) in den erzeugten Graphen
Möglichkeit der Verbindung von Struktur und
Funktion
Beispiel: suche alle Blätter, die Nachfolger des Knotens c
sind, und summiere deren Fläche
transitive Hüllenbildung
Aggregationsoperator
Ergebnis kann
übergeben werden an
prozedurale
Berechnung
Query in einem Pflanzen- / Tier-Modell:
p:Plant,
(* a:Animal, (distance(a,p) < p[radius]) *)
Query in einem Pflanzen- / Tier-Modell:
p:Plant,
(* a:Animal, (distance(a,p) < p[radius]) *)
sucht alle Tiere innerhalb des Radius von p
was ist von der in XL erzeugten Graph-Struktur sichtbar?
alle Geometrieknoten, die von der Wurzel (Zeichen: ^) des
Graphen über genau einen Pfad, der nur aus "successor"und "branch"-Kanten besteht, erreichbar sind.
Erzwingen, dass ein Objekt auf jeden Fall sichtbar ist:
==>> ^ Objekt
Ein XL-Compiler wird zur Verfügung gestellt von der
freien Software GroIMP
http://www.grogra.de
dort auch Link auf Download-Seite
Interaktive 3D-Plattform GroIMP (Growth-grammar related
Interactive Modelling Platform) mit XL-Compiler
• GroIMP ist ein Open Source-Projekt
GroIMP ist eine Kombination von:
- Graph-Grammatiken- (XL-) Interpreter
- Entwicklungsumgebung für XL
- 3D-Modeller
- 3D-Renderer (mehrere Varianten)
- 2D-Graphen-Visualisierer
- Editor für 3D-Objekte und Attribute
- Texturerzeugungswerkzeug
- X3D- (VRML-) Viewer (in Arbeit)
Beispiel eines mit
GroIMP realisierten
Pflanzenmodells
(Gerste):
Anwendungsbeispiel: Modellierung von Parklandschaften
(Rogge & Moschner 2007, für Stiftung Branitzer Park, Cottbus)
mit GroIMP
generierte Erle
in VRML-Welt
virtuelle Landschaft (mit Buchen-Fichten-Mischbestand)
Ergebnisse aus Architektur-Seminar mit XL:
Liang 2007
Jarchow 2007