Rendern Sie folgenden Code und studieren Sie diesen. Stellen Sie danach Fragen, wenn Sie etwas nicht verstehen.

funktionen.pov

// Kamera
camera { 
  sky <0,0,1>           // Vektor, der festlegt, wo oben ist.
  right <-4/3,0,0>     // Bildverhaeltnis 4:3, plus Spiegelung für rechtsdrehendes System
  location <10,0,0>    // Position der Kamera
  look_at <0, 0, 0>    // Blickrichtung (erscheint im Bildmittelpunkt)
  angle 35             // Oeffnungswinkel der Kamera
}
 
// Lichtquellen
light_source { 
  <60,-20,80>              // Position des Lichts
  color rgb <1,1,1>     // Farbe des Lichts, als rot-gruen-blau Vektor (Komponenten 0 bis 1)
}
light_source { 
  <30,100,30>              // Position des Lichts
  color rgb <1,1,1>     // Farbe des Lichts, als rot-gruen-blau Vektor (Komponenten 0 bis 1)
}
 
// yz-Ebene
plane {x,0
  pigment { checker color rgb 0.2 color rgb 0.9 }
}
// y,z-Achse
union {
  cylinder { -2*y, 2*y, 0.05 }
  cylinder { -2*z, 2*z, 0.05 }
  cone {2*y, 0.1, 2.3*y, 0 }
  cone {2*z, 0.1, 2.3*z, 0 }
  text { ttf "timrom.ttf" "y" 0.1, <0,0,0>
    rotate 90*x
    rotate 90*z
    translate 2.3*y
  }
  text { ttf "timrom.ttf" "z" 0.1, <0,0,0>
    rotate 90*x
    rotate 90*z
    translate 1.8*z+0.2*y
  }
  pigment { color rgb z }
  finish { phong 0.95 }
}
 
// Berechnet den Funktionswert an der Stelle xx (x ist schon definiert)
#macro meinf(xx)
  xx*xx-2 // Wert der Funktion
#end
 
#declare starty=-2;
#declare endy=2;
#declare n=100;
#declare dy=(endy-starty)/n;
#while (starty<endy) 
  sphere { <0,starty, meinf(starty)>, 0.02
    pigment { color rgb x }
  }
  #declare starty=starty+dy;
#end

Die Funktion im oberen Code ist $f(x)=x^2-2$. Ändern Sie die Funktion auf folgende Funktionen ab:

• $f(x) = -\frac{1}{2}x^2+1$
• $f(x) = \sin(x)$ Die Funktion sin ist in POV-Ray definiert (Argument in Radiant).
• $f(x) = |x|$ Die Betragsfunktion in POV-Ray ist abs(…) (absolute value).
• $f(x) = \sqrt{x}$ Was müssen Sie anpassen? Die Wurzelfunktion in POV-Ray heisst sqrt(…).
• Gleichzeitig beide Funktionen $f(x)=\sqrt{1-(1-|x|)^2}$ und $g(x)=-3\sqrt{1-\sqrt{\frac{|x|}{2}}}$. Definieren Sie ein neues #macro dafür.

Verbinden Sie jeweils zwei benachbarte Kugeln mit einem Zylinder mit gleichem Radius. So entsteht eine durchgehende Linie.

Geben Sie die Datei auf SharePoint ab: https://sharepoint.ksbg.ch (→ Klassen → 2lW → Abgabe → dort Ihren Ordner öffnen → POV-Ray Datei entweder hineinziehen, oder mit hochladen, durchsuchen auswählen).

Alternative mit weniger Rechenfehler:

#declare starty=-2;
#declare endy=2;
#declare n=50;
#declare dy=(endy-starty)/n;
#declare i=0;
#while (i<n)    // i ist eine ganze Zahl, darum keine Rechenfehler
  #declare yy=starty+i*dy; 
  sphere { <0,yy, meinf(yy)>, 0.04
    pigment { color rgb x }
  }         
  #declare i=i+1;
#end

Eine Funktion kann auch mehr als eine Eingabe haben. In dieser Aufgabe betrachten wir eine Art Landschaft, wobei die Höhe $z$ aus den $x$- und $y$-Koordinaten berechnet wird. Im folgenden Code wird die Funktion $f(x)=\frac{1}{2}\left(x^2+y^2\right)$ abgebildet:

fxy.pov

// Kamera
camera { 
  sky <0,0,1>           // Vektor, der festlegt, wo oben ist.
  right <-4/3,0,0>     // Bildverhaeltnis 4:3, plus Spiegelung für rechtsdrehendes System
  location <5,2,5>    // Position der Kamera
  look_at <0, 0, 0>    // Blickrichtung (erscheint im Bildmittelpunkt)
  angle 35             // Oeffnungswinkel der Kamera
}
 
// Lichtquellen
light_source { 
  <60,-20,80>              // Position des Lichts
  color rgb <1,1,1>     // Farbe des Lichts, als rot-gruen-blau Vektor (Komponenten 0 bis 1)
}
light_source { 
  <30,100,30>              // Position des Lichts
  color rgb <1,1,1>     // Farbe des Lichts, als rot-gruen-blau Vektor (Komponenten 0 bis 1)
}
 
// xy-Ebene
plane {z,0
  pigment { checker color rgb 0.2 color rgb 0.9 }
}
 
#macro hoehe(xx,yy)
  0.5*(xx*xx+yy*yy)
#end
 
#declare startx = -1;
#declare endx = 1;
#declare starty=-1;
#declare endy=1;
#declare n=20;
#declare dx=(endx-startx)/n;
#declare dy=(endy-starty)/n;
 
#declare xx = startx;
#while (xx<endx)
  #declare yy = starty;
  #while (yy<endy) 
    sphere { <xx,yy,hoehe(xx,yy)>, 0.05
      pigment { color rgb x }
    }
    #declare yy=yy+dy;
  #end
  #declare xx=xx+dx;
#end

Rendern und studieren Sie den Code. Stellen Sie Fragen, wenn Sie etwas nicht verstehen.

Ändern Sie die Funktion hoehe ab (und passen Sie evtl. den Bereich und die Kamera an), z.B.

• $f(x,y) = \sin(x)+\sin(y)+2$
• $f(x,y) = \cos\left(\sqrt{x^2+y^2}\right)+1$
• $f(x,y) = 2^{-\sqrt{x^2+y^2}}\cos\left(\sqrt{x^2+y^2}\right)+1$ Hinweis: Potenz $a^b$ in POV-Ray: pow(a,b)
• $f(x,y) = \cos(x)\cdot \cos(y)+1$

Fügen Sie zwischen benachbarten Kugeln Zylinder mit dem selben Radius ein.

Studieren Sie folgenden Text:

Funktionen können beliebig viele Eingaben verarbeiten und beliebige Ausgaben produzieren. Funktionen können sich sogar selbst wieder zur Berechnung des Resultats gebrauchen.

Wir werden eine Funktion (#macro) koch definieren. Als Eingabe benötigt die Funktion 3 Dinge: Startpunkt $A$ und Endpunkt $B$ der Strecke und die Angabe, wieviel mal die Strecke noch unterteilt werden soll (d.h. die Anzahl Rekursionen (Selbstaufrufe)).

Die Funktion ist wie folgt aufgebaut:

 
 Funktion koch(A, B, r)
    wenn r=0: 
       Strecke AB zeichnen
    sonst
       3 Zwischenpunkte P1, P2, P3 aus A,B berechnen
       koch(A$, P1, r-1)    // Teilstück mit einer Rekursion weniger zeichnen
       koch(P1, P2, r-1)
       koch(P2, P3, r-1)
       koch(P3, B, r-1)
    ende wenn
 ende Funktion koch
 

Dazu definieren wir den Vektor $\vec v = \vec{AB}$ und den dazu rechtwinkligen Vektor $\vec u$. Kopieren Sie folgendes Code-Skelett:

#macro kochKurve(a, b, rekursionen)
  #if (rekursionen=0)
    // TODO: Hier die Strecke zeichen, z.B. mit einer Kugel mit Zentrum a und einem Zylinder von a nach b
    // Nur die Objekte ohne Farbe definieren.
  #else
    #local vv = ??;  // TODO: hier den Vektor ab berechnen
    #local uu = <-vv.y, vv.x, 0>;  // Rechwinkliger Vektor (Annahme, Punkte a,b mit gleicher z-Koordinate)
    #local p1 = ??;  // TODO: Aus a und vv den Punkt p1 berechnen.
    #local p2 = ??;  // TODO: p2 berechnen
    #local p3 = ??;  // TODO: p3 berechnen
    kochKurve(a, p1, rekursionen-1)
    // Hier die weiteren Segmente zeichnen
  #end
#end
 
// Zeichnen der Kurve:
// kochKurve liefert einzelne Objekte. Die werden in einer union zusammengefasst, damit
// alle eine gemeinsame Farbe und evtl. Transformationen erhalten können.
union {
  kochKurve(<0,0, 0>, <0,1,0>, 1)  // 1 Rekursion zum Testen, dann auf 2,3,4 bis maximal 6 erhöhen
  pigment { color rgb x }
}