Des lecteurs comme vous aident à soutenir MUO. Lorsque vous effectuez un achat en utilisant des liens sur notre site, nous pouvons gagner une commission d'affiliation. En savoir plus.

Vous pouvez utiliser de nombreux projets pour renforcer vos compétences en vision par ordinateur et Python. L'un de ces projets consiste à créer un compteur push-up simple à l'aide de Python. Vous pouvez écrire le programme de ce projet dans un seul fichier.

Le programme prendra une entrée vidéo ou une entrée en temps réel d'une caméra, effectuera une estimation de la pose humaine sur l'entrée et comptera le nombre de pompes que la personne fait. Pour effectuer l'estimation de la pose humaine, le programme utilisera le modèle d'estimation de la pose humaine MediaPipe.

Il s'agit d'un modèle développé par Google qui suit trente-trois points de repère sur le corps humain. Il prédit également une segmentation du corps entier qu'il représente comme une segmentation à deux classes. L'image suivante montre tous les repères que le modèle est capable d'identifier. Des points numérotés identifient chaque point de repère et se connectent les uns aux autres avec des lignes.

instagram viewer

Crédit d'image: MediaPipe/GitHub

Votre programme de contre pompes utilisera les positions des épaules et des coudes. Dans l'image ci-dessus, les repères de l'épaule sont 11 et 12 tandis que les repères du coude sont 13 et 14.

Configuration de votre environnement

Vous devez déjà être familiarisé avec les bases de Python. Ouvrez un IDE Python et créez un nouveau fichier Python. Exécutez la commande suivante sur le terminal pour installer les packages respectifs sur votre environnement :

pip installer OpenCV-Python

Vous utiliserez OpenCV-Python pour prendre l'entrée vidéo dans votre programme et la traiter. Cette bibliothèque donne à votre programme capacités de vision par ordinateur.

pip installer MediaPipe

Vous utiliserez MediaPipe pour effectuer une estimation de pose humaine sur l'entrée.

pip installer imutils

Vous utiliserez imutils pour redimensionner l'entrée vidéo à la largeur souhaitée.

Importez les trois bibliothèques que vous avez précédemment installées sur votre environnement. Cela permettra d'utiliser leurs dépendances dans le projet.

importer cv2
importer imutils
importer mediapipe comme député

Créez ensuite trois objets MediaPipe et initialisez-les à l'aide des fonctions respectives. Vous utiliserez la fonction mp.solutions.drawing_utils pour dessiner les différents points de repère sur l'entrée. mp.solutions.drawing_styles pour changer les styles dans lesquels les dessins des points de repère apparaissent, et mp.solutions.pose qui est le modèle que vous utiliserez pour identifier ces points de repère.

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

Exécution de l'estimation de la pose humaine

Détecter la pose d'un humain est le processus d'identification de l'orientation de son corps en identifiant et en classant ses articulations.

Déclaration de vos variables

Déclarez les variables que vous utiliserez pour stocker le nombre de pompes, la position des épaules et des coudes et l'entrée vidéo.

compter = 0
poste = Aucun
cap = cv2.VideoCapture("v4.mp4")

Initialisez la variable de position sur Aucune. Le programme le mettra à jour en fonction de la position des coudes et des épaules.

Appelez le modèle d'estimation de pose MediaPipe qui détectera la pose humaine dans l'entrée.

avec mp_pose. Pose(
 min_detection_confidence = 0.7,
 min_tracking_confidence = 0.7) comme pose:

Les initialisations de la confiance de détection et de la confiance de suivi représentent le niveau de précision dont vous avez besoin du modèle. 0,7 est similaire à une précision de 70 %. Vous pouvez le modifier au niveau souhaité.

Prendre et prétraiter l'entrée

Prenez l'entrée que vous passerez plus tard au modèle d'estimation de pose. Redimensionnez la largeur de l'entrée vidéo à l'aide de la bibliothèque imutils. Convertissez l'entrée de BGR en RVB car MediaPipe fonctionne uniquement avec l'entrée RVB. Enfin, passez l'entrée convertie au modèle d'estimation de la pose humaine pour identifier les points de repère.

alors que cap.isOpened() :
 succès, image=cap.read()
sipas succès:
 imprimer("caméra vide")
casser
 image = imutils.resize (image, largeur=500)
 image = cv2.cvtColor (cv2.flip (image, 1), cv2.COLOR_BGR2RGB)
 result = pose.process (image)

Après avoir traité l'entrée, vous avez identifié les points de repère sur l'entrée.

Dessiner les points de repère identifiés sur l'entrée

Créez une liste vide qui stockera les coordonnées de chaque point de repère. Utilisez la classe draw_landmarks pour dessiner un point sur chaque point de repère et les connexions entre eux. À l'aide d'une boucle for, parcourez les points de repère et stockez l'ID et les coordonnées de chaque point de repère dans la liste que vous avez créée. Utilisez la classe image.shape pour calculer la largeur et la hauteur de l'entrée vidéo.

lmListe = []
si result.pose_landmarks :
# Dessine les points de repère et les relie
 mp_draw.draw_landmarks (image, result.pose_landmarks,
 mp_pose. POSE_CONNECTIONS)


pour id, je dans énumérer (result.pose_landmarks.landmark) :
# Trouver la longueur et la largeur de l'entrée vidéo
 h, w, _ = image.forme
# Trouver les coordonnées exactes des points du corps
 X, Y = int (im.x * w), int (im.y * h)
 lmList.append([id, X, Y])

L'ID est le numéro attribué à un point de repère spécifique par le modèle d'estimation de pose MediaPipe. Après avoir identifié la pose de l'humain dans l'entrée, vous devez compter le nombre de pompes qu'il effectue, le cas échéant.

Compter le nombre de pompes

Créez une condition qui vérifie la position des épaules par rapport à la position des coudes. Lorsque les épaules de la personne en entrée sont plus hautes que les coudes, la personne est relevée. Lorsque les épaules sont plus basses que les coudes, la personne est en bas. Vous vérifiez cela en comparant les identifiants des repères des épaules avec ceux des repères des coudes.

# Vérifier s'il y a des repères identifiés
si len (lmListe) != 0:
# Condition qui identifie la position basse
si (lmListe[12][2] et lmListe[11][2] >= lmListe[14][2] et lmListe[13][2]):
 poste = "bas"
# Condition qui identifie la position haute
si (lmListe[12][2] et lmListe[11][2] <= lmListe[14][2] et lmListe[13][2])
et poste == "bas":
 poste = "en haut"
 compter +=1

Pour qu'une personne effectue une pompe complète, elle doit adopter une position basse, puis revenir à la position haute. Après un push-up complet, le programme peut mettre à jour le décompte de un.

Affichage de la sortie

Vous devez afficher le nombre de pompes que le programme a compté. Imprimer la valeur du comptage sur le terminal, chaque fois que l'utilisateur fait un push-up complet. Enfin, affichez la sortie de la personne qui fait des pompes avec les repères dessinés sur son corps.

 imprimer (compter)
 cv2.imshow("Comptoir push-up", cv2.flip (image, 1))
 clé = cv2.waitKey(1)


# Le programme se termine lorsque q est enfoncé
si clé == ord('q'):
casser
cap.release()

La sortie devrait ressembler à ceci :

Vous devriez observer une mise à jour sur le terminal pendant que la personne à la sortie fait une poussée complète.

Renforcez vos compétences en vision par ordinateur

La vision par ordinateur est large. Un compteur push-up est l'un des nombreux projets que vous pouvez utiliser pour mettre en pratique vos compétences en vision par ordinateur. La meilleure façon de renforcer ces compétences est de construire davantage de projets impliquant la vision par ordinateur.

Plus vous construirez de projets, plus vous apprendrez !