De tu cámara al vídeo HDR Full HD

Qué encontrarás en esta entrada?

• Script para pasar de imágenes NEF a vídeo HDR FullHD.
• Ejemplos de uso.
• Análisis: posibilidades y limitaciones. 

Llevaba tiempo jugueteando con esto, de hecho, no recuerdo si ya colgué antes alguna cosa parecida en esta página, pero por fin he realizado el programa definitivo para tratar tus time-lapses o stop-motions. Bueno, quizá "definitivo" no sea la palabra :p (tampoco "programa", es un script de cuatro líneas xD), puesto que tiene un grave inconveniente que abordaremos unas líneas más abajo: el tiempo de ejecución.

Lo que hace el script básicamente es coger un conjunto de imágenes en bruto que saque una cámara digital reflex (por ejemplo, los "NEF" de una Nikon), los procesa con algoritmos HDR y crea con ellas un vídeo FullHD (1920x1080px).

Todo esto funciona bajo Linux y es necesario tener instalado el Qtpfsgui / Luminance HDR (para tratar los HDRs) y ffmpeg (para generar el vídeo).

El funcionamiento del script es muy sencillo: tal y como está configurado (no sería difícil alterar el código para que funcionase para otras variaciones) lee los archivos con nombre "_DSC_####.NEF", los transforma con Qtpfsgui en imágenes HDR (utilizando un procesado básico basado en un único archivo RAW con el algoritmo de Mantiuk), y por último une todos los fotogramas con ffmpeg para crear el vídeo final. El script incluye algún estimador temporal, algo útil debido a que el tiempo de ejecución suele ser largo.

 

Además, lleva incorporado un sistema de "logs" que redactan un informe (centrado principalmente en la duración de la ejecución) cada vez que el programa se pone en marcha.

Dicen que una imagen vale más que mil palabras, pues aquí tenéis unos cuantos de cientos de imágenes unidas para formar un vídeo y que veáis de qué os estoy hablando en esta entrada. 

"Simplemente" tenéis que preocuparos de sacar las fotos, y el programa las edita dándole ese toque HDR tan característico y haciendo el vídeo.

Como todos mis scripts, éste está colgado en 4Shared. Os dejo también el código escrito a continuación para que veáis que no tiene nada raro (la mayor parte de líneas es para hacer las estimaciones temporales).

#!/bin/bash
#
# Este script pretende transformar una serie de archivos consecutivos .NEF
#en una secuencia de vídeo HDR.
#
# Creado por Astaroth (O.R.G.) - http://astarothsworld.blogspot.com
#
# Variables iniciales:
t00=`date +%s` # Marca de tiempo inicial
T00=`date`
dia=`date +%d/%m/%Y`
echo "*****************" > Logs.txt
echo "HDRClip" >> Logs.txt
echo "LOGS - $dia" >> Logs.txt
echo "*****************" >> Logs.txt
echo " " >> Logs.txt
echo "Inicio de la aplicación: $T00" >> Logs.txt
ini=`ls | grep -m 1 -o "[0-9][0-9][0-9][0-9]"` # Primer fotograma
fin=`ls | grep -o "[0-9][0-9][0-9][0-9]" | sed -n '$p'` # Último fotograma
n=`echo "$fin - $ini +1" | bc` # Número de fotogramas
k=0 # Contador de fotogramas
p=0 # Contador de progreso
dt=0 # Retardo inicial.
#
# Conversión HDR (algoritmo Mantiuk):
{
for i in $(seq -w $ini $fin) ; do

# Avisos de la barra de progreso:

p=`echo "100 * $k / $n" | bc`# Porcentage

eta=`echo "$dt * ( $n - $k )" | bc` # Tiempo estimado en segundos

Eta=`echo "scale=2 ; $eta / 60" | bc` # Tiempo estimado en minutos

ETA=`echo "scale=2 ; $Eta / 60" | bc` # Tiempo estimado en horas

ftrat=`echo "$k + 1" | bc` # Contador de fotogramas desplazado

echo "#Convirtiendo a HDR el fotograma número $ftrat de $n\n(ETA ~ $eta s. ~ $Eta min. ~ $ETA h.)\n\nP.D.: En la estimación del tiempo no se tiene en cuenta la creación del vídeo."

echo "$p"

ti=`date +%s` # Marca de tiempo inicial

k=`echo "$k + 1" | bc`

qtpfsgui -r 1920 _DSC$i.NEF -o $k.jpg # Conversión HDR propiamente dicha

tf=`date +%s` # Marca de tiempo final

Tf=`date`

dt=`echo "$tf - $ti" | bc` # Intervalo

echo "Convertido a HDR el fotograma $k: $Tf" >> Logs.txt

echo "Tiempo de vuelta: $dt s." >> Logs.txt

echo "Estimación de tiempo restante para finalizar el procesado HDR: $eta s. (~ $Eta min. ~ $ETA h.)" >> Logs.txt

done
} | zenity --progress --title="HDRClip" --text="Convirtiendo a HDR..." --auto-close --auto-kill
#
# Creación del vídeo:
{
ffmpeg -y -f image2 -i %d.jpg -vcodec mpeg2video -s 1920x1080 -aspect 16:9 -b 25000k -g 12 -trellis 1 videoHDVpan.m2t
} | zenity --progress --title="HDRClip" --text="Creando vídeo..." --pulsate --auto-close --auto-kill
dire=`pwd`
if ( zenity --question --title="HDRClip" --text="FINALIZADO :D\!\n\nSu vídeo debería haberse creado en:\n$dire\n\nDesea reproducirlo?" ) ; then

cvlc videoHDVpan.m2t

else

echo "Adios :)!"

fi
tff=`date +%s` # Marca de tiempo final
Tff=`date`
DT=`echo "$tff - $t00" | bc`
DTT=`echo "$DT / 60" | bc`
DTTT=`echo "$DTT / 60" | bc`
echo "Final de la aplicación: $Tff" >> Logs.txt
echo " " >> Logs.txt
echo "Tiempo total transcurrido: $DT s. (~ $DTT min. ~ $DTTT h.)" >> Logs.txt

Como he dicho antes, el código es muy sencillo y está comentado, con lo cual se pueden hacer fácilmente pequeños cambios para adaptarlo a nuestras necesidades (por ejemplo, si la forma en la que se nombran nuestras fotos es distinta, o si en vez de archivos ".NEF" tenemos archivos con otra extensión).

El mayor problema de este script es el tiempo de ejecución. Típicamente (con mi equipo) el proceso de conversión HDR lleva al rededor de 50 segundos por fotograma. Esto significa que si queremos un vídeo de 4 segundos (a 25 fps, necesitamos 100 fotogramas), tardará unos 100 minutos (1 h. y 40 min.) sólo en la conversión a HDR. A eso habrá que añadirle el tiempo que tarde la unión de todos los fotogramas para realizar el vídeo. Son por tanto tiempos largos y por ello veo muy conveniente dotar al script de un estimador simple de tiempo (que lo que hace es calcular lo que ha tardado en preparar el último fotograma y multiplicar ese tiempo por los fotogramas restantes).

Para hacernos una idea os comentaré un caso basado en la revisión de un log real que ha generado este script. Una de las secuencias del vídeo anterior (la más larga) estaba formada por 997 fotogramas y ha tardado 47.489 s. en generarse. Esto significa que ha tardado unos 48 s. por fotograma (lo cual es un récord). Ahora bien, para hacer una secuencia que dura menos de 40 segundos en el vídeo final el script ha tardado 13 horas en generarla.

Los resultados merecen la pena, pero hasta que no descubra un método mejor, habrá que echarle paciencia :)!