Anleitungen - A bis L


Alphakanal



Erstellt man eine neue Grafik, so besteht das Bild zunächst aus einer Hintergrundebene, vorstellbar als Leinwand unter einem Gemälde. Sollen nur einzelne Bildbereiche verändert werden, so kann man eine neue Ebene öffnen, dort arbeiten, Bildelemente ändern ohne die erste(n) Ebene(n) zu beinflussen.
Sollen nun Teile einer Ebene nicht sichtbar sein., so wird ein Graustufenbild, eine sog. Maske auf die Ebene gelegt, deren Grauwert bestimmt, wieviel von der maskierten Ebene sichtbar bleibt.



  1. Um eine Maske zu erstellen, kopiert man den zu projektierenden Bildbereich mit Hilfe des "Zauberstabwerkzeugs" auf ein Bild mit transparenten Hintergrund.
  2. Man wählt nun die Option "neue Maske erstellen" und speichert diese Maske in den Alphakanal des Bildes, sichert dann das ganze Bild in einem für PoVRay geeigneten Bildformat. Der Alpha-Kanal ist ein Graustufenkanal, der für die Maskensicherung benutzt werden kann. Ein Kanal enthält alle Pixelinformationen für eine bestimmte Farbe: Ein Kanal für Grausufenbilder, drei für Rot-Grün-Blau-Bilder.
  3. Wird dieses Bild nun in PoVRay auf z.B. eine Kugel projiziert, dann ist der Bildhintergrund transparent, die Kugel wird nur dann sichtbar, wenn man ihr reflektierende oder lichtbrechende Eigenschaften zuteilt.
  4. Die Deckfähigkeit der Ebene kann vor der Maskenerstellung verändert werden, man erhält dann eine graue Maske, die eine schwach durchscheinende Bildvorlage erzeugt: siehe rechte Spalte im Demobild oben!

Bei Mausklick auf das ff. Bild, kann das zugehörige Skript eingesehen werden.


































































































Bedingtes Programmieren: Fallunterscheidungen mit SWITCH, CASE, RANGE



POV 3 bietet mehrere Möglichkeiten zum bedingten Bildumwandeln. Zwei davon sollen hier vorgestellt werden. Nicht nur bei der Erstellung von Animationen, sondern auch beim Erzielen anderer Effekte ist dies nützlich.

Für die Syntax des Schalters SWITCH gilt: 

#switch (Variable)
     #case (Variablenwert_1)
        ..........
     #break  //beendet Fall 1

     #case (Variablenwert_2)
        ..........
     #break  //beendet Fall 2
#end


Falls die Variable den Wert "Variablenwert_1" hat, wird der erste Teil des Skripts umgewandelt, bei "Variablenwert_2" der zweite Teil. Auch die Verwendung von #ELSE ist erlaubt..
Beispiel:

#switch (Farbwechsel)
   #case (1)
         pigment {color DarkOrchid}
   #break
   #case (0)
         pigment {color MediumAquamarine}
   #break
#end


Dabei ist "Farbwechsel" eine Variable, die innerhalb einer Zählschleife ihren Wert dauernd von 1 zu 0 und 0 zu 1 wechselt. Im Skript "schalt_2.pov" wird dieses Beispiel verwendet.

Analog zur Verwendung von CASE kann auch RANGE verwendet werden. Mit '#range(a,b)' wird dann derjenige Skriptabschnitt in ein Bild umgewandelt, für den die in '#switch (variable)' gewählte Variable im Bereich von a bis b liegt. Die Syntax ist dieselbe wie bei CASE, auch hier darf ELSE verwendet werden.

Mausklick auf die ff. Beispielbilder zeigt das zugehörige Skript:

Im ersten Bild wurde SWITCH überhaupt nicht eingesetzt, es wurde nur die Variable "Farbwechsel" so definiert, daß sie innerhalb der Zählschleife abwechselnd die Werte 0 und 1 annimmt. Dies wurde dann in der Pigment-Definition als Grünanteil eingesetzt. So entstand die abwechselnde Einfärbung der Scheiben.



Im zweiten Bild wurde dann CASE in Abhängigkeit von FARBWECHSEL eingesetzt (siehe obiges Beispiel), der Spiralkörper hat 2 Farben, die abwechseln auftauchen.



Das dritte Bild ist unter Verwendung von RANGE(zaehler) entstanden. Auf diese Weise wurden drei Farbbereiche festgelegt.















































































Bezierkurven



Bezier-Verbindungslinie beim Drehbankobjekt können seit Version 3.1 benutzt werden, ebenso wie lineare, quadratische und kubische Verbindungslinien.
Für ein Segment werden 4 Punkte benötigt:



Die Punkte 1 und 4 bestimmen dabei Anfang und Ende eines Segments. Die Verbindungslinie zw. Punkt 1 und Punkt 2 bestimmt die Steigung der Kurve in Punkt 1 (Tangente), die Verbindungslinie zw. Punkt 4 und Punkt 4 bestimmt die Steigung in Punkt 4 (Tangente), was in obiger Abbildung verdeutlicht wurde. Zeichnet man sich die Linien auf ein Koordinatensystem, so kann man auf einfache Art die Form eines Drehbankobjekts planen.



















































































Diaeffekte mit image_map



Mit den Schlüsselwörtern image_map, filter und transmit können auch Dia- und BlueScreen-Effekte erzielt werden.
Farbdefinitionen werden bei PovRay vektoriell erstellt:

color rgb <1,0,0>


Die drei ersten Komponenten des Vektors sind der Rot-, Grün- und Blauanteil der gewünschten Farbe. Im obigen Beispiel beträgt der Rotanteil 100%, Grün und Blau sind nicht vorhanden.

Als vierte Vektorkomponente kann das Schlüsselwort 'filter' hinzukommen: 

color rgbf <1,0,0,0.5>


Da der Filtereffekt durch Absorption unerwünschter Wellenlängen des Lichts (es wird so gefiltert, als würde es durch eine rot gefärbte Folie scheinen) entsteht, spricht man auch von subtraktiver Transparenz. Die so gefärbten Objekte werfen also einen farbigen Schatten. Mit obigem Beispiel können u.a. farbige Verglasungen realisiert werden. 'filter' spezifisiert den Betrag des noch hindurchgehenden gefilterten Lichts.

Die fünfte Vektorkomponente ist 'transmit': 

color rgbt <1,0,0,0.7>


Trifft weißes Licht (alle Wellenlängen sind vorhanden) auf ein so gefärbtes Objekt, so erfolgt eine Intensitatsschwächung, alle Wellenlangen werden zu einem bestimmten Betrag durchgelassen, die Wellenlänge für rotes Licht passiert ungehindert. Man spricht hier auch von additiver Transparenz.

Im ersten Beispiel wurde mit 'transmit' die Tiffany-Rose transparent gemacht, sodass der Hintergrund durchscheint. Im nächsten Bild wurden mit 'filter' farbige Lichtstreifen in der Atmosphäre erzeugt













































































Drehbankobjekte (lathe)



Durch Angabe der x- und y-Koordinaten werden Punkte in der x-y-Ebene festgelegt, sodaß dann bei Rotation um die y-Achse ein Drehobjekt entsteht. Die z-Komponente des zugehörigen Vektors wird als Null vorausgesetzt. Im Unterschied zum SOR (surface of revolution) unterscheidet das Drehbank-Objekt zwischen linearer, quadratischer und kubischer Verbindungslinie zwischen den angegebenen Punkten.
Während bei SOR dieselbe y-Koordinate nicht zweimal verwendet werden darf, ist dies beim Drehbank-Objekt erlaubt, die Bildumwandlungszeit ist dafür länger als bei SOR.

Bei Verwendung der Punkte

#declare Red_Point = <1.00, 0.00, 0>
#declare Orange_Point = <1.75, 1.00, 0>
#declare Yellow_Point = <2.50, 2.00, 0>
#declare Green_Point = <2.00, 3.00, 0>
#declare Blue_Point = <1.50, 4.00, 0>


entsteht bei Verwendung linearer Verbindungslinien die ff. Form:



Ändert man nun die Punkte zu 

#declare Red_Point = <1.00, 0.00, 0>
#declare Orange_Point = <2.00, 1.00, 0>
#declare Yellow_Point = <3.50, 2.00, 0>
#declare Green_Point = <2.00, 3.00, 0>
#declare Blue_Point = <1.50, 4.00, 0>


und verwendet quadratische Verbindungslinien, so erhält man



Zwar sind die Punkte durch quadratischen Linienverlauf verbunden, der rote Punkt ist jedoch im Drehkörper nicht mehr enthalten: da man zur Definition einer Geraden nur zwei Bestimmungspunkte braucht, zur Definition einer quadratischen Funktion jedoch drei, verwendet POVRAY den ersten Punkt zur Bestimmung der Funktionsgleichung! Analog werden für kubische Funktionen vier Punkte benötigt.

Mit dem Drehbank-Objekt kann man auf einfache Weise Tiegelchen und Töpfchen in allen Variationen produzieren. Ein Beispiel zur lathe-Syntax findet Ihr im Skript zu nächsten Abbildung (Mausklick auf das Bild zeigt das Skript)
















































































FELDER - ARRAYS





Seit Version 3.1 gibt es nun ein- oder mehrdimensionale Felder (arrays). Ein eindimensionales Feld kann man sich als eine Liste vorstellen, die Listenelemente sind dabei über Indizes ansprechbar und müssen vom gleichen Typ sein. Sie müssen definiert (initialisiert) werden.

Beispiel für ein eindimensionales Feld aus drei Elementen: 

#declare Schöne_Texturen=array[3];
#declare Schöne_Texturen[1]=pigment {Jade}
#declare Schöne_Texturen[2]=pigment {Water}


Eine Fehlermeldung ergäbe 

#declare Schöne_Texturen[1]=normal {dents 0.5}


da hier nicht der gleiche Datentyp vorliegt. Eine Fehlermeldung würde auch die ff. Zeile ergeben: 

#declare Oberfläche=Schöne_Texturen[3]


da das 3. Listenelement oben nicht definiert (initialisiert) wurde.

Da es mühsam ist, jedes Listenelement einzeln zu initialisieren, gibt es eine abkürzende Syntax: 

#include "textures.inc"
#declare Schöne_Texturen = array[3] {Jade, Water, Red_Marble}


Nun darf auch '#declare Oberfläche=Schöne_Texturen[3]' verwendet werden, da nun das 3. Listenelement initialisiert wurde.

Beispiel für ein mehrdimensionales Feld aus 20 Elementen: 

#declare Ziffernblock =
      array[2][10]
      {{01,02,03,04,05,06,07,08,09,10},{11,12,13,14,15,16,17,18,19,20}}


Für "Rubics Cube" links neben der Überschrift wurde ein mehrdimensionales Feld zur Definition der Texturen für die einzelnen 9 Würfelspalten benutzt. Mausklick auf´s Bild zeigt das zugehörige PovSkript. Im mittleren Bild wurde nur ein 1x3 Feld benötigt, da die Definition der Kugelmittelpunkte von der inneren Zählschleife in die mittlere verschoben wurde (vgl. Skript).

Im fogenden Bild wurde ein eindimensionales Feld für die Definition der Kugelfarben verwendet, mit Hilfe von 'switch' und der Funktion 'vlength' wurden die Farben verteilt.



... und immer noch gilt:
Fahnenstocks goldene Regel für Fehlschläge:
Wenn du auf Anhieb keinen Erfolg hast, vernichte alle Hinweise darauf, dass du es jemals versucht hast.













































































Höhenfelder



Höhenfelder (heightfields) sind Würfel der Kantenlänge 1 LE, deren obere Fläche gebirgig ist. Der Würfel liegt in der x-z-Ebene, seine vordere linke untere Ecke befindet sich im Koordinatenursprung. Die Höhe jedes Punktes hängt von der Palettenfarbe der verwendeten Grafikdatei ab. Dabei spielt die Auflösung des verwendeten Bildes für die Skalierung des Höhenfeldes keine Rolle. Bei höherer Auflösung wird das Höhenfeld weicher gezeichnet. Die zughörige POVRAY-Syntax ist: 

height_field { gif "bildname.gif" }


TGA und PNG-Bilder können ebenfalls verwendet werden.
Farben mit kleinem Palettenindex liegen tiefer im Höhenfeld. Ein Bild der Farbe 0 ergibt eine Ebene, ein Bild der Farbe 255 ergibt einen Würfel der Kantenlänge 1 LE. Die Farbe des Palettenindex´spielt für die Höhe des zugehörigen Punktes keine Rolle, nur die Nummer der Farbe in der Palette wird ausgewertet!

Der Parameter ´water_level´ gefolgt von einer Zahl zwischen 0 und 1 kann nach dem Bildnamen hinzugefügt werden, sodaß unterhalb dieses Wertes das Höhenfeld nicht angezeigt wird. (Beispiel: ´water_level 0.5´ heißt, daß nur die obere Hälfte des Höhenfeldes grafisch umgesetzt wird. Auf diese Weise können unerwünschte tiefere Werte weggeschnitten werden. Das Schlüsselwort ´smooth´ glättet das Höhenfeld.

Höhenfelder können für CSG (Constructive Solid Geometry) verwendet werden, man kann sie skalieren, transformieren, rotieren.

Die folgende Tabelle zeigt Höhenfelder mit den zugehörigen Bildvorlagen.

proj. Bild
proj. Bild
proj. Bild
Bild 9 proj. Bild
















































































Isosurface - algebraische Flächen


Bekannt sind Isolinien:
Isobaren: Punkte gleichen Luftdrucks werden miteinander verbunden.
Isothermen: Punkte gleicher Temperatur werden miteinander verbunden.
Isohypsen: Punkte gleicher Höhe über dem Meeresspiegel werden miteinander verbunden (Höhenlinien).

Ebenso kann man bei 3-dimensionalen Flächen Raumpunkte mit gleichen Merkmalen miteinander verbinden und erhält dann Isoflächen.

Mit dem Schlüsselwort 'isosurface' kann man in PoVRay eigene Funktionen definieren oder voreingestellte verwenden.
Die Gleichung x2 + y2 - 4 = 0 stellt bekanntlich einen Kreis um den Koordinatenursprung mit Radius r = 2 dar.
Analog kann 3-dimensional die Gleichung für eine Kugeloberfläche angegeben werden: x2 + y2 + z2 - 4 = 0.

Betrachtet man nun die Relation R = x2 + y2 + z2 - 4 und sucht sich all die Punkte heraus, für die R denselben Wert hat, so erhält man die Punkte, die auf der Oberfläche der Kugel liegen: ISOSURFACE.

Der Wert von R wird in der PoVRay-Syntax durch 'threshold' festgelegt.

Ein "Container" ist nötig, um die 3D-Fläche zu begrenzen.

Beispiel 1


#declare IsoFinish = finish {ambient 0 diffuse 1
                             specular 1 roughness 0.02
                             brilliance 2}

isosurface {
  function { pow(x,3)+pow(y,2)-pow(z,2) }
	threshold 0
	max_gradient 4
	contained_by {box {-1,1} } open
                                    //die Ränder des Containers fallen weg!
		texture {pigment {color Coral} finish {IsoFinish}}
	scale 1/vlength(1)
	scale 10
	rotate <130, -30, 90>
           }//end isosurface


Obige Zeilen liefern das folgende Bild:



Beispiel 2


x2+ y2 = z hat als Lösungsmenge ein Drehparaboloid: Wählt man P(x/y) frei in der Ebene und trägt darüber als Höhe x2 + y2 ab, dann stellt dies die Lösungsmenge dar. 

isosurface {
  function {pow(x,2)+pow(y,2)-z}
	threshold 0
	max_gradient 4
	contained_by {box {-1,1} } open
		texture {
		pigment {color Coral}
		finish {F_MetalC}
	}
	scale 1/vlength(1)
	scale 10
	rotate <180, 90, -90>
	translate < 0, 0, 0>
 }




Beispiel 3


x2 - y2 = z2 hat einen Doppelkegel als Lösungsmenge. 

isosurface {
  function {pow(x,2)-pow(y,2)-pow(z,2)}
	threshold 0
	max_gradient 4
	contained_by {box {-1,1} } open
		texture {
		pigment {color Coral}
		finish {F_MetalA}
	}
	scale 1/vlength(1)
	scale 10} //end isosurface




Beispiel 4


Verändert man die Gleichung x2 - y2 = z2 nur leicht und ersetzt sie durch
x2 - y2 - z2 = 0,2 (Änderung von 'threshold 0' zu 'threshold 0.2')
dann fällt die Singularität (Spitze) weg und man erhält zwei abgerundete Schalen.

isosurface {
  function {pow(x,2)-pow(y,2)-pow(z,2)}
	threshold 0.2
	max_gradient 4
	contained_by {box {-1,1} } open
		texture {
		pigment {color Coral}
		finish {F_MetalA}
	}
	scale 1/vlength(1)
	scale 10

 }




Weitere Informationen zu Algebraischen Flächen, Singularitäten, ... erhältst Du auf meiner Seite
Mathematische Streiflichter,
wenn du dort im Hauptmenü den Punkt 'Isoflächen' wählst.


Einen Überblick über 3D-Flächen mit zugehöriger Gleichung gibt Tore Nordstrand.

Einen weiteren Überblic über mathematische Flächen findet ihr hier.













































































Die Kameraeinstellung in PoVRay

Bei den ff. zwei Bildern wurde die perspektivische Projektion verwendet (=Normaleinstellung der PovRay-Kamera). Sie sollen die Verwendung von "focal_point" bei der Kameraeinstellung sowie die Verwendung von color rgbt und color rgbf (vgl. Skript, per Mausklick auf das Bild einsehbar) verdeutlichen.

Mit

focal_point < x,y,z>
aperture 0.6
blur_samples 12


wird der Brennpunkt für die "Aufnahme" des Bildes eingestellt und der Bildausschnitt festgelegt (größere Zahl ergibt kleineren scharfen Ausschnitt), die 3. Zeile bestimmt die Anzahl der Lichtstrahlen, die auf einen Bildpunkt treffen.



Durch Verwendung des Schlüsselwortes 'normal' werden die Lichtstrahlen zwischen Kamera und Objekt durch das "Normalenmuster" gestört. Dabei ergeben sich teils interessante Effekte. Anhand des Skriptes (Mausklick aufs Bild) könnt Ihr das beim jeweiligen Beispiel benutzte Muster sehen.















































































Die Verwendung von LParser in PoVRay


  1. Vorbemerkungen und Beispielbilder
  2. Einführung, Befehlssatz und Koordinatensystem
  3. Beispiele
  4. Spiralen mi t LParser und PoVRay
Für rekursive Programmierung eignet sich LParser4 und LParser5 mit VRML-Viewer von Laurens Lapre gut.

LParser ist eine Art "Programmiersprache" (vgl. auch Lindenmayer-Systeme: Über deren Umsetzung mit PoVRay findet Ihr auf meiner Seite Mathematische Streiflichter hier Näheres), mit der sich sehr gut Objekte wie Bäume oder andere organische Formen für POV-Bilder programmieren lassen.

Die Befehle von LParser bestehen aus einzelen Buchstaben und sind i.d. Regel Vorschriften, auf welche Art ein Grundelement (z.B. ein Zylinder, ein Oval,...) an ein anderes angefügt wird und wie dieses Grundelement seine Länge, seine Dicke, seine Richtung ändert. Das Grundelement kann verändert werden: Zylinder, Kugeln, Kegel, .. können benutzt werden.



Einführung - LParser4 (ohne Benutzung von VRML-Viewer)


LSystem

Eine regelähnliche Beschreibung eines 3D-Objekts wird LSystem genannt. Die Regel enthält die Information, woraus die einzelnen Elemente bestehen und wie sie zusammengesetzt werden sollen. Vom vorliegenden Freeware-Programm wird sie dann interpretiert und in ein 3D-Objekt verwandelt. Verschiedene Ausgabe-Formate, u.a. POV und DXF, sind möglich.

Mit Hilfe dieser auch downloadbaren Stapel-Datei lpars.bat, die sich im Verzeichnis von LParser befinden muss, werden bei Aufruf von lpars meinpov meinpov zwei Dateien erstellt:
meinpov.pov und meinpov.inc.
In "meinpov.pov" muss dann die Zeile "#include lpar2pov.inc" durch "#include meinpov.inc" ersetzt werden. Eventuell muss das Objekt noch skaliert werden. 

@echo off
cls
if "%1"=="" goto ende
if "%2"=="" goto ende
lparser %1

rem Mit "lparser %1" werden Quader als Grundelemente
rem für die Figuren verwendet.
rem Mit lparser -X ball %1" werden Kugeln verwendet.
rem Mit "dir *.vol " kann man sich im LPARSER-Verzeichnis die
rem möglichen Grundelemente  anzeigen lassen !!!!
rem Wenn gewüscht: obige Zeile austauschen !!!

lparser -vc %1
parser -Bc %1
cls
echo F2 betätigen, dann Bild bewegen, wieder F2 betätigen !
pause
lviewer output
lv2povid 2
cls
ren lpar2pov.pov %2.pov
ren lpar2pov.inc %2.inc
echo --------------------------------------------------------------------
echo In der POV-Datei muss LPAR2POV.INC durch NAME2.INC ersetzt werden !!!
echo --------------------------------------------------------------------
dir *.pov
pause
goto schluss
:ende
cls
echo ---------------------------------------------------
echo Eingabe lpars name1 name2 (name1=*.ls, name2=*.pov)
echo ---------------------------------------------------
pause
:schluss


Befehlssatz und Koordinatensystem




Lparser hat ein rechtshändiges Koordinatensystem: die z-Achse weist nach oben, die x-Achse weist in den Bildschirm, die y-Achse nach links (falls man Daumen, Zeigefinger und Mittelfinger rechtwinklig zueinander hält). Nicht vergessen: LViewer zeigt die Objekte von hinten, d.h. "blickt aus dem Bildschirm heraus".

PovRay dagegen hat ein linkshändiges Koordinatensystem: die x-Achse und die y-Achsen liegen in der "Monitorebene": x weist nach rechts, y weist nach oben. Die z-Achse steht senkrecht zur Monitorebene und weist in den Monitor hinein, daher wird häufig die Kameraposition in der -z-Richtung gewählt, was den Blickwinkel des Computerfreaks vor dem Bildschirm ergibt.

Befehle für Richtungswechsel

 +     Linksdrehung um die x-Achse
 +(x)  Linksdrehung um x Grad um die x-Achse
 -     Rechtsdrehung um die x-Achse
 -(x)  Rechtsdrehung  um x Grad um die x-Achse

 &     Linksdrehung um die y-Achse
 &(x)  Linksdrehung um x Grad um die y-Achse
 ^     Rechtsdrehung um die y-Achse
 ^(x)  Rechtsdrehung  um x Grad um die y-Achse

 <     Drehung geg. d. Uhrzeigersinn um die x-Achse
 <(x)  Drehung um x Grad geg. d. Uhrzeigersinn um die x-Achse
 >     Drehung im Uhrzeigersinn um die x-Achse
 >(x)  Drehung um x Grad im Uhrzeigersinn um die x-Achse


Mit +, -, & und ^ werden also die vier Richtungen in den Bildschirm, aus dem Bildschirm, Bildschirm links und Bildschirm rechts abgedeckt.

Aus der dem Programm beigefügten Text-Datei hier der komplette Befehlssatz:

---------------------------------------------------------------------------
 Turtle Orientation commands
---------------------------------------------------------------------------
 +     turn left around up vector
 +(x)  turn x left around up vector
 -     turn right around up vector
 -(x)  turn x right around up vector
 &     pitch down around left vector
 &(x)  pitch x down around left vector
 ^     pitch up around left vector
 ^(x)  pitch x up around left vector
 <     roll left (counter clockwise) around forward vector
 <(x)  roll x left around forward vector
 >     roll right (clockwise) around forward vector
 >(x)  roll x right around forward vector

---------------------------------------------------------------------------
 Special Orientation commands
---------------------------------------------------------------------------
 |     turn 180 deg around up vector
 %     roll 180 deg around forward vector
 $     roll until horizontal
 ~     turn/pitch/roll in a random direction
 ~(x)        "     in a random direction with a maximum of x degrees
 t     correction for gravity with 0.2
 t(x)  correction for gravity with x

---------------------------------------------------------------------------
 Movement commands                          when {} active
---------------------------------------------------------------------------
 F     move forward and draw full length    record vertex
 F(x)  move x forward and draw              record vertex
 Z     move forward and draw half length    record vertex
 Z(x)  move x forward and draw              record vertex
 f     move forward with full length        record vertex
 f(x)  move x forward                       record vertex
 z     move forward with half length        record vertex
 z(x)  move x forward                       record vertex
 g     move forward with full length        don't record vertex
 g(x)  move x forward                       don't record vertex
 .     don't move                           record vertex

---------------------------------------------------------------------------
 Structure commands
---------------------------------------------------------------------------
 [     push current state
 ]     pop current state
 {     start polygon shape
 }     end polygon shape

---------------------------------------------------------------------------
 Inc/Dec commands
---------------------------------------------------------------------------
 "     increment length with 1.1
 '     decrement length with 0.9
 "(x)  multiply length with x also '(x)
 ;     increment angle with 1.1
 :     decrement angle with 0.9
 :(x)  multiply angle with x also ;(x)
 ?     increment thickness with 1.4
 !     decrement thickness with 0.7
 ?(x)  multiply thickness with x also !(x)

---------------------------------------------------------------------------
 Additional commands
---------------------------------------------------------------------------
 c     increment color index
 c(x)  set color index to x
 @     end of object
---------------------------------------------------------------------------


Eine LParser-Datei besteht aus mindestens 6 Zeilen:
  1. Anzahl der Schleifendurchgänge
  2. Angabe des Drehwinkels
  3. Angabe der Dicke des Grundelements in % seiner Länge
  4. die Zeichenanweisung (das "Axiom")
  5. nötige Definition des verwendeten Elements
  6. das Dateiende-Zeichen

Beispiele

Beispiel A


6                #die Anzahl der Schleifendurchgänge
25               #der Drehwinkel
50               #die Dicke in % der Länge
A                #die Zeichenanweisung
A=+FA            # die Definition von A
@                #Dateiende-Zeichen


Infolge des 6-fachen Programmdurchlaufs wird A zu A=+F+F+F+F+F+F, d.h. 6 mal wird eine Drehung um 25° weg von der z-Achse gemacht, dazu eine Vorwärtsbewegung und das Grundelement in voller Länge mit 50%iger Dicke gezeichnet. In der zugeh. Abb. ist das LViewer-Bild gedreht, sodass die Vorderansicht gezeigt wird.

Beispiel B:



14               #Schleifendurchgänge
25               #Drehwinkel
50               #Dicke
[A]c[B]c[C]c[D]	#Zeichenanw., Erhöhung d. Farbindex
A=+FA            # A: Linksdreh. weg v. z-Achse (rot)
B=-FB            # B: Rechtsdreh. weg v.z-Achse (gelb)
C=^FC            # C: Rechtsdreh. weg v.y-Achse (cyan)
D=&FD            # D: Linksdreh. weg v. y-Achse (grün)
@                #Dateiende


Es entstehen in 4 Richtungen Kreise aus jeweils 14 Grundelementen. Die komplette Zeichenanweisung lautet also:

[+F+F+F+F....][-F-F-F-F....][^F^F^F^F....][&F&F&F&F....]

Beispiel C:
Jeder Kreis wurde im vorherigen Beispiel wieder am Ursprung gestartet wegen der Verwendung der eckigen Klammern! Lässt man bei diesem Beispiel die eckigen Klammern weg, so macht das keinen Unterschied, da die Kreise ohnehin am Startpunkt enden.
Verwendet man jedoch nur 4 Schleifendurchgänge und lässt dann die eckigen Klammern weg, so werdeb die Kreissegmente werden am Ende des vorherigen Kreissegments gezeichnet:



Beispiel D:





Interessant wird LParser bei der Verwendung von Rekursionen: die Zeichenanweisung ruft sich selbst wieder auf!

6
25
15
E
E=[A][B]
A=c+FAE
B=c-FBE
@


Die Zeichenanweisung E ist so aufgebaut, dass bei der Definition von A und B E selbst wieder angehängt wird. Zunächst wird 6 mal A gezeichnet (bis zum dunkelgrünen Element), dann wird zum Anfang dieses Elements zurückgegangen und die Zeichenanweisung erneut ausgeführt.

Rekursive Programmierung ist für das Zeichnen von Bäumen und Sträuchern gut geeignet.

Beispiel E:




Dieses Beispiel soll einige Bewegungsbefehle demonstrieren:
Z führt eine Vorwärtsbewegung von halber Elementlänge aus, zeichnet jedoch nicht, d.h. der erste Kreis (A=z+FA, gelb) hat "Löcher". Der zweite hellgrüne Kreis (B=-ZB) ist der kleinste, da Z nur halbe Elementlängen zeichnet. Der dritte Kreis (C=^FC, türkis) ist "normal". Beim vierten blauen Kreis, dem größten (D=g&FD) wird durch g eine Vorwärtsbewegung mit voller Länge gemacht, dann erst gezeichnet, er hat also ebenfalls "Löcher". 

15
25
50
E
E=c[A]c[B]c[C]c[D]
A=z+FA   	#z: Vorwärtsbewegung mit halber Länge
B=-ZB    	#Z: Vorwärtsbew.+Zeichnen der halben Länge
C=^FC
D=g&FD           #g: Vorwärtsbewegung mit voller Länge
@


Beispiel F:




Hier werden nochmals die Richtungen demonstriert, die man mit ^ + - und & erhält. Sie werden hier mit eckigen Klammern eingesetzt, sodass jeweils zum Ausgangspunkt zurückgekehrt wird. Durch ! wird die Elementdicke verkleinert, durch g(80) entstehen die Lücken. 

3
25
30
C
C=g(80)c![^FC]+[FC]-[FC]&[FC]
        #Dicke mit 0.7 multiplizieren
        #g(80) Vorwärtsbewegung um 80 Pixel
@


Beispiel G:



Im diesem Beispiel werden : und ; zur Winkelmultiplikation mit 0,7 bzw. mit 1,1 eingesetzt. Man erhält eine Spirale bei Vergrößerung des Winkels, bzw. eine (Teil-)kreis mit vergrößertem Radius bei Verkleinerung des Winkels.

15
25
20
E
E=c[A]c[B]c[C]c[D]
A=+FA         # F Vorwärtsbewegung + Zeichnen der vollen Länge
B=-ZB         # Z Vorwärtsbewegung + Zeichnen der halben Länge, gibt kleineren Kreis
C=;^FC        # ; Winkelmultiplikation mit 1,1 ergibt Spirale
D=:&FD        # : Winkelmultiplikation mit 0,7 ergibt größeren Kreisradius
@


Beispiel H:

In dieser Abbildung wurde "(0.5) eingesetzt, d.h. eine Längenmultiplikation mit 0,5. Dazu wurde das Kleinerzeichen für eine Drehung im Uhrzeigersinn um die x-Achse verwendet, die Figur wirkt daher "verdreht". 

4
25
35
C
C=c;!"(0.5)[<^FC]+[<FC]-[<FC]&[<FC]
     # ;Winkelmultiplikation mit 1,1
     # !Multiplikation der Dicke mit 0,7
     # "(0.5)Längenmultiplikation mit 0,5
@




Spiralen mit LParser und PoVRAy


Die Theorie zu Spiralen


Wählt man sich einen Startpunkt und bewegt sich von dort aus um die Strecke s in beliebiger Richtung, ändert man dann die Bewegungsrichtung um den Winkel a , geht dann um die Strecke s+x in die neue Richtung, dreht man sich wieder um den Winkel a, und so fort, dann erhält man eine BEWEGUNGSFUNKTION:



Das 2. Teilstück hat dann die Länge s+1x, das dritte die Länge s+2x, ... das n-te Teilstück hat die Länge s+(n-1)x.
Benutzt man Winkel, die ein Teiler von 360° sind (z.B. 120° im obigen Beispiel), dann erhält man regelmäßige Dreiecke, Vierecke, Fünfecke usw.
Oft sehr schön anzuschauende Spiralfiguren erhält man bei geringer Abweichung von den oben genannten Winkeln.

Für die Programmierung mit PovRay ist LPARSER ideal geeignet.


Bei den ff. Bildern erhält man durch Mausklick das jeweilige Pov-Skript, das zugehörige LParser-Skript ist dabei integriert.

In die letzten 5 LParser-Skripte ist mit 
t
noch eine Schwerkraftkorrektur eingefügt, sodass ein räumliches Bild entsteht.







© 2010 Asti PoVRay-Site Mathematische Streiflichter Algorithmische Kunst