En este tutorial, aprenderá a detectar un parpadeo del ojo humano con los mapeadores de características conocidos como cascadas de haar . Aquí en el proyecto, usaremos el lenguaje python junto con la biblioteca OpenCV para la ejecución del algoritmo y el procesamiento de imágenes, respectivamente. Las cascadas haar que vamos a usar en el proyecto están preentrenadas y almacenadas junto con la biblioteca OpenCV como archivos haarcascade_frontalface_default.xml y haarcascade_eye_tree_eyeglasses.xml. El proyecto desarrolla una comprensión básica de los sistemas, como la detección de somnolencia del conductor, los bloqueos de parpadeo, la detección de ojos, la detección de rostros y también el uso de cascadas haar con la biblioteca OpenCV.
Acerca de las cascadas de Haar:
Los clasificadores en cascada basados en características de Haar son un método eficaz de detección de objetos propuesto por Paul Viola y Michael Jones en su artículo, «Detección rápida de objetos usando una cascada potenciada de características simples» en 2001. Es un enfoque basado en el aprendizaje automático donde una función en cascada se entrena a partir de muchas imágenes positivas y negativas. Aquí, las imágenes positivas son las muestras que contienen el objeto de destino y las negativas son las que no lo contienen. Se necesitan muchas muestras positivas y negativas para entrenar al clasificador.
Características de Haar, fuente – Documentos de OpenCV
Ahora, extraemos las características de la imagen de entrada dada con las características haar que se muestran en la imagen de arriba. Son como núcleos convolucionales. Cada característica es un valor único obtenido al restar la suma de píxeles debajo del rectángulo blanco de la suma de píxeles debajo del rectángulo negro.
Aplicación de haarcascades, fuente – OpenCV Docs
El cálculo excesivo:
con todos los tamaños posibles de los clasificadores, se calculan las características, pero la cantidad de cálculo que se necesita para calcular las características, una ventana de 24 × 24 da como resultado más de 160000 características. Además, para cada cálculo de características, también se necesita la suma de los píxeles. Para hacerlo menos costoso desde el punto de vista computacional, los creadores de Haar Cascades introdujeron la imagen integral, lo que significa que, por grande que sea la imagen, reduce los cálculos para un píxel dado a una operación que involucra solo cuatro píxeles.
Las falsas características
Ahora, entre las características que se calculan, la mayoría de las características son falsas e irrelevantes. Ahora la ventana que se aplica a una región de la imagen puede ver una región diferente que parece tener las mismas características que la ventana pero que no es en realidad. Por lo tanto, es necesario eliminar las funciones falsas que realizó AdaBoost , que ayudó a seleccionar las mejores funciones de más de 160000 funciones. Adaboost, la forma abreviada de Adaptive Boosting, es un algoritmo de aprendizaje automático que se utilizó para esta única tarea.
Algoritmo:
The frame is captured and converted to grayscale. Bilateral Filtering is applied to remove impurities. Face is detected with the haarcascade. The ROI (Region Of Image) of Face is fed to eye detection part of algorithm. Eyes are detected and resulting list is passed to if-else construct. If the length of list is more than two, means that the eyes are there. Else the program is marked to be eye blinked and restarted.
Código:
haarcascade_frontalface_default.xml y haarcascade_eye_tree_eyeglasses.xml son los archivos xml almacenados en el mismo directorio que el script de python.
Python3
#All the imports go here
import numpy as np
import cv2
#Initializing the face and eye cascade classifiers from xml files
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier('haarcascade_eye_tree_eyeglasses.xml')
#Variable store execution state
first_read = True
#Starting the video capture
cap = cv2.VideoCapture(0)
ret,img = cap.read()
while(ret):
ret,img = cap.read()
#Converting the recorded image to grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#Applying filter to remove impurities
gray = cv2.bilateralFilter(gray,5,1,1)
#Detecting the face for region of image to be fed to eye classifier
faces = face_cascade.detectMultiScale(gray, 1.3, 5,minSize=(200,200))
if(len(faces)>0):
for (x,y,w,h) in faces:
img = cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)
#roi_face is face which is input to eye classifier
roi_face = gray[y:y+h,x:x+w]
roi_face_clr = img[y:y+h,x:x+w]
eyes = eye_cascade.detectMultiScale(roi_face,1.3,5,minSize=(50,50))
#Examining the length of eyes object for eyes
if(len(eyes)>=2):
#Check if program is running for detection
if(first_read):
cv2.putText(img,
"Eye detected press s to begin",
(70,70),
cv2.FONT_HERSHEY_PLAIN, 3,
(0,255,0),2)
else:
cv2.putText(img,
"Eyes open!", (70,70),
cv2.FONT_HERSHEY_PLAIN, 2,
(255,255,255),2)
else:
if(first_read):
#To ensure if the eyes are present before starting
cv2.putText(img,
"No eyes detected", (70,70),
cv2.FONT_HERSHEY_PLAIN, 3,
(0,0,255),2)
else:
#This will print on console and restart the algorithm
print("Blink detected--------------")
cv2.waitKey(3000)
first_read=True
else:
cv2.putText(img,
"No face detected",(100,100),
cv2.FONT_HERSHEY_PLAIN, 3,
(0,255,0),2)
#Controlling the algorithm with keys
cv2.imshow('img',img)
a = cv2.waitKey(1)
if(a==ord('q')):
break
elif(a==ord('s') and first_read):
#This will start the detection
first_read = False
cap.release()
cv2.destroyAllWindows()
Salida de muestra:
Ejemplo de ejecución del código anterior
El código fuente y los clasificadores en cascada se pueden encontrar aquí.