POV-Ray

1) Inroduction

POV-Ray (Persistence of Vision Raytracer) est un logiciel libre de lancer de rayons, « Raytracing » en anglais (technique de synthèse d'image en 3D), disponible sur une grande variété de plateformes (Windows, Mac OS, GNU/Linux, etc.). Il a été créé dans les années 1980. Depuis la version 3.7, le logiciel est sous licence AGPL3 en accord avec la définition de la Free Software Foundation.

Développé par L'équipe POV, dernière version 3.7 (8 novembre 2013), il est écrit en C++, fait les calculs en double précision, et est multiprocessus.

Site web www.povray.org

POV-Ray est un Rendeur de scène, et non un Modeleur de scène (comme Blender, par exemple). POV-Ray est un moteur de rendu, c'est à dire qu'il se contente de la phase finale de création d'une image : il transforme la description de la scène, qui est un programme en langage Pov-Ray, en une image de synthèse rigoureuse. Toute la partie de conception de la scène, du programme en langage POV-Ray, reste à faire. Il faut connaitre le langage de description de scène, le langage POV-Ray, afin de pouvoir programmer une scène et que le Rendeur POV-Ray puisse l'interpréter correctement. Les modeleurs, quant à eux, ne s'intéressent qu'à la première partrie, celle de programmation. Ils sont des interfaces utilisateurs-ordinateurs permettant d'éditer des scènes riches, c'est à dire d'écrire de gros programmes en langage POV-Ray, ou autrement dit de programmer des scènes riches.

2) Les bases du langage POV-Ray

2.1) Nombre

Voici quelques exsemples de nombres :

3       -2       +2.0        0.6        2e-5        +3.4e6       -.5e4        pow(pi,pi)/exp(pi)

2.2) Constante

pi = 3.1415926535897932384626
true = on = yes = 1
false = off = no = 0

2.3) Déclaration de variable

Exemple de déclaration d'une variable a initialisée :

#declare a = pi*sqrt(pi);

N'oubliez pas le point-virgule à la fin de l'instruction #declare. Les variables x,y,z,t,u,v sont des vecteurs constants et ne peuvent pas être redéfinies. Parcontre dans l'expression des fonctions, ces variables désignent les composantes du vecteur d'entré, avec toujours u=x et v=y car comme on le verra plus-tard le vecteur (u,v) correspond au début du vecteur (x,y,z,t).

2.4) Opération

Dans les tableau ci-dessous, les variables x,y,z,t représentent des nombres, les variables A et B représentent des nombres ou des vecteurs ou des objets de n'importe quel type. Voici la liste des opérations arithmétiques :

+x  -x   Plus unaire, moins unaire.
x*y  x/y Multiplication, division.
x+y  x-y Addition, soustraction.
abs(x)  int(x) Valeur absolue de x, partie entière trunquée de x.
div(x,y)  mod(x,y) Division entière de x par y, x Modulo y = ((x / y) - int (x / y)) * y.
floor(x)  ceil(x) Etage de x, plafond de x.

Liste des opérations logiques :

!x Non logique.
(x<b)  (x>b) Plus petit, plus grand.
(x<=b)  (x=>b) Plus petit ou égal, plus grand ou égal.
(x=y)  (x!=y) Egal, différent.
(x & y)  (x | y) Et logique, ou logique.
(x ? A : B) Si x alors A sinon B.
select(x,y,z) Si x<0 alors y sinon z.
select(x,y,z,t) Si x<0 alors y sinon si x=0 alors z sinon t.
bitwise_and(x,y,...) Et logique bit à bit de deux ou plusieurs entiers x,y,....
bitwise_or(x,y,...) Ou logique bit à bit de deux ou plusieurs entiers x,y,....
bitwise_xor(x,y,...) Ou exclusif logique bit à bit de deux ou plusieurs entiers x,y,....

Liste des opérations de puissance :

exp(x) Exponentielle de x.
log(x) Logarithme décimal de x.
ln(x) Logarithme néperien de x.
pow(x,y) x puissance y.
sqrt(x) Racine carré de x.

Liste des opérations trigonométriques :

cos(.)  sin(.)  tan(.) Cosinus, sinus tangente.
acos(.)  asin(.)  atan(.) Arc cosinus, arc sinus, arc tangente.
atan2(x,y) Arc tangente de x/y, valable même si y=0.
cosh(.)  sinh(.)  tanh(.) idem mais hyperboliques.
acosh(.)  asinh(.)  atanh(.) idem mais hyperboliques.
radians(.), degrees(.) Convertie x en radians, convertie x en degrées.

Liste des opérations de hasard

seed(x) Retourne un nouveau cannal de nombre aléatoire de graine x.
rand(x) Retourne le nombre aléatoire suivant sur le cannal x.

2.5) Vecteur

Voici quelque exemples de vecteurs :

<0,1,1>        <0,1,1,0.5>         <0,1.1,2,1,2>         <pi, a, a+a*a+pow(a,a)>

Selon la dimension du vecteur attendu, nous avons par exemple :

2 = <2, 2>
2 = <2, 2, 2>
2 = <2, 2, 2, 2>
2 = <2, 2, 2, 2, 2>

En plaçant une caméra en <0,0,0> regardant vers <0,0,5> nous avons :

<5,0,0,0> est à droite.
<0,5,0,0> est en haut.
<0,0,5,0> est loin devant.
<0,0,0,5> est dans le futur.

<-5,0,0,0> est à gauche.
<0,-5,0,0> est en bas.
<0,0,-5,0> est loin derrière.
<0,0,0,-5> est dans le passé.

< Droite ,  Haut ,  Devant ,  Temp >

Le vecteur x désigne la droite.
Le vecteur y désigne le haut.
Le vecteur z désigne le devant.
Le vecteur t désigne le future.

 

 

 

Triède indirecte

2.6) Constante vectorielle

u =<1,0>
v = <0,1>
x = <1,0,0>
y = <0,1,0>
z = <0,0,1>
t = <0,0,0,1>

Les variables x,y,z,t,u,v sont des vecteurs constants et ne peuvent pas être redéfinies. Parcontre dans l'expression des fonctions, ces variables désignent les composantes du vecteur d'entré, avec toujours u=x et v=y car le vecteur (u,v) correspond au début du vecteur (x,y,z,t).

2.7) Déclaration de variable vectorielle

Exemple de déclaration d'une variable vectorielle V, initialisée :

#declare V = <pi,1+a,exp(-1/(a*a))>;

L'addition et la multiplication entre vecteurs se fait composante par composante. Nous avons par exemple :

<1,2,3> + <4,0,-1> = <5,2,2>
<0,1,0>*<1,2,3> = <0,2,0> = 2*<0,1,0>
y*<1,2,3> = <0,2,0> = 2*y

Soit un vecteur V, alors V.x, V.y, V.z sont les composantes en x, y et z. Nous avons par exemple :

<1,2,3>.y = 2
V = <V.x,V.y,V.z>

2.8) Opérations vectorielles

Les produits scalaires de vecteurs :

vdot(U,V) Produit scalaire de U et V c'est à dire U.xV.x+U.yV.y+U.zV.z
vlength(U) Norme de U, c'est à dire sqrt(vdot(U,U))
vcross(U,V) Produit vectoriel de U par V, vlenth(V)vlength(V)
vnormalize(V) Retourne le vecteur normalisé, U/vlentgh(V)
vaxis_rotate(U,V,x) Retourne l'image de U par la rotation autours de l'axe V d'un angle de x degrées.
vrotate(U,V) Retourne l'image de U par la rotation d'angle B.x autours de x
puis d'angle B.y autour de y puis d'angle B.z autours de z
vturbulence(a,b,c,V) Retourne le vecteur de turbulence pour le point de vecteur V.
La turbulence est définie par 3 nombres : Lambda=a, Oméga=b, Octaves=c.

Les opérateurs sur les object O et vecteurs U,V

inside(O,U) Retourne vrai si le point U est à l'intérieur de l'objet O.
min_extends(O) Retourne un vecteur, les coordonnées minimums du cadre de l'object.
max_extends(O) Retourne un vecteur, les coordonnées maximum du cadre de l'object.
trace(O,U,V) Retourne le point d'impacte sur O du rayon partant de U dans la direction V.
Retourne <0,0,0> si pas d'intersection.
trace(O,U,V,W) Idem et stoque dans le vecteur W, la normale de l'objet au point d'intersection
(non compris les perturbations de textures) ou <0,0,0> s'il n'y a pas d'intersection.

2.9) Couleur

Exemples de couleurs :

rgb<1,.2,.2>            red 1 blue .8            rgbt .5 red 1             rgbt V               rgbf V red a

2.10) Déclaration d'une variable couleur

Exemple de déclaration de six variables couleurs Red, Blue, Green, A, B, C initialisées :

#declare Red = rgb<1,0,0>;
#declare Blue = rgb<0,0,1>;
#declare Green = rgb<0,1,0>;
#declare A = rgbf<1,1,1,0.5>;
#declare B = rgbt<1,1,1,0.5>;
#declare C = rgbft <.1,1,1,0.6,0.4>;

L'addition et la multiplication entre couleurs se fait composante par composante comme les vecteurs. Nous avons par exemple :

Red+Blue+Green/2 = <1,1/2,1>

Soit une couleur C, alors C.red, C.green, C.blue, C.filter, C.transmit, C.gray donnent les composantes en red, green, bleu, filter, transmit et gray. Nous avons par exemple :

#declare C = rgb<1,2,3>;
C.green = .2
C = <C.red, C.green, C.bleu>

#declare C = rgbft<1,2,3,4,5>/10;
C.filter = 0.4
C = <C.red, C.green, C.bleu, C.filter, C.transmit>

3) La scène :

Pour la découverte du langage, on commence par utiliser une scène modèle comprenant toujours la même lumière et la même caméra, décrite par ces quelques ligne de code :

#version 3.7

light_source{<-50,50,-50>, 1}
// Crée en <50,50,-50> une source lumineuse de couleur blanche.

camera{
    location <0,0,-5>
    right x*image_width/image_height
    angle 75

    look_at 0
}
// Place la camera en <0,0,-5>.
// Le ration x/y est respecté quelque soit la taille de l'image de sortie.
// L'angle de vue est de 75°.
// La caméra regarde le point <0,0,0>.

#default{
    pigment{rgb 1}
    finish {phong 1}
}
// Par défaut, le pigment des objects est blanc.
// Par défaut, le phong des objets est à 1.

Dans certaines descriptions, on prend une lumière un peu plus en arrière de la caméra pour que l'ombre apparaisse dans le champ de visé :

light_source{<-5,5,-10>, 1}

Dans certaines autres descriptions, on prend une caméra qui regarde le point <0,0,0> d'un peu plus haut pour avoir une vue plongeante et afin de ne pas voir l'horizon et avec un champ de visé un peu plus large :

camera{location <0,5,-5> right x*image_width/image_height angle 75 look_at 0}

L'instructiuon right x*image_width/image_height n'est pas utile si l'image de sortie est de rapport 4/3. Sinon elle corrige l'angle du champ de visé selon l'axe des x et selon l'axe des y afin que les proportion x/y soit conservées.

4) Objet 

Exemple d'objets :

#version 3.7
light_source{<-5,5,-10>, 1}
camera{location <0,0,-5> right x*image_width/image_height look_at 0}
#default{pigment{rgb 1}}


 
plane{V, A}
Plan défini par sa normale extérieure V (l'intérieur étant rempli de matière) et par l'abcisse A de ce plan sur l'axe (0,V)V est normalisé. Par exemple pour faire un sol à une altitude -5, la normale extérieure sera V = <0,1,0> = y et l'altitude sera -5.
  plane{y, -5}
sphere{V, R}
Sphere de centre V et de rayon R
  sphere{<0,0,0>,1}
  plane{y,-5}
box{U, V}
Parallélépipède définie par deux de ses sommets opposés U et V.
  box{-1,<0,1,3> rotate 25}
  plane{y,-5}
torus{R2, R1}
Tore centré en <0,0,0>, défini par son rayon majeur R2 et son rayon mineur R1
  torus{2,.2 rotate -x*20 }
  sphere{<0,0,0>,.8}
  plane{y,-5}
cylinder{U, V, R open}
Cylindre définie par le centre de ses deux faces U et V, et par son rayon R. L'option open signifie ouvert aux deux bouts.
  cylinder{<0,0,0>,<3,2,4>,1.6 open}
  sphere{<0,0,0>,0.5}
  plane{y,-5}
cone{V1, R1, V2, R2 open}
Cône définie par le centre de ses deux faces V1 et V2, et par les rayons de ses deux faces R1 et R2. L'option open signifie ouvert aux deux bouts.
  cone{<0,-1,0>,0.3, <0,1,-2>,1 open}
  plane{y,-5}
plane{V, A}
Plan défini par sa normale extérieure V (l'intérieur étant rempli de matière) et par l'abcisse A de ce plan sur l'axe (0,V)V est normalisé. Par exemple pour faire un sol à une altitude -2, la normale extérieure sera V = <0,1,0> = y et l'altitude sera -2.
   text{
       ttf "timrom.ttf"
       "Hello", 0.4, 0
       scale 2 translate -2*x-y
   }

   plane{y,-5}
 isosurface {function {F}}
 
   isosurface {
      function { x*x + y*sin(2*y) + z*z - 1}
      contained_by {box {-2.5,2.5}}
      max_gradient 6
      rotate <45, 45, 0> translate <0,0,3>}
  plane {y,-5}

Exemple d'objets assemblés :

 blob {
    sphere {<0, -1, 0>, 3, 1}
    sphere {<3, -1, 0>, 3, 1}
    sphere {<0, 2, 0>, 3, 1}
 }
 plane {y,-5}
 merge{
    sphere {<1,0,0>,1}
    sphere {<0,0,0>,1}
    rotate -20*y
 }
 plane {y,-5}
 intersection{
    sphere {<1,0,0>,1}
    sphere {<0,0,0>,1}
    rotate -5*y
 }
 plane {y,-5}
 difference{
    sphere {<1,0,0>,1}
    sphere {<0,0,0>,1}
    rotate -20*y
 }
 plane {y,-5}

5) fichier .ini et commandes lignes linux

On crée un fichier local povray.ini et on y met les options par défaut que l'on souhaitent utiliser.

/home/<Nom_Utilisateur>/.povray/3.7/povray.ini

Height=600
Width=800
Pause_When_Done=On
Antialias=On

 

Option en lligne
de commande
povray.ini
Valeur
par défaut
Déscription
+Wn
Width=n
800
Largeur de l'image en pixels
+Hn
Height=n
600

Hauteur de l'image en pixels

+D, -D
Display=b
on
Affiche l'image calculé
+P, -P
Pause_When_Done=b
off
Une fois l'image terminée, se mettre en pause
+V, -V
Verbose=b
off
Mode verbeux (warnings, statistics,..)
+F, -F
Output_to_File=b
true
Sauvegarde l'image calculé
+Os
Output_File_Name=s
nom_du_scripte.pov
Spécifie le nom du fichier de sortie.
"-" spécifie la sortie standart (la console) et peut alors être piper avec une autre commande
+Is
Input_File_Name=s
object.pov
Spécifie le nom du fichier d'entré.
"-" spécifie l'entré standart (la console) et peut alors provenir d'une autre commande pipé
Exemple : type scene.pov | povray +I-
+Fcn, -Fcn
Output_File_Type=c
Bits_Per_Color=n
N8
Type de fichier de sortie et nombre de couleurs
J : jpeg (compression avec perte)
N : png (8-bits per colour RGB)
Nn : png ('n' bit per colour RGB where 5 ⩽ n ⩽ 16)
+UA, -UA
Output_Alpha=b
off
Enclenche l'écriture d'un canal alpha
+Qn
Quality=n
9
sélectionne le niveau de qualité à employer dans le rendu
0, 1 : Utilise seulement les "quick colors", et l'éclairage ambiant.
2, 3 : Utilise les valeurs locales de diffuse et ambient des objets.
4 : Calcule les ombres, mais pas les lumières étendues.
5 : Calcule les ombres, y compris les lumières étendues.
6, 7 : Utilise les motifs des textures
8 : Calcule la réflection, la réfraction et la transparence.
9 : Calcule les media c'est le niveau de qualité par défaut.
10 : Calcule la radiosité mais pas les media (n'oubliez pas +QR pour enclencher la radiosité).
11 : Calcule la radiosité ET les media (n'oubliez pas +QR pour enclencher la radiosité).
+QR, -QR
Radiosity=b
off
Enclenche le calcul de la radiosité
+A, -A
Antialias=b
off
Enclenche l'anticrénelage
+An.n, -An.n
Antialias_Threshold=n.n
0.3
Spécifie le seuil de déclenchement de l'anticrénelage
+AMn
Sampling_Method=n
1
Sélectionne la méthode à employer (1 ou 2 pour la méthode d'anticrénelage dite "adaptive")
+Rn
Antialias_Depth=n
2
Spécifie la finesse de la subdivision
+J, -J
Jitter=b
+
Enclenche l'errance d'échantillonnage
+Jn.n, -Jn.n
Jitter_Amount=n.n
1
Spécifie le taux d'errance d'échantillonnage
+MIn
Max_Image_Buffer_Memory=n
128
Taille mémoire de l'image. Si dépassé alors écrit directement sur le disque dur
Display_Gamma=n
sRGB
Définit l'affichage gamma à n (sRGB correspond à un environ 2.2)
Declare=abc=2.5
Declare=abc=2.5
  Equivalent à l'ajout dans la scène de la commande #declare r=2.5
       
       
       
       
       
       
       
       

Debug_Console=bool Turn console display of debug info text on/off +GD Same as Debug_Console=On -GD Same as Debug_Console=Off Fatal_Console=bool Turn console display of fatal error text on/off +GF Same as Fatal_Console=On -GF Same as Fatal_Console=Off Render_Console=bool Turn console display of render info text on/off +GR Same as Render_Console=On -GR Same as Render_Console=Off Statistic_Console=bool Turn console display of statistic text on/off +GS Same as Statistic_Console=On -GS Same as Statistic_Console=Off Warning_Console=bool Turn console display of warning text on/off +GW Same as Warning_Console=On -GW Same as Warning_Console=Off All_Console=bool Turn on/off all debug, fatal, render, statistic and warning text to console. +GA Same as All_Console=On -GA All_Console=off

6) Pigment

On définie 8 couleurs :

#declare Red = rgb<1,0,0>;                 
#declare Yellow = rgb<1,1,0>;    
#declare Green = rgb<0,1,0>;    
#declare Cyan = rgb<0,1,1>;    
#declare Blue = rgb<0,0,1>;    
#declare Magenta = rgb<1,0,1>;    
#declare White = rgb<1,1,1>;    
#declare Black = rgb<0,0,0>;    

Le plan plan{y -5} est construit à partr du plan passant à l'origine dont la normal est le vecteur y=<0,1,0> et qui est translaté selon ce vecteur y de -5. Ainsi chaque point du plan possède des coordonnées <x,-5,z>.

Le color_map transforme un nombre compris entre 0 et 1, en une couleur. Le calcul de la couleur se fait par extrapolation linéaire entre plusieurs valeurs données, associées à des couleurs données. Le color_map est périodique, de période 1. C'est à dire que quelque soit un entier n et quelque soit un réel r. Il associe à n+r la même couleur qu'il associe à r. Autrment dit, il associe aux valeurs comprisent entre n et n+1 respectivement les même couleurs qu'il associe aux valeurs comprisent entre 0 et 1 respectivement.

On définie une color_map c pour peindre en rouge une surface noire :

#declare c = color_map {[0 Black] [1 Red]};

On définie une fonction f qui donne l'intensité du rouge en fonction des coordonnées (x,y,z). On choisie par exemple la fonction radiale qui calcule la distance du point à l'axe y.

#declare f = function(x,z){(sqrt(x*x + z*z)};

Cette fonction retourne la distance du point <x,y,z> à l'axe y. Le pigment P se définie à l'aide du color_map c et de la fonction f comme suit :

#declare P = pigment { function{f(x,z)} color_map{c}};

Puis le pigment P s'ajoute aux caractéristiques d'un objet O en anjoutant dans sa liste des caractéristiques séparée par des espace blancs et non par des virgules l'expression Pigment {P}.

#version 3.7
light_source{<-50,50,-50>, 1 parallel} camera{location <0,5,-5> right x*image_width/image_height angle 75 look_at 0} #default{pigment{rgb 1}finish {phong 1}}
#declare Black = rgb<0,0,0>; #declare Red = rgb<1,0,0>; #declare c = color_map {[0 Black] [1 Red]}; #declare f = function(x,z){sqrt(x*x+z*z)}; #declare P = pigment {function{f(x,z)} color_map{c}};
plane{y, 0 pigment{P}} torus{1,1/3 translate 2*y pigment{P}}

 

 

 

---- 10 septembre 2017 ----

 

 

 

 

 

 

 

 

On utilise des fonctions anonyme. Par défaut, elles utilisent comme variables (x,y,z) avec u=x et v=y. Là, x,y,z,u,v sont des nombres variables et nom des vecteurs constant.

Couleurs : rgb <1,3,2>, rgbf <1,3,2,.5>, rgbt <1,3,2,.5>, rgbft <1,3,2,.4,.5>
La couleur rgbft<1,3,2,.4,.5> s'écrie aussi color red 1 green 3 blue 2 filter .4 transmit .5 et peut être écrite dans le désordre.
filter 0.4 signifie que 40% de la lumière résultante est celle tranversant, et qui est filtré par la couleur.
transmit 0.2 signifie que 20% de la lumière résultante est celle tranversant, et qui n'est pas altéré par la couleur.
Soit une couleur C, alors C.red, C.green, C.blue, C.filter, C.transmit donne les composantes rouge, vert ,bleu, filter et transmit.

On choisie de nommer les variables selon leur type comme suit :
  Variable entières : I, J
  Variables flottantes A,B,C,D,R
  Vecteurs U,V,W
  Couleurs c1, c2, c3
  Objets O

Pigmentations unies : pigment{c1}, pigment{rgbf <1,2,1,0.2>}, pigment{rgb 1 }

Objets simples :

plane{V, A}

Plan défini par sa normale extérieure V (l'intérieur étant rempli de matière) et par l'abcisse A de ce plan sur l'axe (0,V)V est normalisé. Par exemple pour faire un sol à une altitude -2, la normale extérieure sera V = <0,1,0> = y et l'altitude sera -2.

sphere{V, R}
Sphere de centre V et de rayon R
box{U, V}
Parallélépipède définie par deux de ses sommets opposés U et V.
cylinder{U, V, R}
Cylindre définie par le centre de ses deux faces U et V, et par son rayon R.
cylinder{U, V, R open} idem mais ouvert aux deux bouts
cone{V1, R1, V2, R2}
Cône définie par le centre de ses deux faces V1 et V2, et par les rayons de ses deux faces R1 et R2.
cone{V1, R1, V2, R2 open}
idem mais ouvert aux deux bouts
torus{R2, R1}
Tore centré en <0,0,0>, défini par son rayon majeur R2 et son rayon mineur R1

Format d'image de sortie : Afin de changer le format d'image de sortie en PNG 16 bits par couleur, ajouter dans le fichier povray.ini les deux lignes suivantes, Output_File_Type=N et Bits_Per_Color=16 ou les deux lignes suivantes Output_to_File=true et Output_File_Type=N16, ou en ligne de commande +FN16

Anti-aliasing : Pour l'activer ajouter dans le fichier povray.ini la ligne suivante, Antialias=true ou en ligne de commande +A

La scène :

Placer les lignes de code suivantes, afin de positionner une camera et une lumière derrière la camera.

light_source{<-5,5,-10>, 1}
// Crée en <5,5,-5> une source lumineuse de couleur blanche.

camera{
    location <0,0,-5>
    look_at 0
}
// Place la camera en <0,0,-10> et la fait regarder le point <0,0,0>.

#default{
    pigment{rgb 1}
}
// Par défaut, le pigment des objects est blanc

 

 

Les transformations vectorielles

Pivote, agrandie, déplace ou manipule de diverses façons les coordonnées d'un objet ou d'une texture.

 translate <1,2,0>  Effectue une translation selon le vecteur <1,2,0>
 scale <2,2,1>  Effectue une dilatation selon les 3 directions <2,2,1>
 rotate <90,0,0>  Effectue 3 rotations selon les 3 directions <90,0,0> dans l'ordre x,y,z
 matrix <m11,m12,m13,
             m21,m22,m23,
             m31,m32,m33,
              t1, t2, t3 >
 Effectue un produit matriciel suivi d'une translation.

#declare L = transform {rotate <45, 10, 0> scale <2,2,1> translate <0,1,1>}

sphere {0, 1 transform L}
sphere {0, 1 transform {L}}
sphere {0, 1 transform {L inverse}} // Effectue la transformation inverse de L

Les fonctions sur les nombres :

Opération logique
!A, A&B, A|B, C?A:B
Opération retournant un boolean
A<B, A<=B, A=B, A!=B, A>=B, A>B
Opération Arithmetique
A+B, A-B, -A, A*B, A/B
Arithmétique
abs(A), div(A,B), mod(A,B), floor(A), ceil(A), int(A), max(A,B, ...), min(A,B, ...), select(A, B, C), select(A, B, C, D),
Hasard
rand(I), seed(I)
Puissance
exp(A), log(A), ln(A), pow(A,B), sqrt(A)
Trigonométrie
acos(A), acosh(A), asin(A), asinh(A), atan2(A,B), atanh(A), cos(A), cosh(A), sin(A), sinh(A), tan(A), tanh(A), radians(A),degrees(A)
Produit scalaire
vdot(U,V), vlength(V)
Est dans ?
inside(O,V)

elect(A, B, C) retourne B ou C selon le signe de A.
select(A, B, C, D) retourne B ou C ou D selon le signe de A.
vdot(U,V), retourne le produit scalaire U•V
vlength(V), retourne la norme du vecteur, c'est à dire sqrt(V•V)
inside(O,V), retourne true ssi le vecteur V désigne un point dans l'objet solide O.

Affectation d'une variable :
#declare A = 0;
#declare A = A+1;
#declare V = <1,3,2> - <1,1+2,1>;
#declare V = <1,3/2,A>;

Les fonctions sur les vecteurs :

U+V, U-V, -U, U*V, U/V
Opération Arithmetique composante par composante.
min_extents(O)
Coordonnées minimales de la boite entourant l'objet O.
max_extents(O)
Coordonnées maximales de la boite entourant l'objet O.
trace(O,U,V)
Point d'intersection entre la droite (U,V) et l'objet O.
Retourne <0,0,0> si pas d'intesection.
trace(O,A,B,W)
Point d'intersection entre la droite (U,V) et l'objet O. Et retourne dans W, la valeur de la normal à O en ce point d'intersection. Retourne <0,0,0> et initialise W à <0,0,0> si pas d'intersection.
vaxis_rotate(U,V,A)
Calcule la rotation du point U de A degrés autour de l'axe V .
vcross(U,V)
Produit vectoriel
vnormalize(U)
Vecteur unitaire de direction U
vrotate(U,V)
Calcule la rotation du point U de V.x degrés autour de l'axe x, puis de V.y degrés autour de l'axe y, puis de V.z degrés autours de l'axe z.
vturbulence(lb,om,oc,U)
Vecteur de turbulence en U, pour un lambda lb, un oméga om, et un octave oc.

13) Les courbes lissées

C'est une fonction qui appliqué à un flottant retourne un vecteur (de 2 ou 3 ou 4 ou 5 composantes)

linear_spline Les points sont connectés par des lignes droites.
quadratic_spline Les points sont connectés par des polynôme du second degrés.
cubic_spline Les points sont connectés par des polynôme du troisième degrés.
natural_spline autre polynôme du troisième degrés.

#declare F = spline{ cubic_spline
   -1,<0,5,2>,
   0,<0,0,0>,
   1,<0,5,2>,
   2,<3,2,5>,
   3,<5,2,4>,
   4,<0,0,0>,
   5,<0,5,2>
}

#declare A = F(3.1)   // Calcul le point de la courbe lissées à la valeur 3.1

 

---- 28 fevrier 2015 ----

 

La camera :

#default{
    pigment{checker scale 2}
}
// Par défaut, le pigment des objects est un quadrillage bicolor

 

 
Ligne d'horizon
plane {y,-5}
Face à face
plane {z, 5}
camera {
location <0,0,-5>
look_at 0
}
camera {
omnimax
location <0,0,-5>
look_at 0
}
camera {
panoramic
location <0,0,-5>
look_at 0
}


 
angle 90
angle 180
 
 
Ligne d'horizon
Face à face
Ligne d'horizon
Face à face
Ligne d'horizon
camera {
fisheye
angle 90
location <0,0,-5>
look_at 0
}
camera {
ultra_wide_angle
angle 90
location <0,0,-5>
look_at 0
}
camera {
spherical
angle 90
location <0,0,-5>
look_at 0
}
camera {
spherical
angle 90 90
location <0,0,-5>
look_at 0
}
camera {
cylinder 1
angle 90
location <0,0,-5>
look_at 0
}
camera {
cylinder 2
angle 90
location <0,0,-5>
look_at 0
}

 

20) Les spectres de couleurs (color_map)

Chacun des types variés de modèles est, en fait, une fonction mathématique, qui prend en entré la position x, y, z, et la transforme en un nombre flottant entre 0 et 1 inclus. Ce nombre est utilisé pour spécifier une couleurs dans un spectre de couleurs (color_map).

#declare cm = color_map {
[0 color rgbf<1,0,0,1>]
[0.3 color rgbf<1,1,0,1>]
[0.6 color <0,1,1>]
[1 color <0,0,1>]
}

 

 

 

 

 

 

 

 

 

 

 

 

 

#declare sm = slop_map {
[0 <0, 1>] // commence en bas et grimpe
[0.5 <1, 1>] // mi parcours, où la croissance stoppe
[0.5 <1,-1>] // descente abrupte
[1 <0,-1>] // fin sur une inclinaison descendante
}

 

Cet exemple commence à la hauteur 0.5 grimpant avec l'inclinaison 1. Au quart du trajet, nous sommes au sommet de la courbe, hauteur 1 et aplanissement. L'espace entre ces deux est une courbe délicate, car les débuts et fins des inclinaisons sont différents. A mi-parcours, nous sommes à mi-hauteur avec une pente vers le bas au 3/4. A la fin, nous remontons avec une pente de 1 pour compléter le cycle. Il y a d'autres exemples dans slopemap.pov, dans les scènes d'exemples.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

L'animation

Ajouter dans le fichier POVRAY.INI les lignes suivantes :

Initial_Frame = 1
Final_Frame = 20

Si vous souhaitez que l'horloge parcours le temps de 0 à 2 et si vous ne souhaitez voir que les images n°51 à 75, alors ajouter les spécifications suivnantes :

Initial_Clock = 0.0
Final_Clock = 2.0
Subset_Start_Frame = 51
Subset_End_Frame = 75


Les variables flottantes internes :

clock Valeur du temps compris par defaut entre 0 et 1.
clock_delta Intervale de temps entre deux images consécutives.
clock_on True, si l'horloge est active.
frame_number Numéro de l'image en cours de calcul. Commence par 1.
initial_clock (+KIn.n) Valeur initiale de la variable clock.
final_clock (+KFn.n) Valeur finale de la variable clock.
initial_frame (+KFIn) numéro de la première image.
final_frame (+KFFn) numéro de la dernière image.

 

 

 

 

Initial_Frame = 1
Final_Frame = 20

 

On définie une variable couleur par :
#declare c1 = rgb <1,4,0>;
#declare c1 = rgb <A+1,4,0>;
#declare c1 = rgb V;
#declare c1 = rgb 1;
#declare c1 = rgb <1,1,1>;

Les composantes des couleurs sont obtenue avec l'opérateur point.
c1.red
c1.green
c1.blue
c1.filter
c1.transmit
c1.gray

les tableaux :

#declare M = array[2][3]
#declare M = array[2][3] {{5,7,1},{3,8,5}}
Chaque élément d'un tableau est de même type et doit être initialisé avant d'être lu.
Les indices commence par zéro.

 

 

 

 

 

Les fonctions définies par l'utilisateurs n'utilisent que ces fonctions :

| & + - * / < <= = >= > !=
abs(.) acos(.) acosh(.) asin(.)
asinh(.) atan(.) atanh(.) atan2(.,.)
ceil(.) cos(.) cosh(.) degrees(.)
div(.,.) exp(.) floor(.) int(.)
ln(.) log(.) max(.,.,...) min(.,.,...)
mod(.,.) pow(.,.) radians(.) sin(.)
sinh(.) sqrt(.) tan(.) tanh(.)
select(.,.,...) val(.)

prod(x, x1, x2, f(x)) sum(x, x1, x2, f(x))

#declare F = function(x, y) { sin(x)(cos(y)+1) }

par défaut les variables x, y, z sont utilisé et u=x et v=y.

#declare F = function(x, y, z) { pattern {checker}}


Une pigmentation est constitué d'une fonction

 

 

 

Chaîne de caractères
strcmp(S1,S2), strlen(S), val(S)
Ttableau
dimensions(ID), dimension_size(ID, A)
Fichier
defined(ID), file_exists(S)

defined(ID), retourne true si ID est définie. (l'identifiant d'un fichier devient indéfinie lorsque on a atteint la fin du fichier).
#fopen MonFichier "monfic.txt" read
#while (defined(MonFichier))
#read (MonFichier,Var1,Var2,Var3)
...
#end

file_exists(S), retourne true si il a pu ouvrir le fichier de nom S.
strcmp(S1,S2), retourne négatif si S1<S2, 0 si S1=S2, et un nombre positif si S1>S2.
strlen(S), retourne le nombre de caractère de S.

dimensions(ID), retourne le nombre de dimenssion du tableau (ex M[3][5] a 2 dimenssions).
dimension_size(ID, A), retourne la taille de la dimenssion n°A en commençant par 1.


On choisie de nommer les variables comme suit :
Entiers : I, J
Réels : a, b, c, d, r
Vecteurs : U, V, W
Couleurs : c1, c2, c3
Object : O1, O2, O3





5) Objets simples

Objets simples
Description
Image exemple
Code exemple
plane{V, A} Plan défini par sa normale extérieure V (l'intérieur étant rempli de matière) et par l'abcisse A de ce plan sur l'axe (0,V) où V est normalisé. Par exemple pour faire un sol à une altitude -2, la normale extérieure sera V = <0,1,0> = y et l'altitude sera -2 plan.png plane{ y, -10 pigment {rgb 1}}
sphere{V, R} Sphere de centre V et de rayon R sphere{ 0, 3 pigment {rgb 1}}
box{U, V} Parallélépipède parallèle aux axes x, y, z et définie par deux de ses sommets opposés U et V. plane {y,-4 pigment {rgb <1,1,0>}}
box {<-2,-4,-2>,<2,2,2> pigment {rgb 1}}
cylinder{U, V, R}
Cylindre définie par le centre de ses deux bouts U et V, et par son rayon R.    
cylinder{U, V, R open}
Idem mais ouvert au deux bouts   cone{<0,0,0>,3,<3,2,4>,3.5 open pigment{rgb 1} }
plane {y,-5 pigment {rgb<1,1,0>}}
cone{V1, R1, V2, R2}
Cône définie par le centre de ses deux faces V1 et V2, et par les rayons de ses deux faces R1 et R2.    
cone{V1, R1, V2, R2 open}
Idem mais ouvert au deux bouts    
torus{RMaj, RMin}
Tore centré en <0,0,0>, défini par son rayon majeur RMaj et son rayon mineur RMin    
       







light_source {
1000*<0,0,-1> // une source lumineuse éloignée derrière.
rgb 1 // lumière blanche
transform {rotate<40,45,0>}
}
camera {
location<0,2,-20> // caméra 2 au dessus et 20 en arrière.
look_at <0,0,1000> // regardant le point 0 loin devant.
transform {rotate <10, -40, 0>}
}



select(A, B, C) retourne B ou C selon le signe de A.
select(A, B, C, D) retourne B ou C ou D selon le signe de A et retourne C si A=0.
vdot(U,V), retourne le produit scalaire U•V
vlength(V), retourne la norme du vecteur, c'est à dire sqrt(V•V)
inside(O,V), retourne true ssi le vecteur V désigne un point dans l'objet solide O.






I) Structuration

On refait une structuration du langage POV-Ray mais adapté à l'homme et non à la machine. C'est à dire que l'on va réécrire les règles syntaxique du langage Pov-Ray sous une forme différente mettant en avant : l'exemple signifiant, les nom de variables signifiants dans différents contextes, et finalement la sémantique en même temps que la syntaxe, car selon l'adage naïf, on ne peut séparer la pensé du langage.

La hierarchie comprend les booleans 0 et 1, puis les entiers, puis les nombres qui sont plus généraux, puis les vecteurs de 2, 3, 4 ou 5 nombres.

Puis vient les opérateurs simples syntaxiquement n'utilisant ni parenthèse ni crochet. Les opérations arithmétiques +, -, *, / qui peuvent combiner des nombres et des vecteurs de mêmes dimenssion (les opérations sont alors faites parallèlement composantes par composante, et les nombres sont considérés le cas échéant comme des vecteurs où chaque composante est égale au nombre en question). Les opérations logiques !, &, |, ? :, et les opérateurs de comparaison <, <=, =, !=, >=, >

Puis les opérateurs dit paramètres nommés qui désigne un champ d'une structure et qui sont éventuellement suivi d'une ou plusieurs valeurs numériques ou vectorielles (et qui peuvent dénommer de différente façons plusieurs fois les mêmes paramètres) : rgb, rgbt, rgbf, rgbft, checker, ambient, cubic_spline, rotate, scale, translate, matrix, inverse, location, look_at,

Puis vient les opérateurs utilisant des parenthèses pour collecter leurs arguments. Les opérateurs arithmétiques abs(.), div(.,.), mod(.,.), floor(.,.), ceil(.), int(.), max(.,.,...), min(.,.,...), select(.,.,.), select(.,.,.,.). Les opérateurs de Hasrad rand(.), seed(.). Les opérateurs de puissance exp(.) log(.), ln(.), pow(.,.), sqrt(.). Les opérateurs trigonométriques cos(.), acos(.), cosh(.), acosh(.), sin(.), asin(.), sinh(.), asinh(.), tan(.), atan(.), tanh(.), atanh(.), atan2(.,.) radians(.), degrees(.). Les produits scalaires de veteurs vdot(.,.), vlength(.). L'opérateur Est de dans ? agissant sur un object O et un vecteur position V comme suit : inside(O,V). Les opérateurs sur les object O et vecteurs U,V et nombre a,b :  min_extends(O), max_extends(O), trace(O,U,V), trace(O,U,V,W), vaxis_rotate(U,V,a), vcross(U,V), vnormalize(V), vrotate(U,V),vturbulence(lb,om,oc,V)

Puis vient les opérateurs de structure de base utilisant des crochets d'ensemble pour collecter leurs arguments et paramètres nommés pigmentation{...}, finish{...}, transform{...}, spline{...}

Puis les objects light_source{V,a ....}, camera{...}, plane{V,a ...}, sphere{V,a ...}, box{U,V ...}, cylinder{U,V,a ...}, cone{U,a,V,b ...}, torus{a,b ...}, blob{...}, text{police,"texte",a,b ...}, isosurface{...}, merge{...}, intersection{...}, difference{...}




 

sf"Entier" = (epsilon |+|-) sf"Chiffre"^"+"

sf"Entier" = (+|-)^0 sf"Chiffre"^"+"

sf"Nombre" = sf"Entier" (epsilon|"e" sf"Entier") |
                      (epsilon | sf"Entier" |+|-) . sf"Chiffre"^"+" (epsilon|"e" sf"Entier")

sf"Nombre" = sf"Entier" ("e" sf"Entier")^0  |
                       (sf"Entier" |+|-)^0 . sf"Chiffre"^"+" ("e" sf"Entier")^0