Gaviones, un pequeño vídeo realizado con Povray.


En este artículo hablaré de un proyecto personal que realicé por simple diversión hace unos doce años. Se trata de un vídeo de animación 3D realizado con Povray y titulado ‘Gaviones’. En este artículo responderé a la pregunta de ¿Cómo se hizo?


Advierto que este artículo, a diferencia de la mayoría de mis artículos técnicos, va a tener escaso valor didáctico salvo para gente muy metida en estos temas que seguramente conocen otras formas mejores de conseguir los mismos resultados con menos esfuerzo, habida cuenta de que desde 1998 en que yo hice este vídeo, han ido apareciendo muchas utilidades infográficas que facilitan mucho el trabajo.

En este artículo solo describiré someramente el procedimiento empleado por mí, pero no pretende ser una lección de como se hacen este tipo de cosas ahora. Hablaré más extensamente sobre el uso de Povray en posteriores capítulos aportando un enfoque más didáctico que  en este ¿Cómo se hizo gaviones?.

Gaviones es una películita de unos dos minutos que yo hice con Povray hace como ya he dicho unos once años. Trabajé sin más ayuda que mis textos de matemáticas, programas de utilidades tipo modeladores para Povray y bastante programación en lenguaje C. No entraré en los detalles de programación, pero aquello fue tan artesanal y tan laborioso, que servirá para desmenuzar el mecanismo de la producción de vídeos con Povray.

En futuros artículos, intentaré proporcionar recetas prácticas que resuelvan problemas concretos. Este vídeo no fue diseñado con fines promocionales, pero no cabe duda que un vídeo de dos a cinco minutos colgado en YouTube, puede servir para promocionar un libro, y un toque de animación infográfica aunque solo sea una nave moviéndose, o un planeta girando, etc. pueden resultar muy adecuados. Este vídeo, aparte de demostrar lo machote y genial que es su inmodesto autor, sirve para ilustrar el potencial que tiene esta herramienta para generar vídeos infográficos.



Relieve del terreno generado con Terrain maker.
Relieve del terreno generado con Terrain maker. (Figura-1)









Image para pigmentación del terreno.
Imagen para pigmentación del terreno. (Figura-2)





arch1
Vista aérea del archipiélago. (Figura-3)







Cuadrícula auxiliar
Cuadrícula auxiliar (Figura-4)

proyección de la cuadrícula para estimar posiciones.
proyección de la cuadrícula para estimar posiciones. (Figura-5)

Escena sin olas en el agua y sin nubes en el cielo. (Figura-5)
Escena sin olas en el agua y sin nubes en el cielo. (Figura-6)

Escena con olas en el agua y nubes en el cielo. (Figura-7)
Escena con olas en el agua y nubes en el cielo. (Figura-7)

Otra perspectiva (Figura-8)
Otra perspectiva (Figura-8)

Añadimos algunos personajes en la playa. (Figura-9)
Añadimos algunos personajes en la playa. (Figura-9)

Gavion con dos pilotos (Figura-10)
Gavion con dos pilotos (Figura-10)

Vista lateral (Figura-11)
Vista lateral (Figura-11)

Detalle de la cabina. (Figura-12)
Detalle de la cabina. (Figura-12)

Para realizar un proyecto de este tipo, lo primero que hay que hacer es trabajar la idea sobre un guión perfectamente detallado. Una de las cosas más importantes es definir bien el entorno ambiental de la escena. Dicho entorno en mi caso sería un archipiélago, quizás situado en un planeta distinto del nuestro y habitado por extraños seres ciberdroides de tipo antropomorfo, capaces de viajar en unos vehículos ciberdroides con forma a mitad de camino entre aviones tipo planeadores, y gaviotas. A estos vehículos ciberdroides les he llamado gaviones.

Empecé dibujando un mapa, generé un terreno en relieve con una utilidad externa. Un modelador que recuerdo se llamaba Terrain maker, conformando una escena tipo archipiélago.Bastaba inundar un poco el terreno para conseguir dicho efecto. En la Figura-1 puede apreciarse como esta utilidad crea terreno realista mediante el efecto de una erosión simulada sobre dicho terreno.A ese terreno se le aplicó una capa de pigmentación mapeada sobre una imagen. Las partes costeras en amarillo para simular playas, las faldas de las montañas marrones, y las cumbres blancas por la nieve. No me interesó nunca lograr un efecto demasiado realista. Para poder ubicar los elementos en la escena, también usé una imagen auxiliar para usos ocasionales que me permitía cuadricular la escena.

Calculé unas rutas de vuelo para mis gaviones.  Su forma estaba a medio camino entre una gaviota y un avión tipo planeator. Situé a varios de estos gaviones tripulados por ciberdroides antropomorfos en dicha ruta. Los ciberdroides antropomorfos los generé con una utilidad externa, un modelador llamado Blob que al igual que Terrain maker generaba salida para Povray.

Primero filmé haciendo que la cámara de un gavíón apuntara al gavión de delante en la ruta, luego con la cámara apuntando al gavíon que viene detrás, también filmé clavando a una cámara fija suspendida en el aire a gran altura. Todos los gaviones volaban en formación siguiendo un par de rutas precisas que tenían una parte común. Los puntos de la ruta fueron calculados situando una serie de puntos de paso y luego interpolando con ayuda de un programa externo que generaba los puntos intermedios. Siempre usando coordenadas X,Y,Z en 3D. El movimiento de los gaviones tenía que ir girando el ángulo de cada gavión para que se orientara en dirección del movimiento. También había que girar lateralmente el gavión en las curvas para el efecto de peralte en la curva. Eso también lo calculaba mi programa realizado  en C. En aquel entonces trabajaba principalmente en Windows. El caso es que tuve que repasar trigonometría y cálculo vectorial

La cosa a grandes rasgos consistía en marcar una serie de puntos de tránsito. Luego un programa llamado animar.c interpolaba esos puntos generando una curva con tantos puntos intermedios como fotogramas tuviera el vídeo. Eso lo hacía llamando a un programa externo llamado spline que volcaba el resultado en un fichero temporal. Con esos nuevos datos hacía llamadas a un segundo programa escrito por mí en C y que lo que hacía era tomar todos los valores secuencialmente, para ir generando en un fichero include todas las variables de la escena sujetas a variación con los valores correspondientes a un determinado fotograma y con todo ello lanzaba el programa Povray.

No hice uso de una facilidad de Povray llamada ‘clock’, porque todavía estaba usando una versión de Povray que no la tenía implementada. Se trata de una variable que puede ir variando su valor y poniendo a otras variables en función de ella se puede establecer las posiciones y orientaciones nuevas de los objetos en cada fotograma. Muy útil.

Actualmente muchas de las cosas que yo implementé, ya han sido implementadas en forma de macros de uso general por Povray, pero no seguí su evolución de versión en versión y tendría que ponerme al día. Quizás lo haga. De todas formas el recurso de programar para obtener determinados efectos con Povray ofrece unas posibilidades ilimitadas y muy interesantes, pero las explicaciones que vienen a continuación solo interesarán a los más curiosos.

Yo partía de una serie de ficheros *.dat que contenían unos pocos puntos con coordenadas X,Y,Z del tipo siguiente:

0   35  140
-40   35  110
-100   30  110
-140   25   70
-140   20  -20
-80   15  -50
0   15    0
40   15   50
100   20   70
160   25   30
110   30  -10
50   35   10
0   30   50
-40   25   70
-80   20  110
-140   15   40
-70   15   20
-20   20   40
20   25   80
70   30  120
0    0    0

Estos datos se refieren a unas pruebas que realice previamente con una escena más sencilla. El resultado de interpolar estos 21 datos de coordenadas X,Y,Z me permitía obtener un mayor número de puntos (en este ejemplo 52 nuevos puntos) que definirán una curva más suave para la trayectoria gracias al uso de la función spline.

-23.051,      14.747,     -24.042
4.106,      14.964,       5.253
19.406,      14.674,      26.342
35.462,      14.799,      45.723
57.149,      16.262,      61.745
84.563,      18.735,      70.039
116.690,      21.161,      66.505
146.666,      23.159,      51.437
160.000,      25.000,      30.000
146.524,      26.958,       7.667
117.776,      29.315,      -8.130
90.232,      31.979,      -9.858
66.218,      34.260,      -0.879
44.331,      34.937,      14.610
22.763,      33.132,      33.779
0.000,      30.000,      50.000
-16.276,      27.929,      57.035
-32.538,      25.943,      64.670
-49.291,      23.749,      79.880
-66.088,      21.489,     101.172
-87.942,      19.339,     109.754
-121.689,      17.076,      85.498
-140.650,      15.349,      47.963
-127.532,      14.351,      26.678
-96.208,      14.205,      19.234
-63.292,      15.403,      21.067
-39.513,      17.589,      28.482
-20.000,      20.000,      40.000
-4.502,      21.899,      53.901
11.087,      23.826,      70.575
32.738,      26.748,      92.640
57.957,      29.790,     114.344
71.895,      28.444,     115.511
45.498,      13.882,      56.719
6.032,       0.712,       2.011
-1.805,       8.182,      40.548
7.092,      28.329,     125.026
-5.595,      35.858,     136.662
-21.029,      36.038,     122.848
-40.000,      35.000,     110.000
-67.277,      32.980,     107.910
-93.822,      30.622,     110.737
-114.466,      28.391,     103.315
-130.616,      26.335,      86.310
-144.257,      24.341,      59.756
-151.404,      22.271,      17.636
-140.000,      20.000,     -20.000
-119.730,      17.828,     -38.348
-93.591,      15.740,     -48.663
-59.674,      14.473,     -46.338

Mi programa no se limitaba a calcular las nuevas posiciones, también calculaba la nueva posición y la orientación. Normalmente generaba una nueva posición por fotograma, pero una opción de mi programa permitía generar los nuevos objetos para ser visualizados simultáneamente en un solo fotograma. El fichero include generado por mi programa para este ejemplo fue el siguiente:

#declare AvionTest = object{
intersection{
object { Cone_Z scale <4, 4, 2>  }
box    { <-4, 1, -4> <4, 2.5, 8> }
}
pigment { Grey }
finish{
ambient 0.2
diffuse 0.2
reflection 0.6
specular 0.4
}
}
object { AvionTest  rotate <0, 0, 3.634886> rotate <0.702329, 47.189268, 0> translate <    -23.051,      14.747,     -24.042> }
object { AvionTest  rotate <0, 0, 0.592125> rotate <-0.555349, 36.636678, 0> translate <      4.106,      14.964,       5.253> }
object { AvionTest  rotate <0, 0, -1.980078> rotate <-0.376085, 36.745914, 0> translate <     19.406,      14.674,      26.342> }
object { AvionTest  rotate <0, 0, -4.779159> rotate <1.844206, 46.694539, 0> translate <     35.462,      14.799,      45.723> }
object { AvionTest  rotate <0, 0, -5.660776> rotate <4.613240, 65.146248, 0> translate <     57.149,      16.262,      61.745> }
object { AvionTest  rotate <0, 0, -6.501959> rotate <4.850674, 87.077278, 0> translate <     84.563,      18.735,      70.039> }
object { AvionTest  rotate <0, 0, -5.307832> rotate <3.481664, 109.348226, 0> translate <    116.690,      21.161,      66.505> }
object { AvionTest  rotate <0, 0, -11.846201> rotate <3.580072, 131.998730, 0> translate <    146.666,      23.159,      51.437> }
object { AvionTest  rotate <0, 0, -14.536922> rotate <4.574525, -169.698320, 0> translate <    160.000,      25.000,      30.000> }
object { AvionTest  rotate <0, 0, -6.238875> rotate <3.852216, -127.575881, 0> translate <    146.524,      26.958,       7.667> }
object { AvionTest  rotate <0, 0, -7.665056> rotate <4.898304, -103.519976, 0> translate <    117.776,      29.315,      -8.130> }
object { AvionTest  rotate <0, 0, -5.430717> rotate <5.758446, -76.905089, 0> translate <     90.232,      31.979,      -9.858> }
object { AvionTest  rotate <0, 0, -3.154625> rotate <3.294735, -59.134744, 0> translate <     66.218,      34.260,      -0.879> }
object { AvionTest  rotate <0, 0, -0.644912> rotate <-1.923112, -49.056616, 0> translate <     44.331,      34.937,      14.610> }
object { AvionTest  rotate <0, 0, 3.102527> rotate <-5.769572, -50.004692, 0> translate <     22.763,      33.132,      33.779> }
object { AvionTest  rotate <0, 0, 2.026612> rotate <-6.774945, -64.034799, 0> translate <      0.000,      30.000,      50.000> }
object { AvionTest  rotate <0, 0, -1.958745> rotate <-6.451204, -67.803745, 0> translate <    -16.276,      27.929,      57.035> }
object { AvionTest  rotate <0, 0, -5.978000> rotate <-5.975413, -56.929543, 0> translate <    -32.538,      25.943,      64.670> }
object { AvionTest  rotate <0, 0, 0.005891> rotate <-4.858050, -37.762157, 0> translate <    -49.291,      23.749,      79.880> }
object { AvionTest  rotate <0, 0, 13.004348> rotate <-4.939931, -46.885893, 0> translate <    -66.088,      21.489,     101.172> }
object { AvionTest  rotate <0, 0, 10.845708> rotate <-3.917471, -110.127395, 0> translate <    -87.942,      19.339,     109.754> }
object { AvionTest  rotate <0, 0, 7.622034> rotate <-2.348607, -142.690937, 0> translate <   -121.689,      17.076,      85.498> }
object { AvionTest  rotate <0, 0, 21.184113> rotate <-2.501944, 175.333433, 0> translate <   -140.650,      15.349,      47.963> }
object { AvionTest  rotate <0, 0, 6.829816> rotate <-1.034799, 113.008959, 0> translate <   -127.532,      14.351,      26.678> }
object { AvionTest  rotate <0, 0, 3.987158> rotate <1.027910, 91.967202, 0> translate <    -96.208,      14.205,      19.234> }
object { AvionTest  rotate <0, 0, 3.640510> rotate <4.155605, 77.597784, 0> translate <    -63.292,      15.403,      21.067> }
object { AvionTest  rotate <0, 0, 3.499941> rotate <6.040489, 64.223413, 0> translate <    -39.513,      17.589,      28.482> }
object { AvionTest  rotate <0, 0, 2.570299> rotate <5.597266, 51.582124, 0> translate <    -20.000,      20.000,      40.000> }
object { AvionTest  rotate <0, 0, 0.631126> rotate <4.791987, 43.868783, 0> translate <     -4.502,      21.899,      53.901> }
object { AvionTest  rotate <0, 0, -0.866231> rotate <5.070838, 43.068491, 0> translate <     11.087,      23.826,      70.575> }
object { AvionTest  rotate <0, 0, -1.700368> rotate <5.615108, 46.915411, 0> translate <     32.738,      26.748,      92.640> }
object { AvionTest  rotate <0, 0, -14.173703> rotate <3.419250, 56.631078, 0> translate <     57.957,      29.790,     114.344> }
object { AvionTest  rotate <0, 0, -6.732610> rotate <-14.597245, -166.150921, 0> translate <     71.895,      28.444,     115.511> }
object { AvionTest  rotate <0, 0, -3.441627> rotate <-11.494915, -148.901502, 0> translate <     45.498,      13.882,      56.719> }
object { AvionTest  rotate <0, 0, -58.049326> rotate <-6.388839, -108.437627, 0> translate <      6.032,       0.712,       2.011> }
object { AvionTest  rotate <0, 0, 0.516846> rotate <12.272273, 7.154983, 0> translate <     -1.805,       8.182,      40.548> }
object { AvionTest  rotate <0, 0, 57.617709> rotate <18.407108, -8.387305, 0> translate <      7.092,      28.329,     125.026> }
object { AvionTest  rotate <0, 0, 1.389890> rotate <2.741509, -130.132130, 0> translate <     -5.595,      35.858,     136.662> }
object { AvionTest  rotate <0, 0, -4.071064> rotate <-1.772367, -130.078422, 0> translate <    -21.029,      36.038,     122.848> }
object { AvionTest  rotate <0, 0, -9.410828> rotate <-3.772218, -106.750143, 0> translate <    -40.000,      35.000,     110.000> }
object { AvionTest  rotate <0, 0, 1.093648> rotate <-4.685517, -81.802957, 0> translate <    -67.277,      32.980,     107.910> }
object { AvionTest  rotate <0, 0, 9.871111> rotate <-5.713235, -96.802582, 0> translate <    -93.822,      30.622,     110.737> }
object { AvionTest  rotate <0, 0, 5.483623> rotate <-5.382397, -128.847087, 0> translate <   -114.466,      28.391,     103.315> }
object { AvionTest  rotate <0, 0, 3.514067> rotate <-4.332137, -146.783603, 0> translate <   -130.616,      26.335,      86.310> }
object { AvionTest  rotate <0, 0, 5.630125> rotate <-3.011548, -162.573370, 0> translate <   -144.257,      24.341,      59.756> }
object { AvionTest  rotate <0, 0, 8.412480> rotate <-2.758416, 174.982061, 0> translate <   -151.404,      22.271,      17.636> }
object { AvionTest  rotate <0, 0, 6.552696> rotate <-4.293617, 141.238867, 0> translate <   -140.000,      20.000,     -20.000> }
object { AvionTest  rotate <0, 0, 5.268344> rotate <-4.550705, 118.868940, 0> translate <   -119.730,      17.828,     -38.348> }
object { AvionTest  rotate <0, 0, 7.688336> rotate <-3.378126, 98.589015, 0> translate <    -93.591,      15.740,     -48.663> }
object { AvionTest  rotate <0, 0, 6.388699> rotate <-0.227275, 67.443258, 0> translate <    -59.674,      14.473,     -46.338> }

Este es un ejemplo para un único objeto. En la escena con gaviones, había varios objetos con movimientos independientes. Por ejemplo establecí una secuencia para el movimiento de las alas que batían de vez en cuando. Igualmente hice algunas escenas en tierra, en una playita de ese archipiélago haciendo tomas desde tierra a los gaviones, y desde los gaviones a tierra. Hice algunas tomas más, acercando la cámara a puntos que me interesaban. Coordiné el giro de la cabeza de un ciberdroide antropomorfo para que siguiera la cámara. Luego del conjunto de todas estas escenas, hice un montaje. Cada escena requería generar un fichero en el cual existía una cabecera con una lista de variables, seguida de tantas líneas como fotogramas se tenían que generar. En cada línea aparecía un valor para cada una de las variables de cabecera. El fichero quedaba de esta forma:

ARCH.POV
ACT_FRAME NUM_FRAMES  RUTA2_GAV01_X RUTA2_GAV01_Y RUTA2_GAV01_Z RUTA2_GAV01_DIST RUTA2_GAV01_ANG_VERT RUTA2_GAV01_ANG_BRUJULA RUTA2_GAV01_ANG_PERALTE RUTA1_GAV02_X RUTA1_GAV02_Y RUTA1_GAV02_Z RUTA1_GAV02_DIST RUTA1_GAV02_ANG_VERT RUTA1_GAV02_ANG_BRUJULA RUTA1_GAV02_ANG_PERALTE RUTA2_GAV03_X RUTA2_GAV03_Y RUTA2_GAV03_Z RUTA2_GAV03_DIST RUTA2_GAV03_ANG_VERT RUTA2_GAV03_ANG_BRUJULA RUTA2_GAV03_ANG_PERALTE RUTA1_PTOMIRA_X RUTA1_PTOMIRA_Y RUTA1_PTOMIRA_Z RUTA1_PTOMIRA_DIST RUTA1_PTOMIRA_ANG_VERT RUTA1_PTOMIRA_ANG_BRUJULA RUTA1_PTOMIRA_ANG_PERALTE RUTA1_GAV04_X RUTA1_GAV04_Y RUTA1_GAV04_Z RUTA1_GAV04_DIST RUTA1_GAV04_ANG_VERT RUTA1_GAV04_ANG_BRUJULA RUTA1_GAV04_ANG_PERALTE RUTA1_GAV05_X RUTA1_GAV05_Y RUTA1_GAV05_Z RUTA1_GAV05_DIST RUTA1_GAV05_ANG_VERT RUTA1_GAV05_ANG_BRUJULA RUTA1_GAV05_ANG_PERALTE RUTA1_GAVX1_X RUTA1_GAVX1_Y RUTA1_GAVX1_Z RUTA1_GAVX1_DIST RUTA1_GAVX1_ANG_VERT RUTA1_GAVX1_ANG_BRUJULA RUTA1_GAVX1_ANG_PERALTE RUTA1_GAVX2_X RUTA1_GAVX2_Y RUTA1_GAVX2_Z RUTA1_GAVX2_DIST RUTA1_GAVX2_ANG_VERT RUTA1_GAVX2_ANG_BRUJULA RUTA1_GAVX2_ANG_PERALTE ALA_IZ1 ALA_DE1 ALA_IZ2 ALA_DE2 ALA_IZ3 ALA_DE3 ALA_IZ4 ALA_DE4
1 500        0.953       0.300       0.513     0.014   0.82   8.49  11.65       0.810       0.347       0.306     0.012 -15.10  56.97   9.99       0.557       0.296       0.207     0.011 -16.70  52.37 -20.16       0.557       0.445       0.206     0.011 -29.45  55.63 -16.64       0.642       0.692      -0.273     0.030 -16.95 -17.33   5.02       0.655       0.707      -0.730     0.021  16.43  11.99   5.42       0.399       0.202       0.486     0.014   8.33 -173.13  -6.27       0.399       0.180       0.738     0.012   0.97 -177.54   3.71               10               -10                10               -10                10               -10                10               -10
2 500        0.955       0.300       0.527     0.014   1.18   5.89  11.04       0.820       0.344       0.313     0.012 -14.86  54.69   9.80       0.565       0.293       0.213     0.011 -13.31  56.94 -17.07       0.565       0.439       0.211     0.011 -27.95  59.75 -13.68       0.634       0.684      -0.246     0.030 -18.04 -18.64   3.78       0.659       0.713      -0.711     0.021  14.36  10.76   5.36       0.397       0.204       0.472     0.014   8.45 -171.68  -6.03       0.399       0.180       0.726     0.012   1.43 -178.44   3.30          7.63912          -7.63912           17.1701          -17.1701           9.99995          -9.99995           10.0138          -10.0138
3 500        0.956       0.301       0.541     0.014   1.47   3.42  10.44       0.830       0.340       0.319     0.012 -14.58  52.47   9.64       0.574       0.291       0.219     0.011 -10.20  60.83 -14.24       0.573       0.434       0.216     0.012 -26.52  63.14 -11.12       0.625       0.674      -0.219     0.030 -19.04 -19.67   2.61       0.663       0.718      -0.691     0.021  12.35   9.54   5.32       0.395       0.206       0.458     0.014   8.51 -170.30  -5.83       0.398       0.181       0.714     0.012   1.87 -179.26   2.87          5.43539          -5.43539           23.4094          -23.4094           9.99984          -9.99984           10.0243          -10.0243

En realidad el fichero era mucho más largo. En total contenía datos para generar 500 fotogramas. Luego a cada invocación del programa trazador de rayos se generaba un fichero include que cotenía todas esas variables con el valor correspondiente a un fotograma. Los valores para el último fotograma eran estos:

/** ruta.INC (500/500) **/
#declare ACT_FRAME=500.000000
#declare NUM_FRAMES=500.000000
#declare RUTA2_GAV01_X=0.950000
#declare RUTA2_GAV01_Y=0.300000
#declare RUTA2_GAV01_Z=0.500000
#declare RUTA2_GAV01_DIST=0.014000
#declare RUTA2_GAV01_ANG_VERT=0.380000
#declare RUTA2_GAV01_ANG_BRUJULA=11.220000
#declare RUTA2_GAV01_ANG_PERALTE=12.240000
#declare RUTA1_GAV02_X=0.800000
#declare RUTA1_GAV02_Y=0.350000
#declare RUTA1_GAV02_Z=0.300000
#declare RUTA1_GAV02_DIST=0.012000
#declare RUTA1_GAV02_ANG_VERT=-15.310000
#declare RUTA1_GAV02_ANG_BRUJULA=59.290001
#declare RUTA1_GAV02_ANG_PERALTE=10.200000
#declare RUTA2_GAV03_X=0.550000
#declare RUTA2_GAV03_Y=0.300000
#declare RUTA2_GAV03_Z=0.200000
#declare RUTA2_GAV03_DIST=0.011000
#declare RUTA2_GAV03_ANG_VERT=-20.270000
#declare RUTA2_GAV03_ANG_BRUJULA=47.080002
#declare RUTA2_GAV03_ANG_PERALTE=-23.480000
#declare RUTA1_PTOMIRA_X=0.550000
#declare RUTA1_PTOMIRA_Y=0.450000
#declare RUTA1_PTOMIRA_Z=0.200000
#declare RUTA1_PTOMIRA_DIST=0.011000
#declare RUTA1_PTOMIRA_ANG_VERT=-30.940001
#declare RUTA1_PTOMIRA_ANG_BRUJULA=50.709999
#declare RUTA1_PTOMIRA_ANG_PERALTE=-20.040001
#declare RUTA1_GAV04_X=0.650000
#declare RUTA1_GAV04_Y=0.700000
#declare RUTA1_GAV04_Z=-0.300000
#declare RUTA1_GAV04_DIST=0.029000
#declare RUTA1_GAV04_ANG_VERT=-15.740000
#declare RUTA1_GAV04_ANG_BRUJULA=-15.690000
#declare RUTA1_GAV04_ANG_PERALTE=6.360000
#declare RUTA1_GAV05_X=0.650000
#declare RUTA1_GAV05_Y=0.700000
#declare RUTA1_GAV05_Z=-0.750000
#declare RUTA1_GAV05_DIST=0.021000
#declare RUTA1_GAV05_ANG_VERT=18.549999
#declare RUTA1_GAV05_ANG_BRUJULA=13.230000
#declare RUTA1_GAV05_ANG_PERALTE=5.490000
#declare RUTA1_GAVX1_X=0.400000
#declare RUTA1_GAVX1_Y=0.200000
#declare RUTA1_GAVX1_Z=0.500000
#declare RUTA1_GAVX1_DIST=0.014000
#declare RUTA1_GAVX1_ANG_VERT=8.140000
#declare RUTA1_GAVX1_ANG_BRUJULA=-174.630005
#declare RUTA1_GAVX1_ANG_PERALTE=-6.520000
#declare RUTA1_GAVX2_X=0.400000
#declare RUTA1_GAVX2_Y=0.180000
#declare RUTA1_GAVX2_Z=0.750000
#declare RUTA1_GAVX2_DIST=0.012000
#declare RUTA1_GAVX2_ANG_VERT=0.520000
#declare RUTA1_GAVX2_ANG_BRUJULA=-176.539993
#declare RUTA1_GAVX2_ANG_PERALTE=4.090000
#declare ALA_IZ1=10.000000
#declare ALA_DE1=-10.000000
#declare ALA_IZ2=23.724400
#declare ALA_DE2=-23.724400
#declare ALA_IZ3=9.999480
#declare ALA_DE3=-9.999480
#declare ALA_IZ4=10.000000
#declare ALA_DE4=-10.000000

Estamos hablando de hace once años. El cálculo de cada fotograma era muy costoso y por ello tuve que reducir la calidad y la resolución del vídeo. Son imágenes con solo 256 colores. Con los medios actuales los resultados habrían sido mejores. Para que se comprenda cual era la situación hace once años, yo hice que mi ordenador al arrancar lanzara un programa que consultaba que fotograma tocaba generar y empezaba a funcionar donde lo dejó la última vez. De esa forma me fui de vacaciones un mes entero dejando el ordenador encendido y trabajando, para que en caso de cortes ocasionales de luz, solo interrumpían momentáneamente la secuencia de trabajo. Fue un proyecto que me llevo muchísimo trabajo y funcionaba en Windows. Yo ahora uso Linux para el 99% de las cosas que hago. Volver a poner en marcha el proyecto me costaría mucho. Ya avisé de que este artículo no tenía un propósito didáctico. Es un mero testimonio de como hice algo hace años con una limitación de medios importante.

Una cosa que si me interesa resaltar es que son muchos los programas capaces de generar código para Povray y que diseñar un programa con un propósito específico que genere código Povray no tiene porque ser complicado. Algunas de las cosas que yo hice quizás ya no sea necesario hacerlas así, pero en cualquier caso, ya lo dije antes pero insisto, la programación combinada con Povray es algo muy recomendable y con posibilidades muy interesantes.

Share

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

*