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

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

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

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

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

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

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

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)

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

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

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

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

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

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 */

/* 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;

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);

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)

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 1 ... for efficiency) */

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)) ] ) ];

// 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)

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

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

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

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

Das Strahlungsmodell von GroIMP

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); /* 100000: number of random rays, 5: recursion depth (nb. of reflections) */ GUI-Shader Strahlungs-Shader

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]);