Detección facial + reconocimiento: 8 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:44

Este es un ejemplo simple de ejecución de detección y reconocimiento de rostros con OpenCV desde una cámara. NOTA: HICE ESTE PROYECTO PARA EL CONCURSO DE SENSORES Y UTILIZÉ LA CÁMARA COMO SENSOR PARA SEGUIR Y RECONOCER CARAS. Entonces, nuestro objetivo En esta sesión, 1. Instalar Anaconda 2. Descargar el paquete de CV abierto 3. Establecer variables ambientales 4. Probar para confirmar 5. Crear código para la detección de rostros 6. Crear código para crear un conjunto de datos 7. Crear código para entrenar al reconocedor 8. Crear código para reconocer las caras y el resultado.

Paso 1: Instale Anaconda

Anaconda es esencialmente un IDE de Python muy bien empaquetado que se envía con toneladas de paquetes útiles, como NumPy, Pandas, IPython Notebook, etc. Parece que se recomienda en todas partes de la comunidad científica. Consulte Anaconda para instalarlo.

Paso 2: Descargue el paquete Open CV

En primer lugar, vaya al sitio oficial de OpenCV para descargar el paquete completo de OpenCV. Elija una versión que le guste (2.xo 3.x). Estoy en Python 2.xy OpenCV 2.x, principalmente porque así es como se configuran / basan los tutoriales de OpenCV-Python.

En mi caso, extraje el paquete (esencialmente una carpeta) directamente a mi unidad F. (F: / opencv).

Paso 3: establecer variables ambientales

Copie y pegue el archivo cv2.pyd

El directorio de paquetes de sitio de Anaconda (por ejemplo, F: / Archivos de programa / Anaconda2 / Lib / paquetes de sitio en mi caso) contiene los paquetes de Python que puede importar. Nuestro objetivo es copiar y pegar el archivo cv2.pyd en este directorio (para que podamos usar la importación cv2 en nuestros códigos Python).

Para hacer esto, copie el archivo cv2.pyd…

Desde este directorio OpenCV (la parte inicial puede ser ligeramente diferente en su máquina):

# Python 2.7 y máquina de 64 bits: F: / opencv / build / python / 2.7 / x64 # Python 2.7 y máquina de 32 bits: F: / opencv / build / python / 2.7 / x84

A este directorio de Anaconda (la parte inicial puede ser ligeramente diferente en su máquina):

F: / Archivos de programa / Anaconda2 / Lib / site-packages

Después de realizar este paso, ahora podremos usar import cv2 en código Python. PERO, todavía tenemos que trabajar un poco más para que funcione FFMPEG (códec de video) (que nos permita hacer cosas como procesar videos).

Haga clic con el botón derecho en "Mi PC" (o "Esta PC" en Windows 8.1) -> haga clic con el botón izquierdo en Propiedades -> haga clic con el botón izquierdo en la pestaña "Avanzado" -> haga clic con el botón izquierdo en el botón "Variables de entorno …". Agregue una nueva variable de usuario para apuntar al OpenCV (ya sea x86 para sistemas de 32 bits o x64 para sistemas de 64 bits). Actualmente estoy en una máquina de 64 bits.

OPENCV_DIRC de 32 bits: / opencv / build / x86 / vc12

OPENCV_DIRC de 64 bits: / opencv / build / x64 / vc12

Agregue% OPENCV_DIR% / bin a la PATH de la variable de usuario.

Por ejemplo, mi variable de usuario PATH se ve así …

Antes:

F: / Usuarios / Johnny / Anaconda; C: / Usuarios / Johnny / Anaconda / Scripts

Después:

F: / Usuarios / Johnny / Anaconda; C: / Usuarios / Johnny / Anaconda / Scripts;% OPENCV_DIR% / bin

¡Esto es todo, hemos terminado! ¡FFMPEG está listo para usarse!

Paso 4: prueba para confirmar

Necesitamos probar si ahora podemos hacer esto en Anaconda (a través de Spyder IDE):

• Importar paquete OpenCV
• Use la utilidad FFMPEG (para leer / escribir / procesar videos)

Prueba 1: ¿Podemos importar OpenCV?

Para confirmar que Anaconda ahora puede importar el paquete OpenCV-Python (es decir, cv2), emita estos en la consola de IPython:

importar cv2

imprimir cv2._ versión_

Si el paquete cv2 se importa correctamente sin errores, y se imprime la versión cv2, ¡estamos todos bien!

Prueba 2: ¿Podemos utilizar el códec FFMPEG?

Coloque una muestra

input_video.mp4

archivo de video en un directorio. Queremos probar si podemos:

• lea este archivo de video.mp4 y
• escribir un nuevo archivo de video (puede ser.avi o.mp4, etc.)

Para hacer esto, necesitamos tener un código de prueba de Python, llámelo test.py. Colóquelo en el mismo directorio que la muestra

input_video.mp4

expediente.

Esto es lo que

test.py

puede verse así (Nota: muchas gracias a las sugerencias de Pete y Warren en el campo de comentarios; he reemplazado mi código de prueba original con el suyo; pruébelo usted mismo y avísenos si funciona mejor):

importar cv2

cap = cv2. VideoCapture ("input_video.mp4") print cap.isOpened () # True = leer el video correctamente. Falso: no se pudo leer el video. fourcc = cv2. VideoWriter_fourcc (* 'XVID') out = cv2. VideoWriter ("output_video.avi", fourcc, 20.0, (640, 360)) print out.isOpened () # True = escribir el video correctamente. Falso: no se pudo escribir el video. cap.release () out.release ()

Esta prueba es MUY IMPORTANTE. Si desea procesar archivos de video, debe asegurarse de que Anaconda / Spyder IDE pueda usar el FFMPEG (códec de video). Me tomó días hacerlo funcionar. ¡Pero espero que te lleve mucho menos tiempo!:) Nota: un consejo más muy importante al utilizar el IDE de Anaconda Spyder. ¡Asegúrese de verificar el directorio de trabajo actual (CWD)!

Paso 5: crea un código para la detección de rostros

Objetivo

En esta sesión,

• Veremos los conceptos básicos de la detección de rostros utilizando clasificadores en cascada basados en características de Haar
• Extenderemos lo mismo para la detección de ojos, etc.

Detección de Haar-Cascade en OpenCV

Aquí nos ocuparemos de la detección. OpenCV ya contiene muchos clasificadores previamente entrenados para rostro, ojos, sonrisa, etc. Estos archivos XML se almacenan en la carpeta opencv / data / haarcascades /. Creemos un detector de rostro y ojo con OpenCV. Primero, necesitamos cargar los clasificadores XML requeridos. Luego cargue nuestra imagen de entrada (o video) en modo de escala de grises O podemos usar la cámara (para detección de rostros en tiempo real)

importar numpy como np

import cv2 face_cascade = cv2. CascadeClassifier ('F: / Archivos de programa / opencv / sources / data / haarcascades / haarcascade_frontalface_default.xml') eye_cascade = cv2. CascadeClassifier ('F: / Archivos de programa / opencv / sources / data / haarcascades_eye.xml ') cap = cv2. VideoCapture (0) while 1: ret, img = cap.read () gray = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale (gris, 1.5, 5) para (x, y, w, h) en caras: cv2.rectangle (img, (x, y), (x + w, y + h), (255, 0, 0), 2) roi_gray = gray [y: y + h, x: x + w] roi_color = img [y: y + h, x: x + w] eyes = eye_cascade.detectMultiScale (roi_gray) para (ex, ey, ew, eh) en ojos: cv2.rectangle (roi_color, (ex, ey), (ex + ew, ey + eh), (0, 255, 0), 2) imprimir "encontrado" + str (len (caras)) + "cara (s)" cv2.imshow ('img', img) k = cv2.waitKey (30) & 0xff si k == 27: romper cap.release () cv2.destroyAllWindows ()

Paso 6: crear código para crear un conjunto de datos

Estamos haciendo reconocimiento facial, por lo que necesitará algunas imágenes faciales. Puede crear su propio conjunto de datos o comenzar con una de las bases de datos faciales disponibles, https://face-rec.org/databases/ le brinda una descripción general actualizada. Tres bases de datos interesantes son (partes de la descripción se citan en

• AT&T Facedatabase
• Yale Facedatabase A
• Base de datos B de Yale ampliada

AQUÍ estoy usando mi propio conjunto de datos … con la ayuda del código que se proporciona a continuación:

importar numpy como np

import cv2 face_cascade = cv2. CascadeClassifier ('F: / Archivos de programa / opencv / sources / data / haarcascades / haarcascade_frontalface_default.xml') cap = cv2. VideoCapture (0) id = raw_input ('ingrese id de usuario') sampleN = 0; while 1: ret, img = cap.read () gray = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale (gris, 1.3, 5) para (x, y, w, h) en caras: sampleN = muestraN + 1; cv2.imwrite ("F: / Archivos de programa / proyectos / face_rec / facesData / User." + str (id) + "." + str (sampleN) + ".jpg", gris [y: y + h, x: x + w]) cv2.rectangle (img, (x, y), (x + w, y + h), (255, 0, 0), 2) cv2.waitKey (100) cv2.imshow ('img', img) cv2.waitKey (1) si muestraN> 20: romper cap.release () cv2.destroyAllWindows ()

Paso 7: crear código para entrenar al reconocedor

Crea la función para preparar el conjunto de entrenamiento

Ahora, definiremos una función

getImagesWithID (ruta)

que toma la ruta absoluta a la base de datos de imágenes como argumento de entrada y devuelve una tupla de 2 listas, una que contiene las caras detectadas y la otra que contiene la etiqueta correspondiente para esa cara. Por ejemplo, si el i-ésimo índice en la lista de caras representa el quinto individuo en la base de datos, entonces la i-ésima ubicación correspondiente en la lista de etiquetas tiene un valor igual a 5.

Ahora convierta las caras del conjunto de datos (que se crea en el paso 6) en un archivo.yml con la ayuda del código que se proporciona a continuación:

importar sistema operativo

import numpy as np import cv2 from PIL import Image # Para el reconocimiento facial usaremos el reconocedor de reconocimiento facial LBPH = cv2.createLBPHFaceRecognizer (); ruta = "F: / Archivos de programa / proyectos / face_rec / facesData" def getImagesWithID (ruta): imagePaths = [os.path.join (ruta, f) para f en os.listdir (ruta)] # print image_path #getImagesWithID (path) faces = IDs = para imagePath en imagePaths: # Leer la imagen y convertirla a escala de grises facesImg = Image.open (imagePath).convert ('L') faceNP = np.array (facesImg, 'uint8') # Obtener la etiqueta de la imagen ID = int (os.path.split (imagePath) [- 1].split (".") [1]) # Detectar la cara en la imagen faces.append (faceNP) IDs.append (ID) cv2.imshow ("Adición de caras para el entrenamiento", faceNP) cv2.waitKey (10) return np.array (ID), ID de caras, caras = getImagesWithID (ruta) Recognizer.train (caras, ID) Recognizer.save ("F: / Archivos de programa / proyectos / face_rec / faceREC / trainingdata.yml") cv2.destroyAllWindows ()

al usar este código, todos los conjuntos de datos faciales se convierten en un solo archivo.yml….. la ubicación de la ruta es ("F: / Archivos de programa / proyectos / face_rec / faceREC / trainingdata.yml")

Paso 8: crea un código para reconocer las caras y el resultado

Guyzz este es el paso final en el que podemos crear el código para reconocer las caras con la ayuda de tu webcam EN ESTE PASO HAY DOS OPERACIONES QUE SE VAN A REALIZAR…. 1. capturar el video de la cámara 2. compararlo con su archivo.yml

importar numpy como npimport cv2 face_cascade = cv2. CascadeClassifier ('F: / Archivos de programa / opencv / sources / data / haarcascades / haarcascade_frontalface_default.xml') cap = cv2. VideoCapture (0) rec = cv2.createLBPH (FaceRecognizer; rec.load ("F: / Archivos de programa / proyectos / face_rec / faceREC / trainingdata.yml") id = 0 font = cv2.cv. InitFont (cv2.cv. CV_FONT_HERSHEY_COMPLEX_SMALL, 5, 1, 0, 4) mientras que 1: ret, img = cap.read () gray = cv2.cvtColor (img, cv2. COLOR_BGR2GRAY) faces = face_cascade.detectMultiScale (gris, 1.5, 5) para (x, y, w, h) en caras: cv2.rectangle (img, (x, y), (x + w, y + h), (255, 0, 0), 2) id, conf = rec.predict (gris [y: y + h, x: x + w]) if (id == 2): id = "alok" if id == 1: id = "alok" if id == 3: id = "anjali" if id == 4: id = "Gaurav" if id = = 5: id = 'rahul' if id == 6: id = "akshay" cv2.cv. PutText (cv2.cv.fromarray (img), str (id), (x, y + h), fuente, 255) cv2.imshow ('img', img) si cv2.waitKey (1) == ord ('q'): romper cap.release ()

cv2.destroyAllWindows ()

y finalmente el resultado vendrá frente a sus ojos …… u también puede descargar el archivo zip desde debajo del enlace: Haga clic aquí para descargar los códigos Entonces, en este instructivo realizamos la tarea de detección de rostros + reconocimiento usando OpenCV …..si usted como este instructivo….. por favor suscríbeme y vota por mí…..gracias amigos:)