O rastreamento manual é o processo de usar a visão computacional para detectar e seguir os movimentos da mão de uma pessoa em tempo real. A aplicação mais dominante de rastreamento de mão está em fones de ouvido de realidade virtual. Os fones de ouvido permitem que você use suas mãos como entrada no lugar de controladores de toque. Isso, por sua vez, torna a experiência mais imersiva.
Descubra como rastrear as mãos de uma pessoa usando Python, OpenCV para visão computacional e MediaPipe.
O Google desenvolveu a estrutura MediaPipe, que contém muitas soluções de aprendizado de máquina. Uma das soluções é a solução de rastreamento de mãos e dedos chamada Mãos MediaPipe. Para rastrear as mãos, o MediaPipe Hands realiza dois processos: detecção de palma e detecção de ponto de referência.
Detecção de palma da mão
O MediaPipe começa identificando onde as palmas estão na imagem de entrada. Uma vez que estimar caixas delimitadoras para objetos rígidos é mais simples do que identificar mãos com dedos articulados.
Detecção de marcos manuais
Após a detecção da palma, o MediaPipe executa a detecção de pontos de referência da mão. O modelo de ponto de referência da mão pode prever 21 coordenadas precisas da localização de cada ponto de referência da mão.
Os números representam um identificador exclusivo para cada ponto de referência.
Configurando seu ambiente
Para acompanhar este projeto, você deve estar familiarizado com o noções básicas de Python. Instale as seguintes bibliotecas em seu ambiente:
- OpenCV: Você usará esta biblioteca para visão computacional e para executar técnicas de processamento de imagem na imagem de entrada.
- MediaPipe: você usará esta biblioteca para realizar detecção e rastreamento de mão na imagem de entrada.
- imutils: Você usará esta biblioteca para redimensionar o quadro de vídeo da entrada.
Execute o seguinte comando em seu terminal para instalar as bibliotecas OpenCV, MediaPipe e imutils. Instalar pip—o gerenciador de pacotes Python-se você precisar. Certifique-se de passar as bibliotecas como uma lista delimitada por espaço.
pip instalar OpenCV-Python MediaPipe imutils
Quando a atualização for concluída, o ambiente estará pronto para você começar a codificar.
O código-fonte completo para este projeto está disponível em seu Repositório GitHub.
Importando as bibliotecas necessárias
Você precisará importar as bibliotecas instaladas para poder usá-las. Abra qualquer Python IDE, crie um arquivo Python e adicione as seguintes importações:
importar cv2
importar mediapipe como mp
importar imutilsCertifique-se de importar OpenCV como cv2 e MediaPipe em letras minúsculas. Deixar de fazer isso gerará um erro.
Você usará mpHands para chamar a solução de mãos do MediaPipe e o objeto de mãos para detectar e rastrear a entrada da mão. Você usará o objeto mpDraw para desenhar as conexões entre os pontos de referência das mãos identificadas.
mpHands = mp.solutions.hands
mãos = mpMãos. Mãos()
mpDraw = mp.solutions.drawing_utilsVocê pode ajustar o modelo de mãos do MediaPipe passando vários parâmetros para o construtor Hands(). Os valores padrão são bons o suficiente para este projeto, mas você pode experimentá-los para ver como eles afetam o modelo:
Você deve deixar o static_image_mode como Falso para garantir que o modelo detecte as mãos uma vez antes de começar a rastreá-las. Ele apenas repete o processo de rastreamento se a confiança de detecção cair abaixo do parâmetro declarado, tornando o processamento geral de entrada mais rápido.
Executando Rastreamento de Mão
Você precisa de três funções para executar o rastreamento de mão: uma para processar a entrada, uma para desenhar as conexões de referência de mão e uma função principal para controlar o fluxo do programa.
Função de processamento de entrada
Essa função pega a entrada, converte-a em escala de cinza e a passa para o modelo de mãos do MediaPipe para detectar e rastrear as mãos na entrada.
# Processando a imagem de entrada
defprocess_image(imagem):
# Convertendo a entrada para tons de cinza
gray_image = cv2.cvtColor (img, cv2.COLOR_BGR2RGB)
resultados = hands.process (gray_image)
# Retornando as mãos detectadas para a função de chamada
retornar resultados
A função retorna os resultados se houver mãos detectadas na entrada.
A função de desenho de conexões de ponto de referência manual
Esta função verifica se a função de processamento de entrada detectou alguma mão. Se houver mãos detectadas, ele faz um loop sobre cada ponto de referência e desenha um círculo ao seu redor, acompanhando o ponto de referência usando Função enumerar do Python. Em seguida, ele desenha as conexões entre os pontos de referência na entrada de vídeo original.
# Desenhando conexões de pontos de referência
defdraw_hand_connections(imagem, resultados):
se results.multi_hand_landmarks:
para handLms em results.multi_hand_landmarks:
para id, lm em enumerar (handLms.landmark):
h, w, c = img.forma# Encontrando as coordenadas de cada ponto de referência
cx, cy = int (lm.x * w), int (lm.y * h)# Imprimindo cada ID de ponto de referência e coordenadas
# no terminal
imprimir (id, cx, cy)# Criando um círculo ao redor de cada ponto de referência
cv2.circle (img, (cx, cy), 10, (0, 255, 0),
cv2.PREENCHIDO)
# Desenhando as conexões do marco
mpDraw.draw_landmarks (img, handLms,
mpHands. HAND_CONNECTIONS)
retornar img
A função começa circulando cada ponto de referência:
Em seguida, desenha as conexões manuais:
Ele finalmente retorna sua saída para a função de chamada.
A função principal
Crie uma função principal que controlará o fluxo do seu programa. Ele receberá a entrada e redimensionará o quadro de vídeo para garantir a consistência da saída. Passe a entrada para a função de processamento que detectará e rastreará as mãos. Leve os resultados retornados para a função de desenho de conexão de marcos manuais, que desenhará a conexão na entrada de vídeo original. Ele finalmente exibirá a saída para o usuário.
defprincipal():
# Substitua 0 pelo caminho do vídeo para usar um
# vídeo pré-gravado
cap = cv2.VideoCapture(0)enquantoVerdadeiro:
# Tomando a entrada
sucesso, imagem = cap.read()
imagem = imutils.resize (imagem, largura =500, altura=500)
resultados = process_image (imagem)
draw_hand_connections (imagem, resultados)# Exibindo a saída
cv2.imshow("Rastreador de mão", imagem)
# O programa termina quando a tecla q é pressionada
se cv2.waitKey(1) == ordem('q'):
cap.release()
cv2.destroyAllWindows()
A última etapa é executar seu programa. O código abaixo garante que, ao executar o programa, a função principal seja executada primeiro.
se __nome__ == "__principal__":
principal()Quando o programa é executado, ele produz uma saída como esta:
O programa rastreia as mãos em tempo real.
Rastreamento de mão para realidade virtual imersiva
O rastreamento de mãos em realidade virtual torna a tecnologia mais atraente. Os fones de ouvido de realidade virtual começaram a introduzir o rastreamento manual, trazendo uma sensação de realidade aumentada ao mundo virtual. Os fones de ouvido permitem que o usuário insira comandos usando uma mão virtual.
O rastreamento de mãos em fones de ouvido virtuais é apenas uma aplicação dessa tecnologia. Você pode incorporar o rastreamento manual em qualquer área aplicável de sua preferência.