O “time lapse” é um processo cinematográfico em que a frequência de cada foto ou quadro (frame) por segundo de filme é muito menor do que aquela em que o filme será reproduzido. Ou seja, quando visto a uma velocidade normal, o tempo parece correr mais depressa e parece saltar (lapsing), sendo uma ferramenta muito útil para mostrar eventos que demoram muito tempo para acontecer em um curto período. Veja a seguir como construir dois sistemas (webcam e câmera IP) em Linux para captura de uma imagem por minuto do céu e fazer o vídeo, tudo via linha de comando. Para testar sua webcam, uma dica é usar o programa Cheese, que geralmente já vem instalado.
Usando webcam
Foi utilizada uma webcam externa, mas funciona com câmera integrada ao computador também. Segue o script (fotografo.sh) criado em linux para obter as fotos. Nos comentários, tem a linha que pode ser incluída no crontab do usuário para tirar fotos a cada 1 minuto. O comando streamer executa a ação; veja se o dispositivo está em video0 ou video1 (“ls /dev” ou, para câmera externa, pode-se descobrir ao rodar o comando dmesg, conectar a câmera e verificar novamente a saída do comando dmesg). Veja mais sobre o streamer no site Daemonio Labs.
#!/bin/bash # Acrescentar no crontab # Tirar foto a cada 1 minuto #*/1 * * * * /home/monolitonimbus/camera/fotografo.sh caminho=/home/monolitonimbus/camera/ pasta=20`date +%y-%m-%d` horario=`date +%H-%M-%S` cd $caminho mkdir -p $pasta streamer -c /dev/video0 -b 16 -o $caminho/$pasta/cupula_$horario.jpeg exit
Veja mais opções do comando date clicando no link.
Usando câmera IP
Foi utilizada uma câmera IP da ACTi ACM4000. Deve-se conectar a câmera no mesmo roteador que o computador (wireless ou cabo). No computador, acessar o site do roteador (192.168.0.1, no caso do roteador D-Link e nessa rede), entrar com login e senha, ir no menu STATUS e buscar os computadores conectados. Lá vai aparecer a câmera e o IP dela (geralmente o IP que aparecerá é 192.168.0.100, que é o default). O que também pode ser feito (no caso do roteador Tp-Link) é usar o comando nmap para encontrar IP da câmera (fazer nmap antes e ver o que aparece de diferente quando conecta, geralmente o IP que aparecerá é 192.168.0.100, que é o default). Digite o IP obtido para acessar a câmera; entrar com login e senha (o padrão dessa câmera é admin, senha 123456).
Segue rotina em shell script (camera.sh) para usar o comando do VLC para obter as imagens. A opção “scene-ratio” dá a frequência de imagens a serem obtidas (nos comentários, está uma opção para tirar imagens a uma razão menor durante a noite).
#!/bin/bash caminho=/home/monolitonimbus/camera/imagens user='digite_o_usuario_da_camera' senha='digite_a_senha_da_camera' ip='digite_o_ip_da_camera' #if [ "$(date +%H)" -gt 19 ] || [ "$(date +%H)" -lt 6 ]; then fratio=1480 # 1 imagem por minuto #else #fratio=150 # 1 imagem a cada 5 segundos #fi cvlc http://$user:$senha@$ip/cgi-bin/cmd/system?GET_STREAM --video-filter=scene --no-audio --vout=dummy --scene-format=jpg --scene-ratio=$fratio --scene-prefix="$(date +%F-%H:%M:%S:%N-)" --scene-path=$caminho --quiet # Estampar legenda => rodar arquivo nomes_frames.sh #file=`ls -t $caminho | head -1` # ultima imagem exit
Para acesso da câmera através da internet, veja mais no blog Metaverse.
Estampando rótulo nas imagens e fazendo vídeo
Segue a rotina em shell script (criavideo.sh) para listar em ordem cronológica (“ls -tr”), etiquetar horário na imagem (comando convert), renomear arquivos e criar vídeo (comando avconv, sucessor do ffmpeg). Está comentada a opção para criar diretórios e sub-diretórios conforme a data e hora, respectivamente.
#!/bin/bash
caminho=/home/monolitonimbus/camera/
cd $caminho
vetor_files=`ls -tr *.jpeg`
n=1
for file in $vetor_files;
do
# Colocar rótulo no frame
filename=${file%.*}
extension=${file##*.}
output=${filename}.${extension}
dim=$(identify -format "%w %h" "$file")
width=${dim%% *}
height=${dim#* }
data=$(stat -c %y $file)
filename="img_"${data:0:10}"_"${data:11:8}".jpeg"
#caminho=/home/monolitonimbus/camera/${data:0:10}/${data:11:2}/
mkdir -p $caminho
if [ $width -ge $height ]
then
pointsize=$((`expr $width / 30`))
else
pointsize=$((`expr $height / 30`))
fi
convert "$file" -gravity SouthEast -font "$font" -pointsize "$pointsize" -fill yellow -annotate 1 "$data" "$caminho$filename"
# Renomear para criar vídeo
mv $filename imagem$n.jpeg
n=`expr $n + 1`
done
#Cria video para o cj de imagens renomeadas
avconv -f image2 -r 5 -i imagem%d.jpeg ../teste.aviOs parâmetros para a criação do vídeo são:
- -f image2 : multiplexador/demultiplexador de imagem a ser utilizado (image2)
- -r 5 : framerate, ou seja, quantidade de frames por segundo. Com o valor 1 será exibido uma imagem por segundo (frame), ou seja, o vídeo composto de 10 imagens terá 10 segundos
- -i imagem%d.jpg : imagens que comporão o vídeo, %d indica um valor decimal inteiro (como na linguagem C), sempre contando do menor valor encontrado para o maior, ou seja, serão lidas as imagens imagem1.jpg, depois imagem2.jpg e assim sucessivamente
- teste.avi : nome e formato do vídeo de saída
Caso não queira colocar rótulo no frame ou não criar vídeo, basta comentar as respectivas partes no código. Agradecimento ao Gustavo pelos comandos para rotular as imagens e aquisição da imagem via câmera IP. Veja o resultado abaixo, num vídeo com imagens a cada 1 minuto do céu tempestuoso de São Paulo no fim da tarde de natal (25/12/2013) e do amanhecer, gravados na cúpula do telescópio do IAG/USP.
Atualização: os smartphones modernos possuem recurso instalado que facilita a geração de time lapse. Veja esse exemplo da movimentação de nuvens sobre Extrema/MG em janeiro de 2019:
One comment