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 acastro@ctv.es ) 
// 
// 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 acastro@ctv.es ) 
// 
// 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 acastro@ctv.es ) 
//
// 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 acastro@ctv.es )
// 
// 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