Detección de cara y movimiento utilizando visión por computadora

OpenCV (Open Source Computy Vision Library) es un módulo Python utilizado para la visión por computadora. Es un módulo inmenso con capacidades excepcionales. Podemos hacer muchas cosas con la visión por computadora, y algunos de los mejores son el reconocimiento facial y la detección de movimiento.

En este tutorial, aprenderá a escribir código para detectar caras en imágenes, videos y movimiento.

Para evitar todo tipo de errores y problemas, descargaremos el archivo OpenCV de GitHub en https: // github.com/opencv/opencv. Usaremos algunos de los archivos dentro para completar el código.

Detección de cara usando imágenes

Dentro del archivo GitHub OpenCV, hay un subdirectorio (OpenCV-Master \ Samples \ Data) llamado datos donde las imágenes de muestra y los videos para trabajar están disponibles. Usaremos fotos y videos que se encuentran en este directorio. En particular, usaré el Lena.archivo jpg. Lo copiaré y lo pegaré en mi directorio de trabajo PyCharm (en mi caso, es C: \ Users \ Never \ PyCharmProjects \ PythonProject). Ahora, comencemos la detección de cara en esta imagen.

Primero, cargamos los módulos que necesitamos:

importar numpy como np
Importar CV2

El archivo que utilizaremos se encuentra en OpenCV-Master \ Data \ Haarcascades \ Haarcascade_Frontalface_Default.XML del archivo descargado desde GitHub. Necesitamos poner un enlace al archivo Haarcascade de la siguiente manera:

face_cascade = CV2.CascadeClassifier ('c: \\ usuarios \\ nunca \\ descarga \\ opencv-master \\ data \\ haarcascades \\ haarcascade_frontalface_default.xml ')

Cargue la foto para llevar a cabo la detección de la cara usando el CV2.método imecado ().

Imagen = CV2.Imread ('lena.jpg ')

Nuestro próximo objetivo es convertir la foto en escala de grises. Este último se termina usando el CV2.método cvtcolor (). Este método toma dos argumentos. El primer argumento es el nombre del archivo a convertir, y el segundo argumento es el formato de conversión. En este caso, usaremos CV2.Color_bgr2gray para convertirlo en un formato de escala de grises.

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

Luego usamos la función DetectMultiscale () para detectar objetos o, en este caso, enfrenta. Aquí, le diremos a Python Face_Cascade.DetectMultiscale (), que detectará caras, ya que eso es lo que en el parámetro Face_Cascade. La función detectMultiscale () toma algunos argumentos, la imagen, un factor de escala, el número mínimo de vecinos, banderas, tamaño mínimo y tamaño máximo.

caras = face_cascade.detectMultiscale (gris, 1.5, 5)

Para colocar una caja rectangular alrededor de la cara, necesitamos usar el CV2.método rectangle (). Usando este método, necesitamos darle algunos argumentos. El primer argumento es la imagen en la que desea esto, el segundo argumento es el punto de inicio del rectángulo, el tercer argumento es el punto final del rectángulo, el cuarto argumento es el color del rectángulo y el quinto argumento es el grosor de la línea. En este caso, W es para ancho, H es para altura, y X e Y son el punto de partida.

para (x, y, w, h) en las caras:
CV2.rectángulo (imagen, (x, y), (x+w, y+h), (0,255,0), 3)

Por último, mostramos la imagen usando el CV2.método imshow (). También usamos el CV2.WaitKey (0) para establecer un tiempo de espera infinito y use el CV2.Método DestryallWindows () para cerrar la ventana.

CV2.imshow ('imagen', imagen)
CV2.Waitkey (0)
CV2.DestroyallWindows ()

Detección de cara usando videos/webcam

En este caso, vamos a detectar caras en tiempo real utilizando una cámara web o un video. Una vez más, comenzamos importando los módulos requeridos.

importar numpy como np
Importar CV2

A continuación, necesitamos especificar la ubicación de los archivos de Haarcascade. Hacemos esto de la siguiente manera (exactamente como para la imagen):

face_cascade = CV2.CascadeClassifier ('c: \\ usuarios \\ nunca \\ descarga \\ opencv-master \\ data \\ haarcascades \\ haarcascade_frontalface_default.xml ')

Ahora, necesitamos especificar el video que queremos lidiar con el uso del CV2.Método Videocapture (). En mi caso, he optado por lidiar con un video que tuve e ingresé el nombre del video. Si desea tratar con cámaras web, pondrá un 0 en lugar del nombre del archivo de video.

Video = CV2.Videocapture ("Video.mp4 ")

Luego comenzamos un bucle de tiempo. En un lugar cierto, le pedimos al programa que detecte las caras hasta que lo detengamos. En primera instancia, leemos el archivo de video usando la función Read ().

Mientras que es cierto:
ret, imagen = video.leer()

Al igual que en la sección anterior, necesitamos convertir las imágenes o los marcos a la escala de grises para facilitar la detección. Usamos el CV2.método cvtcolor () para cambiar los marcos a gris.

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

Para detectar las caras, usamos la función DetectMultiscale (). Una vez más, se necesitan los mismos parámetros que en la sección anterior.

caras = face_cascade.detectMultiscale (gris, 1.1, 4)

Para colocar rectángulos alrededor de las caras, usamos el CV2.método rectangle (). Esto es similar a la sección anterior.

para (x, y, w, h) en las caras:
CV2.rectángulo (imagen, (x, y), (x+w, y+h), (255, 0, 0), 2)

Luego mostramos los cuadros usando el CV2.método imshow (). Este método toma dos argumentos, el primero es el nombre del marco, y el segundo es el marco a mostrar.

CV2.imshow ('imagen', imagen)

Luego ponemos una cláusula, si el usuario presiona la tecla ESC (o 27), entonces el código saldrá del bucle.

Si CV2.WaitKey (0) y 0xff == 27:
romper

Finalmente, lanzamos el video usando la función de lanzamiento ().

video.liberar()

Detección de movimiento

La detección de movimiento es excelente! Lo que significa es que con Python y una buena cámara web, podemos crear nuestra propia cámara de seguridad! Vamos a empezar.

importar numpy como np
Importar CV2

Elegiré un video de las muestras (OpenCVV-Master \ Samples \ Data) del archivo GitHub.

Video = CV2.Videocapture ("VTest.avi ")

Para detectar el movimiento, en lo que básicamente confiamos es la diferencia en los valores de píxeles de dos imágenes, una imagen de referencia y una segunda imagen o marco. Entonces, creamos dos imágenes, Frame1 y Frame2.

Ret, Frame1 = video.leer()
Ret, Frame2 = Video.leer()

Mientras el video se abre o se usa la función ISOPERED (), comenzamos un bucle.

Video.está abierto():

Primero calculamos la diferencia absoluta entre Frame1 y Frame2 usando el CV2.Método ABSDIFF (). Obviamente, se necesitan dos argumentos, el primer y segundo cuadro.

diferencia = CV2.Absdiff (Frame1, Frame2)

Como las cosas son más fáciles en blanco y negro, convertiremos la diferencia en escala de grises usando el CV2.método cvtcolor (). El CV2.El método cvtcolor () toma dos argumentos, el primero es el marco o la imagen, y la segunda es la transformación. En este caso, usaremos CV2.Color_bgr2gray.

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

Una vez que la imagen está en escala de grises, luego debemos difuminar la imagen para eliminar el ruido usando el CV2.Método Gaussianblur (). El CV2.El método gaussianblur () toma algunos argumentos: la imagen de origen para difuminar, la imagen de salida, el tamaño del núcleo gaussiano, la desviación estándar del núcleo a lo largo del eje x, la desviación estándar del núcleo a lo largo del eje y tipo de borde.

desenfoque = CV2.Gaussianblur (Gray, (5,5), 0)

A continuación, colocamos un valor umbral usando el CV2.Método umbral (). Esta técnica aislará el movimiento segmentando el fondo y el primer plano (o el movimiento). El CV2.El método umbral () toma cuatro argumentos: la imagen, el valor umbral, el valor máximo de usar con Thresh_binary y Thresh_binary_inv, y el tipo de umbral.

_, umbral = CV2.umbral (desenfoque, 20, 255, CV2.Thresh_Binary)

A continuación, nos dilatamos usando el CV2.método dilate () que toma 6 argumentos al máximo: la imagen, el núcleo, el ancla, las iteraciones, el tipo de borde y el valor del borde.

dilato = CV2.dilato (umbral, ninguna, iteraciones = 3)

El CV2.El método FindConTours () hace exactamente lo que significa, encuentra contornos. Se necesitan tres argumentos: la imagen fuente, el modo de recuperación y el método de aproximación de contorno.

contorno, _ = CV2.FindConTours (Dilate, CV2.Retr_tree, v2.Chain_approx_simple)

El CV2.El método DrawConTours () se usa para dibujar los contornos. Se necesitan algunos argumentos: la imagen, los contornos, el ContourIdx (este valor es negativo si se dibujan todos los contornos), el color, el grosor, el tipo de línea, la jerarquía, el nivel máximo y la compensación.

CV2.DrawConTours (Frame1, Contour, -1, (0, 0, 255), 2)

Por fin, mostramos la imagen usando el CV2.método imshow ().

CV2.Imshow ("Imagen", Frame1)

Ahora, establecemos el marco inicial 2 como el primer cuadro, y leemos el video para un nuevo cuadro que colocamos en el parámetro Frame2.

Frame1 = Frame2
Ret, Frame2 = Video.leer()

Si se presiona la tecla "Q", salga del bucle:

Si CV2.WaitKey (40) == Ord ('Q'):
romper
video.liberar()

El código en su conjunto para la detección de movimiento se vería algo así:

importar numpy como np
Importar CV2
Video = CV2.Videocapture ("VTest.avi ")
Ret, Frame1 = video.leer()
Ret, Frame2 = Video.leer()
Video.está abierto():
diferencia = CV2.Absdiff (Frame1, Frame2)
gris = cv2.cvtcolor (diferencia, CV2.Color_bgr2gray)
desenfoque = CV2.Gaussianblur (Gray, (5,5), 0)
_, umbral = CV2.umbral (desenfoque, 20, 255, CV2.Thresh_Binary)
dilato = CV2.dilato (umbral, ninguna, iteraciones = 3)
contorno, _ = CV2.FindConTours (Dilate, CV2.Retr_tree, CV2.Chain_approx_simple)
CV2.DrawConTours (Frame1, Contour, -1, (0, 0, 255), 2)
CV2.Imshow ("Imagen", Frame1)
Frame1 = Frame2
Ret, Frame2 = Video.leer()
Si CV2.WaitKey (40) == Ord ('Q'):
romper
video.liberar()

Es tan simple! Unas pocas líneas de código, y podemos hacer nuestros propios programas de reconocimiento facial y detección de movimiento. Unas pocas líneas adicionales, e incluso podemos hacer que hablen (digamos que usando PTTSX3) y crear nuestras propias cámaras de seguridad!

Codificación feliz!