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: Script Página 1 de 2

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.

dirs2vid.py (Utilidad para pasar varios directorios a vídeo)

Esta utilidad ‘dirs2vid.py‘ es un nuevo script escrito en lenguaje Python y con licencia libre GPL, basada en una utilidad que propusimos hace ya un tiempo dir2avi.py‘.

Mejoras:
Las mejoras son significativas y justifican el cambio de nombre. Para empezar el anterior script tomaba un directorio y lo convertía en un avi. ‘dirs2vi.py’ puede tomar varios directorios de fotogramas, con lo cual resulta muy útil para hacer un montaje final. Además, el formato por defecto es avi, pero puede ser variado a cualquier otro formato compatible con ffmpeg que continúa siendo la base del nuevo script.

Entre otras novedades podemos pasar un fichero de audio para que lo use como audio del vídeo. Nuevamente resulta muy útil para montajes finales de vídeo partiendo de directorios de fotogramas.

Se ha añadido una opción –exif para evitar que cierto tipo de imágenes que vienen con información exif conflictiva para ffmpeg causen distorsiones del color en la imagen. En definitiva hace el proceso más lento, pero más seguro.

Está pensado para su uso en Linux, y resulta especialmente útil para los aficionados a realizar Timelapses.

Portabilidad:
Dado que existe un intérprete de Python para Windows, y un ffmpeg para Windows, su adaptación no debería ser complicada. (Por ejemplo: Algunos comandos Linux contenidos en el script, deberían ser reconvertidos a sus equivalentes en Windows).

Código fuente de ‘dirs2vid.py’
#!/usr/bin/python
# -*- coding: latin1 -*-
"""
Sinopsis: 'dirs2vid.py': Procesa las imagenes contenidas en los directorios indicados y crea un vídeo usando 'ffmpeg.
Autor**: Antonio Castro Snurmacher (acastro0841@gmail.com) (http://www.ciberdroide.com)
Licencia: GPL.
Version: version 1.0 (marzo-2011)
"""

import sys, os, Image
import string

##################
def comando(comm):
print comm
os.system(comm)

#######################################
def GetOpcion(cadopcion):
'''
Capturar y procesar las opciones.
'''
opc_val= string.split(cadopcion, '=')
if opc_val[0] not in [ '--help', '-help', '-h', '-exif', '-vcodec', '-fimg', '-size', '-audio', '-out' ]:
Uso("Opción '%s' desconocida" % opc_val[0])
if len(opc_val)==1:
return opc_val[0], ''
else:
opc_val[1]=opc_val[1].strip()
if opc_val[0]=='-size': # Expandir uso abreviado
if opc_val[1]=='720p':
opc_val[1]='1280x720'
if opc_val[1]=='1080p':
opc_val[1]='1920x1080'
return opc_val[0], opc_val[1]

############
def Uso(cad):
print "Error: %s" % cad
Help()

################################################################
def GetFilesDir(dir, ExtImg):
if not os.path.isdir(dir):
Uso("'%s' no es un directorio" % dir)
if (dir[len(dir)-1]=='/'):
dir=dir[:-1]
finamelist=[]
ListaFicheros=os.listdir(dir)

n=0
for fi in ListaFicheros:
finame, ext= os.path.splitext(fi)
if ext in ExtImg:
finamelist.append(finame)
n=n+1
if n==0:
Uso("El directorio '%s' no contiene ficheros '%s'" % (dir, ExtImg))
finamelist.sort()
return finamelist, ext

####################################################
def CompilaDir(n, finamelist, dir, ext, DirDest, Opc_Exif):
# Las listas se pasan por referencia (no es variable local)
for fi in finamelist:
FiNum="img_%06d%s" % ( n, ext.lower())
if Opc_Exif:
img=Image.open("%s/%s%s" % (dir, fi, ext))
(x,y)=img.size
img.resize(img.size) # Redimensionamos al mismo tamaño. (truco para suprimir toda la info exif)
img.save("%s/%s" % (DirDest, FiNum))
print "%s/%s" % (DirDest, FiNum)

else:
comando ("cd %s ; ln -s ../%s/%s%s %s" % (DirDest, dir, fi, ext, FiNum))
n=n+1
return n

####################
def Timestamp():
"Un Timestamp de 4 digitos se considera suficiente."
import time
return int(time.time()) % 10000

####################
def Help():

print """
USO:
dirs2vid.py [ Opciones... ] Dir...

OPCIONES:
-help # Muestra esta ayuda y finaliza.
-exif # Suprime la información exif. Necesario para evitar cierto bub y forzar el correcto procesado
de los canales RGB de algunas imágenes que contienen información exif erronea.
-fimg= # Para indicar el formato de la imagen que por defecto se considera '.jpg' o '.JPG'.
-size= # Para indicar la resolución del video de salida que por defecto conserva la resolución de las
imagenes originales.
-audio= # Para indicar el fichero que contiene el audio.
-vcodec= # Para especificar un codec de vídeo concreto a ffmpeg.
-out= # Especificar un nombre de fichero de video que por defecto sería del tipo 'd2v9999.avi'
"""
raw_input('Pulse la tecla [Intro] para continuar...')
print """
SINOPSIS:
'dirs2vid.py': Procesa las imágenes contenidas en los directorios indicados (dir...) y crea un vídeo usando 'ffmpeg.

REQUERIMIENTOS:
Dentro de cada directorio las imágenes serán procesadas siguiendo el orden alfabético del nombre del fichero.
Todas las imágenes de todos los directorios deben tener la misma resolución.

EJEMPLOS:
# Obtener un video 'avi' a partir del directorio 'dir_fotogramas' donde los ficheros son de la forma '*.jpg' o '*.JPG'
# (coincide con con los valores de las opciones por defecto)
dirs2vid.py dir_fotogramas

# Obtener un video con nombre 'video.avi' a partir del directorio 'dir_fotogramas' donde los ficheros son de la forma
# '*.jpg' o '*.JPG' e incluir el audido contenido en 'audio.mp3'
dirs2vid.py -out=video.avi -audio=audio.mp3 dir_fotogramas

# Obtener un video 'avi' de 1280x720 a partir del directorio 'dir_fotogramas' donde los ficheros son de la forma '*.jpg' o
# '*.JPG' suprimendo previamente la informacion exif de las imágenes. (Proteccion de ffmpeg frente a BUGS EXIF en JPG)
dirs2vid.py -exif -size=1280x720 dir_fotogramas

# Obtener un video 'mp4' con vcodec='libxvid' a partir del directorio dir_fotogramas donde los ficheros son de la forma '*.PNG' '
dirs2vid.py -fimg=PNG -fvidOut=mp4 -vcodec=libxvid dir_fotogramas

Para más detalle consulte el artículo de referencia en http://www.ciberdroide.com/fotos
Este programa se ofrece bajo licencia GPL. Si llegara a serle de alguna utilidad y tiene oportunidad, incluya desde su web una
referencia (link) a la web de ciberdroide. Si desea comunicar con el autor, localice el artículo de referencia y ponga allí un
comentario. Con mucho gusto resolveré las dudas que tenga.

Antonio Castro.
"""
sys.exit()

#######################################################
def main():
'''
Vease Help().
'''
import sys, os, Image

opc={}
while (len(sys.argv)>1 and sys.argv[1][0]=='-'):
opcion, valor=GetOpcion(sys.argv[1])
print opcion, valor
opc[opcion]=valor
del sys.argv[1]
for h in [ '--help', '-help', '-h']:
if h in opc.keys():
Help()
Opc_Exif = '-exif' in opc.keys()
if '-vcodec' in opc.keys():
Opc_Vcodec= " -vcodec %s " % opc['-vcodec']
else:
Opc_Vcodec='' # default
if '-fimg' in opc.keys():
ExtImg=[ '.'+ opc['-fimg'] ]
else:
ExtImg=['.jpg', '.JPG'] # default
if '-size' in opc.keys():
Opc_Size=" -s %s " % opc['-size']
else:
Opc_Size=''
if '-audio' in opc.keys():
Audio=" -i %s -acodec copy " % opc['-audio']
else:
Audio=' -an '
# print opc
# print "exif=%s, vcodec=%s, fvidOut=%s, fimg=%s," % (Opc_Exit, Opc_Vcode, ExtVidOut, ExtImg)
if (len(sys.argv)<2): Uso("Debe indicar como mínimo un directorio origen.") directorios=sys.argv del directorios[0] if '-out' in opc.keys(): Out=opc['-out'] else: Out="d2v%d.avi" % Timestamp() n=1 DirDest="tmp_fotogramas" comando("rm -r %s; mkdir %s" % (DirDest, DirDest)) for dir in directorios: if dir[-1:]=='/': # Si termina en '/' eliminarlo dir=dir[:-1] finamelist, ext =GetFilesDir(dir, ExtImg) n=CompilaDir(n, finamelist, dir, ext, DirDest, Opc_Exif) comando("ffmpeg %s -f image2 -i %s/img_%%06d%s %s -sameq %s -y %s" % (Audio, DirDest, ext.lower(), Opc_Vcodec, Opc_Size, Out ) ) ############################################################# if __name__ == "__main__": main()

Bug repartido entre ImageMagick, ffmpeg, mencoder, y recordmydesktop.

Si haces uso de estos programas este artículo te puede interesar, y en caso contrario te parecerá la típica batallita de programación que sólo interesa a los frikis del software libre.

Tengo publicado un artículo en el cual presenté un script ‘dir2avi.py’ que procesaba todas la imágenes ‘*.jpg’ de un directorio y obtenía un vídeo avi, pero he descubierto que no siempre funciona bien, lo curioso es que no es por un problema de mi script y el bug está muy repartido entre diversas aplicaciones.

El fallo de ordenador de dio nombre a los bugs de programación.

El fallo de ordenador de dio nombre a los bugs de programación.

He usado aquel script y en determinadas ocasiones generaba unos vídeos con ciertas anomalías cromáticas, apareciendo manchas de colores. Incluso he publicado algún vídeo en youtube que presentaba este problema ante la impotencia de localizar el problema, pero esta vez me afectaba a un proyecto que quiero que tenía mucho interés en que quedara perfecto así que he dedicado bastante tiempo a investigarlo.

El vídeo siguiente de sólo 8 segundos muestra el efecto que tiene el bug en un vídeo.

Hice varias pruebas haciendo toda clase de variaciones posibles para hacer vídeos a partir de imágenes y para mi sorpresa resultó que de una forma o de otra en algunos casos concretos reaparecía siempre el mismo problema fuera cual fuera el método empleado.


Las imágenes jpeg de partida aparecían perfectas, pero el vídeo que producían determinadas colecciones de imágenes presentaba problemas y era difícil saber la razón. Intenté un montón de cosas:
  • Para descartar un bug en ffmpeg probé a generar el vídeo con mencoder, pero no tuve suerte.
  • Para descartar un bug en algún codec probé con distintos codecs de vídeo en ffmpeg, igualmente sin éxito.
  • El problema también apareció pasando un vídeo de formato ogg a un formato avi con ffmpeg, lo cual parecía descartar totalmente el problema en mis imágenes. Este ogg lo generé capturando vídeo desde el escritorio con recordmydesktop así que  el problema parecía burlarse de mi sentido de la lógica.
  • Quizás fuera el formato de vídeo y probé a generarlo en varios formatos (avi, mp4, mpeg, ogg, flv), pero tampoco.
  • Quizás a ffmpeg no le gusta que yo redimensione con la opción -s y use simultáneamente -sameq, así que probé a no redimensionar, a redimensinar con el mismo tamaño de la imagen, a no indicar la dimensión para que la tomara de las imágenes originales, pero nada de eso tuvo éxito.

Fueron varios días insistiendo sin éxito. El problema sólo aparece usando algunas colecciones de imágenes,  pero no lograba descubrir en que se diferencian los jpegs que daban problemas de los restantes que no los daban. Por fin llegó mi primer éxito y una posible solución. Si las imágenes que daban problemas al pasarlas a vídeo eran convertidas previamente a otro formato, por ejemplo png, el problema desaparecía confirmando el problema con el formato de las imágenes de entrada.

Decido entonces investigar un poco más los jpegs y verificando una de estas imágenes usando el comando identify -verbose de ImageMagick descubro que aparece una información contradictoria en la cabecera exif respecto al ColorSpace. En la misma imagen figura lo siguiente:
  • exif:ColorSpace: 1
  • jpeg:colorspace: 2

Uno de los dos valores debe de ser incorrecto, y los campos exif son meramente informativos.

Una breve aclaración sobre exif:
Exchangeable image file format (abreviatura oficial Exif) es una especificación para formatos de archivos de imagen usado por las cámaras digitales. Las etiquetas (tags) de metadatos definidas en el estándar Exif cubren un amplio espectro de valores. Los programas antiguos no tienen en cuenta estos valores, y los modernos los manejan como información de usuario final  principalmente.
Una imagen sin información exif es perfectamente funcional, así que no parecía muy lógico que un dato erróneo en un campo exif tuviera consecuencias en el software, pero tratándose de un caso rarito y existiendo el dato contradictorio me construyo un script que elimine todos los campos exif de mis imágenes jpeg, y … ¡Eureca!
Quitar la información exif en la imágenes jpg solucionaba el problema para ffmpeg.

Esto puede que no resulte muy emocionante para la inmensa mayoría de los mortales, pero apuesto que son muchos a lo largo y ancho de Internet que han tropezado con este escurridizo bug sin sospechar de qué se trata. Para eliminar la información exif del jpeg recurrí a la librería de imágenes PIL en python, y lo que hago con cada fichero de imagen es simplemente esto:
import Image
img=Image.open(fi)
(x,y)=img.size
img.resize(img.size) # Redimensinamos al mismo tamaño. Es un truco para suprimir toda la info de exif
img.save(fi)
Después de hacer esto las imágenes quedan sin campo exif y ffmpeg ya genera el vídeo correctamente. (Me quedé muy sorprendido cuando esto funcionó y pensé que a pesar de que una historia de bugs no resulta muy emocionante merecía la pena comentarlo en un artículo).  Publicaré en breve alguna solución que incluiré como parte de un paquete de utilidades. De momento solo tengo un parche poco presentable.


Conclusiones:
Es muy posible que ImageMagick bajo ciertas circunstancias cometa algún error en el mantenimiento de la información exif, y puede que la inconsistencia en los campos exif no sea algo tan raro, incluso podría considerarse como algo asumible porque donde tiene realmente sentido es en un fichero recién salido de una cámara de fotos.
También es muy posible que recordmydesktop genere un vídeo ogg con metainformación errónea o inconsistente y sería un bug independiente del anterior. En cualquier caso el hecho de que la información exif pueda provocar fallos en ffmpeg como mencoder, significa que ambos hacen un uso muy cuestionable de esta información, que debería ser ignorada. Sí estas se suprimen el vídeo se genera perfectamente. No tiene mucho sentido.
No descarto que todos estos programas que estoy mencionando estén haciendo cosas incorrectas y que sólo den problemas cuando se hace un determinado uso combinado de los mismos. Estaríamos ante una epidemia de bugs.

Que ffmpeg y mencoder compartan un mismo bug en la adquisición de imágenes jpeg no sería demasiado sorprendente ya que ambos son software libre y cabe la posibilidad de que uno copiara el bug del vecino.

Página 1 de 2

Funciona con WordPress & Tema de Anders Norén