Trabajando con OpenCV y la cámara de la Raspberry Pi

Como ya comentábamos en la entrada anterior, podemos hacer reconocimiento de imágenes, en concreto vamos a ver en esta entrada como hacer reconocimiento  de la posición de la mano con OpenCV. Para ello necesitamos conectar y habilitar la cámara de la Raspberry Pi, como indicamos en otra entrada anterior Sistema de vigilancia con Raspberry Pi.

Con el siguiente código podemos hacer que reconozca si la mano está abierta o cerrada:

# import the necessary packages
from imutils.video import VideoStream
import imutils
import cv2
import numpy as np
import math
import time
import sys

# initialize the video stream and allow the cammera sensor to warmup
vs = VideoStream(usePiCamera=True, resolution=(1296,972)).start()
time.sleep(2.0)
# loop over the frames from the video stream
while True:
img = vs.read()
cv2.rectangle(img,(300,300),(100,100),(0,255,0),0)
crop_img = img[100:300, 100:300]
grey = cv2.cvtColor(crop_img, cv2.COLOR_BGR2GRAY)
value = (37,37)
blurred = cv2.GaussianBlur(grey, value, 0)
_, thresh1 = cv2.threshold(blurred, 127, 255,
cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)
_, contours, hierarchy = cv2.findContours(thresh1.copy(),cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)

max_area = -1
for i in range(len(contours)):
cnt=contours[i]
area = cv2.contourArea(cnt)
if(area>max_area):
max_area=area
ci=i
cnt=contours[ci]
x,y,w,h = cv2.boundingRect(cnt)
cv2.rectangle(crop_img,(x,y),(x+w,y+h),(0,0,255),0)
hull = cv2.convexHull(cnt)
drawing = np.zeros(crop_img.shape,np.uint8)
cv2.drawContours(drawing,[cnt],0,(0,255,0),0)
cv2.drawContours(drawing,[hull],0,(0,0,255),0)
hull = cv2.convexHull(cnt,returnPoints = False)
defects = cv2.convexityDefects(cnt,hull)
count_defects = 0
cv2.drawContours(thresh1, contours, -1, (0,255,0), 3)
for i in range(defects.shape[0]):
s,e,f,d = defects[i,0]
start = tuple(cnt[s][0])
end = tuple(cnt[e][0])
far = tuple(cnt[f][0])
a = math.sqrt((end[0] – start[0])**2 + (end[1] – start[1])**2)
b = math.sqrt((far[0] – start[0])**2 + (far[1] – start[1])**2)
c = math.sqrt((end[0] – far[0])**2 + (end[1] – far[1])**2)
angle = math.acos((b**2 + c**2 – a**2)/(2*b*c)) * 57
if angle <= 90:
count_defects += 1
cv2.circle(crop_img,far,1,[0,0,255],-1)
dist = cv2.pointPolygonTest(cnt,far,True)
cv2.line(crop_img,start,end,[0,255,0],2)
cv2.circle(crop_img,far,5,[0,0,255],-1)

if count_defects>3:
cv2.putText(img,”ABIERTA”, (50,50), cv2.FONT_HERSHEY_SIMPLEX, 2, 4)
else:
cv2.putText(img,”CERRADA”, (50,50), cv2.FONT_HERSHEY_SIMPLEX, 2, 4)

#cv2.imshow(‘drawing’, drawing)
#cv2.imshow(‘end’, crop_img)
cv2.imshow(‘Gesture’, img)
all_img = np.hstack((drawing, crop_img))
cv2.imshow(‘Contours’, all_img)
k = cv2.waitKey(10)
if k == 27:
cv2.destroyAllWindows()
vs.stop()
break

Lo primero que hacemos es iniciar la cámara de la Raspberry con una resolución concreta, para ir procesando cada imagen que vamos leyendo.

Dibujamos un cuadrado en la posición de la imagen donde estará la mano.

2016-08-19-171040_1824x984_scrot - copia.png

A continuación convertimos la imagen a escala de grises.

2016-08-19-171040_1824x984_scrot-copia-copia

Le aplicamos un filtro Gaussiano, que desenfoca la imágen de la siguiente forma:

bf.png

Después le aplicamos la función treshold, que nos devolvería un resultado similar al siguiente:
hand

Donde podemos localizar, y dibujar muy fácilmente el contorno de la imagen.

2016-08-19-171040_1824x984_scrot - copia (2)

Tras aplicar una serie de funciones matemáticas, podemos interpretar si la mano esta cerrada o abierta.

2016-08-19-171040_1824x984_scrot
Ejemplo Mano Abierta
2016-08-19-171718_1824x984_scrot
Ejemplo Mano Cerrada

Aquí os dejo un vídeo donde os muestra el funcionamiento de esta práctica (tiempo 2:29), además de otras.

 

 

Anuncios

Instalar OpenCV en Raspbian Jessie

OpenCV (Open Source Computer Vision) es una librería software de código abierto sobre visión artificial.

OpenCV_Logo_with_text
Logo OpenCV

Es multiplataforma por lo que existen distintas versiones en C/C++, Java, Python y distintos soportes para cada sistema operativo (Linux, Mac, Windows …).

Contiene más de 500 funciones que abarcan una gran gama de áreas en el proceso de visión, como reconocimiento de objetos o reconocimientos facial, calibración de cámaras, visión estérea y visión robótica.

2016-08-18-171351_1824x984_scrot - copia
Reconocimiento Facial con OpenCV

Siguiendo los pasos que vamos a enumerar a continuación podemos instalar OpenCV en nuestra Raspberry Pi con Raspbian Jessie instalado, en unas dos horas. (25 minutos que tardaremos en preparar todo, y luego algo más de hora y media para dejar que se compile y se instale).

Lo primero de todo será comprobar que la Raspberry está actualizada:

sudo apt-get update

sudo apt-get upgrade

sudo rpi-update

sudo reboot

Una vez actualizada y reiniciada, seguimos con los siguientes pasos, para instalar las dependencias:

sudo apt-get install build-essential git cmake pkg-config

1

sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev

2

sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev

3

sudo apt-get install libxvidcore-dev libx264-dev

4

sudo apt-get install libgtk2.0-dev

5

sudo apt-get install libatlas-base-dev gfortran

6

sudo apt-get install python2.7-dev python3-dev

7

Descargamos y descomprimimos el código fuente de Open CV:

cd ~

8

wget -O opencv.zip https://github.com/Itseez/opencv/archive/3.0.0.zip

9

unzip opencv.zip

10

wget -O opencv_contrib.zip https://github.com/Itseez/opencv_contrib/archive/3.0.0.zip

11

unzip opencv_contrib.zip

12

Configuramos Python, puesto que en nuestro caso será con el que utilizaremos OpenCV en la Raspberry Pi.

wget https://bootstrap.pypa.io/get-pip.py

13

sudo python get-pip.py

14

Virtual Enviroment:

sudo pip install virtualenv virtualenvwrapper

15

sudo rm -rf ~/.cache/pip

16

sudo nano ~/.profile

profile

El archivo debe quedar con el aspecto anterior, guardamos con Ctrl+X  y ejecutamos lo siguiente:

source ~/.profile

18

mkvirtualenv cv

20

Siempre que cerremos sesión o apaguemos la Raspberry, si queremos trabajar en el entorno virtual tenemos que ejecutar lo siguiente:

source ~/.profile

workon cv

Y ya nos aparecerán las letras (cv), indicando que estamos en el entorno virtual

20 - copia

pip install numpy

21

cd ~/opencv-3.0.0/

22

mkdir build

23

cd build

Compilamos e instalamos OpenCV:

24

cmake -D CMAKE_BUILD_TYPE=RELEASE \

-D CMAKE_INSTALL_PREFIX=/usr/local \

-D INSTALL_C_EXAMPLES=ON \

-D INSTALL_PYTHON_EXAMPLES=ON \

-D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib-3.0.0/modules \

-D BUILD_EXAMPLES=ON ..

25

Aseguramos que en el apartado de Python 2,  tanto el intérprete , como numpy apuntan al entorno virtual.

26

27

Compilamos:

make -j4

(Si queremos compilar utilizando 4 núcleos)

o make simplemente (compilación más lenta)

28

Empezará la compilación que puede durar hora y media si se usan los 4 núcleos, o más si sólo se utiliza uno.

Si todo sale bien, una vez que llegue al 100 % de la compilación y si no se han recibido mensajes de error, ya tendremos casi listo nuestro Open CV.

29

En caso de recibir error, puedes probar a borrar la compilación con el comando make clean

y una vez eliminada, volver a probar ejecutando make.

Una vez compilado sin errores, seguimos con el siguiente paso:

sudo make install

30

sudo ldconfig

31

cd ~/.virtualenvs/cv/lib/python2.7/site-packages/

32

ln -s /usr/local/lib/python2.7/site-packages/cv2.so cv2.so

33

Y ya tenemos listo nuestro OpenCV en la Raspberry Pi.

Para verificar que todo ha ido correctamente podemos hacer la siguiente comprobación:

python

34

cv2.__version__

35

En entradas posteriores veremos diferentes usos de OpenCV con la cámara de la Raspberry Pi.

Gracias a http://www.pyimagesearch.com/2015/10/26/how-to-install-opencv-3-on-raspbian-jessie/