Detección de caras con Python usando OpenCV

Introducción a los clasificadores en cascada de Haar

Este método se introdujo por primera vez en el artículo Rapid Object Detection Using a Boosted Cascade of Simple Features, escrito por Paul Viola y Michael Jones.

La idea que subyace a esta técnica consiste en utilizar una cascada de clasificadores para detectar distintas características en una imagen. A continuación, estos clasificadores se combinan en un clasificador potente que puede distinguir con precisión entre las muestras que contienen un rostro humano y las que no.

El clasificador en cascada de Haar integrado en OpenCV ya ha sido entrenado en un gran conjunto de datos de rostros humanos, por lo que no es necesario ningún entrenamiento adicional. Sólo tenemos que cargar el clasificador de la biblioteca y utilizarlo para realizar la detección de caras en una imagen de entrada.

Instalar OpenCV para Python

Para instalar la biblioteca OpenCV, sólo tienes que abrir el símbolo del sistema o la ventana del terminal y ejecutar el siguiente comando:

pip install opencv-python

Este comando sólo funcionará si ya tienes pip instalado en tu dispositivo. Si quieres saber más sobre el gestor de paquetes pip, puedes leer nuestro Tutorial PIP Python.

OpenCV para la detección de caras en imágenes

Construiremos un detector para identificar el rostro humano en una foto de Unsplash. Asegúrate de guardar la imagen en tu directorio de trabajo y de cambiarle el nombre a input_image antes de codificar.

Paso 1: importar el paquete OpenCV

Ahora, vamos a importar OpenCV e introducir la ruta de la imagen de entrada con las siguientes líneas de código:

import cv2

imagePath = 'input_image.jpg'

Paso 2: leer la imagen

A continuación, tenemos que leer la imagen con la función imread() de OpenCV:

img = cv2.imread(imagePath)

Esto cargará la imagen desde la ruta de archivo especificada y la devolverá en forma de matriz Numpy. 

Vamos a imprimir las dimensiones de esta matriz:

img.shape

(4000, 2667, 3)

Observa que se trata de una matriz tridimensional. Los valores de la matriz representan la altura, la anchura y los canales de la imagen, respectivamente. Como se trata de una imagen en color, se utilizan tres canales para representarla: azul, verde y rojo (BGR). 

Observa que, mientras que la secuencia convencional utilizada para representar imágenes es RGB (Rojo, Azul, Verde), la biblioteca OpenCV utiliza la disposición opuesta (Azul, Verde, Rojo).

Paso 3: convertir la imagen a escala de grises

Para mejorar la eficiencia computacional, primero tenemos que convertir esta imagen a escala de grises antes de realizar en ella la detección de caras:

gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

Examinemos ahora las dimensiones de esta imagen en escala de grises:

gray_image.shape

(4000, 2667)

Observa que esta matriz sólo tiene dos valores, ya que la imagen está en escala de grises y ya no tiene el tercer canal de color.

Paso 4: cargar el clasificador

Carguemos el clasificador Haar Cascade preentrenado que está incorporado en OpenCV:

face_classifier = cv2.CascadeClassifier(
    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)

Observa que estamos utilizando un archivo llamado haarcascade_frontalface_default.xml. Este clasificador está diseñado específicamente para detectar rostros frontales en la entrada visual. 

OpenCV también proporciona otros modelos preentrenados para detectar distintos objetos dentro de una imagen, como los ojos de una persona, su sonrisa, la parte superior de su cuerpo e incluso la matrícula de un vehículo. Puedes obtener más información sobre los distintos clasificadores integrados en OpenCV examinando el repositorio GitHub de la biblioteca.

Paso 5: realizar la detección facial

Ahora podemos realizar la detección de caras en la imagen en escala de grises utilizando el clasificador que acabamos de cargar:

face = face_classifier.detectMultiScale(
    gray_image, scaleFactor=1.1, minNeighbors=5, minSize=(40, 40)
)

Vamos a desglosar los métodos y parámetros especificados en el código anterior:

1. detectMultiScale():

El método detectMultiScale() se utiliza para identificar caras de distintos tamaños en la imagen de entrada.

1. grey_image:

El primer parámetro de este método se llama grey_image, que es la imagen en escala de grises que creamos anteriormente.

1. scaleFactor:

Este parámetro se utiliza para reducir el tamaño de la imagen de entrada y facilitar al algoritmo la detección de caras más grandes. En este caso, hemos especificado un factor de escala de 1.1, lo que indica que queremos reducir el tamaño de la imagen un 10 %.

1. minNeighbors:

El clasificador en cascada aplica una ventana deslizante a través de la imagen para detectar caras en ella. Puedes pensar en estas ventanas como rectángulos. 

Inicialmente, el clasificador captará un gran número de falsos positivos. Éstos se eliminan mediante el parámetro minNeighbors, que especifica el número de rectángulos vecinos que deben identificarse para que un objeto se considere una detección válida.

En resumen, pasar un valor pequeño como 0 o 1 a este parámetro daría lugar a un número elevado de falsos positivos, mientras que un número grande podría hacer que se perdieran muchos verdaderos positivos.

El truco está en encontrar un equilibrio que nos permita eliminar los falsos positivos y, al mismo tiempo, identificar con precisión los verdaderos positivos.

1. minSize:

Por último, el parámetro minSize establece el tamaño mínimo del objeto a detectar. El modelo ignorará las caras que sean más pequeñas que el tamaño mínimo especificado.

Paso 6: dibujar un cuadro delimitador

Ahora que el modelo ha detectado las caras dentro de la imagen, vamos a ejecutar las siguientes líneas de código para crear un cuadro delimitador alrededor de estas caras:

for (x, y, w, h) in face:
    cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 4)

La variable face es una matriz con cuatro valores: los ejes x e y en los que se detectaron las caras, y su anchura y altura. El código anterior itera sobre las caras identificadas y crea un cuadro delimitador que abarca estas medidas.

El parámetro 0,255,0 representa el color del cuadro delimitador, que es verde, y 4 indica su grosor.

Paso 7: visualizar la imagen

Para visualizar la imagen con las caras detectadas, primero tenemos que convertir la imagen del formato BGR a RGB:

img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

Ahora, vamos a utilizar la biblioteca Matplotlib para visualizar la imagen:

import matplotlib.pyplot as plt



plt.figure(figsize=(20,10))
plt.imshow(img_rgb)
plt.axis('off')

El código anterior debería generar el siguiente resultado: 

¡Estupendo!

El modelo ha detectado con éxito el rostro humano en esta imagen y ha creado un cuadro delimitador a su alrededor. 

Detección de caras en tiempo real con OpenCV

Ahora que hemos realizado con éxito la detección de caras en una imagen estática con OpenCV, veamos cómo hacer lo mismo en una secuencia de vídeo en directo. 

Paso 1: requisitos previos

En primer lugar, vamos a importar la biblioteca OpenCV y a cargar el modelo Haar Cascade como hicimos en la sección anterior. Puedes saltarte este bloque de código si ya lo has ejecutado anteriormente:

import cv2

face_classifier = cv2.CascadeClassifier(
    cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
)

Paso 2: acceder a la Webcam

Ahora, necesitamos acceder a la cámara de nuestro dispositivo para leer un flujo de datos de vídeo en directo. Esto se puede hacer con el siguiente código:

video_capture = cv2.VideoCapture(0)

Observa que hemos pasado el parámetro 0 a la función VideoCapture(). Esto indica a OpenCV que utilice la cámara predeterminada de nuestro dispositivo. Si tienes varias cámaras conectadas a tu dispositivo, puedes cambiar el valor de este parámetro en consecuencia.

Paso 3: identificar rostros en el flujo de vídeo

Ahora, vamos a crear una función para detectar caras en el flujo de vídeo y dibujar un cuadro delimitador a su alrededor:

def detect_bounding_box(vid):
    gray_image = cv2.cvtColor(vid, cv2.COLOR_BGR2GRAY)
    faces = face_classifier.detectMultiScale(gray_image, 1.1, 5, minSize=(40, 40))
    for (x, y, w, h) in faces:
        cv2.rectangle(vid, (x, y), (x + w, y + h), (0, 255, 0), 4)
    return faces

La función detect_bounding_box toma como entrada el fotograma de vídeo.

En esta función, utilizamos los mismos códigos que antes para convertir el fotograma en escala de grises antes de realizar la detección de caras.

A continuación, también detectamos la cara en esta imagen utilizando los mismos valores de parámetros para scaleFactor, minNeighbors, y minSize que hicimos anteriormente.

Por último, dibujamos un cuadro delimitador verde de grosor 4 alrededor del marco.

Paso 4: crear un bucle para la detección de caras en tiempo real

Ahora, tenemos que crear un while loop indefinido que capture el fotograma de vídeo de nuestra webcam y le aplique la función de detección de caras:

while True:

    result, video_frame = video_capture.read()  # read frames from the video
    if result is False:
        break  # terminate the loop if the frame is not read successfully

    faces = detect_bounding_box(
        video_frame
    )  # apply the function we created to the video frame

    cv2.imshow(
        "My Face Detection Project", video_frame
    )  # display the processed frame in a window named "My Face Detection Project"

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

video_capture.release()
cv2.destroyAllWindows()

Después de ejecutar el código anterior, deberías ver aparecer en la pantalla una ventana llamada My Face Detection Project:

El algoritmo debe rastrear tu cara y crear un cuadro delimitador verde a su alrededor, independientemente de dónde te muevas dentro del fotograma.

En el fotograma de arriba, el modelo reconoce mi cara y mi foto en el permiso de conducir que sostengo.

También puedes probar la eficacia de este modelo sosteniendo varias fotos o haciendo que distintas personas se coloquen en distintos ángulos detrás de la cámara. El modelo debe ser capaz de identificar todos los rostros humanos en diferentes fondos o configuraciones de iluminación.

Si quieres salir del programa, puedes pulsar la tecla "q" de tu teclado para salir del bucle.

Detección de caras con OpenCV - Próximos pasos

Ahora que has aprendido a detectar con éxito rostros humanos tanto en imágenes como en vídeos en tiempo real utilizando la biblioteca OpenCV, aquí tienes algunos pasos que puedes dar para llevar tus conocimientos al siguiente nivel:

Crea tu propio proyecto

Puedes utilizar el código proporcionado en este tutorial como punto de partida para tu propio proyecto de detección de caras.

Una forma de ampliar este proyecto es identificar rostros humanos en distintos tipos de datos de entrada, como archivos PDF o imágenes de vigilancia. Incluso puedes instalar una cámara de seguridad propia y realizar la detección facial con los datos que capte en tiempo real.

Además, puedes crear un modelo de detección de caras en grandes conjuntos de datos o ir un paso más allá y realizar tareas como detectar si una persona lleva máscaras en conjuntos de datos de imágenes.

Los conjuntos de datos Face Detection in Images y Face Mask Detection en Kaggle son buenos puntos de partida para un proyecto de portafolio en este ámbito.

Construir un modelo de reconocimiento facial

Mientras que la detección facial se utiliza para detectar un rostro humano en una entrada visual, el reconocimiento facial va un paso más allá. Esta tecnología se utiliza para verificar la identidad de una persona cotejando su rostro con una base de datos existente.

Puedes intentar construir un modelo de reconocimiento facial que identifique un rostro concreto (quizá incluso el tuyo) entre una multitud de otras personas. 

Esta tarea será un poco más difícil que la detección de caras, ya que el modelo debe entrenarse con muchas muestras de datos antes de que pueda distinguir entre las personas.

Antes de construir un modelo de reconocimiento facial, puede que también necesites realizar técnicas de preprocesamiento, como la reducción del ruido y la transformación de la imagen. 

Si estos conceptos te suenan extraños, ¡no te preocupes! Puedes aprender todo sobre el procesamiento de imágenes siguiendo nuestro curso de Procesamiento de imágenes en Python.

Adquirir experiencia en el dominio

El procesamiento de imágenes y vídeo tiene aplicaciones en una amplia gama de sectores, como la seguridad, el comercio minorista, la sanidad y la fabricación.

Si quieres conseguir un trabajo como especialista en visión artificial, primero tienes que entender los tipos de datos que se utilizan en estas industrias. La experiencia en el dominio te facilitará etiquetar, transformar y entrenar conjuntos de datos en escenarios del mundo real.

Para empezar, puedes seguir nuestro curso de Análisis de imágenes biomédicas en Python. Este programa te enseñará a procesar imágenes de tomografía computarizada, segmentar una serie temporal de resonancia magnética cardiaca y determinar si la enfermedad de Alzheimer modifica la estructura cerebral. 

Estos conceptos te dotarán de las habilidades necesarias para entrar en el campo de la imagen biomédica.