IMPLEMENTACIÓN DE VERIFICACIÓN DE EJERCICIOS DE POSE BASADA EN

MEDICIONES DE ÁNGULOS DE BRAZOS

ESTUDIANTE  
RONALDO BALLESTEROS SALGUERO  
 
 
 

 
 
PROFESOR 
DR. JESUS EMILI PINTO LOPERA 
 
 

 
 
 
UNIVERSIDAD DE LA AMAZONIA 
FACULTAD DE INGENIERIA 
INGENIERIA DE SISTEMAS 
FLORENCIA, COLOMBIA 
2023
Contenido
INTRODUCCION............................................................................................................................3
METODOLOGÍA DE DESARROLLO..........................................................................................4
RESULTADO.................................................................................................................................16
EJERCICIO BICEPS4 BIEN........................................................................................................20
CONCLUSIONES..........................................................................................................................24
 INTRODUCCION

En este informe, se presenta un modelo de reconocimiento de gestos que utiliza la potente librería
MediaPipe1 como base. MediaPipe es un marco de trabajo diseñado específicamente para construir
pipelines de aprendizaje automático que procesan datos de series temporales, como videos. En este
estudio, se ha aprovechado la capacidad de MediaPipe para procesar y analizar videos, utilizando
las librerías cv2 (OpenCV) y math para complementar las funcionalidades del modelo.
El objetivo principal de este modelo es trabajar con dos grupos musculares específicos: el bíceps y
la espalda. El enfoque se centra en verificar si los ejercicios que involucran estos grupos musculares
se están ejecutando correctamente. Para lograrlo, se aprovechan los puntos de referencia
proporcionados por MediaPipe, que detecta y rastrea las manos y los hombros en los videos de los
ejercicios. Estos puntos de referencia son fundamentales para calcular los ángulos y las distancias
entre ellos, lo que brinda información valiosa sobre la correcta ejecución de los movimientos.
La utilización de MediaPipe junto con las librerías cv2 y math permite un análisis preciso y
detallado de los gestos y movimientos realizados durante los ejercicios de bíceps y espalda. Al
medir los ángulos y las distancias entre los puntos clave, se puede determinar de manera objetiva si
el ejercicio se está ejecutando de acuerdo con las pautas y técnicas establecidas. Esta
retroalimentación objetiva puede ser invaluable para los usuarios, ya que les brinda la oportunidad
de corregir y mejorar su técnica, optimizando así los resultados y reduciendo el riesgo de lesiones.
En el desarrollo de este informe, se describirán en detalle los pasos y algoritmos utilizados en el
modelo de reconocimiento de gestos. Además, se presentarán y analizarán los resultados obtenidos,
los cuales se compararán con referencias y estándares reconocidos en el ámbito del fitness y la
biomecánica.
 METODOLOGÍA DE DESARROLLO

Se importan las librerías necesarias para el reconocimiento de gestos utilizando mediapipe, trabajar
con funciones relacionadas al tiempo utilizando time, realizar el procesamiento de imágenes y
videos utilizando cv2 (OpenCV), y realizar cálculos matemáticos utilizando math, como se observa
en la ilustración 1

Ilustración 1 librerías

Estas líneas de código inicializan las variables mp_drawing y mp_pose utilizando funciones y
componentes de la librería mediapipe.
mp_drawing se inicializa con la función drawing_utils de mediapipe, que proporciona utilidades
para dibujar puntos, líneas y conexiones en imágenes o videos.
mp_pose se inicializa con la función pose de mediapipe, que brinda funcionalidad para detectar y
seguir los puntos de referencia del cuerpo humano en imágenes o videos.
Estas variables inicializadas te permiten utilizar las funcionalidades proporcionadas por mediapipe
para el reconocimiento de gestos y la detección de la pose del cuerpo humano en tu proyecto, como
se observa en la ilustración 2.

Ilustración 2 inicializan las variables

Esta función calcula el ángulo entre los vectores AB y BC utilizando el método de la función
arcotangente (atan2) provisto por la librería math.
Los parámetros de entrada de la función (a, b, c) representan las coordenadas de tres puntos en un
plano, donde el punto b es el vértice del ángulo.
Primero, se calculan las diferencias en las coordenadas x y y entre los puntos b y c, y entre los
puntos a y b.
Luego, se utiliza la función math.atan2 para calcular el ángulo en radianes entre los vectores AB y
BC.
A continuación, se convierte el ángulo en radianes a grados multiplicándolo por el factor de
conversión 180.0 / math.pi y tomando el valor absoluto.
Si el ángulo calculado es mayor a 180 grados, se ajusta para que esté en el rango de 0 a 180 grados
restando el ángulo a 360 grados.
Por último, se devuelve el ángulo calculado.
Como se observa en la ilustración 3.

Ilustración 3 calcula el ángulo entre los vectores

Esta función verifica si el ejercicio de bicep1 se está realizando correctamente, utilizando los
ángulos obtenidos para el brazo derecho (angle_right) y el brazo izquierdo (angle_left).
En la línea, se define el rango de ángulos aceptables para el ejercicio de bicep1. En este caso, el
rango es de 10 a 30 grados, y se almacena en la variable bicep1 como una tupla.
A continuación, se evalúa la condición en la línea utilizando una estructura condicional (if-else). La
condición verifica si alguno de los ángulos (angle_right o angle_left) se encuentra dentro del rango
definido (bicep1).
Si alguno de los ángulos cumple esta condición, se devuelve el valor True en la línea, lo que indica
que el ejercicio se está realizando correctamente. En caso contrario, se devuelve el valor False en la
línea, indicando que el ejercicio no se está ejecutando correctamente.
Como se observa en la ilustración 4
 Ilustración 4

Esta función se encarga de verificar si el ejercicio de bicep2 se está realizando correctamente. Aquí
está la descripción de cada línea:
En la línea, se define el rango de ángulos aceptables para el ejercicio de bicep2. En este caso, el
rango es de 50 a 60 grados, y se almacena en la variable bicep2 como una tupla.
A continuación, en la línea, se evalúa una condición utilizando una estructura condicional (if-else).
La condición verifica si alguno de los ángulos (angle_right o angle_left) se encuentra dentro del
rango definido (bicep2).
Si alguno de los ángulos cumple esta condición, se devuelve el valor True en la línea, indicando que
el ejercicio se está realizando correctamente. En caso contrario, se devuelve el valor False en la
línea, lo que significa que el ejercicio no se está ejecutando correctamente.
Como se observa en la ilustración 5.

Ilustración 5
Esta función se encarga de verificar si el ejercicio de bicep3 se está realizando correctamente. Aquí
está la descripción de cada línea:
En la línea, se define el rango de ángulos aceptables para el ejercicio de bicep3. En este caso, el
rango es de 70 a 80 grados, y se almacena en la variable bicep3 como una tupla.
A continuación, en la línea, se evalúa una condición utilizando una estructura condicional (if-else).
La condición verifica si alguno de los ángulos (angle_right o angle_left) se encuentra dentro del
rango definido (bicep3).
Si alguno de los ángulos cumple esta condición, se devuelve el valor True en la línea, indicando que
el ejercicio se está realizando correctamente. En caso contrario, se devuelve el valor False en la
línea, lo que significa que el ejercicio no se está ejecutando correctamente.
Como se observa en la ilustración 6.

Ilustración 6

Esta función se encarga de verificar si el ejercicio de bicep4 se está realizando correctamente. Aquí
está la descripción de cada línea:
En la línea, se define el rango de ángulos aceptables para el ejercicio de bicep4. En este caso, el
rango es de 30 a 40 grados, y se almacena en la variable bicep4 como una tupla.
A continuación, en la línea 6, se evalúa una condición utilizando una estructura condicional (if-
else). La condición verifica si alguno de los ángulos (angle_right o angle_left) se encuentra dentro
del rango definido (bicep4).
Si alguno de los ángulos cumple esta condición, se devuelve el valor True en la línea, indicando que
el ejercicio se está realizando correctamente. En caso contrario, se devuelve el valor False en la
línea, lo que significa que el ejercicio no se está ejecutando correctamente.
Como se observa en la ilustración 7.
 Ilustración 7

Esta función se encarga de verificar si el ejercicio de bicep5 se está realizando correctamente. Aquí
está la descripción de cada línea:
En la línea, se define el rango de ángulos aceptables para el ejercicio de bicep5. En este caso, el
rango es de 30 a 50 grados, y se almacena en la variable bicep5 como una tupla.
A continuación, en la línea, se evalúa una condición utilizando una estructura condicional (if-else).
La condición verifica si alguno de los ángulos (angle_right o angle_left) se encuentra dentro del
rango definido (bicep5).
Si alguno de los ángulos cumple esta condición, se devuelve el valor True en la línea, indicando que
el ejercicio se está realizando correctamente. En caso contrario, se devuelve el valor False en la
línea, lo que significa que el ejercicio no se está ejecutando correctamente.
Como se observa en la ilustración 8.

Ilustración 8
Esta función se encarga de verificar si el ejercicio de espalda2 se está realizando correctamente.
Aquí está la descripción de cada línea:
En la línea 5, se define el rango de ángulos aceptables para el ejercicio de espalda2. En este caso, el
rango es de 80 a 92 grados, y se almacena en la variable espalda2 como una tupla.
A continuación, en la línea 6, se evalúa una condición utilizando una estructura condicional (if-
else). La condición verifica si alguno de los ángulos (angle_right o angle_left) se encuentra dentro
del rango definido (espalda2).
Si alguno de los ángulos cumple esta condición, se devuelve el valor True en la línea 7, indicando
que el ejercicio se está realizando correctamente. En caso contrario, se devuelve el valor False en la
línea 9, lo que significa que el ejercicio no se está ejecutando correctamente.
Como se observa en la ilustración 9.

Ilustración 9

Esta función se encarga de verificar si el ejercicio de espalda3 se está realizando correctamente.

Aquí está la descripción de cada línea:
En la línea, se define el rango de ángulos aceptables para el ejercicio de espalda3. En este caso, el
rango es de 55 a 65 grados, y se almacena en la variable espalda3 como una tupla.
A continuación, en la línea, se evalúa una condición utilizando una estructura condicional (if-else).
La condición verifica si alguno de los ángulos (angle_right o angle_left) se encuentra dentro del
rango definido (espalda3).
Si alguno de los ángulos cumple esta condición, se devuelve el valor True en la línea, indicando que
el ejercicio se está realizando correctamente. En caso contrario, se devuelve el valor False en la
línea, lo que significa que el ejercicio no se está ejecutando correctamente.
Como se observa en la ilustración 10.

Ilustración 10
Esta función se encarga de verificar si el ejercicio de espalda4 se está realizando correctamente.
Aquí está la descripción de cada línea:
En la línea, se define el rango de ángulos aceptables para el ejercicio de espalda4. En este caso, el
rango es de 55 a 65 grados, y se almacena en la variable espalda4 como una tupla.
A continuación, en la línea, se evalúa una condición utilizando una estructura condicional (if-else).
La condición verifica si alguno de los ángulos (angle_right o angle_left) se encuentra dentro del
rango definido (espalda4).
Si alguno de los ángulos cumple esta condición, se devuelve el valor True en la línea, indicando que
el ejercicio se está realizando correctamente. En caso contrario, se devuelve el valor False en la
línea, lo que significa que el ejercicio no se está ejecutando correctamente.
Como se observa en la ilustración 11.

Ilustración 11

Esta función se encarga de verificar si un ejercicio específico se está realizando correctamente

según los ángulos de los brazos proporcionados. Aquí está la descripción de cada línea:
En la línea, se convierte el nombre del video (video_name) a minúsculas y se almacena en la
variable exercise_name. Esto se hace para asegurar que el nombre del ejercicio sea reconocido
correctamente, independientemente de si se ingresó en mayúsculas o minúsculas.
A continuación, se utiliza una estructura condicional (if-elif-else) para determinar qué función de
verificación de ejercicio se debe llamar, según el nombre del ejercicio (exercise_name). Si el
nombre coincide con uno de los ejercicios de bíceps o espalda especificados, se llama a la función
correspondiente pasando los ángulos derechos e izquierdos como argumentos, y se devuelve el
resultado de la verificación.
Si el nombre del ejercicio no coincide con ninguno de los ejercicios especificados, se imprime un
mensaje indicando que el ejercicio no es reconocido y se devuelve el valor False, lo que significa
que el ejercicio no se está realizando correctamente.
Como se observa en la ilustración 12.
 Ilustración 12

En esta línea de código, se solicita al usuario que ingrese el nombre del video que desea evaluar. La
función input() muestra un mensaje entre paréntesis y espera que el usuario ingrese un valor desde
el teclado. El valor ingresado por el usuario se asigna a la variable entrada2.
En esta línea de código, se inicializa la captura de video utilizando la biblioteca OpenCV (cv2). Se
crea un objeto VideoCapture que se utilizará para abrir y leer el video especificado por el nombre
almacenado en la variable entrada2. El objeto cap se utilizará posteriormente para acceder a los
fotogramas del video.
En esta línea de código, se solicita al usuario que ingrese el nombre del ejercicio que desea evaluar.
Al igual que en la primera línea de código, se utiliza la función input() para mostrar un mensaje y
esperar la entrada del usuario. El valor ingresado por el usuario se asigna a la variable entrada.
Como se observa en la ilustración 13.

Ilustración 13
En esta línea de código, se crea un contexto utilizando la clase mp_pose.Pose de la librería
MediaPipe. Se establecen los valores de confianza mínima tanto para la detección como para el
seguimiento de la pose. Dentro de este contexto, se llevará a cabo la detección y seguimiento de la
pose en los fotogramas del video.
Como se observa en la ilustración 14.

Ilustración 14

En esta línea de código, se inicia un bucle while que se ejecutará mientras el objeto cap
(VideoCapture) esté abierto. Esto permite procesar cada uno de los fotogramas del video.
Como se observa en la ilustración 15.

Ilustración 15

En esta línea de código, se utiliza el método read() del objeto cap para leer un fotograma del video.
El valor de retorno ret indica si la lectura fue exitosa, y el fotograma se almacena en la variable
frame.
Como se observa en la ilustración 16.

Ilustración 16
En esta línea de código, se utiliza el método read() del objeto cap para leer un fotograma del video.
El valor de retorno ret indica si la lectura fue exitosa, y el fotograma se almacena en la variable
frame.
En esta línea de código, se utiliza el método read() del objeto cap para leer un fotograma del video.
El valor de retorno ret indica si la lectura fue exitosa, y el fotograma se almacena en la variable
frame.
En esta línea de código, se verifica si la lectura del fotograma fue exitosa. Si no se pudo leer un
fotograma (por ejemplo, si se llegó al final del video), se sale del bucle while utilizando la
instrucción break.
En esta línea de código, se obtienen las dimensiones del fotograma del video. El método shape
devuelve una tupla que contiene el alto, el ancho y los canales de color del fotograma. En este caso,
solo se almacenan las dimensiones de altura (image_height) y ancho (image_width).
Como se observa en la ilustración 17.

Ilustración 17

En esta línea de código, se procesa el fotograma del video utilizando el objeto pose creado
anteriormente. Se obtienen los resultados de la detección y seguimiento de la pose en el fotograma.
En esta línea de código, se verifica si se detectaron landmarks (puntos de referencia) de la pose en
el fotograma. La condición results.pose_landmarks evalúa si hay landmarks detectados y devuelve
True si existen, y False en caso contrario.
En estas líneas de código, se obtienen las coordenadas del landmark del hombro derecho utilizando
los resultados de la detección de pose. Se multiplica la coordenada x y la coordenada y del
landmark por las dimensiones del fotograma (image_width e image_height, respectivamente) para
obtener las coordenadas en píxeles.
En esta línea de código, se calcula el ángulo formado por los landmarks del hombro derecho, el
codo derecho y la muñeca derecha utilizando la función calculate_angle(). Esta función toma como
argumentos las coordenadas de los landmarks y devuelve el ángulo correspondiente.
Como se observa en la ilustración 18.
 Ilustración 18

En esta línea de código, se llama a la función verificar_ejercicio() para determinar si el ejercicio se

realiza correctamente. Se pasan como argumentos los ángulos del brazo derecho (angle_right), del
brazo izquierdo (angle_left) y el nombre del ejercicio (entrada). El resultado se almacena en la
variable exercise_correct.
En estas líneas de código, se agrega un texto al fotograma del video para indicar si el ejercicio se
realizó correctamente o no. Dependiendo del valor de exercise_correct, se muestra el texto
"Ejercicio Correcto" en verde o "Ejercicio Incorrecto" en rojo.
En esta línea de código, se dibujan los landmarks de la pose y las conexiones entre ellos en el
fotograma utilizando la función draw_landmarks() de MediaPipe. Esto proporciona una
representación visual de los puntos de referencia detectados y cómo están conectados entre sí.
Como se observa en la ilustración 19.

Ilustración 19
En esta línea de código, se muestra el fotograma con los landmarks y el texto agregado utilizando la
función imshow() de OpenCV. El primer argumento es el título de la ventana y el segundo
argumento es el fotograma que se va a mostrar.
Como se observa en la ilustración 20.

Ilustración 20

En esta línea de código, se libera el objeto cap (VideoCapture) que se utilizó para abrir el video. La
liberación del objeto asegura que todos los recursos asociados con la captura de video se liberen
correctamente.
En esta línea de código, se cierran todas las ventanas creadas con la función imshow() de OpenCV.
Esto asegura que todas las ventanas abiertas durante el procesamiento del video se cierren
adecuadamente y no queden abiertas después de finalizar el programa.
Como se observa en la ilustración 21.

Ilustración 21
 RESULTADO

EJERCICIO BICEPS1 BIEN

En la primera ejecución del ejercicio bíceps 1 se puede observar que si cumple con los ángulos
correspondientes para el ejercicio que son 10° y 30° como se observa en la imagen 1

Imagen 1

EJERCICIO BICEPS1 MAL

En la segunda ejecución del ejercicio bíceps 1 se puede observar que no cumple con los ángulos
correspondientes para el ejercicio que son 10° y 30° como se observa en la imagen 2

Imagen 2
EJERCICIO BICEPS2 BIEN

En la primera ejecución del ejercicio bíceps 2 se puede observar que si cumple con los ángulos
correspondientes para el ejercicio que son 50° y 60° como se observa en la imagen 3

Imagen 3

EJERCICIO BICEPS2 MAL

En la segunda ejecución del ejercicio bíceps 2 se puede observar que no cumple con los ángulos
correspondientes para el ejercicio que son 50° y 60° como se observa en la imagen 4

Imagen 4
EJERCICIO BICEPS3 BIEN

En la primera ejecución del ejercicio bíceps 3 se puede observar que si cumple con los ángulos
correspondientes para el ejercicio que son 75° y 80° como se observa en la imagen 5

Imagen 5

EJERCICIO BICEPS3 MAL

En la segunda ejecución del ejercicio bíceps 3 se puede observar que no cumple con los ángulos
correspondientes para el ejercicio que son 75° y 80° como se observa en la imagen 6

Imagen 6
EJERCICIO BICEPS4 BIEN

En la primera ejecución del ejercicio bíceps 4 se puede observar que si cumple con los ángulos
correspondientes para el ejercicio que son 30° y 40° como se observa en la imagen 7

Imagen 7

EJERCICIO BICEPS4 MAL

En la segunda ejecución del ejercicio bíceps 4 se puede observar que no cumple con los ángulos
correspondientes para el ejercicio que son 30° y 40° como se observa en la imagen 8

Imagen 8
EJERCICIO BICEPS4 BIEN
En la primera ejecución del ejercicio bíceps 4 se puede observar que si cumple con los ángulos
correspondientes para el ejercicio que son 30° y 40° como se observa en la imagen 9

Imagen 9

EJERCICIO BICEPS5 MAL

En la segunda ejecución del ejercicio bíceps 5 se puede observar que no cumple con los ángulos
correspondientes para el ejercicio que son 30° y 40° como se observa en la imagen 10

Imagen 10
EJERCICIO ESPALDA2 BIEN

En la primera ejecución del ejercicio espalda2 se puede observar que si cumple con los ángulos
correspondientes para el ejercicio que son 80° y 92° como se observa en la imagen 11

Imagen 11

EJERCICIO ESPALDA2 MAL

En la segunda ejecución del ejercicio espalda 2 se puede observar que no cumple con los ángulos
correspondientes para el ejercicio que son 80° y 92° como se observa en la imagen 10

Imagen 12
EJERCICIO ESPALDA3 BIEN

En la primera ejecución del ejercicio espalda3 se puede observar que si cumple con los ángulos
correspondientes para el ejercicio que son 55° y 65° como se observa en la imagen 13

Imagen 13

EJERCICIO ESPALDA3 MAL

En la segunda ejecución del ejercicio espalda 3 se puede observar que no cumple con los ángulos
correspondientes para el ejercicio que son 55° y 65° como se observa en la imagen 14
 Imagen 14

EJERCICIO ESPALDA4 BIEN

En la primera ejecución del ejercicio espalda4 se puede observar que si cumple con los ángulos
correspondientes para el ejercicio que son 65° y 70° como se observa en la imagen 13

Imagen 15

EJERCICIO ESPALDA4 MAL

En la segunda ejecución del ejercicio espalda 4 se puede observar que no cumple con los ángulos
correspondientes para el ejercicio que son 68° y 85° como se observa en la imagen 16
 Imagen 16

CONCLUSIONES

Como primera conclusión podemos observar que el modelo si puede detectar cuando un ejercicio si
se esta realizando correctamente, esto quiere decir que el modelo si quedo bien entrenado.

Como segunda conclusión podemos observar que el modelo si puede detectar los ejercicios que se
están realizando de manera incorrecta, esto quiere decir que el modelo si quedo bien entrenado.