Welcome to LinuxFocus

Las escenas que utilizaré como ejemplo para ilustrar algunos aspectos técnicos no serán meros ejercicios técnicos sino que intentaré buscar la belleza estética y un acabado más completo de la escena aunque eso suponga introducir elementos extraños no explicados aun en el ejemplo.

Poco a poco se irán revisando todos los conceptos para que lo que no se pudo comprender en una primera lectura se pueda asimilar en futuros artículos. Por otra parte muchos conceptos son tan visuales que apenas necesitan excesiva explicación porque el verlos en un ejemplo resulta suficiente para poder aplicarlo a la perfección. Quizas mejor incluso que si lo leemos en el manual sin una buena imagen como ejemplo. Tampoco hay que olvidar que para los que deseen avanzar más deprisa siempre pueden recurrir a este manual de Povray.

Objetos geométricos simples

El número de objetos que se pueden diseñar usando estas formas básicas es enorme, y además hay que tener en cuenta que el uso de formas sencillas representa un ahorro considerable en el tiempo de proceso de la escena.

Objetos geométricos compuestos. (CSG)

Utilización de bucles y condiciones en Povray.

Prueba y error, frente al cálculo.

sin(a) = A / C = (Cateto opuesto / Hipotenusa)
cos(a) = B / C = (Cateto adyacente / Hipotenusa)
tan(a) = A / B = (Cateto opuesto / Cateto adyacente)

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

Vamos a recordar los rangos de las principales funciones trigonométricas, en función del cuadrante:

Esta última función es un poco ambigua. Realmente no podemos conocer el valor de Alfa si no conocemos el cuadrante, por ello es preferible usar:
a = atan2(A,B)

Hay muchas fórmulas útiles en trigonometría pero creo que con estas es suficiente para la mayoría de los casos. En Povray se asume que para las funciones trigonométricas trabajamos con radianes por lo que usaremos la función de conversión radians(). radians(Alfa) Por el contrario para los giros se asume que trabajamos con grados. :-(

Erizos marinos

Empezmos mostrando el fuente de los peces. Se trata de una figura compuesta en la que usamos las primitivas CGS que ya hemos comentado.

// (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.
///////////////////////////////////////////////////// 

//------------------------------------------------------------ 
// balistap.inc (1-Mayo-1998) 
//------------------------------------------------------------ 
// Esta versión está dedicada a su inclusión en la revista 
//                     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 

// Aleta inferior
#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 }
}

// Aleta superior
#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 }
}

// Aleta caudal (cola)
#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 }
}

// Pez completo
#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.
/////////////////////////////////////////////////// 
  

//-----------------------------------------------------------
//erizo.pov (1-Mayo-1998)
//-----------------------------------------------------------
//Esta versión esta dedicada a su inclusión en la revista //
//LinuxFocus
//-----------------------------------------------------------

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

#declare RadioCuerpo = 5
#declare NumEspinasMeridiano = 40

// Definimos el tamaño de las puas en función del tamaño del
// cuerpo Los erizos de mar en la naturaleza presentan puas
// largas en la parte superior y cortas en la parte inferior.

#declare LongitudMaximaPua  = RadioCuerpo * 2
#declare LongitudMinimaPua  = RadioCuerpo / 4

// Color del erizo
#declare TexturePua = texture { pigment {VeryDarkBrown} }
#declare TextureCuerpo = texture { pigment {DarkBrown} }

// Todas las definiciones que siguen a continuación están
// calculadas a partir de las anteriores.  Suponemos
// inicialmente un erizo con cuerpo esférico.  pi está
// predefinido como

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

// Suponemos que está totalmente recubierto de púas cónicas. 
// El radio de una púa en su base será 'RadioPua'  

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

// Usaremos la notación de eje, meridiano, y paralelo en el
// erizo tal como lo haríamos con el eje, los meridianos, y
// paralelos terrestres.  Para recubrir el erizo totalmente de
// púas trazaremos varios circulos 'paralelos del erizo', y
// para ello tomaremos un 'meridiano del erizo' como punto de
// partida de todos ellos. Llamaremos angulo vertical al
// angulo formado con el 'eje del erizo' y el punto de
// comienzo de un paralelo. En los polos este angulo vertical
// valdrá 0 y 180, y en el ecuador valdrá 90. Necesitamos ir
// incrementado este angulo para procesar en cada uno de ellos
// las puas de un paralelo.  Para calcular el incremento del
// angulo vertical hacemos una regla de tres LongitudMeridiano
// ---> 360 MeridianoPua ---> IncAngVert

#declare IncAngVert   = 360 * MeridianoPua / LongitudMeridiano

// Para que el erizo no sen unda en la arena ni flote en el
// agua calculamos la distancia del centro al extremo de las
// puas pequeñas situadas en la parte inferior del erizo.

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

// En el fondo del mar la luz llega de varios puntos debido al
// oleaje en la superficie. Para simular esto usaremos varias
// fuentes de luz.

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}

// Para conseguir la coloracion del agua utilizamos un efecto
// atmosférico.

fog { distance 250 color SeaGreen   }

// La arena la definimos con un color Sienna, y con profundas
// ondulaciones de gran tamaño.

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

// ******************* Declaracion del erizo ****************

#declare erizo = object {
union {

// Calcularemos un paralelo de puas para cada valor de AngVert
// El primer valor será 0. (0 puas en la misma dirección del
// eje vertical.  El segundo valor serán una pocas puas
// situadas en el primero paralelo El máximo valor se
// conseguirá para AngVert == a 90 porque es la zona del
// ecuador donde cabe el máximo de puas.  Las puas en un mismo
// meridiano se calculan variando el ángulo 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


// El cuerpo es una esfera.
sphere { <0,0,0> RadioCuerpo
texture { TextureCuerpo }
}

} // end union
// Colocamos el erizo a la altura correcta.
translate y*CorreccionY

// Pero los erizos no son esféricos sino que tanto el cuerpo
// como el resto están achatados. Lo que hacemos es conservar
// la proporción en el eje Y aumentando las proporciones en X,
// y Z.  Multiplicándolas por 1.5

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

// Ya tenemos un erizo perfecto. Vamos a colocar unos cuantos
// En primero lugar establecemos una distancia mínima entre
// ellos.

#declare DistanciaMinima = 3 * (RadioCuerpo+LongitudMaximaPua)

// Vamos a disponerlos en un cuadrado de 5 * 5.  Para evitar
// que se vean como una formación excesivamente geométrica Los
// desplazamos ligeramente en horizontal con valores
// aleatorios.

#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

// Vamos ahora a colocar los peces. Usaremos un procedimiento
// muy parecido al utilizado para colocar los erizos. En este
// caso en lugar de disponerlos en un único cuadrado de 5 * 5
// los colocaremos en tres grupos de 4 * 4 En primero lugar
// establecemos una distancia mínima entre ellos.

#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

// Vamos a colocar a uno de ellos como si estuviera comiendo
// algo en el fondo.

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

/** Este nos puede servir para visualizar el pez completo *****

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

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

La luz de esta escena se consigue usando muchos puntos de luz para simular la iluminación subacuática caracterizada por el desorden introducido por el oleaje en superficie. Un solo foco de luz nos delataría en seguida porque la sombra del erizo en el fondo sería demasiado nítida.

Generación mediante programas externos.

Vamos a poner un ejemplo de lo estamos diciendo. Este programa está escrito en C y trata de lo siguiente. Define un espacio con las proporciones de la resolución empleada (1000*750). Una vez definida esta área, el programa trata de situar esferas en dicha área de forma aleatoria. Habrá que detectar que la posición generada no tiene cerca ninguna otra de las esferas ya generadas para evitar que se ínter-penetren. Para controlar esto vamos guardando la posición de cada esfera y su tamaño. Si la posición obtenida cae encima de una esfera ya existente probaremos en otro lugar. En caso contrario comprobamos cual es la distancia mínima al borde más cercano del resto de las esferas. Si es necesario reducimos el tamaño de la esfera para que pueda entrar. En esta ocasión la nueva esfera será menor que el tamaño inicial establecido y quedará en contacto con otra. Después de un elevado número de iteraciones obtendremos una superficie llena de esferas de distintos tamaños sin apenas espacios libres entre ellas. Estamos usando mucha fuerza bruta de cálculo porque cada vez el programa necesita más intentos para colocar una nueva esfera.

/////////(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.  

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

//-----------------------------------------------------------
//burbujas.c (1-Mayo-1998) */
//-----------------------------------------------------------
//Esta versión esta dedicada a su inclusión en la revista
//LinuxFocus
//-----------------------------------------------------------

  

/*************************************************************/ 
/** Compilar mediante 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;   /** Siguiente bola **/
          }
   }
   return; /** fallo nuevo intento **/
}

/****************************************/
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);
   }
}

Tenemos que tener paciencia, pero si vemos que pasa el tiempo y no hay avances podemos interrumpir el proceso. Bastará editar el fichero y comprobar que la última linea está entera y sino quitarla. El fuente pov será el siguiente:

/////////(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.
//////////////////////////////////////////////////////////////
  

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

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

// Esta versión esta dedicada a su inclusión en la revista Lin
// uxFocus
//------------------------------------------------------------

// Se recomienda usar el siguiente comando para la utilidad 'pov' 
// pov burbujas 6 9 1 4  
//              ^ ^ ^ ^  
//              | | | |  
// Resolucion __/ | | |  
// Calidad ____/  | | | 
// Desde Clock = 1 _/ |  
// Hasta Clock = 4 ___/  

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

// Por defecto max_trace_level vale 5 . Aumentado a 15
// conseguimos mayor nivel detalle en las imágenes recursivas
// generadas por reflejos

global_settings {
#max_trace_level 15
}

// Declaramos distintos puntos de vista y solo elegiremos
// finalmente una en función del valor 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

// Fuente de luz blanca
object {
  light_source {
  <100, 1000, 100>
  color White
  }
}

#declare textureBall = texture { Gold_Metal }

// El fichero include 'burbujas.inc' es un fichero obtenido
// mediante la salida de un programa escrito en lenguaje C.

#include "burbujas.inc"

Ya mencionamos en el artículo anterior que veríamos algunos ejemplos para comprobar las posibilidades de la cámara. Pues bien nos referíamos a este ejemplo. Podemos ver los distintos efectos de perspectiva conseguidos dependiendo de usar un ángulo muy pequeño desde muy lejos, o usar un ángulo muy abierto desde muy cerca. El máximo ángulo posible para la apertura del objetivo es 180. Es un caso extremo en el que no se distinguen las formas. Como puede verse un simple juego con la cámara puede producir efectos interesantes.

Los renders se han realizado en un Pentium 200 MMX 48 MB Ram (398 bogomips). Lo ejecutamos según se sugiere usando nuestra herramienta 'pov' con el comando siguiente:

Tiempo total = 4 horas y media.
Primer fotograma 2 minutos
Segundo fotograma 5 minutos.
Tercer fotograma 10 minutos
Cuarto fotograma 13 minutos
Quinto fotograma 4 horas !!

Veamos ahora los resultados. En primer lugar en los cuatro primeros fotogramas solo varia la cámara. (posición, angulo, dirrección, etc)

Falta un fotograma que lo mostraremos seguidamente pero antes vamos a tratar algunos temas en relación con este último fotograma.

Optimización del uso de la CPU

Como vemos, el último fotograma es el más complejo, y Povray no ha sabido optimizarlo. Cuando tenemos una figura compuesta, el trazador intenta determinar una figura más simple que lo envuelva.

Esto en versiones anteriores de Povray había que hacerlo siempre a mano. Se especificaba con la primitiva 'bounded_by' una forma que envolviera a uno o más objetos y de esta forma el trazador asumía que los rayos que no incidían en este en voltorio tampoco incidían en los objetos internos ahorrandose esa comprobación. Actualmente son poco frecuentes los casos donde una optimización manual resulte util, pero estamos precisamente ante uno de esos casos.

El último fotograma se corresponde con una figura compuesta excesivamente compleja. Por ello habría sido mejor o bien agrupar las burbujas por zonas bien delimitadas y combinarlas previamente en varias figuras compuestas para guiar así al optimizador o bien de combinarlas todas juntas en una como se hace en el ejemplo pero envolviendo grupos de esferas que esten en una zona bien delimitada usando 'bounded_by'. La sintaxisis sería:

Se puede aplicar no solo a uniones o intersecciones etc. sino a cualquier objeto, y se puede usar en 'bounded_by' una forma distinta para envolver aunque los mejores resultados los dan las esferas y las cajas.

Si la forma elegida deja fuera una parte del objeto el resultado puede ser defectuoso. Repito que la necesidad de hacer esto es muy rara. Este último ejemplo tenía muy mala idea y el optimizador de Povray no pudo hacer más. Se trata de un objeto compuesto con 2154 esferas. Puede contarlas en la imagen si no me cree. :-) La última imagen es el resultado de seguir jugando con las posibilidades del trazador de rayos.

Muchas veces a una misma idea se le pueden sacar muchas posibilidades y es aquí donde entra nuestra creatividad y nuestra imaginación. Es decir, que muchas veces no basta con partir de una buena idea sino que hay que seguir imaginando y jugando con distintas posibilidades hasta encontrar algo que nos guste.

Se pueden imaginar cantidad de escenarios en los que la programación puede servir de apoyo a la generación de imagenes sintéticas, estáticas o en movimiento.

Lo que se hecha de menos.

Povray proporciona muchas funciones matemáticas más o menos interesantes, pero hay una interesantísima que falta. Se trata de la una función spline. Nada hay más cómodo que trazar con lápiz y papel una serie de puntos y luego aplicar una función y obtener una curva que pase por esos puntos. La primitiva spline de Povray no puede usarse como función sino que genera una línea como base para construir formas, pero sería mucho mejor poder aplicar esa función a las variables que nosotros quisiéramos. De esta forma podríamos mover por ejemplo tanto objetos como la cámara siguiendo una trayectoria cualquiera. También sería bueno poder implementar funciones externamente.

Bueno de alguna manera todo eso se puede compensar usando includes y programación externa. Tenemos en Linux una utilidad llamada 'spline'. Se utiliza como un comando y genera la salida correspondiente a la curva deseada, a partir de una entrada que pueden ser parejas de puntos. Puede ser muy útil combinar este comando con el uso de la programación externa. Por ejemplo para obtener animaciones, o movimientos de cámara.

Diseñando estructuras iterativas en Povray

El arte y la técnica en la infografía.