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

Aprenda a escrever um programa que observe seu treino e conte os resultados.

Você pode usar muitos projetos para fortalecer suas habilidades em visão computacional e Python. Um desses projetos é a criação de um contador de flexões simples usando Python. Você pode escrever o programa deste projeto em um único arquivo.

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

O que é o modelo de estimativa de pose humana MediaPipe?

É um modelo desenvolvido pelo Google que rastreia trinta e três pontos de referência no corpo humano. 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 pontos de referência que o modelo é capaz de identificar. Os pontos numerados identificam cada ponto de referência e conectam-se uns aos outros com linhas.

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

Configurando seu ambiente

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

pip install OpenCV-Python

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

pip install MediaPipe

Você usará o MediaPipe para realizar estimativas de pose humana na entrada.

pip install imutils

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

Importações e inicializações do MediaPipe

Importe as três bibliotecas instaladas anteriormente em seu ambiente. Isso tornará possível utilizar suas dependências no projeto.

import cv2
import imutils
import mediapipe as 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 aparecem os desenhos dos pontos de referência, e mp.solutions.pose que é o modelo que você usará para identificar esses pontos de referência.

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

Realizando a estimativa da pose humana

Detectar a pose de um ser humano é o processo de identificar a orientação do 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.

count = 0
position = None
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.

Chamando o modelo de estimativa de pose do MediaPipe

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

with mp_pose.Pose(
    min_detection_confidence = 0.7,
    min_tracking_confidence = 0.7) as pose:

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

Obtendo 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. Finalmente, passe a entrada convertida para o modelo de estimativa de pose humana para identificar os pontos de referência.

while cap.isOpened():
    success, image=cap.read()
    if not success:
        print("empty camera")
        break
    image = imutils.resize(image, width=500)
    image = cv2.cvtColor(cv2.flip(image, 1), cv2.COLOR_BGR2RGB)
    result = pose.process(image)

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 ponto de referência 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 = []
if result.pose_landmarks:
    # Draws the landmarks' points and connects them
    mp_draw.draw_landmarks(image, result.pose_landmarks,
                               mp_pose.POSE_CONNECTIONS)
    for id, im in enumerate(result.pose_landmarks.landmark):
        # Finding the length and width of the video input
        h, w, _ = image.shape
        # Finding the exact coordinates of the body points
        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 compare a posição dos ombros com a posição dos cotovelos. Quando os ombros da pessoa na entrada estão mais altos que os cotovelos, a pessoa está em pé. Quando os ombros estão abaixo dos cotovelos, a pessoa está abaixada. Você verifica isso comparando os IDs dos pontos de referência dos ombros com os dos pontos de referência dos cotovelos.

# Checking whether there are any identified landmarks
if len(lmList) != 0:
    # Condition that identifies the down position
    if (lmList[12][2] and lmList[11][2] >= lmList[14][2] and lmList[13][2]):
        position = "down"
    # Condition that identifies the up position
    if (lmList[12][2] and lmList[11][2] <= lmList[14][2] and lmList[13][2])
    and position == "down":
         position = "up"
         count +=1

Para que uma pessoa complete uma flexão completa, ela deve assumir uma posição para baixo e depois voltar para a posição para cima. 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 o resultado da pessoa que faz flexões com os pontos de referência desenhados em seu corpo.

            print(count)
    cv2.imshow("Push-up counter", cv2.flip(image, 1))
    key = cv2.waitKey(1)
    # Program terminates when q is pressed
    if key == ord('q'):
        break
cap.release()

A saída deve ser semelhante a esta:

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 é construindo mais projetos que envolvam visão computacional.

Quanto mais projetos você construir, mais aprenderá!