Reconocimiento de la cara con OpenCV

La complejidad de las máquinas ha aumentado a lo largo de los años y las computadoras no son una excepción. Las computadoras han ayudado a la humanidad a resolver muchos problemas y completar muchas tareas difíciles. Atrás quedaron los días en que todas las computadoras eran operaciones aritméticas simples, las computadoras ahora impulsan el mundo.

Las computadoras se han vuelto tan complejas que están siendo entrenados para pensar como humanos.
Sí!

Vamos a hacer algo de esa naturaleza en este artículo. Como humanos, reconocer las caras de otras personas es una tarea simple y, a pesar de las habilidades de las computadoras de hoy, no es tan fácil para la computadora, por lo que tenemos que entrenarla para poder hacer lo mismo para poder hacer lo mismo.

Muchos artículos que verías por ahí se detienen en una simple detección de cara, pero en este artículo estaría cubriendo no solo la detección de la cara sino también el reconocimiento de la cara.

Esto significa que si la computadora se presenta con dos fotos mías, no solo reconocería qué parte de la imagen es mi cara, sino que también reconocería que yo también soy yo en ambas imágenes.

Para comenzar, primero tendríamos que instalar OpenCV en nuestras máquinas, lo que solo se puede hacer si tiene Python instalado. La instalación de Python no es el objetivo de este artículo, por lo que si aún no lo tiene en su máquina, puede instalar Python desde el sitio web de Python.

Para instalar Open CV, podemos hacerlo utilizando el comando PIP.

PIP Instalar OpenCV-Python

También haremos uso del paquete Numpy en este artículo, que debe instalarse junto con OpenCV utilizando el comando anterior.

Si Numpy no se instaló, puede hacerlo fácilmente usando el comando a continuación:

PIP install numpy

Para confirmar que su OpenCV está instalado, cuando activa el entorno interactivo de Python, intente importarlo usando:

Importar CV2

Si no recibe un error, entonces puede continuar.

Para llevar a cabo el reconocimiento facial, estaríamos escribiendo tres scripts. Uno para crear un conjunto de datos de imágenes, otro para entrenar esas imágenes y luego el último para reconocer las caras en función de los resultados de la capacitación que atraviesa la computadora.

Necesitaríamos la cascada Haar proporcionada por Open CV. Este archivo se puede obtener del directorio OpenCV que es CV2/data/haarcascade_frontalface_default.XML en mi máquina también debería ser lo mismo en tu máquina. Copie el archivo en la carpeta donde desea hacer el reconocimiento de la cara.

Ahora vamos a metámonos en el meollo de las cosas.
Intentaríamos obtener nuestra cámara web para obtener las imágenes, necesarias para el conjunto de datos.

Importar CV2
vid_cam = CV2.Videocapture (0)
face_detector = CV2.CascadeClassifier ('Haarcascade_Frontalface_Default.xml ')
face_id = 1
recuento = 0
Mientras (Vid_Cam.está abierto()):
ret, image_frame = Vid_cam.leer()
gris = cv2.cvtcolor (image_frame, CV2.Color_bgr2gray)
caras = face_detector.detectMultiscale (gris, 1.3, 5)
para (x, y, w, h) en las caras:
CV2.Rectangle (image_frame, (x, y), (x+w, y+h), (255,0,0), 2)
recuento += 1
CV2.imwrite ("conjunto de datos/usuario." + str (face_id) + '.' + str (count) + ".jpg ", gris [y: y+h, x: x+w])
CV2.imshow ('frame', image_frame)
Si CV2.WaitKey (100) y 0xff == ord ('Q'):
romper
Elif cuenta> 100:
romper
Vid_Cam.liberar()
CV2.DestroyallWindows ()

Entonces, para explicar qué hace cada línea de código:

Importar CV2

Aquí está el comando que le dice a Python que incluya una biblioteca externa que se utilizará en este código, en este caso está abierto CV.

vid_cam = CV2.Videocapture (0)

Este código llama a la biblioteca de CV abierta importada para comenzar a capturar y la cámara web se inicia en este momento. Si el CV abierto no admite su cámara web, el código fallará aquí.

face_detector = CV2.CascadeClassifier ('Haarcascade_Frontalface_Default.xml ')

Para que podamos llevar a cabo la detección de imágenes, este código es necesario. Open CV usa el 'haarcascade_frontalface_default.XML 'para la clasificación en cascada. El objeto resultante se almacena luego en la variable Face_Detector.

face_id = 1

Aquí hay un caso de establecer el número de identificación de la cara, por lo que la primera cara obtiene una ID de 1.

recuento = 0

Tomaremos un par de imágenes a medida que el CV abierto necesita entrenar imágenes para poder reconocer caras, la variable de conteo sirve como un recuento de imágenes.

Mientras (Vid_Cam.está abierto()):

Esto permite que las siguientes operaciones continúen siempre que se abra la cámara de video. El método isOpened () devuelve verdadero o falso.

ret, image_frame = Vid_cam.leer()

Aquí, el Vid_Cam.Read () analiza la captura de video y luego captura el marco que se almacena en la variable Image_Frame, si la operación es exitosa, la verdadera booleana se devuelve y almacena en la variable RET

gris = cv2.cvtcolor (image_frame, CV2.Color_bgr2gray)

El método cvtcolor () se utiliza para convertir el marco de la imagen en el tipo de color deseado. En este caso lo hemos convertido en escala de grises.

caras = face_detector.detectMultiscale (gris, 1.3, 5)

Esto verifica marcos de diferentes tamaños e intenta establecerlos en escala, esto se aplica en la variable a la que se aplicó la cascada de Haar.

para (x, y, w, h) en las caras:

Aquí atravesamos las caras y sus dimensiones, donde X e Y representan las coordenadas y W y H representan el ancho y la altura respectivamente.

CV2.Rectangle (image_frame, (x, y), (x+w, y+h), (255,0,0), 2)

Recuerde que todavía estamos trabajando con la cámara de video, la cámara de video luego cultiva parte de la imagen de la imagen de acuerdo con las dimensiones anteriores.

recuento += 1

Inmediatamente se hace, la variable de conteo que se mantiene como contador y luego incrementa.

CV2.imwrite ("conjunto de datos/usuario." + str (face_id) + '.' + str (count) + ".jpg ", gris [y: y+h, x: x+w])

La imagen recortada es la guardada con el nombre de nombre (Face_id).(contar).JPG y poner en una carpeta llamada DataSet.

CV2.imshow ('frame', image_frame)

Después de guardar, este código asegura que el marco de video de imagen se muestre con un rectángulo en la cara del individuo después de que se haya realizado la detección de la cara.

Si CV2.WaitKey (100) y 0xff == ord ('Q'):
romper

Después de cada imagen, el usuario puede evitar que el programa tome más fotos que se pueden hacer presionando la 'Q' en el teclado para al menos 100 ms.

Elif cuenta> 100:
romper

Lo que hace este código es evitar que el video funcione en el momento en que se han tomado 100 imágenes, independientemente de si el usuario quiere tomar más o no.

Vid_Cam.liberar()

Aquí, la cámara web está cerrada y no solo se detiene para tomar fotos.

CV2.DestroyallWindows ()

Entonces todos los Windows OpenCV han abierto se han destruido y el código se ejecuta hasta la conclusión.

Ahora que hemos terminado con eso, podemos poder entrenar el conjunto de datos de imágenes:

Importar CV2, OS
importar numpy como np
de la imagen de importación de pil
reconocimiento = CV2.rostro.createLbphFacerCognizer ()
detector = CV2.CascadeClassifier ("Haarcascade_Frontalface_Default.xml ");
Def getMagesAndLabels (ruta):
ImagePaths = [OS.camino.unirse (ruta, f) para f en el sistema operativo.listDir (ruta)]
muestras de cara = []
IDS = []
Para ImagePath en ImagePath:
Pil_img = imagen.Abierto (ImagePath).convertir ('l')
img_numpy = np.Array (pil_img, 'uint8')
id = int (OS.camino.Split (ImagePath) [-1].dividir(".") [1])
caras = detector.DetectMultiscale (img_numpy)
para (x, y, w, h) en las caras:
muestra.append (img_numpy [y: y+h, x: x+w])
IDS.anular (ID)
Devuelve las muestras, IDS
caras, ids = getImagesAndLabels ('DataSet')
reconocer.tren (caras, NP.Array (IDS))
reconocer.salvar ('entrenador/entrenador.yml ')

Sigamos y expliquemos este código también:

Importar CV2, OS

Al igual que el otro código, aquí estamos importando OpenCV y OS que necesitaríamos para la ruta de archivo.

importar numpy como np

También estamos importando la biblioteca Numpy que se utilizaría para el cálculo de la matriz (una matriz es solo una disposición de matrices).

de la imagen de importación de pil

Estamos importando la biblioteca de imágenes de Python y luego también estamos obteniendo la biblioteca de imágenes de este paquete.

reconocimiento = CV2.rostro.createLbphFacerCognizer ()

Lo que esto hace es aplicar el método createelbphfacerCognizer () al CV2.Face Object, esto ayudaría a facilitar el reconocimiento de las caras, ya que no tenemos que encontrar nuestro propio conjunto de algoritmos.

detector = CV2.CascadeClassifier ("Haarcascade_Frontalface_Default.xml ");

Si ha estado siguiendo el tutorial, se habría encontrado con esto antes. Ayuda con la detección de la cara usando el "Haarcascade_Frontalface_Default.XML ”para la clasificación Cascade.

Def getMagesAndLabels (ruta):

Ahora, estamos a punto de comenzar el entrenamiento de imagen propiamente dicho, por lo que creamos una función.

ImagePaths = [OS.camino.unirse (ruta, f) para f en el sistema operativo.listDir (ruta)]

Este código se verifica en el directorio actual del archivo y verifica los archivos de imagen y luego los agrega a esta lista.

muestras de cara = []

Esto inicializa una lista de muestras, está vacía en este punto, pero las caras se agregarían a medida que se ejecuta el código.

IDS = []

Inicializar una lista de ID, que inicialmente está vacía.

Para ImagePath en ImagePath:

Recuerde el código que verificó los archivos de imagen en el directorio? Sí? Ahora, vamos a recorrer cada uno de esos archivos y llevar a cabo operaciones en ellos.

Pil_img = imagen.Abierto (ImagePath).convertir ('l')

Ahora lo primero que le hacemos a la imagen es convertirlo a escala de grises, y este código lo hace.

img_numpy = np.Array (pil_img, 'uint8')

La imagen con escala gris es solo una serie de números, todo en un solo lugar, por lo que creamos una matriz numpy de ellos y la asignamos a una variable.

id = int (OS.camino.Split (ImagePath) [-1].dividir(".") [1])

Si recuerda el archivo que obtiene las imágenes, recordaría que llamamos al usuario de archivos (face_id).contar.JPG. Así que aquí estamos dividiendo los nombres con el "."Y luego extraemos el face_id y asignamos a una variable aquí. Necesitaríamos la identificación de reconocimiento.

caras = detector.DetectMultiscale (img_numpy)

Desde la matriz Numpy, el método DetectMultiscale () intentará detectar las caras del patrón que encuentra en la matriz Numpy. Luego asigna los valores en la variable de caras.

para (x, y, w, h) en las caras:

Aquí, estamos recorriendo los valores asignados a la variable. Los valores aquí son las coordenadas X e Y que podríamos tomar como origen, y luego W y H representan el ancho y la altura respectivamente.

muestra.append (img_numpy [y: y+h, x: x+w])

Anteriormente creamos una lista de muestras de cara, pero estaba vacío. Aquí podemos agregar caras a esa lista, y estamos agregando la Y a H para obtener los dos valores de las coordenadas y y lo mismo se hace a X.

IDS.anular (ID)

Ahora tenemos una lista de muestras de cara a cara, por lo que también obtenemos su identificación y la agregamos a la lista de IDS.

Devuelve las muestras, IDS

Luego, después de todo, devolvemos la lista de muestras de cara y la lista de IDS.

caras, ids = getImagesAndLabels ('DataSet')

Recuerde que GetImagesAndLabels () es solo una función. Por lo tanto, podemos llamar a la función aquí, y los valores de retorno se guardan en las variables de caras e IDS.

reconocer.tren (caras, NP.Array (IDS))

Aquí es donde ocurre el verdadero entrenamiento. Aplicamos el método createelbphfacerCognizer () en algún momento antes y asignado a una variable reconocida. Es hora de entrenamiento!

reconocer.salvar ('entrenador/entrenador.yml ')

Después del entrenamiento, podemos guardar los resultados de la capacitación.
Después de ejecutar el código, crea un archivo llamado entrenador.YML que luego sería utilizado por el código de reconocimiento de la cara.

Aquí está el código de reconocimiento de la cara:

Importar CV2
importar numpy como np
reconocimiento = CV2.rostro.createLbphFacerCognizer ()
reconocer.carga ('entrenador/entrenador.yml ')
cascadepath = "haarcascade_frontalface_default.XML "
facecascade = cv2.Cascadeclassifier (Cascadepath)
fuente = CV2.Font_hershey_simple
CAM = CV2.Videocapture (0)
Mientras que es cierto:
ret, im = cam.leer()
gris = cv2.cvtcolor (IM, CV2.Color_bgr2gray)
caras = facecascada.detectMultiscale (gris, 1.2,5)
para (x, y, w, h) en las caras:
CV2.rectángulo (im, (x-20, y-20), (x+w+20, y+h+20), (0,255,0), 4)
ID = Reconocimiento.Predecir (gris [y: y+h, x: x+w])
if (id == 1):
Id = "nazmi"
demás:
Id = "desconocido"
CV2.Rectángulo (IM, (X-22, Y-90), (X+W+22, Y-22), (0,255,0), -1)
CV2.PutText (im, str (id), (x, y-40), fuente, 2, (255,255,255), 3)
CV2.Imshow ('im', im)
Si CV2.WaitKey (10) y 0xff == ord ('Q'):
romper
leva.liberar()
CV2.DestroyallWindows ()

Si ha estado siguiendo el artículo desde el principio, lo hemos hecho antes. Si no lo has hecho.

reconocer.carga ('entrenador/entrenador.yml ')

Recuerde que entrenamos al reconocedor y guardamos un archivo? Sí? Estamos cargando ese archivo ahora.

cascadepath = "haarcascade_frontalface_default.XML "

Estaríamos trabajando con el archivo Haarcascade, y aquí hemos asignado el nombre del archivo a una variable.

# Crear clasificador a partir del modelo prebuilt
facecascade = cv2.Cascadeclassifier (Cascadepath)

Aquí podemos llevar a cabo la clasificación Cascade en el archivo de Haarcascade.

fuente = CV2.Font_hershey_simple

Establecemos el tipo de fuente que se utilizaría cuando el código reconoce la cara en una imagen y muestra el nombre.

CAM = CV2.Videocapture (0)

Hemos estado aquí antes, pero esta vez es hora de reconocer las caras. Si no sabe qué hace este código, inicia la cámara web.

Mientras que es cierto:
ret, im = cam.leer()
gris = cv2.cvtcolor (IM, CV2.Color_bgr2gray)
caras = facecascada.detectMultiscale (gris, 1.2,5)
para (x, y, w, h) en las caras:

Todo esto se ha hecho antes, verifique amablemente el código que se usó para guardar imágenes si no sabe qué hace el código.

CV2.rectángulo (im, (x-20, y-20), (x+w+20, y+h+20), (0,255,0), 4)

Entonces esto ayuda a la cámara web a detectar dónde están las caras y coloca un rectángulo para indicar una cara.

ID = Reconocimiento.Predecir (gris [y: y+h, x: x+w])

Tenemos a Alrerady cargando el archivo del tren en el reconocedor, por lo que es capaz de reconocer la cara ahora.

if (id == 1):
Id = "yo mismo"
demás:
Id = "desconocido"

Después de tratar de reconocer qué cara es, verifica la identificación y ve si existe. Aquí, el valor de la identificación sería el nombre de quien fuera el dueño de la cara con tal ID cuando se creó el conjunto de datos de la imagen.

CV2.Rectángulo (IM, (X-22, Y-90), (X+W+22, Y-22), (0,255,0), -1)
CV2.PutText (im, str (id), (x, y-40), fuente, 2, (255,255,255), 3)

El código después de encontrar al propietario de la identificación, dibuja un rectángulo alrededor de la cara y coloca el nombre del propietario de la cara. Cara reconocida!

CV2.Imshow ('im', im)

Aquí, el marco de video se muestra con el rectángulo limitado.

Si CV2.WaitKey (10) y 0xff == ord ('Q'):
romper
leva.liberar()
CV2.DestroyallWindows ()

Entonces, cuando termine, puede detener el programa presionando la tecla 'Q', y detiene la cámara web y la cierra.

Ahí lo tienes, tu cámara web ahora puede reconocer caras y puedes usarlo cuando lo desees. Asides utilizando la cámara web también puede cargar una imagen, sin embargo, eso requiere otros pasos que se toman en este artículo.