Welcome to LinuxFocus

Les sc�nes que j'utilise comme exemple pour illustrer certains aspects techniques ne seraient que des exercices techniques si je n'essayait de chercher la beaut� esth�tique et la compl�tude de la sc�ne m�me si cela suppose l'introduction d'�l�ments externes non expliqu�s dans cet exemple.

Petit � petit nous revisiterons tous les concepts pour que ce qui ne peut-�tre compris en premi�re lecture trouve un �claircissement dans de futurs articles. Au contraire, d'autre concepts sont si visuels que tr�s peu d'explications sont n�cessaire � leurs sujet, les voir dans un exemple suffit pour pouvoir les appliquer parfaitement, certainement mieux que si nous le lisions dans le manuel sans une image comme exemple. Cependant ceux qui voudrons avancer plus rapidement peuvent bien entendu recourir au manuel de Povray.

Objets geométriques simples

Le nombre de formes que l'on peut concevoir avec ces formes basiques est �normes, et il faut se souvenir que l'utilisation de forme simple peut faire r�aliser d'importantes �conomies sur le temps de calcul de la sc�ne.

Objets g�om�triques compos�s (CSG)

Utilisation des boucles et conditions avec Povray.

Les �l�ments d'une sc�ne se d�crivent g�n�ralement dans un ordre arbitraire. A cot� de cela, il y a des situations dans lesquelles il peut �tre n�cessaire d'utiliser des boucles d�crivant la sc�ne, pour cr�er des structures r�p�titives par exemple. Avec Povray nous avons plusieurs fa�ons de faire cela Un moyen de le faire est d'utiliser les structures de contr�le que propose le langage de Povray. Pour le moment nous avons vu les directives #declare et #include en mentionnant que les autres n'�taient pas aussi importantes. Maintenant nous allons les utiliser car nous verrons qu'elles sont indispensables. Dans l'exemple qui suit, nous utiliserons un programme ecrit directement en langage Povray. Je tiens � dire que personnelement c'est la premi�re fois que j'utilise ceci car je ne le crois pas n�cessaire. On peut dire la m�me chose d'un programme qui cr�erait le fichier source n�cessaire, et nous verrons plus loin un exemple de cette seconde possibilit�, que j'utilise peu �galement. On peut faire un m�lange des deux ; Nous verrons que le style de programmation avec Povray n'est pas aussi �l�gant qu'avec un langage informatique classique. La raison est que Povray se con�oit comme un langage de description de sc�nes et ces choses sonts des ajouts r�cents. Nous verrons qu'avec Povray on peut programmer toutes sorte de boucles et d'expressions math�matiques complexes. Mon avis est que cela est bien mais pas indispensable, on peut s'en sortir en utilisant un programme externe qui g�n�re le code source de la sc�ne plus ou mois complexe ou it�ratif. Je pense que le moyen de r�aliser cela n'a rien � voir avec la partie artistique qui est la plus importante et qu'il n'y a pas plus de m�rite � le faire par l'une ou l'autre mani�re. Le plus important c'est l'image finale, dans une moindre mesure cela peut �tre les effort de d�veloppement et la quantit� de ressources employ�es. Si vous connaissez un langage appropri� avec lequel vous vous sentez � l'aise utilisez Povray en fin de cha�ne de d�veloppement. Si vous voulez cr�er quelque chose de simple, vous vous pouvez utiliser Povray directement. Nous verrons plus loin la mani�re de le faire, mais avant quelques commentaires.

Essai et erreur, face aux calculs.

sin(a) = A / C = (Cot� oppos� / Hypot�nuse)
cos(a) = B / C = (Cot� adjacent / Hypot�nuse)
tan(a) = A / B = (Cot� oppos� / Cot� adjacent)

Egalement:
A = sin(a)/C
B = cos(a)/C
C = sqrt(A^2 + B^2)
Como 2* Pi radians = 360º

Ainsi que les domaines de d�finitions des principales fonctions trigonom�triques en fonction du quadrant du cercle trigonom�trique.

Cette derni�re fonction est un peu ambigu� car en fait on ne peux pas conna�tre la valeur de alpha si nous ne connaissons pas le quadrant, c'est pourquoi il est pr�f�rable d'utiliser :
a = atan2(A,B)

Il y a beaucoup de formules utiles en trigonom�trie mais avec celles-ci on doit pouvoir r�soudre la majeur partie des cas. En Povray, on notera que les fonctions trigonom�triques marchent avec des radians et que l'on peut utiliser la fonction de conversion radians(). Au contraire pour les rotations, Povray suppose que l'on travaille en degr�s :-(

Oursins de mer

L'exemple suivant est un bon exercice pour r�viser sa g�om�trie. Vous pouvez remarquez que les piquants d'un oursin on un placement bien particuliers que l'on ne peut pas improviser, il faut l'analyser, choisir un algorithme et l'impl�menter en connaissant exactement l'effet recherch�. Le code source est largement comment� afin d'�tre le plus clair possible. C'est un cas pratique de d�claration de structure it�rative, dans ce cas nous avons choisi d'utiliser Povray comme langage d'impl�mentation mais il n'existe aucune raisons qui emp�chent de le faire d'une autre mani�re comme nous le verrons plus tard avec un programme externe.

Nous commen�ons par le code sources des diff�rentes parties, il s'agit d'une figure compos�e dans laquelle nous utilisons les primitives CSG d�crites plus haut.

// (Copyright) (No modificar estas 11 primeras Lineas) 
// Autor: Antonio Castro Snurmacher  
// (E-mail [email protected] ) 
// 
// Este fuente puede ser utilizado, distribuido, y modificado
// libremente pero siempre se deberá respetar la propiedad
// intelectual de su autor.  El autor renuncia a todo tipo de
// beneficio económico y no se hace responsable de los
// posibles perjuicios derivados del uso del mismo.  Toda
// modificación queda sujeta a las mismas condiciones de uso
// que el original.  En caso de traducción deberá conservarse
// el texto original de esta cabecera y añadirse la traducción
// a continuación de ella.
// 
// Ce code source peut-�tre librement utilis� modifi� et distribu�
// mais doit toujours rester la propri�t� intellectuelle de l'auteur
// l'auteur renonce � tous b�n�fices �conomiques et ne peut-�tre
// �tre tenu responsable des pr�judices �ventuels caus� par son utilisation.
// Toute modification reste sujette aux m�mes conditions que l'original
// En cas de traduction le pr�sent texte doit �tre conserv� et la traduction
// ajout�e � la suite de celui-ci
///////////////////////////////////////////////////// 

//------------------------------------------------------------ 
// balistap.inc (1-Mayo-1998) 
//------------------------------------------------------------ 
// Cette version est destin�e � la revue 
//                     LinuxFocus 
//------------------------------------------------------------ 
  

#declare Color1 = color red 0.5 green 0.2 blue 0.4 
#declare ColorEye = color red 0.5 green 0.5 blue 0.5 

// Nageoire inf�rieure (aleta en esp.)
#declare AletDown =
intersection {
   sphere { <-10,-7,0> 10
      scale <2, 1, 0.1>
   }
   sphere { <-15,-17,0> 10
      scale <2, 1, 1>
      inverse<
   }
   cone { <-10, 0, 0>, 0 <-45, 0, 0>, 20 inverse }
   pigment { color Color1 }
}

// Nageoire sup�rieure
#declare AletUp =
intersection {
   sphere { <-10,7,0>, 10 
         scale <2, 1, 0.1>
   }
   sphere { <-15, 17,0>, 10 
         scale <2, 1, 1>
         inverse
   }
   cone { <-10, 0, 0>, 0 <-45, 0, 0>, 20 inverse }
   pigment { color Color1 }
}

// nageoire caudale (queue)
#declare Tail =
intersection {
            sphere { <-19,0,0>, 10
                    scale <2, 1, 0.1>
             }
             sphere { <-25,0,0>, 10
             scale <2, 1.3, 1>
             inverse
             }
             pigment { color Color1 }
}

// Poison complet
#declare Balistap =
union{
   sphere { <10, 4,0>,4 
      pigment { color ColorEye }
         scale <1,1, 0.6>
   }
   sphere { <10.2, 4.35,0>,3.43
      pigment { color Gray20 }
         scale <1,1, 0.7>
   }
   sphere { <0,0,0> 10 
         scale <2, 1, 0.3>
        pigment { 
           gradient y 
           colour_map {
                [0.0  colour White]
                [0.1  colour Grey]
                [0.99  colour Black]
           }
          scale <1, 17, 1>
          translate <0, -7, 0>
        }
   }

   cone {<19, 0, 0>, 1.5 <-2, 0, 0> 8
        scale <1,1, 0.5>
        pigment { color Color1 }
   }
   cone {<21, 0, 0>, 1 <0, 0, 0> 13
        scale <1,1, 0.1>
        pigment { color Color1 }
   }
  object {AletUp}
  object {AletDown}
  object {Tail}
}

/////////(Copyright) (No modificar estas 11 primeras Lineas)  
// Autor: Antonio Castro Snurmacher (E-mail [email protected] ) 
// 
// Este fuente puede ser utilizado, distribuido, y modificado
// libremente pero siempre se deberá respetar la propiedad
// intelectual de su autor.  El autor renuncia a todo tipo de
// beneficio económico y no se hace responsable de los
// posibles perjuicios derivados del uso del mismo.  Toda
// modificación queda sujeta a las mismas condiciones de uso
// que el original. En caso de traducción deberá conservarse
// el texto original de esta cabecera y añadirse la traducción
// a continuación de ella.
//
// Ce code source peut-�tre librement utilis� modifi� et distribu�
// mais doit toujours rester la propri�t� intellectuelle de l'auteur
// l'auteur renonce � tous b�n�fices �conomiques et ne peut-�tre
// �tre tenu responsable des pr�judices �ventuels caus� par son utilisation.
// Toute modification reste sujette aux m�mes conditions que l'original
// En cas de traduction le pr�sent texte doit �tre conserv� et la traduction
// ajout�e � la suite de celui-ci
/////////////////////////////////////////////////// 
  

//-----------------------------------------------------------
//erizo.pov (1-Mayo-1998)
//-----------------------------------------------------------
// Cette version est destin�e � la revue LinuxFocus
//-----------------------------------------------------------

#include "colors.inc"
#include "textures.inc"
#include "balistap.inc"

#declare RadioCuerpo = 5
#declare NumEspinasMeridiano = 40

// Nous d�finissons la tailles des piquants en fonction de la taille du
// corps des oursins de mer Dans la nature ils ont des piquants plus
// grands en haut et plus petits en bas
#declare LongitudMaximaPua  = RadioCuerpo * 2
#declare LongitudMinimaPua  = RadioCuerpo / 4

// Couler de l'oursin
#declare TexturePua = texture { pigment {VeryDarkBrown} }
#declare TextureCuerpo = texture { pigment {DarkBrown} }

// toutes les d�finitions qui suivent d�pendent des d�finitions
// pr�c�dentes. Nous supposons tout d'abord que le corps des 
// oursins est sph�rique. Pi est une constante pr�d�fini
// comme

#declare pi = 3.1415926535897932384626
#declare LongitudMeridiano  = 2 * pi * RadioCuerpo

// nous supposons qu'ils sont totalement recouverts de piquants coniques
// le rayon � la base d'un piquant sera : 'RadioPua'  

#declare MeridianoPua =  LongitudMeridiano / NumEspinasMeridiano
#declare RadioPua     =  MeridianoPua / 2

// Nous utilisons la notation longitude/latitude sur l'oursin en
// faisant l'analogie avec les parall�les et m�ridiens terrestres
// Pour recouvrir totalement l'oursin de piquants
// on trace diff�rents cercles : les parall�les, et pour chaque
// on prends un point de d�part ; le m�ridien de l'oursin
// Nous appellerons angle vertical l'angle
// form� entre l'axe de l'oursin et le point de d�part d'un 
// parall�le. Aux p�les c'est angle vaudra 0 et 180 et � l'�quateur
//  90. En incr�mentant r�guli�rement cet angle on passera par tous les 
// piquants d'un parall�le. Pour calculer l'incr�ment angulaire
// on fait une r�gle de trois LongitudMeridiano
// ---> 360 MeridianoPua ---> IncAngVert

#declare IncAngVert   = 360 * MeridianoPua / LongitudMeridiano

// pour que l'oursin ne soit pas dans le sable ni ne flotte dans
// l'eau on calcule ladistance du centre au bout des piquants
// situ�s sur la partie basse de l'oursin.

#declare CorreccionY = RadioCuerpo + LongitudMinimaPua
camera {
        location < -40, 40, -40>
        look_at < 25, CorreccionY , 25>
}

// Au fond de la mer la lumi�re vient de plusieurs points � cause de
// la houle en surface. Pour simuler cela on utilise plusieurs
// sources de lumi�re

light_source { <-200, 300, -200> color White}
light_source { <-300, 300, -100> color White}
light_source { <-100, 300, -300> color White}
light_source { <0, 1200, 0> color White}

// Ensuite pour la coloration de l'eau on utilise en effet atmosph�rique

fog { distance 250 color SeaGreen   }

// Le sable est d�fini de couleur Sienne avec des ondulations de
// grande amplitude.

plane { y, 0
  pigment { Sienna }
  normal {
  ripples 1.0
  frequency 300.0
  }
  finish {
  ambient 0.1
  diffuse 0.9
  }
  scale <3000, 3000, 3000>
}

// ******************* D�finition de l'oursin ****************

#declare erizo = object {
union {

// On calcule un parall�le pour chaque valeur de AngVert
// en partant de 0. (0 piquants dans la direction de l'axe
// vertical.  La seconde valeur sera � peut pr�s situ�e sur le premier
// parall�le, la valeur maximale sera pour 
// AngVert == a 90 car c'est dans la zone de l'�quateur qu'il y a
// le maximum de piquants.  les piquants sur un m�me m�ridien 
// se calcule en faisant varier l'angle horizontal :
// 'AngHoriz'

#declare AngVert=0
#while (AngVert < 180 )
#declare RadParalelo = abs ( RadioCuerpo * sin(radians(AngVert)))
#declare LongitudParalelo = 2 * pi * RadParalelo
#declare NumEspinasParalelo = LongitudParalelo / MeridianoPua
#declare LongitudPua = LongitudMinimaPua + (   \
     (LongitudMaximaPua-LongitudMinimaPua) * ((180-AngVert)/180) )
// #declare LongitudPua = LongitudMaximaPua
#declare IncAngHoriz = 360 / NumEspinasParalelo
#declare Ybase = RadioCuerpo * cos (radians(AngVert))
#debug concat("\nAngVert=", str(AngVert,5,0), \
   " LongitudPua=", str(LongitudPua,5,0),     \
   "Ybase=", str(Ybase,5,0), "  ");
#declare Ypunta = (RadioCuerpo + LongitudPua)* \
                      cos (radians(AngVert))
#declare AngHoriz=0
#while (AngHoriz < 360)
#declare Xbase = RadParalelo * cos (radians(AngHoriz))
#declare Xpunta = (RadParalelo + LongitudPua) * \ 
                      cos (radians(AngHoriz))
#declare Zbase = RadParalelo * sin (radians(AngHoriz))
#declare Zpunta = (RadParalelo + LongitudPua) * \
                      sin (radians(AngHoriz))  
//#debug concat( "Vert=", str(AngVert,5,0), \
//               "  Horiz=", str(AngHoriz,5,0), \
//               "\n")     
cone { , RadioPua, , 0 
texture { TexturePua }
}
#declare AngHoriz =AngHoriz + IncAngHoriz
#end
#declare AngVert=AngVert+IncAngVert
#end


// Le corps est une sph�re.
sphere { <0,0,0> RadioCuerpo
texture { TextureCuerpo }
}

} // end union
// On le situe � une altitude convenable.
translate y*CorreccionY

// Mais comme les oursins ne sont pas sph�riques, se que l'on fait est
// est de conserver les proportions sur l'axe des Y et nous augmentons 
// dans un rapport 1.5 les dimensions sur les axes X et Z.

scale <1.5, 1, 1.5>
} // end object erizo

// Ca y est nous avons un oursin parfait, nous allons le dupliquer
// d'abord nous d�finissons une distance minimale entre eux.

#declare DistanciaMinima = 3 * (RadioCuerpo+LongitudMaximaPua)

// Nous allons les disposer sur un carr� 5 * 5.  Pour �viter 
// qu'ils donnent une impression trop g�om�trique, nous les d�pla�ons 
// l�g�rement en X d'une quantit� al�atoire.

#declare Xi=0
#declare R1 = seed(0);
#while (Xi < 5)
#declare Yi=0
#while (Yi<5)
#declare Xpos= Xi * DistanciaMinima + \
           ( rand(R1) * DistanciaMinima * 0.5 )

#declare Ypos= Yi * DistanciaMinima + \
           ( rand(R1) * DistanciaMinima * 0.5 )

#debug concat ("\nXpos=", str(Xpos, 5, 0), \
               "  Ypos=", str(Ypos, 5,0))

object {erizo
translate
}
#declare Yi= Yi+1
#end
#declare Xi= Xi+1
#end

// Nous allons placer les poissons en utilisant une m�thode 
// analogue � celle des oursins. Nous allons les placer en
// trois groupes de 4 * 4. Nous allons tout d'abord d�finir une
// distance minimale entre eux.

#declare DistanciaMinima = 90
#declare Xi=0
#declare R1 = seed(0);
#while (Xi < 4)
#declare Yi=0
#while (Yi<4)
#declare Xpos= Xi * DistanciaMinima + \
       ( rand(R1) * DistanciaMinima * 0.5 )

#declare Ypos= Yi * DistanciaMinima + \
      ( rand(R1) * DistanciaMinima * 0.5 )

#debug concat ("\nXpos=", str(Xpos, 5, 0), \ 
      "  Ypos=", str(Ypos, 5,0))

object { Balistap 
         scale  1.2
         rotate y*50*rand(R1)
         translate
        }

object { Balistap 
         scale  1.2
         rotate y*50*rand(R1)
         translate
        }

object { Balistap 
         scale  1.2
         rotate y*50*rand(R1)
         translate
        }
#declare Yi= Yi+1
#end
#declare Xi= Xi+1
#end

// Nous allons placer l'un deux comme s'il mangeait des
// algues au fond de l'eau.

object { Balistap
         scale 1.1
         rotate z* -45
         rotate y*200
         translate<80, 19, 360>
        }

/** Ceci peut nous servir � voir le poisson en entier *****

object { Balistap 
         scale  1.1
         rotate y*225
         translate<25, 40, 25>
        }

**********************

La lumi�re de cette sc�ne s'obtient en utilisant de nombreuses sources de lumi�re pour simuler l'illumination sous-marine caract�ris�e par le d�sordre introduit par la houle en surface. Une seule source de lumi�re nous aurait trahie car l'ombre des oursins sur le sol aurait �t� trop net.

G�n�ration par un programme externe

Nous allons donner un exemple de ce que nous venons de dire. Le programme qui suit est �crit en C et r�alise les choses suivantes : il d�finit un espace avec les ratios de la r�solutions utilis�es (1000*750). Une fois que cela est fait le programme place des sph�res � des positions al�atoires. Apr�s avoir d�tect� que la position g�n�r�e n'est utilis�e par une autre sph�re il g�n�re la sph�re de mani�re � ce qu'elles ne s'interp�n�trent pas. Pour contr�ler cela nous garderons en m�moire la position de chaque sph�re ainsi que sa taille. Si la position g�n�r� tombe sur une sph�re existante on essaye une autre position, sinon on calcule la distance minimale � la plus proche des sph�res en r�duisant la taille si n�cessaire, elle sera alors plus petite que la taille initiale et en contact avec une autre sph�re. Apr�s un grand nombre d'it�rations on obtient une surface pleine de sph�re de tailles diff�rentes sans espace entre elles. Ce programme utilise beaucoup de puissance de calcul car � chaque fois que l'on place une sph�re on consulte toute la liste des sph�res pr�c�demment plac�es.

/////////(Copyright) (No modificar estas 11 primeras Lineas)
// Autor: Antonio Castro Snurmacher (E-mail [email protected] ) 
//
// Este fuente puede ser utilizado, distribuido, y modificado
// libremente pero siempre se deberá respetar la propiedad
// intelectual de su autor.  El autor renuncia a todo tipo de
// beneficio económico y no se hace responsable de los
// posibles perjuicios derivados del uso del mismo.  Toda
// modificación queda sujeta a las mismas condiciones de uso
// que el original. En caso de traducción deberá conservarse
// el texto original de esta cabecera y añadirse la traducción
// a continuación de ella.  
//
// Ce code source peut-�tre librement utilis� modifi� et distribu�
// mais doit toujours rester la propri�t� intellectuelle de l'auteur
// l'auteur renonce � tous b�n�fices �conomiques et ne peut-�tre
// �tre tenu responsable des pr�judices �ventuels caus� par son utilisation.
// Toute modification reste sujette aux m�mes conditions que l'original
// En cas de traduction le pr�sent texte doit �tre conserv� et la traduction
// ajout�e � la suite de celui-ci
/////////////////////////////////////////////////////////////

//-----------------------------------------------------------
//burbujas.c (1-Mayo-1998) */
//-----------------------------------------------------------
//Cette version est destin�e � la revue
//LinuxFocus
//-----------------------------------------------------------

  

/*************************************************************/ 
/** compilation : cc balls.c -lm -o balls **/
/*************************************************************/ 

#include 
#include 
#include 

#define MAX_X       1000.0
#define MAX_Z        750.0
#define MAX_BALLS   10000
#define MIN_RAD     3.0
#define MAX_RAD     55.0

double PosX[MAX_BALLS];
double PosZ[MAX_BALLS];
double Rad[MAX_BALLS];
int contBall=0;
int contIter=0;
int i;

/*****************************************/
void intento(double x, double z, int cont){
   double distX2;
   double distZ2;
   double rad, cur_rad;

   contIter++;
   rad=MAX_RAD;
   for (i=0; i MAX_RAD)
         rad = MAX_RAD;
   if (rad >= MIN_RAD ){
       Rad[contBall]=rad;
       PosX[contBall]=x;
       PosZ[contBall]=z;
       printf("sphere { <%4.0f, 0, %4.0f> %3.7f
               texture { textureBall } } //(%d/%d)\n",
               x, z, rad, contBall,contIter);
       contBall++;
       if ( (contBall >= MAX_BALLS) )  ){
              exit(0);
       }
          else{
              return;   /** boule suivante **/
          }
   }
   return;
}

/****************************************/
int r_rand(int m){
   return (int) ( (double)m * rand()/(RAND_MAX+1.0));
}

/****************************************/
main (){
  int X, Z;

  for(;;){
        X=r_rand(MAX_X);
        Z=r_rand(MAX_Z);
        X -= MAX_X/2;
        Z -= MAX_Z/2;
        intento(X, Z, contBall);
   }
}

Il faut prendre patience mais si nous voyons que cela prends beaucoup de temps et n'avance pas, on peut interrompre le programme. Il suffi d'�diter le fichier et de s'assurer que les derni�res lignes sont enregistr�es sinon on le quitte. Le code source de pov sera le suivant:

/////////(Copyright) (No modificar estas 11 primeras Lineas)
//Autor: Antonio Castro Snurmacher (E-mail [email protected] )
// 
// Este fuente puede ser utilizado, distribuido, y modificado
// libremente pero siempre se deberá respetar la propiedad
// intelectual de su autor.  El autor renuncia a todo tipo de
// beneficio económico y no se hace responsable de los
// posibles perjuicios derivados del uso del mismo.  Toda
// modificación queda sujeta a las mismas condiciones de uso
// que el original. En caso de traducción deberá conservarse
// el texto original de esta cabecera y añadirse la traducción
// a continuación de ella.
//
// Ce code source peut-�tre librement utilis� modifi� et distribu�
// mais doit toujours rester la propri�t� intellectuelle de l'auteur
// l'auteur renonce � tous b�n�fices �conomiques et ne peut-�tre
// �tre tenu responsable des pr�judices �ventuels caus� par son utilisation.
// Toute modification reste sujette aux m�mes conditions que l'original
// En cas de traduction le pr�sent texte doit �tre conserv� et la traduction
// ajout�e � la suite de celui-ci

//////////////////////////////////////////////////////////////
  

//------------------------------------------------------------

// burbujas.pov (1-Mayo-1998) 
//------------------------------------------------------------

// Cette version est destin�e � la revue
// LinuxFocus
//------------------------------------------------------------

// Il est recommand� d'utiliser la commande suivante pour 'pov'
//        pov burbujas 6 9 1 4  
//                     ^ ^ ^ ^  
//                     | | | |  
//  R�solution ________/ | | |  
//  Qualit� _____________/ | |
//  A partir de Clock = 1 _/ |  
//  jusqu'� Clock = 4 _______/  

#include "colors.inc"
#include "textures.inc"

// Par d�faut max_trace_level vaut 5 . On l'augmente � 15
// afin d'obtenir un meilleur niveau de d�tail dans les images
// g�n�r�es par les reflets

global_settings {
#max_trace_level 15
}

// On d�finit diff�rent points de vue en en utilisant qu'un
// en fonction de la valeur de Clock

#declare img1 =
camera {
  location <0, 10000 ,0 >
  look_at <0, 0, 0>
  angle 7
}

#declare img2 =
camera {
  location <0, 250 ,0 >
  look_at <0, 0, 0>
  angle 130
}

#declare img3 =
camera {
  location <12, 3 ,12 >
  look_at <200, 3, 50>
  angle 30
}

#declare img4 =
camera {
  location <12, 3 ,12 >
  look_at <200, 3, 50>
  angle 120
}

  #switch (clock)
    #case (1)
      // This section is parsed if clock=1
       camera {img1}
    #break  
    #case (2)
      // This section is parsed if clock=2
       camera {img2}
    #break  
    #case (3)
      // This section is parsed if clock=4
       camera {img3}
    #break 
    #case (4)
      // This section is parsed if clock=5
       camera {img4}
    #break 
    #else
      #warning "Clock outside expected range\n"
  #end // End of conditional part

// Une source de lumi�re blanche
object {
  light_source {
  <100, 1000, 100>
  color White
  }
}

#declare textureBall = texture { Gold_Metal }

// le fichier inclus 'burbujas.inc' est un fichier obtenu
// � partir de la sortie d'un programme C.

#include "burbujas.inc"

Je vous avais dit dans un article pr�c�dent que nous verrions l'utilisation de la cam�ra. Nous pouvons nous r�f�rer � cet exemple : on peut y voir les effets de perspective obtenu par l'utilisation d'un angle tr�s petit ou bien tr�s lointain. Ou bien l'utilisation d'un angle tr�s ouvert puis tr�s ferm�. l'angle maximal d'ouverture est de 180 degr�s. C'est un cas extr�me o� l'on ne distingue plus les formes. Comme vous pouvez le constater une simple utilisation de la cam�ra peut produire des effets int�ressants.

Les rendus ont �t� effectu�s sur un Pentium 200 MMX 48 MB Ram. En utilisant 'pov' avec la commande suivante:

Temps total = 4 heures et demi.
premi�re image 2 minutes.
seconde image 5 minutes.
troisi�me image 10 minutes.
quatri�me image 13 minutes.
cinqui�me image 4 heures !!

Regardons les r�sultats. Tout d'abord sur les quatre premi�res images seule la cam�ra varie. (position, angle, direction, etc.)

Il manque une image que nous montrerons plus tard, mais d'abord nous allons traiter quelques questions en relation avec cette derni�re image.

Optimisation du temps de calcul

Comme nous l'avons vu la derni�re image est la plus complexe et Povray n'a pas sut l'optimiser. Quand on d�finit une figure compos�e le programme essaye de trouver une figure plus simple l'englobant.

Dans les versions ant�rieures de Povray il fallait le faire � la main. Cela se faisait par la primitive 'bounded_by' qui permet de d�finir une primitive qui englobe un ou plusieurs objets et de cela le programme suppose que les rayons ne passant pas dans ce volume ne passent pas non plus sur les objets � l'int�rieur. Aujourd'hui il reste peut de cas o� une optimisation manuelle reste n�cessaire, mais ici c'est le cas.

La derni�re image est une figure compos�e tr�s complexe. Pour am�liorer cela nous allons grouper les sph�res par zones ou bien toutes les grouper comme dans l'exemple mais par groupes bien localis�s et d�limit�s par une primitive englobante en utilisant 'bounded_by'. La syntaxe sera la suivante:

On peut appliquer des formes obtenue par unions ou intersections etc. mais �galement n'importe quel objet et l'on peut utiliser dans 'bounded_by' une forme quelconque bien que les meilleurs r�sultats s'obtiennent avec les sph�res et les boites.

Si la forme choisie n'inclue pas tout l'objet le r�sultat peut-�tre mauvais. Je rappelle que la plupart du temps il n'est pas n�cessaire de faire cette optimisation. Ce dernier exemple est un cas particulier o� l'optimisateur de Povray ne pouvais pas faire mieux. Il s'agit tout de m�me d'un objet compos� de 2154 sph�res. Vous pouvez les compter si vous ne me croyez pas. :-) La derni�re image est le r�sultat d'exp�rimentation avec Pov.

La plupart du temps, d'une m�me id�e on peut faire plusieurs choses et c'est ici qu'entre en sc�ne notre imagination et notre cr�ativit� La plupart du temps il n'est pas suffisant de partir d'une bonne id�e mais il faut aussi se laisser � imaginer et � jouer avec les diff�rentes possibilit�s que nous avons rencontr�es et qui nous plaisent.

On peut imaginer des quantit� de sc�nes dans lesquelles la programmation peut servir de base � la g�n�ration d'images de synth�se statiques ou dynamiques.

Encore quelques mots.

Povray fournit de nombreuses fonctions math�matiques plus ou moins int�ressantes, mais il y en a une tr�s int�ressantes qui manque. Je veux parler de la fonction spline. Il n'y a rien de plus commode que de tracer avec un crayon et du papier ne s�rie de points et d'appliquer une fonction qui nous donne une courbe passant par chacun de ces points. La primitive Spline de Povray ne peut pas s'utiliser comme une fonction, elle sert � g�n�rer une ligne pour construire des formes de bases, mais cela serait bien mieux si l'on pouvait l'appliquer aux variables que l'on veut. On pourrait en faire des trajectoires de cam�ra par exemple. Il serait bien �galement que l'on puise impl�menter n'importe quelle fonction...

Quoiqu'il en soit cela peut se contourner en utilisant les inclusion et la programmation. Nous avons sous Linux un utilitaire appel� 'spline'. Il s'utilise comme une commande et g�n�re en sortie la courbe d�sir�e � partir d'une entr�e qui peut-�tre une suite de points. Il peut-�tre tr�s utile de combiner cette commande avec un programme externe pour obtenir des trajectoires ou bien des animations.

Concevoir des structures it�ratives avec Povray.

L'art et la technique en Infographie