Créez vos images de synthèse avec POV-Ray

Linux Pratique n° 088 | mars 2015 | Vincent Magnin
Creative Commons
  • Actuellement 0 sur 5 étoiles
0
Merci d'avoir participé !
Vous avez déjà noté cette page, vous ne pouvez la noter qu'une fois !
Votre note a été changée, merci de votre participation !
Les logiciels de dessin en 3D sont souvent difficiles à prendre en main. Et si finalement il était plus simple de décrire une scène en tapant du code et en utilisant la ligne de commandes ? Nous allons voir à quel point il est simple de créer ses premières images de synthèse avec POV-Ray !

1. Introduction

Le projet Persistence of Vision Raytracer, ou plus simplement POV-Ray, a été initié en 1989 et se base sur le logiciel DKBTrace développé par David K. Buck en 1987 [HIS]. Depuis la version 3.7 sortie fin 2013, POV-Ray est sous licence libre AGPL3, alors qu'auparavant il utilisait sa propre licence. Autre changement majeur apporté par cette version, POV-Ray est désormais multi-processus : plus votre processeur a de cœurs et plus le rendu de la scène sera rapide.

Il faut dire que le ray tracing, ou lancer de rayons en français, est un type d'algorithme qui peut être parallélisé assez naturellement. Il consiste en effet à lancer un grand nombre de rayons lumineux et à calculer leurs trajectoires et leurs interactions avec les objets rencontrés. Dans le cas de la synthèse d'images, on calcule en fait le chemin inverse de la lumière, c'est-à-dire que les rayons sont lancés de la caméra vers les objets [RAY].

Le présent article se veut une initiation à POV-Ray. Après avoir vu comment installer le logiciel, nous verrons comment créer une scène basique et effectuer son rendu, puis nous verrons comment l'améliorer. Nous verrons ensuite comment fabriquer de nouveaux objets et nous terminerons par les possibilités d'animation offertes par le logiciel.

2. Installation

La distribution utilisée pour écrire cet article est une Kubuntu 14.10 : la version de POV-Ray disponible dans le dépôt universe est la 3.7.0. L'installation peut se faire avec votre gestionnaire de paquets ou en ligne de commandes :

$ sudo apt-get install povray povray-examples

La documentation est en ligne sur le site officiel [DOC]. Elle est très complète, mais en anglais. Vous trouverez néanmoins facilement sur internet des documents [RAP] ou des tutoriels en ligne [TUT1, TUT2, CLA] en français. Les exemples du deuxième paquet sont installés dans le répertoire /usr/share/doc/povray/examples. Leur consultation constitue une bonne méthode d'apprentissage des possibilités du logiciel.

3. Création d'une scène basique

Fig. 1 : Rendu de la scène basique.

POV-Ray est un logiciel en ligne de commandes. Vous n'aurez donc besoin pour travailler que d'une fenêtre de terminal et de votre éditeur de texte préféré (Kate, gedit, Vim…).

Une scène contient une caméra, une source lumineuse et des objets. La première étape pour générer une image avec POV-Ray est de décrire la scène dans un fichier texte ayant pour extension .pov. Nous allons travailler à partir de l'exemple suivant que nous sauvegarderons sous le nom basique.pov :

1: #version 3.7;

2: #include "colors.inc"

3: global_settings { assumed_gamma 1.0 }

4:

5: camera { location <-20, 8, 20>

6: right x*image_width/image_height

7: look_at <-2, 4, 0> }

8:

9: light_source { <10, 75, -40> color rgb <1, 1, 1> }

10:

11: // Paysage :

12: sky_sphere { pigment {color LightBlue} }

13:

14: plane { <0, 1, 0>, 0 pigment {color YellowGreen} }

15:

16: // Objets :

17: sphere { <0, 5, 0>, 5 pigment {color OrangeRed} }

18:

19: box { <-10, 0, 0>, <-5, 5, 5> pigment {color Red} }

20:

21: cylinder{ <-5, 13, -7>, <-5, 10, +5>, 1 pigment {color White} }

22:

23: // Trièdre :

24: cylinder{ <0, 0, 0>, <3, 0, 0>, 0.1

25: pigment {color Red}

26: translate <-1, 0, +7> }

27: cylinder{ <0, 0, 0>, <0, 3, 0>, 0.1

28: pigment {color Green}

29: translate <-1, 0, +7> }

30: cylinder{ <0, 0, 0>, <0, 0, 3>, 0.1

31: pigment {color Blue}

32: translate <-1, 0, +7> }

Attention !

Pour éviter toute ambiguïté dans le code source, les nombres, vecteurs et matrices doivent être séparés par des virgules.

Au premier coup d’œil, la syntaxe de POV-Ray semble clairement inspirée de celle du langage C : un #include en ligne 2, des commentaires introduits par //, un grand nombre d'accolades… À noter qu'il ne s'agit pas ici d'un langage algorithmique, mais d'un langage de description de scène contenant essentiellement des déclarations d'objets géométriques. Contrairement à ce qui se passe dans un algorithme, l'ordre dans lequel sont déclarés les objets n'aura donc ici pas d'importance.

Attention, le système d'axes de POV-Ray est un peu particulier puisqu'il ne s'agit pas d'un trièdre direct (la règle de la main droite, vous vous souvenez ?). Le trièdre étant indirect, vous pouvez utiliser votre main gauche : l'axe x est représenté par votre pouce pointant vers la droite, l'axe y par votre index pointant vers le haut, et l'axe z par le majeur pointant vers l'écran. La coordonnée y correspond donc à l'altitude et z à la profondeur de l'image. Dans l'image de la figure 1, les axes x, y, z ont été représentés respectivement en rouge, vert, bleu (voir les lignes 23 à 32 du fichier).

Ceci posé, nous pouvons commencer à analyser le fichier source. Première ligne, la directive #version permet de spécifier une version du logiciel, ce qui peut être intéressant pour accéder à une fonctionnalité désormais obsolète. À noter que si vous voulez bénéficier de toutes les nouveautés apportées par la version 3.7, vous devez obligatoirement spécifier cette version. N'oubliez pas le point virgule final !

L'instruction global_settings permet de définir des paramètres globaux, comme ici le gamma de l'image, paramètre qu'il est obligatoire de déclarer à partir de la version 3.7. Nous ne rentrerons pas dans les détails de ce paramètre compliqué qui sert à corriger les couleurs apparaissant à l'écran.

3.1. Caméra

La caméra est définie principalement par sa localisation (ligne 5) en coordonnées cartésiennes et par les coordonnées du point qu'elle regarde (ligne 7). Les coordonnées sont indiquées entre crochets triangulaires et séparées par des virgules. Le paramètre right ligne 6 permet de régler le rapport d'aspect en fonction de la largeur et de la hauteur de l'image spécifiées dans la ligne de commandes.

Une caméra peut utiliser neuf types de projection : perspective, orthographic, mesh_camera, fisheye, ultra_wide_angle, omnimax, panoramic, cylinder, CylinderType, spherical. Par défaut, c'est le type perspective qui est utilisé. Sinon, vous devez indiquer le type de projection comme premier paramètre de l'instruction camera {}. Vous pouvez ajouter un paramètre angle suivi d'un nombre pour régler l'angle de vue horizontal (exprimé en degrés).

3.2. Sources

Vous pouvez disposer dans une scène jusqu'à 127 sources lumineuses. Une source est caractérisée au minimum par ses coordonnées (location) et par sa couleur, que nous avons indiquée ligne 9 sous sa forme RGB : dans POV-Ray, l'intensité du rouge, du vert et du bleu sont indiquées par un réel compris entre 0 et 1. Dans notre exemple, il s'agit donc d'une lumière blanche.

Par défaut, les sources lumineuses sont ponctuelles et éclairent donc dans toutes les directions. Parmi les autres types de sources disponibles, vous pouvez essayer spotlight qui simulera un spot avec un éclairage fort au centre et une zone d'ombre autour (Fig. 2) :

light_source { <10, 75, -40> color rgb <1, 1, 1> spotlight radius 10 falloff 15 tightness 50 point_at <0, 0, 0>}

Dans cet exemple, le spot pointe vers l'origine (paramètre point_at), éclaire à 100 % dans un cône de demi-angle 10° (paramètre radius) et à 0 % au-delà d'un demi-angle de 15° (paramètre falloff), le caractère abrupt de la transition entre les deux étant déterminé par le paramètre tightness, généralement compris entre 0 (frontière nette) et 100 (frontière très floue).

Fig. 2 : La même scène éclairée par un spot.

À noter que les sources sont invisibles par la caméra et ne peuvent donc pas l'éblouir !

3.3. Ciel et sol

Ligne 12, nous définissons le ciel grâce à l'instruction sky_sphere, un ciel étant effectivement une sphère de rayon infini. Une scène ne peut donc bien sûr contenir qu'un seul ciel. Le ciel de cette scène basique est lui aussi basique, puisque c'est simplement une sphère de couleur unie. La couleur d'un objet est définie par une instruction pigment. Le plus simple est de spécifier la couleur par le mot clé color suivi d'un nom de couleur prédéfini ou de rgb <r, g, b>r, g et b seront remplacés par un réel entre 0 et 1, comme déjà vu pour la source lumineuse. On trouvera un tableau des couleurs prédéfinies sur le site en référence [COL].

Attention !

Un pigment fait normalement partie d'une texture, mais pour simplifier la syntaxe il est permis d'utiliser directement l'instruction pigment comme nous l'avons fait.

Quant au sol (ligne 14), il s'agit d'un plan infini créé par l'instruction plane. Un plan est défini au minimum par son vecteur normal entre crochets triangulaires, suivi par sa distance (ici nulle) par rapport à l'origine. Comme le vecteur normal est simplement ici dirigé selon l'axe y, on aurait pu également écrire simplement :

plane { y, 0 pigment {color YellowGreen} }

Attention, l'orientation de la normale du plan est importante pour certains effets. Par exemple, si vous ajoutez un effet atmosphérique tel que du brouillard, celui-ci n'apparaîtra que du côté du plan pointé par cette normale.

3.4. Solides de base

POV-Ray propose dix-sept types de solides. Lignes 17 à 21, notre exemple en présente trois. Une sphère est définie par l'instruction sphere avec au minimum pour paramètres les coordonnées de son centre suivies de son rayon, une boîte par box et les coordonnées de deux sommets opposés, un cylindre par cylinder et par les coordonnées des centres des deux cercles aux extrémités suivies du rayon. Des paramètres modifiant l'aspect de l'objet peuvent être ajoutés, par exemple un pigment ou une texture.

Vous remarquerez également l'instruction translate suivi d'un vecteur déplacement : un objet peut ainsi être créé à un endroit de l'espace puis être translaté ensuite à l'endroit voulu. J'ai utilisé ici cette possibilité parce qu'il est souvent plus simple mentalement d'imaginer les coordonnées d'objets autour de l'origine et de les déplacer ensuite.

Parmi les autres solides disponibles, vous trouverez en particulier dans la documentation en ligne le cône (cone) tronqué ou non, les solides de révolution (lathe), l'ovoïde (ovus), le tore (torus), le texte (text) que nous verrons plus loin, etc.

3.5. Compilation

Pour compiler la scène basique.pov et obtenir l'image correspondante, il vous suffit de taper en ligne de commandes :

$ povray basique.pov +H1024 +W768 +Q9 +A +P

Le nom du fichier de sortie est par défaut celui du fichier source, mais avec l'extension .png. Les autres formats d'image supportés par POV-Ray sont : GIF, TGA, IFF, PPM, PGM, HDR, JPEG, TIFF, OpenEXR. Un autre nom de fichier avec l'extension voulue peut être imposé avec l'option +O.

La hauteur de l'image en pixels est spécifiée par +H et sa largeur par +W. Par défaut, l'image sera affichée dans une fenêtre, dont vous pouvez empêcher l'ouverture en ajoutant l'option -D (comme Display). L'option +P empêchera cette fenêtre de se fermer automatiquement quand le calcul de l'image sera terminé. Vous pourrez alors fermer la fenêtre en cliquant à l'intérieur, ce qui est nécessaire pour que POV-Ray rende la main. La qualité de l'image peut être réglée avec l'option +Q suivi d'un nombre entre 0 (moins bonne) et 11 (meilleure). En attendant de futurs développements, certaines valeurs ont le même effet, par exemple 9, 10 et 11. L'option +A améliore également l'image avec un algorithme d'antialiasing (anti-crénelage en français), dont le comportement peut d'ailleurs être réglé finement.

Le temps de calcul total de cette scène est de deux secondes avec un processeur à 3,3 GHz. Le temps effectif sera encore plus court si votre processeur possède plusieurs cœurs et que vous utilisez la version 3.7 ou plus du logiciel.

4. Améliorons la scène

Nous allons maintenant voir comment nous pouvons améliorer notre scène.

Fig. 3 : Scène améliorée avec des textures et des matériaux.

4.1. Textures

Jusqu'à maintenant, nos objets étaient simplement colorés. L'application de textures est le meilleur moyen d'améliorer très rapidement le rendu de notre scène. Une texture comprend un pigment, une méthode d'altération de la normale à la surface (bosses, rides, ondulations…) et une finition optique modifiant la réflexion de la lumière. Ce sujet est très complexe et POV-Ray dispose de très nombreuses et puissantes possibilités. Nous ne donnerons donc que quelques exemples permettant d'améliorer sans trop d'efforts notre scène.

La librairie textures.inc contient des textures prédéfinies. Pour l'importer, il suffit d'ajouter après la ligne 2 de la scène la ligne suivante :

#include "textures.inc"

Vous pourrez alors modifier comme suit les lignes 14 à 21 en remplaçant les couleurs par des textures plus élaborées :

plane { <0, 1, 0>, 0 texture{Bronze_Metal} }

// Objets :

sphere { <0, 5, 0>, 5 texture{Red_Marble} }

box { <-10, 0, 0>, <-5, 5, 5> texture{Green_Glass} }

cylinder{ <-5, 13, -7>, <-5, 10, +5>, 1 texture{Polished_Chrome} }

En comparant les figures 1 et 3, vous pouvez constater la différence ! Vous pouvez essayer d'autres textures : la liste des textures prédéfinies peut être consultée sur la page web [TEX].

Notez que si le cube en verre est bien transparent, il ne respecte pas les lois de l'optique puisqu'il n'y a pas de réfraction de la lumière. Mais vous pouvez ajouter à l'objet le paramètre interior { ior 1.5 } pour indiquer l'indice de réfraction (ior) du matériau.

4.2. Texte

L'objet text permet d'afficher du texte avec des lettres 3D. Il utilise des polices TrueType, qui sont stockées dans le répertoire /usr/share/povray-3.7/include. Dans cet exemple (Fig. 4), nous affichons le nom du magazine en Times New Roman (timrom.ttf). Les trois autres polices fournies avec POV-Ray sont povlogo.ttf (ne contient que le logo du logiciel), cyrvetic.ttf et crystal.ttf. Mais vous pouvez utiliser n'importe quelle autre police TrueType installée sur votre système en indiquant son chemin complet.

text {

ttf "timrom.ttf" "Linux Pratique" 0.1, 0

pigment { Red }

scale 2.5

rotate <0, 180, 0>

translate <1, 5, 7> }

Les paramètres numériques qui suivent la chaîne de caractères sont l'épaisseur des lettres (ici 0,1) et un décalage suivant x ou y (0.1*x permettrait par exemple d'augmenter l'espacement entre les lettres). Par défaut, le texte commence au point origine et se poursuit suivant l'axe x, les lettres étant extrudées selon z. Si vous voulez placer votre texte ailleurs ou l'orienter différemment, vous devrez donc utiliser les paramètres translate et rotate (ici une rotation de 180° autour de l'axe y). Pour modifier la taille de la police, le paramètre scale sera nécessaire.

Fig. 4 : Texte 3D.

4.3. Brouillard

Deux types de brouillard sont disponibles : uniforme (1) ou au sol (2). Avec les lignes ci-dessous, vous définissez un brouillard blanc uniforme (Fig. 5) :

fog{ fog_type 1

distance 150

color White }

Le paramètre distance définit une distance caractéristique au-delà de laquelle la vision devient difficile. Pour un brouillard au sol, on ajoutera les paramètres fog_offset et fog_alt qui définiront respectivement l'altitude en dessous de laquelle le brouillard aura une densité constante et la rapidité avec laquelle il décroîtra au-dessus. À l'altitude fog_offset+fog_alt, la densité du brouillard ne sera plus que de 25 %.

Fig. 5 : Un brouillard uniforme.

Attention !

POV-Ray permet également de créer des arcs-en-ciel avec l'instruction rainbow.

4.4. Motifs

Les patterns sont des motifs en 3D que vont intersecter vos objets : imaginez par exemple du bois dans lequel vous allez sculpter un objet, à la surface duquel vous verrez apparaître les veines du matériau. Les patterns sont nombreux et occupent une place conséquente dans la documentation de POV-Ray. Nous allons donc simplement vous présenter quelques exemples.

Un des patterns les plus simples est le gradient, qui permet d'obtenir un dégradé de couleur suivant l'axe indiqué. On pourra par exemple s'en servir pour obtenir un ciel un peu plus réaliste (Fig. 3 et 4) :

sky_sphere {

pigment {

gradient y

color_map {

[0.00 color rgb <0.47, 0.86, 1> ]

[0.20 color rgb <0.20, 0.59, 1> ]

} } }

L'instruction gradient transmet une valeur entre 0 et 1 à color_map, qui renvoie une couleur : dans notre exemple, pour la valeur 0 ce sera la première couleur indiquée, entre 0 et 0,2 une combinaison linéaire des deux couleurs et au-delà de 0,2 ce sera la seconde couleur. Une color_map peut comporter entre 2 et 256 couleurs.

Pour obtenir la figure 6, il reste à modifier comme suit les lignes 14 à 21 du script de départ :

plane { <0, 1, 0>, 0 pigment{tiling 22} }

// Objets :

sphere { <0, 5, 0>, 5 pigment {

image_map {"lune.jpg" gamma 1.5 map_type 1}}

}

box { <-10, 0, 0>, <-5, 5, 5>

pigment{ brick pigment{White} pigment{Red} scale 0.5 }}

cylinder{ <-5, 13, -7>, <-5, 10, +5>, 1
 pigment{wood turbulence 0.03} }

Tout d'abord, nous recouvrons le sol d'un pattern tiling (carrelage en français) : il en existe 27 que vous trouverez dans la documentation officielle et nous avons ici choisi le n°22.

Pour la sphère, nous utilisons une image_map : une carte de la lune a été récupérée sur internet [LUN] et nous la plaquons sur la sphère. Le paramètre map_type est important, car il règle la façon dont l'image va être appliquée sur la surface de l'objet. Dans le cas d'une sphère, le type 1 permettra d'enrouler l'image autour de la sphère. Si vous utilisez le type 0, l'image sera répétée un grand nombre de fois sur la surface de l'objet. Le paramètre gamma permet de régler le contraste de l'image appliquée.

Notre cube utilise un pattern brick, avec ici des briques de couleur rouge et un mortier blanc. Le paramètre scale sert ici à diviser la taille des briques par 2.

Enfin, pour le cylindre nous utilisons un pattern wood qui simule les veines d'un bois. Le paramètre turbulence permet d'obtenir un motif moins régulier pour plus de réalisme.

Fig. 6 : Utilisation de différents patterns.

4.5. Profondeur de champ

Si vous voulez simuler la profondeur de champ de la caméra, vous pouvez ajouter dans l'instruction camera les paramètres suivants avant l'accolade fermante :

aperture 1.0 blur_samples 100 focal_point<-7,4,2>

Par défaut l'ouverture (aperture) vaut 0. Plus ce paramètre sera élevé, plus l'image sera floue. blur_samples est le nombre de rayons qui vont être lancés à des positions voisines pour calculer chaque pixel. Plus il sera grand, plus la qualité sera bonne, mais plus le temps de calcul augmentera. Enfin le vecteur focal_point permet d'indiquer la position du plan focal de la caméra, où l'image sera nette.

5. Construction de solides

POV-Ray dispose d'un système de géométrie de construction de solides (Constructive Solid Geometry en anglais) qui permet d'obtenir l'union, l'intersection ou la différence de plusieurs solides, avec respectivement les instructions union, intersection et difference. En remplaçant dans le script basique.pov les objets des lignes 17 à 21 par les lignes suivantes, vous obtiendrez la scène de la figure 7 :

difference {

box { <0, 0, 0>, <3, 3, 3> }

sphere { <0, 3, 0>, 3 }

texture{Jade}

}

 

union {

box { <0, 0, 0>, <3, 3, 3> }

sphere { <0, 3, 0>, 3 }

texture{Jade}

translate <-6, 0, -4>

}

 

intersection {

box { <0, 0, 0>, <3, 3, 3> }

sphere { <0, 3, 0>, 3 }

texture{Jade}

translate <-2, 3, 0>

}

 

blob {

threshold 0.6

sphere { <3.5, 3, 0>, 3, 1 }

sphere { <0 , 3, 0>, 3, 1 }

texture{Jade}

translate <-4, 6, -4>

}

Fig. 7 : Construction de solides par différence (à gauche), intersection (au milieu), union (à droite) et blob (en haut).

Les opérations union, intersection et difference sont effectuées sur le premier objet défini à l'intérieur des accolades : nos exemples ne comportent qu'un second objet, mais vous pouvez en mettre autant que vous voulez pour créer des formes complexes. Une texture ou un pigment sont également nécessaires.

À noter que l'union conserve les frontières des objets de départ à l'intérieur de l'objet final, ce qui peut être gênant si l'objet est transparent. Mais cela peut être évité en remplaçant l'instruction union par merge, au détriment toutefois du temps de calcul.

On peut également créer des objets complexes ayant des frontières courbes : les blobs. Attention, un blob ne peut être composé que de sphères et de cylindres. À chaque objet du blob est associé un champ dont l'intensité au centre de l'objet est indiquée après les autres caractéristiques de l'objet : dans notre exemple, cette intensité vaut 1 pour les centres des deux sphères. Le champ d'un objet est nul à sa surface. Les différents champs s'additionnent et le blob est une iso-surface composée des points où l'intensité du champ global est égale à une valeur seuil (threshold en anglais), ici 0,6. À noter qu'une intensité peut être négative.

6. Animations

Il est possible de réaliser avec POV-Ray des animations en calculant certains paramètres à partir de la valeur d'une variable nommée clock qui par défaut variera de 0 à 1. Par exemple, pour faire tourner un objet autour de l'axe vertical, il suffit de lui ajouter une instruction rotate <0, clock*360, 0>. Vous pouvez alors calculer par exemple 50 images en utilisant l'option de compilation +KFF50 (clocK Final Frame) :

povray basique.pov +H1024 +W768 +Q9 +A +KFF50

Les noms des fichiers images seront alors amelioree01.png jusque amelioree50.png. Il ne vous reste alors plus qu'à générer un film avec un encodeur audio/vidéo tel que ffmpeg ou avconv (fork du précédent) :

avconv -y -i basique%02d.png -r 24 -qscale 5 basique.mp4

L’option -y permet d’écraser le fichier résultant sans confirmation s’il existe déjà [AVC]. Les fichiers d'entrée sont numérotés avec deux chiffres (%02d, même format qu'en C dans un printf). L'option -r indique le nombre d'images par seconde. L'option -qscale règle la qualité de la vidéo obtenue (et donc aussi sa taille), cette qualité étant d'autant meilleure que la valeur est proche de 1.

Pour créer des animations plus complexes, on pourra s'intéresser aux directives #if, #for, #while et #switch qui permettront d'écrire des algorithmes à l'intérieur même des fichiers .pov. Une autre méthode est d'utiliser un programme écrit dans un langage algorithmique (C, Python…) qui créera des fichiers .pov et appellera à chaque fois POV-Ray pour générer une image.

Conclusion

J'espère vous avoir donné envie de découvrir ce monde qu'est POV-Ray. Nous n'avons abordé qu'une petite partie des instructions disponibles, chacune de ces instructions possédant de plus de nombreux paramètres permettant de modifier son comportement. Mais vous pouvez déjà créer de belles images de synthèse et même de courts films.

Les plus anciens fouilleront dans leurs archives pour retrouver la série d'articles publiée dans GNU/Linux Magazine par Saraja Olivier dans les numéros 45 à 71. Sinon, comme déjà évoqué, la documentation en ligne est très complète [DOC], en anglais, et POV-Ray est fourni avec des fichiers d'exemples qui vous aideront à aller plus loin. Enfin, vous trouverez facilement sur le web tout un tas de tutoriels et d'exemples dans toutes les langues, le projet POV ayant quand même fêté ses 25 ans !

Références

[HIS] http://www.povray.org/documentation/view/3.6.0/7/

[RAY] http://fr.wikipedia.org/wiki/Lancer_de_rayon

[DOC] http://www.povray.org/documentation/3.7.0/index.html

[RAP] http://ddata.over-blog.com/xxxyyy/0/02/32/70/principal.pdf

[TUT1] http://www.f-lohmueller.de/pov_tut/pov__fra.htm

[TUT2] http://povray.free.fr/un/index1.html

[CLA] http://openclassrooms.com/courses/pov-ray

[COL] http://www.f-lohmueller.de/pov_tut/tex/tex_150f.htm

[TEX] http://www.f-lohmueller.de/pov_tut/tex/tex_160f.htm

[LUN] http://laps.noaa.gov/albers/sos/moon/moon_8k_color_brim16.jpg

[AVC] https://libav.org/avconv.html