POV-Ray

Flottants : -2.0, -4, 34, +3.4e6, 2e-5, .3, 0.6
Flottants constant : pi = 3.1415926535897932384626, true = on = yes = 1, false = off = no = 0
Vecteurs : <0,1,1>, <0,1,1,0.5>, <0,1,2,0.4,0.5>, 2.5 = <2.5, 2.5, 2.5, 2.5, 2.5>, 1=<1,1,1,1,1>
Vecteurs constants : u =<1,0>, v = <0,1>, x = <1,0,0>, y = <0,1,0>, z = <0,0,1>, t = <0,0,0,1>

Triède indirecte

<Droite, Haut, Loin, Temp>
L'axe x désigne la droite
L'axe y désigne le haut
L'axe z désigne le loin devant
L'axe t désigne le temps
Soit un vecteur V, alors V.x, V.y, V.z donne les composantes en x, y et z.
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é.

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

Exemple d'objets simples :

 plane{y, -5}

 sphere{<0,0,0>,1}
 plane{y,-5}

 
 torus{2,.2 rotate -x*20 }
 sphere{<0,0,0>,.8}
 plane{y,-5}

 plane{y,-5}
 cone{<0,0,0>,1.5, <3,2,4>,2 open}
 sphere{<0,0,0>,0.5}

 text{
    ttf "timrom.ttf"
    "Hello", 0.4, 0
    scale 2 translate -2*x-y
 }

 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}
 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}
 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}

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{...}