Clever Geek Handbook

Como ve la computadora





¿Alguna vez se ha preguntado cómo encuentra la computadora los objetos necesarios para procesar desde la transmisión de video? A primera vista, esto parece una tarea de programación "alta" que utiliza una gran cantidad de fórmulas de análisis matemático, matemáticas discretas, etc., requiere una gran cantidad de conocimientos para escribir al menos un programa pequeño como "Hola, mundo" en el mundo del reconocimiento. imágenes en el video. ¿Y si te dijeran que de hecho ahora es mucho más fácil entrar en el mundo de la visión por computadora y luego de leer este artículo puedes escribir tu propio programa que le enseñará a tu computadora a ver y detectar rostros? También al final del artículo encontrará un bono que puede aumentar la seguridad de su PC usando visión artificial.



Para que su computadora comience a comprender que le está mostrando algo que parece una cara, necesitamos:



  1. Computadora;
  2. Cámara web;
  3. Python 3;
  4. Tu editor de código favorito (PyCharm, Jupyter, etc.).


Entonces, después de haber recopilado todo lo que necesita de acuerdo con la lista anterior, podemos comenzar a escribir nuestro programa para el reconocimiento facial directamente.



Primero, descargue las bibliotecas de Python necesarias usando el comando en la línea de comandos: 



pip install opencv-python; numpy






Brevemente sobre por qué los necesitamos:



OpenCV. Esta biblioteca es la columna vertebral de casi todos los proyectos modernos de visión por computadora. Alberga cientos de algoritmos de procesamiento de imágenes y visión por computadora. Originalmente fue escrito en C / C ++, pero luego fue reescrito también en Python debido a su gran demanda en este lenguaje.



Numpy. Ayudará con los cálculos internos de la biblioteca OpenCV.



Después de terminar la instalación de las bibliotecas que necesitamos, abra nuestro editor de código favorito y comience a escribir nuestro programa:



Adjunte la biblioteca de visión por computadora OpenCV 



import cv2 as cv


2. Capturamos un flujo de video desde una cámara web usando el método VideoCapture (índice), donde el índice es el número de serie de nuestra cámara web en el sistema. Si solo hay una cámara, el parámetro será igual a 0. 



capture = cv.VideoCapture(0)


3. Para obtener el video, usaremos el método read (), que nos devuelve la bandera rtrn - muestra el éxito de capturar un fotograma del flujo de video y la imagen - el fotograma de nuestro flujo de video (matriz numpy). Leeremos datos de la transmisión de video continuamente hasta que se presione la tecla Escape. 



while True:
    rtrn, image = capture.read()
    cv.imshow("Capture from Web-camera", image) #      
    if cv.waitKey(1) == 27:  #      Esc
        break
capture.release()
cv.destroyAllWindows()


Guardamos nuestro archivo, lo ejecutamos desde la línea de comando usando python our_file_name.py. ¡Ahora nuestro programa puede recibir una transmisión de video desde una cámara web! Esto significa que ya estamos a medio camino del hecho de que la computadora puede reconocer rostros.



4. Hagamos que nuestra computadora también pueda escribir video en un archivo:



Especifique el códec para guardar el video, especifique el nombre del archivo guardado, fps y tamaños. Para nuestra tarea, tomamos el códec XVID. 



import cv2 as cv
capture = cv.VideoCapture(0)
codec = cv.VideoWriter_fourcc(*'XVID')


5. Generamos secuencialmente los cuadros en la ventana de video y luego guardamos el resultado en la variable de salida. Luego, los datos de la salida, una vez finalizada la transmisión de video, se transferirán al archivo "Saved_from_camera.avi": 



output = cv.VideoWriter('saved_from_camera.avi ', codec, 25.0, (640, 480))
while capture.isOpened():
    rtrn, image = capture.read()
    if cv.waitKey(1) == 27 or rtrn == False:
        break
    cv.imshow('video for save', image)
    output.write(image)
output.release()
capture.release()
cv.destroyAllWindows()


Una vez que hayamos aprendido cómo tomar un video de una cámara web y guardarlo en un archivo, podemos proceder a lo más interesante: el reconocimiento facial en una transmisión de video. Para encontrar la cara en los marcos, usaremos las llamadas Características Haar. Su esencia es que si tomamos áreas rectangulares en la imagen, entonces por la diferencia de intensidades entre los píxeles de los rectángulos adyacentes, podemos distinguir las características inherentes a las caras.



Por ejemplo, en imágenes con rostros, el área alrededor de los ojos es más oscura que alrededor de las mejillas. Por lo tanto, uno de los signos de Haar para caras se puede llamar 2 rectángulos adyacentes en las mejillas y los ojos.



Hay muchos otros métodos más rápidos y precisos para detectar objetos en la imagen, pero para comprender los principios generales, solo necesitaremos conocer los signos de Haar por ahora.



Los desarrolladores de OpenCV ya han trabajado en la definición de Haar Signs y han proporcionado a todos los resultados de las capacidades de procesamiento del flujo de video.



Comencemos a escribir un detector de rostros desde nuestra cámara web:



6. En primer lugar, obtenga nuestras características Haar y defina los parámetros para capturar una transmisión de video. El archivo Traits se encuentra en la ruta donde están instaladas las bibliotecas de Python. Por defecto, se encuentran en la carpeta 



C:/Python3X/Lib/sitepackages/cv2/data/haarcascade_frontalface_default.xml


donde X es su subversión de Python 3. 



import cv2 as cv
cascade_of_face = cv.CascadeClassifier('C:/Python3.X/Lib/site-packages/cv2/data/haarcascade_frontalface_default.xml ')
capture = cv.VideoCapture(0)
capture.set(cv.CAP_PROP_FPS, 25) #   25


7. A continuación, en un bucle, nos turnaremos para leer los fotogramas de la cámara web y transmitirlos a nuestro detector facial: 



while True:
    rtrn, image = capture.read()
    gr = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    faces_detect = cascade_of_face.detectMultiScale(
        image=gr,
        minSize=(15, 15),
        minNeighbors=10,
        scaleFactor=1.2
    )
    for (x_face, y_face, w_face, h_face) in faces_detect:
        cv.rectangle(image, (x_face, y_face), (x_face + w_face, y_face + h_face), (0, 0, 255), 2)
    cv.imshow("Image", image)
    if cv.waitKey(1) == 27:  # Esc key
        break
capture.release()
cv.destroyAllWindows()


8. Ahora combinemos todo en un todo y obtengamos un programa que capture video de una cámara web, reconozca rostros y guarde el resultado en un archivo: 



import cv2 as cv
faceCascade = cv.CascadeClassifier('C:/Users/Zet/Desktop/Python/test_opencv/Lib/site-packages/cv2/data/haarcascade_frontalface_default.xml')
capture = cv.VideoCapture(0)
capture.set(cv.CAP_PROP_FPS, 25)
codec = cv.VideoWriter_fourcc(*'XVID')
output = cv.VideoWriter('saved_from_camera.avi', codec, 25.0, (640, 480))
while True:
    rtrn, image = capture.read()
    gr = cv.cvtColor(image, cv.COLOR_BGR2GRAY)
    faces_detect = faceCascade.detectMultiScale(
        image=gr,
        minSize=(15, 15),
        minNeighbors=10,
        scaleFactor=1.2
    )
    for (x_face, y_face, w_face, h_face) in faces_detect:
        cv.rectangle(image, (x_face, y_face), (x_face + w_face, y_face + h_face), (255, 0, 0), 2)
    cv.imshow("Image", image)
    output.write(image)
    if cv.waitKey(1) == 27:  # Esc key
        break
output.release()
capture.release()
cv.destroyAllWindows()


¡Todos! Ha escrito un programa que es el primer paso para comprender cómo ve una computadora. Además, puede mejorar el reconocimiento facial, por ejemplo, para que la computadora reconozca a ciertas personas en el video al entrenar redes neuronales. También puede escribir un detector configurado para reconocer objetos más complejos (por ejemplo, seguimiento del tráfico) con la capacidad de analizarlos. Y también para resolver otras tareas no menos interesantes de la visión por ordenador.



BONIFICACIÓN



Apliquemos el programa en la práctica: realizaremos un seguimiento de los inicios de sesión en la cuenta.



  1. Vayamos al Programador de tareas (se puede encontrar a través de la búsqueda estándar de Windows);
  2. Creemos una Tarea Simple, pongamos un título y una breve descripción;






3. Haga clic en Siguiente y vaya al elemento Activador. Aquí seleccionamos el evento en el que se producirá el lanzamiento de nuestra tarea. Seleccionamos "Al entrar en Windows";



4. A continuación, en acción, indicamos "Ejecutar el programa";



5. En Acción, especifique la ruta a python.exe, y en los Parámetros, la ruta a nuestro programa:







¡Listo! Como resultado, al iniciar sesión, se grabará la persona que inició sesión con la cuenta y se guardará el video. Por lo tanto, puede rastrear quién trabajó en la computadora en su ausencia, mientras mantiene un registro de evidencia.


More articles:


All Articles