Conte flexões usando Python e a câmera do seu computador

Você pode usar muitos projetos para fortalecer suas habilidades em visão computacional e Python. Um desses projetos é criar um contador de push-up simples usando Python. Você pode escrever o programa deste projeto em um único arquivo.

O programa receberá uma entrada de vídeo ou uma entrada em tempo real de uma câmera, executará uma estimativa de pose humana na entrada e contará o número de flexões que a pessoa está fazendo. Para executar a estimativa de pose humana, o programa usará o modelo de estimativa de pose humana MediaPipe.

É um modelo desenvolvido pelo Google que rastreia trinta e três marcos no corpo humano. Ele também prevê uma segmentação de corpo inteiro que representa como uma segmentação de duas classes. A imagem a seguir mostra todos os marcos que o modelo é capaz de identificar. Pontos numerados identificam cada ponto de referência e se conectam uns aos outros com linhas.

Seu programa de contra-flexão utilizará as posições dos ombros e dos cotovelos. Na imagem acima, os pontos de referência do ombro são 11 e 12, enquanto os pontos de referência do cotovelo são 13 e 14.

Configurando seu ambiente

Você já deve estar familiarizado com o básico de Python. Abra um Python IDE e crie um novo arquivo Python. Execute o seguinte comando no terminal para instalar os respectivos pacotes em seu ambiente:

pip instalar OpenCV-Python

Você usará o OpenCV-Pythonto para obter a entrada de vídeo em seu programa e processá-la. Esta biblioteca dá ao seu programa recursos de visão computacional.

pip instalar MediaPipe

Você usará o MediaPipe para executar a estimativa de pose humana na entrada.

pip instalar imutils

Você usará imutils para redimensionar a entrada de vídeo para a largura desejada.

Importe as três bibliotecas que você instalou anteriormente em seu ambiente. Isso possibilitará o uso de suas dependências no projeto.

importar cv2
importar imutils
importar mediapipe como mp

Em seguida, crie três objetos MediaPipe e inicialize-os usando as respectivas funções. Você usará a função mp.solutions.drawing_utils para desenhar os vários pontos de referência na entrada. mp.solutions.drawing_styles para alterar os estilos em que os desenhos dos marcos aparecem e mp.solutions.pose que é o modelo que você usará para identificar esses marcos.

mp_draw = mp.solutions.drawing_utils
mp_draw_styles = mp.solutions.drawing_styles
mp_pose = mp.solutions.pose

Realizando a estimativa de pose humana

Detectar a pose de um ser humano é o processo de identificar a orientação de seu corpo, identificando e classificando suas articulações.

Declarando suas variáveis

Declare as variáveis ​​que você usará para armazenar o número de flexões, a posição dos ombros e cotovelos e a entrada de vídeo.

contagem = 0
posição = Nenhum
cap = cv2.VideoCapture("v4.mp4")

Inicialize a variável de posição como None. O programa irá atualizá-lo dependendo da posição dos cotovelos e ombros.

Chame o modelo de estimativa de pose MediaPipe que detectará a pose humana na entrada.

com mp_pose. Pose(
 min_detecção_confiança = 0.7,
 min_tracking_confiança = 0.7) como pose:

As inicializações da confiança de detecção e confiança de rastreamento representam o nível de precisão que você precisa do modelo. 0,7 é semelhante a 70% de precisão. Você pode alterá-lo para o nível desejado.

Tomando e pré-processando a entrada

Pegue a entrada que você passará posteriormente para o modelo de estimativa de pose. Redimensione a largura da entrada de vídeo usando a biblioteca imutils. Converta a entrada de BGR para RGB, pois o MediaPipe funciona apenas com entrada RGB. Por fim, passe a entrada convertida para o modelo de estimativa de pose humana para identificar os pontos de referência.

enquanto cap.isOpened():
 sucesso, imagem=cap.read()
senão sucesso:
 imprimir("câmera vazia")
quebrar
 imagem = imutils.resize (imagem, largura =500)
 imagem = cv2.cvtColor (cv2.flip (imagem, 1), cv2.COLOR_BGR2RGB)
 resultado = pose.process (imagem)

Depois de processar a entrada, você identificou os pontos de referência na entrada.

Desenhando os marcos identificados na entrada

Crie uma lista vazia que armazenará as coordenadas de cada ponto de referência. Use a classe draw_landmarks para desenhar um ponto em cada marco e as conexões entre eles. Usando um loop for, itere sobre os pontos de referência e armazene o ID e as coordenadas de cada ponto de referência na lista que você criou. Use a classe image.shape para calcular a largura e a altura da entrada de vídeo.

lmList = []
se result.pose_landmarks:
# Desenha os pontos dos marcos e os conecta
 mp_draw.draw_landmarks (imagem, result.pose_landmarks,
 mp_pose. POSE_CONNECTIONS)
para id, eu em enumerar (result.pose_landmarks.landmark):
# Encontrando o comprimento e a largura da entrada de vídeo
 h, w, _ = imagem.forma
# Encontrando as coordenadas exatas dos pontos do corpo
 X, Y = int (im.x * w), int (im.y * h)
 lmList.append([id, X, Y])

O ID é o número atribuído a um ponto de referência específico pelo modelo de estimativa de pose do MediaPipe. Tendo identificado a pose do humano na entrada, você precisa contar o número de flexões que ele está fazendo, se houver.

Contando o número de flexões

Crie uma condição que verifique a posição dos ombros em relação à posição dos cotovelos. Quando os ombros da pessoa na entrada são mais altos que os cotovelos, a pessoa está de pé. Quando os ombros estão mais baixos que os cotovelos, a pessoa está caída. Você verifica isso comparando os IDs dos pontos de referência dos ombros com os dos pontos de referência dos cotovelos.

# Verificando se existem pontos de referência identificados
se len (lmLista) != 0:
# Condição que identifica a posição para baixo
se (lmLista[12][2] e lmLista[11][2] >= lmList[14][2] e lmLista[13][2]):
 posição = "abaixo"
# Condição que identifica a posição para cima
se (lmLista[12][2] e lmLista[11][2] <= lmLista[14][2] e lmLista[13][2])
e posição == "abaixo":
 posição = "acima"
 contar +=1

Para uma pessoa completar uma flexão completa, ela deve assumir uma posição para baixo e depois voltar para a posição superior. Após uma flexão completa, o programa pode atualizar a contagem em um.

Exibindo a Saída

Você precisa exibir o número de flexões que o programa contou. Imprima o valor da contagem no terminal, cada vez que o usuário fizer uma flexão completa. Por fim, exiba a saída da pessoa fazendo flexões com os pontos de referência desenhados em seu corpo.

 imprimir (contar)
 cv2.imshow("Contador de flexões", cv2.flip (imagem, 1))
 chave = cv2.waitKey(1)
# O programa termina quando q é pressionado
se chave == ord('q'):
quebrar
cap.release()

A saída deve ser algo como isto:

Você deve observar uma atualização no terminal conforme a pessoa na saída faz uma flexão completa.

Fortaleça suas habilidades de visão computacional

A visão computacional é ampla. Um contador de flexões é um dos muitos projetos que você pode usar para colocar em prática suas habilidades de visão computacional. A melhor maneira de fortalecer essas habilidades é criar mais projetos que envolvam visão computacional.

Quanto mais projetos você construir, mais aprenderá!