Detección de rostros de OpenCV mediante el clasificador en cascada de Haar

En esta demostración, aprenderemos los conceptos básicos de la detección de rostros con la ayuda de los clasificadores en cascada basados ​​en funciones de haar y aprenderemos a detectar rostros a partir de una imagen y un video en OpenCV.

Cree un proyecto de detección de rostros con el clasificador en cascada de Haar en OpenCV

La detección de objetos mediante los clasificadores en cascada basados ​​en características de Haar es un método eficaz de detección de objetos propuesto por Paul Viola y Michael Jones en su gente. El clasificador de cascadas basado en funciones de Haar es un enfoque basado en el aprendizaje automático en el que se entrena una función en cascada para muchas imágenes positivas y negativas.

Entonces, ¿cuáles son estas imágenes positivas y negativas? Un clasificador se entrena con unos pocos cientos de vistas de muestra de un objeto en particular, que puede ser una cara, un automóvil o cualquier otro objeto llamado positivo.

Por ejemplo, si va a detectar una cara, debe entrenar su clasificador con la cantidad de imágenes que contienen caras. Entonces, se llama las imágenes positivas.

En otro caso, si desea detectar el rostro y la imagen no contiene el rostro, se denomina imagen negativa.

Una vez que se entrena un clasificador, se puede aplicar a una región de interés en una imagen de entrada. La salida del clasificador es un 1 si es probable que la región muestre el objeto; de lo contrario, es 0.

Veamos cómo podemos usar la detección de Haar Cascade en OpenCV.

OpenCV viene con un entrenador y un detector. Si desea entrenar su clasificador para cualquier objeto como un reloj, un automóvil o cualquier cosa, puede usar este clasificador.

Podemos encontrar algunos archivos XML de clasificadores entrenados en la página de OpenCV GitHub. Muchos clasificadores capacitados están disponibles dentro de este repositorio.

Solo necesita abrir este archivo resaltado y luego descargarlo haciendo clic en el botón del icono sin procesar. Cuando se abre, puede hacer clic derecho y guardarlo en su computadora.

Abramos el editor de código y definamos nuestros clasificadores.

Hay un método llamado CascadeClassifier() donde podemos proporcionar nuestra ruta de clasificador. Una vez que hemos definido el clasificador, leemos la imagen.

F_C = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")

Dado que este clasificador funcionará con las imágenes en escala de grises, debemos convertir nuestra imagen en una imagen en escala de grises. Será realmente fácil implementar la conversión de imágenes.

IMG = cv2.imread("inp.png")
G_scale = cv2.cvtColor(IMG, cv2.COLOR_BGR2GRAY)

El siguiente paso es detectar las caras dentro de esta imagen; para ello, declararemos una variable llamada Faces. Llamaremos al método detectMultiScale(), que toma tres parámetros.

El primero es la imagen en escala de grises, y el segundo argumento que vamos a usar es el factor de escala, que se usa para especificar cuánto se reduce el tamaño de la imagen en cada escala de imagen. El siguiente es el parámetro de vecinos mínimos, que especifica cuántos vecinos en cada rectángulo candidato deben tener para retenerlo.

Faces = F_C.detectMultiScale(G_scale, 1.1, 4)

El último paso será iterar sobre todas las caras que hemos detectado y luego dibujar un rectángulo. Esta variable Faces será el vector del rectángulo donde cada rectángulo contiene un objeto detectado, y en nuestro caso, será la cara detectada.

Obtendremos el parámetro (x,y,w,h) del objeto Faces. Estos son valores del rectángulo del objeto.

Mientras obtenemos las coordenadas, dibujaremos el rectángulo usando el método rectangle().

Toma algunos parámetros. El primero es una imagen, el segundo son los puntos (x,y), que obtuvimos usando el vector Faces, y el siguiente parámetro es el segundo punto del rectángulo.

Los siguientes dos parámetros son el color y el grosor.

import cv2

F_C = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")

IMG = cv2.imread("inp.png")
G_scale = cv2.cvtColor(IMG, cv2.COLOR_BGR2GRAY)
Faces = F_C.detectMultiScale(G_scale, 1.1, 4)

for (x, y, w, h) in Faces:
    cv2.rectangle(IMG, (x, y), (x + w, y + h), (255, 0, 0), 3)

cv2.imshow("IMG", IMG)

cv2.waitKey()

Ahora podemos ver que la cara se detecta dentro de una imagen.

Intentemos detectar la cara dentro de un video, por lo que este no será un enfoque diferente. Solo necesitaremos aplicar este enfoque a cada cuadro, por lo que en lugar de leer la imagen, usaremos el método VideoCapture() para capturar el video.

Para capturar los fotogramas, necesitamos definir una variable Video y hacerla igual a VideoCapture() y proporcionar un archivo mp4. Si tiene la cámara, puede proporcionarla 0.

Ahora encerraremos todo el código anterior dentro de un bucle while, y al bucle while, definimos el método isOpened(). Si este método devuelve un valor verdadero, entonces el programa procederá a leer el cuadro; vamos a llamar Video.read(), lo que significa que estamos leyendo cada cuadro.

Definiremos una condición cuando alguien presione la tecla q, entonces el programa saldrá del bucle while. Por fin, fuera de nuestro bucle while, lanzaremos nuestro video.

import cv2

F_C = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")

Video = cv2.VideoCapture("inp.mp4")

while Video.isOpened():
    _, IMG = Video.read()

    G_scale = cv2.cvtColor(IMG, cv2.COLOR_BGR2GRAY)
    Faces = F_C.detectMultiScale(G_scale, 1.1, 4)

    for (x, y, w, h) in Faces:
        cv2.rectangle(IMG, (x, y), (x + w, y + h), (255, 0, 0), 3)

    cv2.imshow("Window", IMG)
    K = cv2.waitKey(1)
    if K & 0xFF == ord("q"):
        break

Video.release()

En este vídeo podemos ver los rostros detectados en vídeo en tiempo real.