87. Vídeo con Raspberry Pi, crea tu sistema de vigilancia

Podcast: Download (32.9MB)

En el capítulo de hoy te voy a hablar de cómo podemos capturar el vídeo con Raspberry Pi, para crear nuestro propio sistema de vigilancia. Pero este no es el único proyecto que podemos crear. En el momento que conectamos una cámara a la Raspberry Pi, se nos abre un mundo de oportunidades. Si lo combinamos junto a la Visión Artificial, sacaremos el máximo provecho y rendimiento.

Ya te he hablado en otras ocasiones sobre la Visión Artificial, te dejo a continuación todos los artículos y capítulos del podcast.

No voy a hacer más hincapié en las ventajas y beneficios que nos ofrece esta ciencia. Hoy vamos a ver un caso práctico donde analizamos un vídeo con Raspberry Pi.

Empezaremos por el principio, veremos que es lo que necesitamos para empezar y el coste que supone. Luego continuaremos con la configuración del hardware, Raspberry Pi y cámara. Por último te daré lo básico para empezar. El primer algoritmo que debemos implementar para detectar movimiento con Raspberry Pi, OpenCV y Python.

CURSO GRATIS

Introducción a la Visión Artificial con OpenCV y Python

Apúntate y empieza ahora mismo con el curso.

Vídeo con Raspberry Pi

Raspberry Pi es un ordenador de propósito general de muy bajo coste. Lo que más me gusta de él es su bajo consumo, podemos tenerlo conectado todo el día. Para que te quede más claro, la Raspberry Pi 2 y 3 consumen unos 4 W/hora. Una torre puede consumir hasta 100 veces más pero pongamos que consume 200W/hora, 50 veces más. Imagínate lo que te puedes ahorrar si lo tienes todo el día encendido. Por este motivo, este dispositivo puede ser un gran aliado en nuestras instalaciones y proyectos.

Dentro de los posibles usos dentro del análisis de vídeo con Raspberry Pi encontramos algunos como los siguientes:

Espejo inteligente con reconocimiento facial.
Detector de presencia con grabación de vídeo.
Usos posibles con Kinect
Visión artificial dentro de la robótica

Material necesario

Vamos a ver ahora que material vamos a necesitar:

No es necesario comprar todo el material. Seguramente tengas una tarjeta Mirco SD, o un teclado y ratón. También puedes utilizar un cargador de móvil para alimentar la Raspberry Pi pero ojo, este debe suministrar 5V y 2A.

Una vez que ya tengas todo el material pasamos a hacer la instalación básica.

Instalación básica de Raspberry Pi

Hay multitud de tutoriales en Internet muy buenos. Te recomiendo que veas este tutorial de Gabriel Viso de Pitando. La versión que yo utilizo es Raspbian Jessie y con la que seguiré en este capítulo.

Una vez que lo tengamos todo instalado, es importante seguir los siguientes pasos para instalar Python + OpenCV. Empezaremos por Python y todos los paquetes necesarios orientados a la programación científica con este lenguaje de programación.

Actualizar paquetes

Lo primero que debemos hacer es actualizar el sistema y los paquetes que tenemos instalados en la Raspberry Pi. Primero abre una línea de comandos y ejecuta lo siguiente.

sudo apt-get update

1	sudo apt-get update

Cuando haya terminado ejecuta este otro, aplicará las actualizaciones que se han descargado.

sudo apt-get upgrade

1	sudo apt-get upgrade

Ten paciencia, puede tardar un poco. Es importante siempre trabajar con las últimas versiones del software. Así estaremos seguros de que se han corregido bugs de seguridad y demás problemas que hayan surgido.

Instalar paquetes básicos de Python

Escribir en una línea de comandos el siguiente comando.

sudo apt-get install build-essential python-dev python-distlib python-setuptools python-pip python-wheel libzmq-dev libgdal-dev

1	sudo apt-get install build-essential python-dev python-distlib python-setuptools python-pip python-wheel libzmq-dev libgdal-dev

Esto nos instalará los siguientes paquetes:

build-essential
python-dev
python-distlib
python-setuptools
python-pip
python-wheel
libzmg-dev
libgdal-dev

Puedes comprobar que versión de Python tienes instalada escribiendo el comando python -V.

Instalar los paquetes de Python científico

Para poder trabajar con OpenCV y Python, necesitamos ciertos paquetes que nos hará la vida más fácil. Puedes leer el artículo donde explico los requerimientos de OpenCV con Python. También te aconsejo que veas el curso de Introducción a la Visión Artificial con OpenCV y Python.

sudo apt-get install python-numpy python-matplotlib python-mpltoolkits.basemap python-scipy python-sklearn python-statsmodels

1	sudo apt-get install python-numpy python-matplotlib python-mpltoolkits.basemap python-scipy python-sklearn python-statsmodels

Este comando instala los siguientes paquetes:

python-numpy
python-matplotlib
python-mpltoolkits.basemap
python-scipy
python-sklearn
python-statsmodels

Instalar OpenCV

Quizás una de las cosas más complicadas de esta instalación sea la de hacer combinar todo lo necesario para que OpenCV funcione correctamente. Este framework se puede instalar de diferentes maneras. Bajo mi experiencia, aconsejo la instalación con este comando.

sudo apt-get install libopencv-dev python-opencv

1	sudo apt-get install libopencv-dev python-opencv

Una vez instalado ya podemos empezar a dar los primeros pasos con la visión artificial. Puedes comprobar que todo funciona correctamente escribiendo lo siguiente en una línea de comandos.

python

python

Intenta importar estas dos librerías

import cv2
import numpy as np

1 2	import cv2 import numpy as np

Debes obtener un resultado como este, sin errores.

Instalación de la cámara en la Raspberry Pi

Para instalar la cámara en la Raspberry Pi, solo tienes que insertar un extremo de la cinta en la placa. Es muy sencillo. Te dejo otro tutorial de Gabriel Viso donde lo explica paso a paso.

Instalar Picamara

Vamos a necesitar un paquete para acceder a la cámara desde Python. El paquete se llama Picamara. Ejecuta esta serie de comandos.

sudo apt-get install python-picamera python3-picamera

1	sudo apt-get install python-picamera python3-picamera

Esto nos instala los paquetes necesarios. Ahora solo falta actualizar la instalación.

sudo apt-get update
sudo apt-get upgrade

1 2	sudo apt-get update sudo apt-get upgrade

Con todo esto, si hemos seguido bien los pasos, ya podemos empezar a programar con Python. Dentro de Raspberry Pi encontramos el IDE oficial que nos puede resultar de mucha ayuda.

Programación algoritmo detección de movimiento

No te voy a hablar de en que consiste este tipo de algoritmos. Ya escribí una entrada en el blog donde daba un ejemplo. Basándome en este artículo he modificado el código y lo he adaptado para ejecutar el vídeo con Raspberry Pi. El código te lo dejo a continuación.

#Importamos los paquetes necesarios
from picamera.array import PiRGBArray
from picamera import PiCamera
import time
import cv2

# Inicializamos la cámara con resolución 640x480
camera = PiCamera()
camera.resolution = (640, 480)
camera.framerate = 32
rawCapture = PiRGBArray(camera, size=(640, 480))

# Tiempo de espera para que la cámara arranque
time.sleep(0.5)

# Inicializamos el primer frame a vacío.
# Nos servirá para obtener el fondo
fondo = None

# Capturamos frame a frame de la cámara
for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):
	# Obtenemos el array en formato NumPy
	image = frame.array

	# Convertimos a escala de grises
	gris = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # Aplicamos suavizado para eliminar ruido
	gris = cv2.GaussianBlur(gris, (21, 21), 0)

	# Si todavía no hemos obtenido el fondo, lo obtenemos
	# Será el primer frame que obtengamos
	if fondo is None:
            fondo = gris

    # Calculo de la diferencia entre el fondo y el frame actual
	resta = cv2.absdiff(fondo, gris)
 
	# Aplicamos un umbral
	umbral = cv2.threshold(resta, 25, 255, cv2.THRESH_BINARY)[1]
 
	# Dilatamos el umbral para tapar agujeros
	umbral = cv2.dilate(umbral, None, iterations=2)

    # Copiamos el umbral para detectar los contornos
	contornosimg = umbral.copy()

	# Buscamos contorno en la imagen
	contornos, hierarchy = cv2.findContours(contornosimg,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)

	# Recorremos todos los contornos encontrados
	for c in contornos:
		# Eliminamos los contornos más pequeños
		if cv2.contourArea(c) < 500:
			continue

		# Obtenemos el bounds del contorno, el rectángulo mayor que engloba al contorno
		(x, y, w, h) = cv2.boundingRect(c)
		# Dibujamos el rectángulo del bounds
		cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)

        
	# Mostramos las diferentes capturas
	cv2.imshow("Imagen Movimiento", image)
	cv2.imshow("Umbral", umbral)
	cv2.imshow("Resta", resta)
	cv2.imshow("Contornos", contornosimg)
	key = cv2.waitKey(1) & 0xFF

	# Reseteamos el archivo raw para la siguiente captura
	rawCapture.truncate(0)

	# Con la letra s salimos de la aplicación
	if key == ord("s"):
		break

#Importamos los paquetes necesarios

from picamera.array import PiRGBArray

from picamera import PiCamera

import time

import cv2

# Inicializamos la cámara con resolución 640x480

camera = PiCamera()

camera.resolution = (640, 480)

camera.framerate = 32

rawCapture = PiRGBArray(camera, size=(640, 480))

# Tiempo de espera para que la cámara arranque

time.sleep(0.5)

# Inicializamos el primer frame a vacío.

# Nos servirá para obtener el fondo

fondo = None

# Capturamos frame a frame de la cámara

for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):

# Obtenemos el array en formato NumPy

image = frame.array

# Convertimos a escala de grises

gris = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Aplicamos suavizado para eliminar ruido

gris = cv2.GaussianBlur(gris, (21, 21), 0)

# Si todavía no hemos obtenido el fondo, lo obtenemos

# Será el primer frame que obtengamos

if fondo is None:

fondo = gris

# Calculo de la diferencia entre el fondo y el frame actual

resta = cv2.absdiff(fondo, gris)

# Aplicamos un umbral

umbral = cv2.threshold(resta, 25, 255, cv2.THRESH_BINARY)[1]

# Dilatamos el umbral para tapar agujeros

umbral = cv2.dilate(umbral, None, iterations=2)

# Copiamos el umbral para detectar los contornos

contornosimg = umbral.copy()

# Buscamos contorno en la imagen

contornos, hierarchy = cv2.findContours(contornosimg,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)

# Recorremos todos los contornos encontrados

for c in contornos:

# Eliminamos los contornos más pequeños

if cv2.contourArea(c) < 500:

continue

# Obtenemos el bounds del contorno, el rectángulo mayor que engloba al contorno

(x, y, w, h) = cv2.boundingRect(c)

# Dibujamos el rectángulo del bounds

cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)

# Mostramos las diferentes capturas

cv2.imshow("Imagen Movimiento", image)

cv2.imshow("Umbral", umbral)

cv2.imshow("Resta", resta)

cv2.imshow("Contornos", contornosimg)

key = cv2.waitKey(1) & 0xFF

# Reseteamos el archivo raw para la siguiente captura

rawCapture.truncate(0)

# Con la letra s salimos de la aplicación

if key == ord("s"):

break

Vídeo

Puedes ver el siguiente vídeo donde te muestro como funciona el algoritmo.

Ventajas de la detección de movimiento

Cuando estamos analizando un vídeo con Raspberry Pi, debemos ser muy óptimos en cuanto al rendimiento. No tenemos que olvidar que Raspberry Pi es lo que es, un mini ordenador. Nos permitirá abaratar costes y reducir el consumo. Pero también tendremos que optimizar nuestro código a las nuevas circunstancias. Esto implica que en el tratamiento de vídeo con Raspberry Pi, debamos utilizar técnicas como la detección de movimiento.

Esta técnica consiste en detectar los objetos en movimiento dentro de una escena. Una vez localizados podemos utilizar esa detección para centrarnos en los objetos en movimiento y desechar el resto de la imagen. Un ejemplo sería si queremos reconocer objetos. Esto se puede hacer a través de diferentes algoritmos como SIFT o SURF. El gran inconveniente que tienen es que el coste de computación es muy alto. Esto implica que casi sea imposible analizar imágenes grandes en tiempo real y además añadimos las limitaciones de Raspberry Pi.

Por lo tanto, en estos casos, cuando queremos analizar vídeo con Raspberry Pi, debemos de tirar de métodos que nos optimicen el tiempo de computación. Eso es lo que haremos con la detección de movimiento.