Reconocimiento facial 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 simples operaciones aritméticas, las computadoras ahora manejan el mundo.

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

Vamos a hacer algo de esa naturaleza en este artículo. Como humanos, reconocer los rostros de otras personas es una tarea sencilla y, a pesar de las capacidades de las computadoras actuales, no es tan fácil para la computadora, por lo que tenemos que entrenarla para que pueda hacer lo mismo.

Muchos artículos que vería por ahí se detienen en la detección simple de rostros, pero en este artículo cubrirían no solo la detección de rostros, sino también el reconocimiento de rostros.

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

Para empezar, 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 llegar a instalar Python desde el sitio web de Python.

Para instalar Open CV, podemos hacerlo usando el comando pip.

pip instalar opencv-python

También usaremos el paquete numpy en este artículo, que debe instalarse junto con OpenCV usando el comando anterior.

Si numpy no se instaló, puede hacerlo fácilmente usando el siguiente comando:

pip instalar numpy

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

importar cv2

Si no obtiene un error, puede continuar.

Para realizar el reconocimiento facial estaríamos escribiendo tres guiones. Uno para crear un conjunto de datos de imágenes, otro para entrenar esas imágenes y luego el último para reconocer los rostros en base a los resultados del entrenamiento por el que pasa la computadora.

Necesitaríamos el Haar Cascade proporcionado por Open CV. Este archivo se puede obtener del directorio opencv que es cv2 / data / haarcascade_frontalface_default.xml en mi máquina, debería ser el mismo en su máquina también. Copie el archivo en la carpeta donde desea realizar el reconocimiento facial.

Ahora entremos en el meollo de las cosas.
Intentaríamos que nuestra cámara web obtuviera 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
cuenta = 0
mientras (vid_cam.está abierto()):
ret, image_frame = vid_cam.leer()
gris = cv2.cvtColor (marco_imagen, cv2.COLOR_BGR2GRAY)
faces = face_detector.detectMultiScale (gris, 1.3, 5)
para (x, y, w, h) en caras:
cv2.rectángulo (cuadro_imagen, (x, y), (x + w, y + h), (255,0,0), 2)
contar + = 1
cv2.imwrite ("conjunto de datos / usuario."+ str (face_id) + '.'+ str (recuento) + ".jpg ", gris [y: y + h, x: x + w])
cv2.imshow ('marco', marco_imagen)
si cv2.waitKey (100) y 0xFF == ord ('q'):
rotura
recuento de elif> 100:
rotura
vid_cam.lanzamiento()
cv2.destroyAllWindows ()

Entonces, para explicar lo que hace cada línea de código:

importar cv2

Aquí está el comando que le dice a Python que incluya una biblioteca externa para usar en este código, en este caso es Open CV.

vid_cam = cv2.VideoCapture (0)

Este código llama a la biblioteca Open CV importada para comenzar a capturar y la cámara web se inicia en este punto. Si el CV abierto no es compatible con su cámara web, el código fallará aquí.

face_detector = cv2.CascadeClassifier ('haarcascade_frontalface_default.xml ')

Para que podamos realizar la detección de imágenes, se necesita este código. Open CV usa el 'haarcascade_frontalface_default.xml 'para la clasificación en cascada. El objeto resultante se almacena 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 identificación de 1.

cuenta = 0

Vamos a tomar un par de imágenes ya que Open CV necesita entrenar imágenes para poder reconocer caras, la variable de conteo sirve como conteo 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í, la vid_cam.read () busca en la captura de video y luego captura el marco que se almacena en la variable image_frame, si la operación es exitosa, el booleano True se devuelve y se almacena en la variable ret

gris = cv2.cvtColor (marco_imagen, 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 a escala de grises.

faces = face_detector.detectMultiScale (gris, 1.3, 5)

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

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

Aquí recorremos las caras y sus dimensiones, donde xey representan las coordenadas y w y h representan el ancho y la altura, respectivamente.

cv2.rectángulo (cuadro_imagen, (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 recorta la parte necesaria de la imagen de acuerdo con las dimensiones anteriores.

contar + = 1

Inmediatamente después de eso, la variable de recuento que se encuentra como un contador se incrementa.

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

La imagen recortada se guarda con el nombre Usuario (face_id).(contar).jpg y ponerlo en una carpeta llamada conjunto de datos.

cv2.imshow ('marco', marco_imagen)

Después de guardar, este código garantiza que la imagen del cuadro de video se muestre con un rectángulo en la cara de la persona una vez realizada la detección de rostros.

si cv2.waitKey (100) y 0xFF == ord ('q'):
rotura

Después de cada imagen, el usuario puede detener el programa para que deje de tomar más imágenes, lo que se puede hacer presionando la 'q' en el teclado durante al menos 100 ms.

recuento de elif> 100:
rotura

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

vid_cam.lanzamiento()

Aquí, la cámara web está cerrada y no solo deja de tomar fotografías.

cv2.destroyAllWindows ()

Luego, todas las ventanas abiertas de OpenCV se han destruido y el código se ejecuta hasta la conclusión.

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

importar cv2, os
importar numpy como np
de la imagen de importación PIL
reconocedor = cv2.cara.createLBPHFaceRecognizer ()
detector = cv2.CascadeClassifier ("haarcascade_frontalface_default.xml ");
def getImagesAndLabels (ruta):
imagePaths = [os.camino.unirse (ruta, f) para f en el sistema operativo.listdir (ruta)]
faceSamples = []
ids = []
para imagePath en imagePaths:
PIL_img = Imagen.abrir (imagePath).convertir ('L')
img_numpy = np.matriz (PIL_img, 'uint8')
id = int (os.camino.dividir (imagePath) [- 1].separar(".") [1])
caras = detector.detectMultiScale (img_numpy)
para (x, y, w, h) en caras:
faceSamples.añadir (img_numpy [y: y + h, x: x + w])
identificadores.añadir (id)
return faceSamples, ids
caras, ids = getImagesAndLabels ('conjunto de datos')
reconocedor.tren (caras, np.matriz (ids))
reconocedor.guardar ('entrenador / entrenador.yml ')

Sigamos adelante y expliquemos este código también:

importar cv2, os

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

importar numpy como np

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

de la imagen de importación PIL

Estamos importando la biblioteca de imágenes de Python y luego de ella obtenemos la biblioteca de imágenes de este paquete.

reconocedor = cv2.cara.createLBPHFaceRecognizer ()

Lo que esto hace es aplicar el método createLBPHFaceRecognizer () al cv2.Face object, esto ayudaría a facilitar el reconocimiento de rostros ya que no tenemos que idear 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 rostros usando el "haarcascade_frontalface_default.xml ”para la clasificación en cascada.

def getImagesAndLabels (ruta):

Ahora, estamos a punto de comenzar el entrenamiento de la imagen propiamente dicho, así que creamos una función.

imagePaths = [os.camino.unirse (ruta, f) para f en el sistema operativo.listdir (ruta)]

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

faceSamples = []

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

ids = []

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

para imagePath en imagePaths:

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

PIL_img = Imagen.abrir (imagePath).convertir ('L')

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

img_numpy = np.matriz (PIL_img, 'uint8')

La imagen en escala de grises es solo una serie de números en un solo lugar, por lo que creamos una matriz numerosa a partir de ellos y la asignamos a una variable.

id = int (os.camino.dividir (imagePath) [- 1].separar(".") [1])

Si recuerda el archivo que obtiene las imágenes, recordará que llamamos a los archivos Usuario (face_id).contar.jpg. Así que aquí dividimos los nombres con el "."Y luego extraemos el face_id y lo asignamos a una variable aquí. Necesitaríamos la identificación para el reconocimiento.

caras = detector.detectMultiScale (img_numpy)

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

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

Aquí, estamos recorriendo los valores asignados a la variable. Los valores aquí son las coordenadas xey que podríamos tomar como origen, y luego w y h representan ancho y alto respectivamente.

faceSamples.añadir (img_numpy [y: y + h, x: x + w])

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

identificadores.añadir (id)

Ahora tenemos una cara en la lista de muestra de caras, por lo que obtenemos su identificación y la agregamos a la lista de identificaciones también.

return faceSamples, ids

Luego, después de todo, devolvemos la lista de muestras de caras y la lista de identificadores.

caras, ids = getImagesAndLabels ('conjunto de datos')

Recuerde que getImagesAndLabels () es solo una función. Entonces podemos llamar a la función aquí, y los valores de retorno se guardan en las variables de caras e ID.

reconocedor.tren (caras, np.matriz (ids))

Aquí es donde ocurre el verdadero entrenamiento. Aplicamos el método createLBPHFaceRecognizer () en algún momento antes y lo asignamos a una variable de reconocimiento. Es tiempo de entrenamiento!

reconocedor.guardar ('entrenador / entrenador.yml ')

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

Aquí está el código de reconocimiento facial:

importar cv2
importar numpy como np
reconocedor = cv2.cara.createLBPHFaceRecognizer ()
reconocedor.load ('entrenador / entrenador.yml ')
cascadePath = "haarcascade_frontalface_default.xml "
faceCascade = cv2.CascadeClassifier (cascadePath)
font = cv2.FONT_HERSHEY_SIMPLEX
cam = cv2.VideoCapture (0)
mientras que es verdadero:
ret, im = cam.leer()
gris = cv2.cvtColor (im, cv2.COLOR_BGR2GRAY)
faces = faceCascade.detectMultiScale (gris, 1.2,5)
para (x, y, w, h) en caras:
cv2.rectángulo (im, (x-20, y-20), (x + w + 20, y + h + 20), (0,255,0), 4)
Id = reconocedor.predecir (gris [y: y + h, x: x + w])
si (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'):
rotura
leva.lanzamiento()
cv2.destroyAllWindows ()

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

reconocedor.load ('entrenador / entrenador.yml ')

Recuerde que entrenamos el 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í le hemos asignado el nombre del archivo a una variable.

# Crear clasificador a partir del modelo prediseñado
faceCascade = cv2.CascadeClassifier (cascadePath)

Aquí podemos realizar la clasificación en cascada en el archivo haarcascade.

font = cv2.FONT_HERSHEY_SIMPLEX

Establecemos el tipo de fuente que se usaría cuando el código reconozca la cara en una imagen y muestre el nombre.

cam = cv2.VideoCapture (0)

Hemos estado aquí antes, pero esta vez es hora de reconocer las caras. Si no sabes que hace este código, lanza la webcam.

mientras que es verdadero:
ret, im = cam.leer()
gris = cv2.cvtColor (im, cv2.COLOR_BGR2GRAY)
faces = faceCascade.detectMultiScale (gris, 1.2,5)
para (x, y, w, h) en caras:

Todo esto se ha hecho antes, por favor revise el código que se usó para guardar imágenes si no sabe lo que hace el código.

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

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 = reconocedor.predecir (gris [y: y + h, x: x + w])

Ya hemos cargado el archivo del tren en el reconocedor, por lo que ahora puede reconocer la cara.

si (Id == 1):
Id = "Yo mismo"
demás:
Id = "Desconocido"

Después de intentar reconocer qué cara es, busca la identificación y ve si existe. Aquí, el valor de la identificación sería el nombre de la persona que tenía la propiedad frente a dicha identificación cuando se estaba creando 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. Rostro reconocido!

cv2.imshow ('im', im)

Aquí, el cuadro de video se muestra con el rectángulo delimitado.

si cv2.waitKey (10) y 0xFF == ord ('q'):
rotura
leva.lanzamiento()
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 webcam ahora puede reconocer caras y puedes usarla cuando quieras. Además de usar la cámara web, también puede cargar una imagen, sin embargo, eso requiere algunos pasos distintos a los que se siguen en este artículo.

Puede encontrar el código fuente utilizado en su repositorio de github. También envíenos un tweet si tiene comentarios o desea discutir sobre @linuxhint