POV-Ray

1) Inroduction

POV-Ray (Persistence Of Vision Raytracer) est un logiciel libre de lancer de rayons, une technique de synthèse d'image représentant une scène 3D. Il a été créé dans les années 1980. Le logiciel dans sa dernière version 3.7 (datant de novembre 2013) est passé sous licence AGPL3 en accord avec la définition de la Free Software Foundation. Il est écrit en C++, fait les calculs en double précision, et est multiprocessus. Voir :

www.povray.org	[Google-Traduction]
Options de ligne de commande	[Google-Traduction]
Langage de description de scène	[Google-Traduction]
Éléments du fichier de scène	[Google-Traduction]
Tutoriel de démarage	[Google-Traduction]
Tutoriel avancé	[Google-Traduction]
FAQ	[Google-Traduction]

POV-Ray Documentation de Fabien Mosen

POV-Ray est un rendeur de scène, appelé aussi, moteur de rendu. il transforme la description d'une scène qui est un programme, en une image de synthèse rigoureuse. C'est à dire qu'il calcule la trajectoire des rayons lumineux dans une scène en trois dimension pour produire une image, l'image qui, dans la scène, est théoriquement perçu par la caméra. On dit qu'il interprète la scène en une image. Le programme décrivant la scène est écrit dans un langage qui porte le même nom que le logiciel de rendu "povray", et que nous allons décrire.

La scène peut contenir un paramètre de temps et être interprétée par le rendeur povray en une liste d'images de synthèse, une image pour chaque valeur du paramètre temps considéré. Cette liste d'images est agglomérée en une animation à l'aide d'une commande ffmpeg.

2) Installation sous Linux

Installez le paquet povray, le paquet ffmpeg utile pour aggréger des images en une vidéo, et les paquets gedit et gedit-plugins, un éditeur de texte avec coloration syntaxique qui nous sera utile pour programmer en povray.

apt install povray ffmpeg gedit gedit-plugins

Téléchargez le fichier povray.lang que j'ai mis à jour et qui est à placer dans le répertoire /usr/share/gtksourceview-4.0 . Si vous avez une version plus ancienne, téléchargé le fichier povray.lang qui est à placer dans le répertoire /usr/share/gtksourceview-3.0. Il contient les règles de coloration syntaxique du langage povray pour l'éditeur gedit. Ce fichier est adaptable et la coloration syntaxique est personnalisable. Voir le chapitre coloration syntaxique dans gedit ici.

Créez un répertoire de travail. Dans ce répertoire, on crée un fichier local povray.ini et on y met les options par défaut que l'on souhaitent utiliser :

Output_File_Type=N Bits_Per_Color=16 Antialias=On Height=600 Width=800 Pause_When_Done=On

Ces options seront activée à chaque fois que l'on exécutera la commande povray appliquée à un fichier se trouvant dans ce répertoire de travail et sans spécifier de fichier ".ini".

3) Créer une image de synthèse

On crée un fichier de scène a.pov et on y met une scène :

#version 3.7 #default { pigment { rgb 1}} light_source {<-9000,9000,-9000>, 1} camera {    location <0,5,-10>    right x*image_width/image_height    look_at z    up y } sphere {<0,5,0>,2} plane {y,0}

On exécute cette scène avec l'instruction suivante povray a.pov. Cela crée une image de synthèse a.png :

4) Créer une animation

Pour effectuer un film d'animation, on modifie le fichier povray.ini comme suit.

Output_File_Type=N Bits_Per_Color=16 Antialias=On Height=600 Width=800 Pause_When_Done=Off   Initial_Frame = 1 Final_Frame = 100 Initial_Clock = -6.0 Final_Clock = 10.0

Pause_When_Done=Off afin que les images soit créées les une à la suite des autre sans intervention de l'utilisateur. Initial_Frame = 1 et Final_Frame = 100 signifie que les images seront numéroté de 001 à 100. Initial_Clock = -6.0 et Final_Clock = 10.0 signifie que le paramètre clock commence à la valeur -6 et évolue linéairement jusqu'à la valeur 10.

#version 3.7 #declare T = clock ; #default { pigment { rgb 1}} light_source {<-9000,9000,-9000>, 1} camera {    location <0,5,-20>    right x*image_width/image_height    look_at <0,5,0> } sphere{<0,T,0>,5} plane{y,0}

On execute cette scène avec l'instruction suivante povray a.pov. Cela crée 100 image de synthèse a000.png ... a100.png. Puis on agglomère ces images à l'aide de l'instruction suivante :

ffmpeg -framerate 24 -i a%03d.png -c:v png output.avi

Cela produit sans perte de données la vidéo suivante :

Le paramètre a%03d.png signifie que les images utilisées sont nommées de la forme axxx.png où xxx est un nombre décimal.

clock	Valeur du temps compris par défaut entre 0 et 1.
clock_delta	Intervalle 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.

5) Les bases du langage POV-Ray

5.1) Nombre

Voici quelques exsemples de nombres :

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

5.2) Constante

pi = 3.1415926535897932384626

true = on = yes = 1

false = off = no = 0

5.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).

Toute affectation se fait par une instruction #declare. Ainsi pour faire doubler la valeur de a, nous écrirons l'instruction suivante :

#declare a = 2*a ;

5.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 canal de nombre aléatoire de graine x.
rand(y)	Retourne le nombre aléatoire suivant sur le canal y.

5.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>

5.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).

5.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>

5.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
vnormalize(V)	Retourne le vecteur normalisé, V/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 V.x autours de x puis d'angle V.y autour de y puis d'angle V.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.

5.9) Les transformations vectorielles

Pivote, agrandie, déplace ou applique une transformation affine sur un objet ou 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

Mais ces applications affines ne font pas que modifier les paramètres de l'objet, elles complètent l'architecture de l'objet en l'incorporant comme une composante à part de sa construction. Ainsi dans un objet d'abord translaté puis tourné, la translation sera tourné également. Le scripte ci-dessous dispose 10 spheres en cercle :

#declare I = 0 ; #while (I < 10) #declare I=I+1; sphere{<0,6,0>, 2 finish{ phong 1} pigment{rgb <1,1,1>}   translate 10*z rotate y*I*36 } #end plane{y,0 pigment{rgb <1,1,1>}}

6) 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 et de force 1. camera{     location <0,5,-5>     right x*image_width/image_height     angle 75     look_at 0 }// Place la camera en <0,5,-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,5,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 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.

7) 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) où 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) 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.		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}

8) 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. Le chemin de la librairie (où se trouve les fichiers "include" du système.

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

Library_Path=/usr/share/povray-3.7/include Height=600 Width=800 Pause_When_Done=On Antialias=On

Le manpage de povray :

povray [+ O fichier_sortie ] [ option +/- ...] [ fichier_entrée ]

povray [ + I fichier_entrée ] [ + O fichier_sortie ] [ option +/- ...] [ fichier_INI ]

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

9) Couleurs

On définie une couleur de 4 façons : rgb <1,2,3>, rgbf <1,2,3,4>, rgbt <1,2,3,4>, rgbft <1,3,2,4,5>. La couleur rgbft<1,3,2,4,5> s'écrie aussi

  red 1
  green 2
  blue 3
  filter 4
  transmit 5

et peut être écrite dans le désordre. Chaque valeurs de red de green et de blue se situe en principe entre 0 et 1 et correspond à une saturation. Néanmoins il est possible de sortir de ces limites et même d'envisager des valeurs négatives. Quand une couleur est codée en trois valeurs rgb de 0 à 255 telles que (100,110,90), cela correspond à la couleur X suivante :

#declare X = rgb<100,110,90>/255

Les valeurs de filter et de transmit sont en principe de somme égale à 1 et correspond à aux proportions de lumière filtré et transmise.
filter 0.4 signifie que 40% de la lumière résultante est celle tranversant en étant filtré par la couleur.
transmit 0.2 signifie que 20% de la lumière résultante est celle tranversant sans être altéré par la couleur.

Soit une couleur X, alors X.red, X.green, X.blue, X.filter, X.transmit donne les composantes rouge, vert ,bleu, filter et transmit de X.

Exemple de déclaration de six variables couleurs R, B, G, X, Y, Z, C initialisées :

#declare R = rgb<1,0,0> ;
#declare B = rgb<0,0,1> ;
#declare G = rgb<0,1,0> ;
#declare X = rgbf<1,1,1,0.5> ;
#declare Y = rgbt<1,1,1,0.5> ;
#declare Z = rgbft <.1,1,1,0.6,0.4> ;

#declare V = <1,2,3,4,5> ;
#declare C = rgbft V red C.red + 0.9 ;

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

R+G/2+B = <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> ;
#declare C = rgb<C.gray, C.red, C.blue> ;

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

10) 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 à partir 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 ajoutant 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}}

11) Les courbes lissées

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

#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

12) La camera :

	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 }