TP 1 : Introduction à l`utilisation de POV

TP 1 : Introduction à l'utilisation de POV-Ray
Option Géométrie et Infographie
Premiers éléments du langage de PovRay
Un fichier de scène comporte toujours un certain nombre d'éléments, dans un ordre précis : une
seule caméra active, puis au moins une lumière et enfin une série d'objets. Toutes les descriptions se
font par rapport à un repère orthonormé indirect. Tapez le listing depart.pov suivant, puis
calculez l'image. Les parties entre /* et */ sont des commentaires pour vous aider :vous n'êtes pas
obligés de les recopier ! Remarquez la structure suivante qui est obligatoire : en premier,
l'observateur, puis les lampes et seulement après les objets.
/* depart.pov : Scene de base pour la suite... */
#include "colors.inc"
/* incorpore les definitions des couleurs */
#include "textures.inc" /* incorpore les definitions des textures */
/****************** D'abord une camera : *******************/
camera {
location <0,3,-5> /* Position de la camera */
look_at <0,1,0> /* Point qu'elle vise */
}
/****************** Puis au moins une lumiere : *******************/
light_source { <-3,5,-5>
/* Position de la lumiere : */
/* un peu au dessus et a gauche de la camera */
color White /* Lumiere blanche */
}
/****************** Maintenant les objets : *******************/
/* Un plan pour materialiser un sol vert : */
plane { <0,1,0>,0 /* vecteur normal au plan (vers l'exterieur), */
/* distance a laquelle commence le plan dans cette direction */
texture { pigment { color Green } }}
/* Une boule blanche posee sur le sol : */
sphere { <0,1,0>,1 /* coordonnees du centre et rayon de la sphere */
texture { pigment { color White } }}
Modifiez des paramètres dans la scène et effectuez le rendu pour voir si l'effet prévu est bien celui
produit.
Les primitives
Ce sont les briques de base qui permettent de construire des objets plus complexes.
Syntaxe des objets de base
sphere { <x,y,z>,r }
Une sphère de rayon dont le centre est à la coordonnée
.
box { <xmin,ymin,zmin>,<xmax,ymax,zmax> }
Un boite définie par un coin min et un coin max, les arêtes sont parallèles aux axes.
cylinder { <x1,y1,z1>,<x2,y2,z2>,r }
Un cylindre de rayon dont l'axe est le segment
.
cone { <x1,y1,z1>,r1,<x2,y2,z2>,r2 }
Même signification que pour le cylindre, mais avec un rayon pour chaque extrémité du segment.
torus { grand,petit }
Un tore centré en
et dont le grand rayon est
rayon du trou intérieur est égal à
et le petit
. Par conséquent, le
et le rayon extérieur est égal à
plane { <normx,normy,normz>,distance}
Un plan (en fait un demi-espace) dont la normale est le vecteur
situé à
.
. Ce plan est
unités de l'origine.
En fait, tous ces objets sont pleins. La notion de leur intérieur et extérieur est bien définie. Ce ne
sont pas juste des surfaces. Le coté plein est toujours celui qui est à l'intérieur. Pour le plan c'est un
peu plus subtil, le vecteur normal de la définition indique le demi-espace qui n'est pas le coté plein.
Il existe plusieurs autres types de primitives que nous aborderons ultérieurement car elles sont
moins évidentes.
Opérateurs booléens : Constructive Solid Geometry
Puisqu'on peut toujours savoir par le calcul si un point est à l'intérieur d'un objet, on peut définir les
opérateurs suivants.
Soient deux objets A et B, les commandes
union { A B }
intersection { A B }
difference { A B }
désignent respectivement l'union logique de A et B,leur intersection et leur différence (A-B).Par
exemple, pour qu'un point soit à l'intérieur de difference { A B }, il doit être à l'intérieur de
A mais pas de B. Tapez la scène csg.pov suivante, puis effectuez le rendu.
/* csg.pov: Demo des Constructive Solid Geometry */
#include "colors.inc"
#include "textures.inc"
/****************** D'abord une camera : *******************/
camera {
location <2,3,-3> /* Position de la camera */
look_at <0,0,0> /* Point qu'elle vise */
}
/****************** Puis au moins une lumiere : **************/
light_source { <-6,5,-5> color White }
light_source { < 6,5,-5> color White }
/****************** Maintenant les objets : *******************/
plane { <0,1,0>,-1 texture { pigment { color Green } }}
union {
sphere { <-.5,0,0>,1 texture { pigment { Red } } }
sphere { < .5,0,0>,1 texture { pigment { Blue } } }
}
Changez le mot clé union successivement en intersection puis en difference et
calculez l'image à chaque fois.
Opérateurs de transformation
Il existe plusieurs opérateurs permettant de transformer un objet : translate, scale, rotate
et matrix. Ils s'insèrent tous à la fin d'un objet (juste avant le "}" final).
Pour déplacer un objet, on dispose de la commande translate qui est suivie d'un vecteur< , ,
> qui indique le vecteur de translation souhaité.
La commande rotate est normalement suivie d'un vecteur comme translate, mais il est, en
général, plus simple de l'écrire comme un produit. Par exemple, la commande rotate 60*z
provoquera une rotation de l'objet de 60 degrés dans le sens positif, autour de l'axe .
La commande scale < , , > effectue une affinité sur chaque axe de rapport respectifs ,
et
. Un rapport égal à -1 donne une symétrie.
La commande matrix <
de coefficients
,
,...,
> effectue une transformation suivant la matrice
.
Attention, l'ordre est important, ces opérations ne sont pas commutatives : elles opérent dans l'ordre
où elles apparaissent dans le fichier.
sphere { <0,1,0>,1
/* centre et rayon de la sphere */
scale <1,1,2>
/* affinité de rapport 2 suivant 0z */
translate <1,1,1> /* puis translation en (1,1,1) */
}
Attention, l'ordre est important, ces opérations ne sont pas commutatives : elles opérent dans l'ordre
où elles apparaissent dans le fichier.
sphere { <0,1,0>,1
/* centre et rayon de la sphere */
scale <1,1,2>
/* affinité de rapport 2 suivant 0z */
translate <1,1,1> /* puis translation en (1,1,1) */
}
L'instruction #declare
On peut donner un nom à une construction pour y faire référence plus tard. Cela se fait grâce à
#declare :
#declare rayon
= 10 ;
/* une valeur */
#declare position = <1,2,3> ;
/* un vecteur */
#declare boule
= sphere { position,rayon }
/* un objet
*/
#declare truc = union { boule
/* objet declare au dessus */
torus { rayon+rayon2 , rayon2 /* les deux rayons du tore */
translate position } /* on deplace le tore pour qu'il entoure la boule */}
Puis pour que l'objet déclaré boule apparaisse dans le résultat, il faut en plus placer une (ou
plusieurs) référence(s) à cet objet par :
object { boule }
De manière générale, un #declare "apprend" au logiciel quelque chose, mais cela ne le fait pas
pour autant apparaître dans la scène. On se sert de cette méthode pour factoriser certains éléments
constituant une scène qui apparaissent plusieurs fois : ça évite de les taper inutilement.
C'est aussi très utile pour paramétrer une construction : dans l'exemple truc utilise les mêmes
paramètres que boule, ainsi si on veut changer rayon ou position, cela modifiera d'un coup
boule et truc. Tapez la scène complexe.pov suivante, effectuez en le rendu.
/* complexe.pov: Mise en scene complexe avec references d'objets. */
#include "colors.inc"
#include "textures.inc"
/****************** D'abord une camera : *******************/
camera {
location <0,3,-5> /* Position de la camera */
look_at <0,1,0> /* Point qu'elle vise */
}
/****************** Puis au moins une lumiere : *******************/
light_source { <-3,5,-5>
/* Position de la lumiere : */
/* un peu au dessus et a gauche de la camera */
color White /* Lumiere blanche */}
/****************** Maintenant les objets : *******************/
/* Un plan pour materialiser un sol vert : */
plane { <0,1,0>, /* vecteur normal au plan (vers l'exterieur), */
0 /* distance a laquelle se trouve le plan dans cette direction */
texture { pigment { color Green } }}
#declare longueur_cote
= 4 ;
#declare hauteur_cendrier = 1 ;
#declare cendrier = difference {
box { <-longueur_cote/2, 0,-longueur_cote/2>, < longueur_cote/2,
hauteur_cendrier, longueur_cote/2> }
sphere { <0,hauteur_cendrier,0>,1 scale
<longueur_cote/2.1,hauteur_cendrier*0.8,longueur_cote/2.1> }}
object { cendrier texture { pigment { color Grey } } rotate <0,30,0>}
#declare intervalle
= 1 ;
#declare rayon
= 0.2 ;
#declare hauteur_tube = 4 ;
#declare tube = cylinder { <0,0,0>,<0,hauteur_tube,0>,rayon}
#declare rangee = union {
object {tube translate -4*intervale*<1,0,0> }
object {tube translate -3*intervale*<1,0,0> }
object {tube translate -2*intervale*<1,0,0> }
object {tube translate -1*intervale*<1,0,0> }
object {tube}
object {tube translate 1*intervale*<1,0,0> }
object {tube translate 2*intervale*<1,0,0> }
object {tube translate 3*intervale*<1,0,0> }
object {tube translate 4*intervale*<1,0,0> }
}
object { rangee texture { pigment { color Blue } } translate <0,0,5>}
Exercice 1 : modélisation d'une table
Le but est de modéliser une table à partir de certains paramètres :
1. longueur, largeur et épaisseur de la planche,
2. hauteur et épaisseur des pieds (forme à choisir)
3. distance entre les pieds et le bord de la planche.
Une fois que vous avez une table acceptable, placez la sur un sol (plane)que vous aurez créé (à
l'altitude 0).Faites varier les paramètres, si vous vous êtes bien débrouillés, vous ne devriez pas
avoir de table volante ou autres bizarreries...
Exercice 2 : rotations d'un dé à jouer
Modélisez un dé à jouer, cube sur les faces duquel sont posés des symboles en nombre égal à 1, 2,
3, 4, 5, 6.
Faites d'abord 6 copies de ce cube, orientées pour présenter chacune des 6 faces, puis présentez le
cube posé sur un coin, c'est-à-dire présentant à l'observateur 3 faces contigües.