Foto-blog de Antonio Castro

Retoque fotográfico con Gimp, fotos copyleyft, licencia Creative Commons (CC-BY), fotos gratis para uso comercial con reconocimiento.

Macrofotografía abeja

Etiqueta: Povray Página 1 de 6

Como hacer scrolling para créditos finales. (Tutorial avanzado)

Imagen para el scroll.

Imagen para el scroll.

La mayoría de mis tutoriales son para usuarios noveles, pero de vez en cuando me gusta incluir alguna cosilla con algo más de chicha. Este es el caso.

Trataré de explicar como se hizo el final de uno de mis vídeos.

Ignoro como harán los demás las cosas, porque en el tema de edición y producción de vídeo hay auténticas maravillas de software, pero yo me limito a usar Software Libre.

Muchas veces me apaño usando scripts propios. Eso me da mucha flexibilidad y me permite ir construyendo poco a poco una librería de recursos de software que iré compartiendo con vosotros.

Esta vez no nos vamos a conformar con añadir un scrolling. Vamos a construir un final en tres partes: Un fundido previo, un efecto 3D y un scrolling con los créditos.

1) Preparación previa al scrolling:

Mi técnica de scrolling consiste en meter todo lo que necesito para el scrolling en una imagen alargada verticalmente.

La imagen debe tener el mismo ancho que el ancho de la imagen de la película. En nuestro caso usamos HD 720p. Es decir  1280×720. Así que el ancho será 1280 pixels.

Yo he usado Gimp para eso.

Quedará como la imagen de la izquierda.

2) Fundido previo:

Tomaremos una imagen de 1280×720 recortando la parte superior. Yo usé gThumb para eso.

Guardamos esta imagen con el nombre de ‘Fin04.jpg’. Sacamos una copia que llamaremos  ‘FinAux.jpg’ y la editamos suprimendo todo excepto el título.

También tomamos la última imagen de la película y la copiamos con el nombre de ‘Fin01.jpg’. La abrimos con Gimp y cargamos ‘FinAux.jpg’. Superponemos ambas inmágenes. (Yo lo hice pasando el negro a a blanco, conviertiéndo el blanco en transparente con la opción clolores -> color a alfa y luego desde editar copie y pegué sobre ‘Fin01.jpg’ y salve con el nombre de ‘Fin02.jpg’.

La imágenes a las que acabo de referirme son estas:

Fin01

Fin01.jpg

Fin02

Fin02.jpg

Fin04

Fin04.jpg

FinAux

FinAux.jpg

(No existe ninguna imagen ‘Fin03.jpg’ porque decidí  no incluirla en el fundido y la renombré como ‘FinAux.jpg’)

Ahora para hacer una transición fundiendo secuencialmente estas imágenes ejecuto un script muy sencillito que hace uso de la opción ‘-morph‘ de la utilidad ‘convert’ de ‘ImageMagick’ de la que hemos hablado en otras ocasiones.

Nos genera un directorio con los fotogramas. Estos pueden compilarse usando la utilidad ‘ffmpeg’. (Yo uso un script propio ‘dirs2vid.py’ del que ya hablaré en otra ocasión y que es muy similar a otro que ya mencioné como ‘dir2avi.py‘ descrito aquí.)

#!/bin/bash
rm -fr morph 2> /dev/null
rm morph.avi 2> /dev/null
mkdir morph
convert -morph 25 Fin0?.jpg morph/FIN%04d.JPG
dirs2vid.py -exif -out=FIN.avi morph

Con esto ya tenemos el fundido.

3) Preparar un bonito efecto de explosión invertida en 3D para nuestro logo:

Esto obviamente es una filigrana opcional, pero dar al logo una presentación variada es una idea que permite aumentar la atención sobre él y con esta costumbre iremos reforzando la imagen de la marca de nuestro sitio. Uno de los sitios que practica esta idea es Google a pesar de que ya tiene una imagen de marca potente.

Para ello recurrimos al trazador de rayos PovRay del cual ya hemos tratado ampliamente en otros artículos. Para no extendernos me limito a copiar el fuente.

[…]

Vemos cerca del final dentro de la cláusula object un #include «Explode.inc» Que llama al fichero que realiza la explosión de objetos.

Este include se proporciona como una utilidad para PovRay. Su autor es Chris Colefax. ‘OBJECT EXPLODER INCLUDE FILE for Persistence of Vision 3.x’

Usando nuestro lanzador PovRay usaríamos el comando:

pov.py Logo3_ j 11 11 1 500 0 4

Esto generará 500 fotogramas (‘Logo3_001.jpg’ … ‘Logo3_500.jpg’) haciendo variar el valor de clock entre 0 y 4.

Dado que en el fuente Povray hemos omitido el fondo, este aparecerá en negro.

Podemos obtener fotogramas en png con el fondo transparente reconvirtiendo esos fichros con mogrify de ImageMagick.

mogrify -format png -transparent black Logo3_???.jpg

De esa forma ya queda preparado para poder superponer esos fotogramas con fondo transparente sobre los fotogramas de nuestro scrolling. Para ello hacemos un script que genere el scrolling del texto y que superonga los fotogramas 3D que hemos generado en los fotogramas finales de nuestro scrolling.

#!/usr/bin/python
# -*- coding: latin1 -*-
import os, sys
################
def comando(comm):
print comm
os.system(comm)
######## MAIN ##########
comando ("mkdir fot1 fot2")
Top=1501
Ini3D=650
for n in range(1,Top):
comando("convert scroll.jpg -crop 1280x720+0+%d fot1/%04d.jpg" % (n, n))
m=0
# Añadir logo 3D
for n in range(1, Top):
if (n

Para finalizar juntamos el primer fundido con el vídeo de scroll que acabamos de generar ahora y ya está completo.
Puedes ver a continuación uno de los fotogramas generados.

Un fotograma del final del scrolling.

Un fotograma del final del scrolling.

El resultado completo puede verse en los créditos, al final del vídeo, de  LasVentas TML Noct 2011.

Curioso fractal en 3D (Povray)

La he llamado «bola hexaédrica recursiva», porque no sabría qué otro nombre dar a esto tan raro.

Es una forma inesperada surgida de unas pruebas que hice. Me ha sorprendido el resultado. Cada bola da origen a otras seis bolas más pequeñas. De ahí el nombre, pero he intentado hacer algo similar usando un patrón tetraédrico y el resultado no es ni de lejos tan llamativo como este. Supongo que la gente que diseña fractales hace pruebas hasta que obtiene algún resultado curioso. Este sin duda lo es.

El vídeo está pensado para que se comprenda como surge la forma final. Sólo dura 1min y 16 segundos.

La macro recursiva que genera la forma es bastante sencilla y se ha implementado en un fichero include.

// hexarec.inc
// (C) Antonio Castro Snurmacher
// Licencia GPL de GNU
#declare NullObj=object{ sphere{<0,0,0>,0.00000000001} pigment {color rgb <0,0,0>} }
#macro Hexa(K, Level, T1, T2)
union{
object{
sphere {<0,0,0>, 1}
texture {T1}
}
#if (Level>0)
object{ Hexa(K, Level-1, T2, T1) scale K translate x }
object{ Hexa(K, Level-1, T2, T1) scale K translate -x }
object{ Hexa(K, Level-1, T2, T1) scale K translate y }
object{ Hexa(K, Level-1, T2, T1) scale K translate -y }
object{ Hexa(K, Level-1, T2, T1) scale K translate z }
object{ Hexa(K, Level-1, T2, T1) scale K translate -z }
#else
object {NullObj}
#end
}
#end

El programa principal que llama a esa macro recursiva, se complica algo con el fin de introducir algunas optimizaciones, sentencias para la animación y algunas mejoras estéticas. Es este:

// demo_hexarec.pov
// (C) Antonio Castro Snurmacher
// Licencia GPL de GNU
#include "hexarec.inc"
#include "colors.inc"
#include "textures.inc"
#include "shapes.inc"
#declare Oliva = pigment {color rgb <0, 0.5, 0.3>} // Verde oliva oscuro
#declare Azul = pigment {color rgb <.2, 0.6, 0.9>}
#declare AmarilloClaro = pigment {color rgb <1,1, 0.6>}
#declare RojoOscuro = pigment {color rgb <.7, 0, 0.1>} // Rojo oscuro
#declare Blanco = pigment {color rgb <.9,.9,.95>} // Blanco azulado
#declare Textu1=texture{
pigment {RojoOscuro}
finish{
reflection .4
ambient 0.2
diffuse 0.4
phong .4
phong_size 40
}
}
#declare Textu2=texture{
pigment {Blanco}
finish{
reflection 0
ambient 0.3
diffuse 0.7
phong .5
phong_size 20
}
}
#declare Textu3=texture{
pigment {AmarilloClaro}
finish{
reflection 0
ambient 0.3
diffuse 0.7
phong .5
phong_size 20
}
}
#declare Textu4=texture{
pigment {Azul}
finish{
reflection .6
ambient 0.1
diffuse 0.3
}
}
#declare Luz=light_source { <30, 40, -60> color White }
#declare CameraUp= camera {
location <0, 10, -40>
look_at <0,0,0>
angle 65
// AspectRatio debe declararse en el '.ini'
// Su valor es el ancho/alto y normalmente valdrá 16/9 o 4/3
right AspectRatio*x
}
/**
Pensado para clock 1..1900
pov.py demo_hexarec t 11 11 1 1900 1 1900
**/
// En el intervalo de clock de 0 a 1000 va aumentando la recursividad luego ya no.
#declare Clock1 = clock/2000;
#declare Clock2=clock/2;
global_settings { charset utf8 }
#declare FontSize = 3;
#declare FonTTF = "aa_cooperbt.ttf"
#declare texto="CIBERDROIDE.COM"
#declare Clock3 = clock -1000;
#if (Clock3<0) #declare Clock3=0; #end #if (Clock3>0)
#declare PosText=19-(Clock3/12);
text { ttf FonTTF texto 1, 0
texture { Textu4 }
scale FontSize
translate // clock*??
}
text { ttf FonTTF texto 1, 0
texture { Textu3 }
scale
translate // clock*??
}
#end
/** Ajustar la recursividad al nivel de detalle requerido para
acelerar los primeros fotogramas. **/
#declare K=7;
#if (Clock1>.5)
#declare Clock1=.5;
#end
#if (Clock1<.4) #declare K=6; #end #if (Clock1<.3) #declare K=5; #end #if (Clock1<.2) #declare K=4; #end #if (Clock1<.1) #declare K=3; #end object{ Hexa(Clock1, K, Textu1, Textu2) /** LLAMADA A LA MACRO RECURSIVA **/ rotate y*Clock2 scale 8 } camera {CameraUp} Luz

El fichero ttf con la fuente "aa_cooperbt.ttf" no se proporciona, pero se puede usar cualquier fuente ttf.

Es la primera vez que usamos en la primitiva text. Como puedes ver en el fuente, su uso es trivial, y no hay ninguna otra cuestión técnica que hayamos mencionado anteriormente. En cualquier caso si tienes dudas no tienes más que preguntar aquí en los comentarios.

Escena navideña en Povray (Tutorial)

'demo_navidad.pov' Para luz a medio día.

'demo_navidad.pov' Para luz a medio día.

En esta última entrega de nuestra serie navideña, hemos armado una bonita escena (espero que os guste) recurriendo a los recursos que hemos ido construyendo en los últimos artículos. Con ella finalizamos esta serie navideña.

Podemos apreciar lo enriquecedor que resulta usar las iteraciones y la recursividad para crear una escena. Hemos colocado quince pinos. Se podrían haber puesto tantos como quisiéramos, pero el consumo de CPU ya es suficientemente importante. ¿Te has parado a pensar cuantas diminutas púas de pino están definidas en la escena? En efecto, son un montón.

La parte de los árboles debe de ser comentada si queremos hacer pruebas para ajustar otros elementos de la escena, porque ellos solos consumen mucha CPU. Les hemos cargado de bolas ornamentales y les hemos puesto un tiesto.

Jugamos con el realismo y la ficción. La escena sugiere que tiene lugar al aire libre (por el cielo y los efectos atmosféricos), pero hemos usado un suelo de mármol rojo (privilegio de un creador caprichoso) Lo hice así porque me gustó como destacaba con el verde de los pinos.

No nos hemos limitado a recopilar el material presentado en artículos anteriores. En esta escena hemos añadido alguna cosilla nueva, y como de costumbre aprovecharemos para comentarla. Por algo llamamos a esto tutorial. La idea es aprender cada vez alguna cosilla suelta. De esta forma, el día que necesites algo dispondrás de un ejemplo completo para reutilizar lo que te convenga.

En esta ocasión aprovecharemos para aprender un poco, el tema de las nubes y de la niebla baja.

Para ello empezaremos comentando algunas sentencias.

color_map:
Esta sentencia se usa en la definición de muchos diseños de color. Por ejemplo: agate, bozo, granite, leopard, marble, onion, spotted, wood, gradiente, crackle, … Sin duda merece mucho la pena jugar con ella y aprender a usarla. Aquí la usamos para el cielo. ¿Serías capaz de cambiar el cielo a tu gusto modificando esta sentencia? Te vamos ayudar con dos ejemplos de cielo para la misma escena.

Puede que no sepas que a pesar de no haberla comentado antes, no es la primera vez que usamos ‘color_map’.

En ‘Exploración espacial’ (parte 4): La nave, ya habíamos usado ‘color_map’ para crear un patrón de colorido de tipo ‘crackle’, pero no habíamos explicado en qué consiste ‘color_map’.

El diseño de colores se hace en base a una tabla que se define para valores comprendidos entre 0 y 1. Ponemos como ejemplo el ‘color_map’ de ‘Exploración espacial’ (parte 4): La nave.
#declare ColorMap = color_map {
[0.0 color rgb <0.1,0,0.1>]
[0.02 color <0.3,0.2,0.2>]
[0.15 color <0.5, 0.4, 0.3>]
[1.0 color <0.6, 0.4, 0.6>]
}
#declare Crackle = texture {
pigment { crackle
color_map { ColorMap }
scale 20
}
}

crackle:
Usando la sentencia ‘crackle’ estamos indicando que los colores se reparten adoptando formas poliédricas irregulares. En el patrón anterior se ve que en 0.0 hemos asociado un color que es casi negro, y muy próximo a él, en 0,02 un valor considerablemente más claro para que queden lineas oscuras delgadas resaltando los polígonos tal y como puede verse a continuación.

Nave espacial sobre un fondo crackle.

Nave espacial sobre un fondo crackle.

bozo:
Usando la sentencia ‘bozo’ el color se reparte usando una función tipo ruido aleatorio donde puntos cercanos tienen valores similares. Esta función podrás encontrarla con el nombre de plasma. Es muy útil y usando variaciones de la misma sirve para un montón de cosas diferentes.

turbulence:
La sentencia turbulence indica alteración de la distribución de los colores mediante aplicación de efectos de distorsión por aremolinamiento aleatorio. Su acción será similar a la agitación de un fluido, y su efecto será más o menos pronunciado dependiendo del valor introducido a continuación de la palabra turbulence.

Definiendo nuestro cielo de dos formas diferentes:

Para las nubes de la escena navideña hemos definido nuestra propia textura para el cielo en lugar de tomar una de la librería de Povray. No es difícil hacerlo, y como ves han quedado bastante realistas.

Recordemos que ‘rgb .95’ es una forma abreviada de indicar el color cuando sus componentes R,G,B tienen el mismo valor. ‘rgb .95’ equivale a ‘rgb <0.95, 0.95, 0.95>’ (casi blanco).
Vemos una amplia zona azul entre 0.00 y 0.45, y en el resto algunas gamas de blanco más o menos gris.

Nosotros hemos usado una variable ‘Ocaso’ para ilustrar en el mismo fuente dos ejemplos distintos. Uno de ellos con luz de día y el otro con luz de ocaso.

'demo_navidad.pov' Para luz de ocaso.

'demo_navidad.pov' Para luz de ocaso.

Lo que de verdad nos interesa al ofrecer este dos en uno, es ilustrar el cambio tan importante que puede obrarse en el aspecto de las nubes cambiando el patrón de colores con ‘color_map’. Lógicamente hemos cambiado también la niebla y el color de la luz del sol para lograr una nueva escena coherente.

#declare Azul=rgb <.15, .15, .4>;
#declare Naranja=rgb <1,.9, .3>;
#declare Gris=rgb .3;

#declare Ocaso=0; // EDITAR EL VAR DE ESTA VARIABLE *** Ocaso=1 --> Ocaso; Ocaso=0 --Luz de día
#if (Ocaso) // En el ocaso
#declare ColorLuz=Naranja;
#declare ColorFog=Naranja*.7;
#declare DistFog=3000; // Niebla ligera
#declare TextuCielo=texture{
pigment{ bozo turbulence 0.92
color_map {
[0.00 Azul]
[0.45 Azul]
[0.6 (Azul+Naranja*2)/3]
[0.65 Naranja]
[0.7 (Naranja*3+Gris)/4]
[0.85 rgb Gris]
[0.99 rgb Gris] }
scale<1,1,1>*2.5
translate<1.0,0,-1>
}// end of pigment
finish {ambient 1 diffuse 0}
}// end of TextuCielo
#else // A plena luz del dia
#declare ColorLuz=White;
#declare ColorFog=White;
#declare DistFog=1700; // Niebla densa blanca
#declare TextuCielo=texture{
pigment{ bozo turbulence 0.92
color_map {
[0.00 rgb <0.3, 0.3, 1>*0.95]
[0.45 rgb <0.3, 0.3, 1>]
[0.75 rgb .95]
[0.85 rgb .9]
[1.0 rgb .8]}
scale<1,1,1>*2.5
translate<1.0,0,-1>
}// end of pigment
finish {ambient 1 diffuse 0}
}// end of texture
#end

fog { fog_type 2
distance DistFog
color ColorFog
fog_offset 50
fog_alt 40
turbulence 1.8
}
#declare Luz=light_source { <1500, 950, 0> ColorLuz }
#declare Cielo=sphere{<0,0,0> 10000
texture{TextuCielo scale <600,150,600>}
hollow
}

fog:
La niebla que hemos usado, da un aspecto más realista a la escena. Normalmente, las imágenes sintéticas son demasiado limpias y eso no es algo realista. La hemos definido de la siguiente forma.

fog { fog_type 2
distance 1700
color White
fog_offset 50
fog_alt 40
turbulence 1.8
}

Se trata de una niebla de color blanco. No es una niebla uniforme sino de tipo 2 (fog_type 2) es decir una niebla estratificada. En ella fog_set determina la altura que tiene la niebla manteniendose constante a máxima intensidad, y fog_alt determina una altura extra en la cual se va diluyendo hasta desaparecer completamente.

La sentencia ‘distance’ afecta a la densidad de la niebla. El valor de distance determinará la distancia donde el 36.8% del fondo resulta aún visible.

hollow:
Las nieblas no se pueden usar dentro de objetos mazizos. Habrá que usar la sentencia ‘hollow’ (hueco) para indicar que el cuerpo es hueco. Nosotros hemos usado como de costumbre una esfera a modo de boveda celeste, y dado que podemos mirar desde dentro de ella, tenemos tendencia a olvidar que el objeto esfera no es hueco. Se trata de un olvido frecuente.

Paquete de fuentes ‘Navidad.zip:
Todos lo fuentes de las escenas navideñas han sido empaquetadas ennavidad.zip (15 KBytes)junto a un lanzador en lenguaje python. (pov.py). Un shell ‘makepov.sh’ para renderizar un fuente pov determinado con el comando (pov.py $1 t 11 11) y un shell ‘makeallpov.sh’ que sirve para renderizar todos los pov que encuentra invocando a ‘makepov.sh’. (Se trata de facilitar el trabajo a los principiantes).

Es decir, en Linux, si tienes instalado Povray bastará, ejecutar ‘makeallpov.sh’ en un directorio incluido en el $PATH,

  1. Asegúrate que tienes instalado ‘povray’
  2. Descomprime el fichero ‘Navidad.zip’
  3. Abre un terminal y sitúate en el directorio ‘Navidad’ creado.
  4. Ejecuta el comando: PATH=.:$PATH
  5. Ejecuta el comando: makeallpovs.sh
  6. Ya te puedes ir a tomar algo.

Todas las imágenes de los diferentes fuentes pov (6 en total) se irán obteniendo con resolución 1280×720 y en formato tga para mayor calidad.

Recuerda que el fuente ‘demo_navidad.pov’ debe ser reeditado para obtener la imagen alternativa dependiendo del valor de la variable Ocaso (Tal cual viene la escena para luz de día). Si decides editarlo, puedes renderizar luego este fuente usando el comando:
makepov.sh demo_navidad

Al estar comprimido e incluir sólo los fuentes, el paquete ocupa sólo 15 Kbytes. La licencia de todo ello es GPL.

Página 1 de 6

Creado con WordPress & Tema de Anders Norén