Clever Geek Handbook

Como o computador vê





Você já se perguntou como o computador encontra os objetos necessários para o processamento do stream de vídeo? À primeira vista, parece uma tarefa de programação "alta" usando um grande número de fórmulas de análise matemática, matemática discreta, etc., requer uma grande quantidade de conhecimento para escrever pelo menos um pequeno programa como "Olá, mundo" no mundo do reconhecimento imagens no vídeo. E se lhe dissessem que de fato agora é muito mais fácil entrar no mundo da visão computacional e depois de ler este artigo você pode escrever seu próprio programa que ensinará seu computador a ver e detectar rostos? Também no final do artigo você encontrará um bônus que pode aumentar a segurança do seu PC usando a visão computacional.



Para que seu computador comece a entender que você está mostrando algo que se parece com um rosto, precisamos:



  1. Computador;
  2. Câmera web;
  3. Python 3;
  4. Seu editor de código favorito (PyCharm, Jupyter, etc.).


Então, depois de coletar tudo o que você precisa da lista acima, podemos começar a escrever nosso programa de reconhecimento facial diretamente.



Primeiro, baixe as bibliotecas Python necessárias usando o comando na linha de comando: 



pip install opencv-python; numpy






Resumidamente sobre por que precisamos deles:



OpenCV. Esta biblioteca é a espinha dorsal de quase todos os projetos modernos de visão computacional. Abriga centenas de algoritmos de visão computacional e processamento de imagem. Foi originalmente escrito em C / C ++, mas posteriormente também foi reescrito em Python devido a sua grande demanda nesta linguagem.



Numpy. Ajudará nos cálculos internos da biblioteca OpenCV.



Depois de terminar a instalação das bibliotecas de que precisamos, abra nosso editor de código favorito e comece a escrever nosso programa:



Anexe a biblioteca de visão computacional OpenCV 



import cv2 as cv


2. Capturamos um fluxo de vídeo de uma câmera da Web usando o método VideoCapture (índice), onde índice é o número de série de nossa câmera da Web no sistema. Se houver apenas uma câmera, o parâmetro será igual a 0. 



capture = cv.VideoCapture(0)


3. Para obter o vídeo, usaremos o método read (), que nos retorna o sinalizador rtrn - mostra o sucesso da captura de um quadro do fluxo de vídeo e imagem - o quadro de nosso fluxo de vídeo (matriz numpy). Leremos os dados do fluxo de vídeo continuamente até que a tecla Escape seja pressionada. 



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


Nós salvamos nosso arquivo, rodamos a partir da linha de comando usando python our_file_name.py. Agora nosso programa é capaz de receber um stream de vídeo de uma câmera da Web! Isso significa que já estamos na metade do caminho para o fato de que o computador pode reconhecer rostos.



4. Vamos fazer com que nosso computador também possa gravar vídeo em um arquivo:



Especifique o codec para salvar o vídeo, especifique o nome do arquivo salvo, fps e tamanhos. Para nossa tarefa, pegamos o codec XVID. 



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


5. Produzimos sequencialmente os quadros na janela de vídeo e, em seguida, salvamos o resultado na variável de saída. Em seguida, os dados de saída, após o término do stream de vídeo, serão transferidos para o arquivo "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()


Depois de aprendermos como fazer um vídeo de uma câmera da web e salvá-lo em um arquivo, podemos prosseguir para a coisa mais interessante - o reconhecimento de rosto em um stream de vídeo. Para encontrar o rosto nas molduras, usaremos os chamados Recursos Haar. A essência deles é que, se pegarmos áreas retangulares na imagem, então pela diferença de intensidades entre os pixels de retângulos adjacentes, podemos distinguir características inerentes às faces.



Por exemplo, em imagens com rostos, a área ao redor dos olhos é mais escura do que ao redor das bochechas. Portanto, um dos sinais de Haar para rostos pode ser chamado de 2 retângulos adjacentes nas bochechas e olhos.



Há um grande número de outros métodos mais rápidos e precisos para detectar objetos na imagem, mas para entender os princípios gerais, por enquanto, só precisaremos conhecer os Sinais de Haar.



Os desenvolvedores do OpenCV já trabalharam na determinação dos sinais de Haar e forneceram a todos os resultados para as capacidades de processamento do fluxo de vídeo.



Vamos começar a escrever um detector de rosto a partir de nossa webcam:



6. Em primeiro lugar, obtenha nossos recursos Haar e defina os parâmetros para capturar um stream de vídeo. O arquivo Traits está localizado no caminho onde as bibliotecas Python estão instaladas. Por padrão, eles estão localizados na pasta 



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


onde X é sua subversão 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. Em seguida, no loop, vamos nos revezar na leitura de frames da câmera da Web e transmiti-los ao nosso detector de rosto: 



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. Agora vamos combinar tudo em um todo e obter um programa que captura vídeo de uma câmera da Web, reconhece rostos nela e salva o resultado em um arquivo: 



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()


Tudo! Você escreveu um programa que é o primeiro passo para entender como um computador vê. Além disso, você pode melhorar o reconhecimento de rosto, por exemplo, para que o computador reconheça certas pessoas no vídeo treinando redes neurais. Você também pode escrever um detector configurado para reconhecer objetos mais complexos (por exemplo, rastreamento de tráfego) com a capacidade de analisá-los. E também para resolver outras tarefas não menos interessantes da visão computacional.



BÔNUS



Vamos aplicar o programa na prática - rastrearemos os logins na conta.



  1. Vamos para o Agendador de Tarefas (pode ser encontrado no Windows Search padrão);
  2. Vamos criar uma Tarefa Simples, dê a ela um título e uma breve descrição;






3. Clique em Next e vá para o item Trigger. Aqui selecionamos o evento em que ocorrerá o lançamento de nossa tarefa. Selecionamos "Ao entrar no Windows";



4. A seguir, em ação, indicamos "Executar o programa";



5. Em Ação, especifique o caminho para python.exe e, em Parâmetros, o caminho para o nosso programa:







Pronto! Como resultado, ao fazer o login, a pessoa conectada na conta será gravada e o vídeo será salvo. Assim, você pode rastrear quem trabalhou no computador na sua ausência, enquanto mantém um registro das evidências.


More articles:


All Articles