Struktur-Funktions-Modelle von Pflanzen

Präsentation zum Thema: "Struktur-Funktions-Modelle von Pflanzen"—  Präsentation transkript:

1 Struktur-Funktions-Modelle von Pflanzen
- Sommersemester Winfried Kurth Universität Göttingen, Lehrstuhl Computergrafik und Ökologische Informatik 11. Vorlesung:

2 zuletzt: Übersicht zu XL und GroIMP Graph-Queries in XL
Beschattungskegel-Modell

3 als nächstes: sequenzieller und paralleler Ableitungs-Modus
Instanzierungsregeln einfaches Struktur-Funktions-Modell (erste Schritte)

4 Ableitungsmodi in XL standardmäßig voreingestellt: parallele Regelanwendung (wie bei L-Systemen) Umschalten auf sequenzielle Anwendung (in jedem Schritt wird dann höchstens eine Regel angewandt): setDerivationMode(SEQUENTIAL_MODE) Rückschaltung auf parallel: setDerivationMode(PARALLEL_MODE) testen Sie das Beispiel sm09_b32.rgg

5 Modellierung des Dickenwachstums in Pflanzen
häufig verwendete Ansätze: Regression Durchmesser ~ Länge für neue Wachstumseinh. Zuwachs dann von Alter, Verzweigungsordnung etc. abhängig verwende z.B. Regel mit jährlichem festem Wachstum Shoot(l, d) ==> Shoot(l, d+delta_d); Interpretationsregel für Shoot: Shoot(d) ==> F(l, d); oder: “pipe-model“-Annahme

6 “pipe model“ (SHINOZAKI et al. 1964) : Parallel geschaltete
“unit pipes“ Querschnitt ~ Blattmasse ~ Feinwurzelmasse

7 Folgerung : „Leonardo-Regel“ (da Vinci, um 1500) di   In jedem Verzweigungsknoten gilt d2 =  di2 (Invarianz der Querschnittsfläche) d

8 Realisierung in einem XL-Modell:
A = A1 + A2 d 2 = d12 + d22 A A2 Realisierung in einem XL-Modell: siehe Beispiele sm09_b33.rgg, sm09_b34.rgg dort wird zunächst das Längen- und Strukturwachstum simuliert, dann in getrennten Schritten das Dickenwachstum, berechnet von oben nach unten (es ist auch eine – realistischere – Kombination möglich)

9 Ein weiterer Regeltyp in XL: Instanzierungsregeln
Zweck: Ersetzung einzelner Module durch kompliziertere Strukturen, nur für die Darstellung (wie bei Interpretationsregeln) aber: es wird weniger abgespeichert (Einsparen von Speicherplatz) anders als bei Interpretationsregeln dürfen keine Turtle- Befehle mit Wirkung auf andere Knoten verwendet werden weitere Möglichkeit: „Replikator-Knoten“ zum Kopieren und Neuplatzieren von ganzen Strukturen

10 Instanzierungsregeln: Syntax
kein neuer Regelpfeil Angabe der Instanzierungsregel direkt in der Moduldeklaration module A ==> B C D; ersetzt (instanziert) überall A durch B C D Beispiel sm09_b43.rgg

11 const int multiply = EDGE_0; /* selbstdefinierter Kantentyp */
module Tree ==> F(20, 1) [ M(-8) RU(45) F(6, 0.8) Sphere(1) ] [ M(-5) RU(-45) F(4, 0.6) Sphere(1) ] Sphere(2); module Replicator ==> [ getFirst(multiply) ] Translate(10, 0, 0) [ getFirst(multiply) ]; public void run1() [ Axiom ==> F(2, 6) P(10) Tree; ] public void run2() Axiom ==> F(2, 6) P(10) Replicator -multiply-> Tree; Tree wird mit der roten Struktur instanziert es wird eingefügt, was an der „multiply“-Kante hängt

12 weiteres Beispiel einer Anwendung eines Multiplikator-Knotens mit Instanzierungsregel:
(Henke 2006)

13 Ein einfaches Funktions-Struktur-Modell einer Pflanze (FSPM) in 9 Schritten
- keine spezielle Pflanzenart, eher eine allgemeine Grundform - (vgl. Goethe: „Urpflanze“) - zunächst eher wie eine annuelle Pflanze aufgebaut - Modifikation / Anpassung des Modells wird Teil der Hausarbeit sein - funktionaler Teil wird sein: Lichtinterzeption, Photosynthese, Assimilatverteilung in der Pflanze - in den ersten Schritten aber reines Strukturmodell

14 Erster Schritt (sfspm01.rgg):
/* Steps towards a simple FSPM. sfspm01.rgg: A simple plant with leaves and branching is generated. Original version by G. Buck-Sorlin; modified. */ module Bud extends Sphere(0.1) {{ setShader(RED); }}; module Node extends Sphere(0.07) {{ setShader(GREEN); }}; module Internode extends F; /* leaves are rectangles: */ module Leaf extends Parallelogram(2, 1); const float G_ANGLE = 137.5; /* golden angle */

15 /* simple plant, with leaves and branches: */
protected void init() [ Axiom ==> Bud; ] public void run() Bud ==> Internode Node [ RL(50) Bud ] [ RL(70) Leaf ] RH(G_ANGLE) Internode Bud;

16 Zweiter Schritt (sfspm02.rgg):
Einschränkung der Verzweigungsordnung module Bud(int order) extends Sphere(0.0001) {{ setShader(RED); setRadius(0.2); }}; module Node extends Sphere(0.07) {{ setShader(GREEN); }}; module Internode extends F; module Leaf extends Parallelogram(2, 1); const float G_ANGLE = 137.5; /* golden angle */ /* simple plant, with leaves and branches: */ protected void init() [ Axiom ==> Bud(0); ] public void run() Bud(o), (o < 3) ==> Internode Node [ RL(50) Bud(o+1) ] [ RL(70) Leaf] RH(G_ANGLE) Internode Bud(o);

17

18 Dritter Schritt: genaueres Timing für Erscheinen neuer Metamere (Internodium, Nodium, Blatt) Phyllochron = Zeitraum zwischen dem Erscheinen neuer Metamere in apikaler Position an derselben Sprossachse (oft gleichbedeutend gebraucht: Plastochron, dies ist aber eigentlich der Zeitraum zwischen zwei Initiierungen neuer Metamere) (Phyllochron: unabhängig davon, ob präformiertes oder neoformiertes Wachstum vorliegt) Zeitzählung im Modell in diskreten Zeitschritten (1 Schritt = 1 parallele Regelanwendung)

19 sfspm03.rgg module Bud (int ph, int order) extends Sphere(0.1)
{{ setShader(RED); }}; module Node extends Sphere(0.07) {{ setShader(GREEN); }}; module Internode extends F; module Leaf extends Parallelogram(2, 1); const float G_ANGLE = 137.5; /* golden angle */ /* introducing a phyllochron */ const int PHYLLO = 25; protected void init() [ Axiom ==> Bud(PHYLLO, 0); ] public void run() Bud(p, o), (p > 0) ==> Bud(p-1, o); /* first parameter counted down until...*/ Bud(p, o), (p == 0 && o <= 1) ==> Internode Node [ RL(50) Bud(PHYLLO, o+1) ] [RL(70) Leaf] RH(G_ANGLE) Internode Bud(PHYLLO, o); /* (order restricted to for efficiency) */

20 sfspm04.gsz: mit Blütenbildung; texturierte Organe
const ShaderRef leafmat = new ShaderRef("Leafmat"); const ShaderRef petalmat = new ShaderRef("Petalmat"); const ShaderRef internodemat = new ShaderRef("Internodemat"); const ShaderRef nodemat = new ShaderRef("Nodemat"); module Bud(int time, int ph, int order) extends Sphere(0.1) {{ setShader(nodemat); }}; module Node extends Sphere(0.07) {{ setShader(GREEN); }}; module NiceNode extends Sphere(0.07) module Internode extends F(1, 0.1, 7); module NiceInternode extends Cylinder(1, 0.08) {{ setShader(internodemat); }}; module Leaf extends Parallelogram(2, 1) {{ setColor(0x82B417); }}; module NiceLeaf extends Parallelogram(2,2) {{ setShader(leafmat); }}; module Flower ==> /* Instanzierungsregel */ RU(180) Cone(0.3, 0.3).(setColor(0x82B417)) M(-0.25) RL(90) [ for (int i=1; i<=5; i++) ( [ RU(i*360/5) RL(20) Parallelogram(2, 1).(setColor(0xFF00FF)) ] ) ] RU(45) [ for (int i=1; i<=5; i++) ( [ RU(i*360/5) RL(40) F(0.3, 0.1, 14) RV(-0.3) F(0.3, 0.1, 14) RV(-0.3) F(0.3, 0.1, 14) ] ) ] RU(-45) [ for (int i=1; i<=5; i++) ( [ RU(i*360/5) RL(70) Frustum(0.7, 0.2, 0.05).(setColor(0x8DAF58)) ] ) module NiceFlower ==> RU(180) Cone(0.3, 0.3).(setShader(internodemat)) M(-0.25) RL(90) Parallelogram(2, 1).(setShader(petalmat)) ] ) ] RU(45) [ for (int i=1; i<=2; i++) ( [ RU(i*360/3) RL(40) F(0.3, 0.1, 14) RV(-0.3) Frustum(0.7, 0.2, 0.05).(setColor(0x8DAF58)) ] ) ];

21 // sfspm04.gsz, Fortsetzung
const float G_ANGLE = 137.5; /* golden angle */ const int PHYLLO = 25; protected void init() [ Axiom ==> Bud(1, PHYLLO, 0); ] public void run() Bud(r, p, o), (p > 0) ==> Bud(r, p-1, o); Bud(r, p, o), (r<10 && p==0 && o<=2) ==> RV(-0.1) NiceInternode NiceNode [ RL(50) Bud(r, PHYLLO, o+1) ] [ RL(70) NiceLeaf ] RH(G_ANGLE) RV(-0.1) NiceInternode Bud(r+1, PHYLLO, o); Bud(r, p, o), (r == 10) ==> RV(-0.1) NiceInternode RV(-0.1) NiceInternode NiceFlower; hinzu kommen noch Bilddateien für die verwendeten Texturen, die manuell in GroIMP mit den Shader-Namen „Leafmat“, „Petalmat“ etc. verbunden werden (vgl. Vorlesung 5: Texturen)

22 Variante mit einfacher „Flower“ statt texturierter „NiceFlower“:

23 Variante mit „NiceFlower“, „NiceLeaf“ etc.:

24 Raytracing - ein Verfahren aus der Computergrafik Grundprinzip:
Modellansatz für Beleuchtungsrechnung (physikalisch genauer als der „Beschattungskegel“-Ansatz vom letzten Mal): Raytracing - ein Verfahren aus der Computergrafik Grundprinzip: Bild Lichtquelle Kamera Sichtstrahl Schattenteststrahl Objekt aus der Szene zusätzlich kann der Strahl über eine oder mehrere Reflexionen weiterverfolgt werden

25 wir wollen kein Bild erzeugen, sondern für alle Blätter der virtuellen Pflanze das aufgenommene Licht berechnen  Umkehrung der Strahlrichtung: die Strahlen laufen von den Lichtquellen zu den beschienenen Objekten („Photontracing“). Ein Extra-Schattentest entfällt. Es wird eine große Zahl von Strahlen mit zufälligen Richtungen erzeugt: „Monte-Carlo-Raytracing“ Akkumulation der aufgenommenen Strahlungs-Leistung (in der Einheit W = Watt) für jedes Objekt möglich Voraussetzung: es muss eine Lichtquelle in der Szene sein DirectionalLight, PointLight, SpotLight, Sky

26

27 Das Strahlungsmodell von GroIMP

28 sfspm05.gsz (nur neue Teile des Modells dargestellt: )
Lichtquelle in die Szene einfügen; Besonderheit: AlgorithmSwitchShader // module definitions ..... /* the leaf collects light and gets a new shader for the radiation model: */ module Leaf(float al) extends Parallelogram(2, 1) {{ setShader(new AlgorithmSwitchShader(new RGBAShader(0, 1, 0), GREEN)); }}; // further module definitions ..... /* the light source: */ module MyLamp extends SpotLight {{ setPower(200.0); /* power in W */ setAttenuationDistance(50.0); /* in m */ setAttenuationExponent(0.0); setInnerAngle(22.5*Math.PI/180.0); setOuterAngle(30.0*Math.PI/180.0); }}; module MyLight extends LightNode(1.0, 1.0, 1.0) /* R, G, B */ {{ setLight(new MyLamp()); }}; /* the radiation model is defined */ LightModel lm = new LightModel(100000, 5); /* : number of random rays, 5: recursion depth (nb. of reflections) */ GUI-Shader Strahlungs-Shader

29 sfspm05.gsz (nur neue Teile des Modells dargestellt; Fortsetzung: )
protected void init() [ Axiom ==> Bud(1, PHYLLO, 0); ==> ^ M(50) RU(180) MyLight; /* Light source is placed above the scene */ ] public void grow() { run(); lm.compute(); absorb(); } protected void run() Bud(r, p, o), (p>0) ==> // further rules.... protected void absorb() lf:Leaf ::> lf[al] = lm.getAbsorbedPower3d(lf).integrate() * 2.25; lf.(setShader(new AlgorithmSwitchShader( new RGBAShader((float) lf[al]/5.0, (float) lf[al]*2, (float) lf[al]/100.0), GREEN))); println(lf[al]);