IMPLEMENTACION DE VISION COMPUTACIONAL PARA EL DIAGNOSTICO

DE LA CORRECTA EJECUCION DE POSES DE RUGBY

ESTUDIANTES

CARLOS ALEXANDER GUTIERREZ MARIN

JOHAN SEBASTIAN OSORIO

DOCENTE

JESUS EMILIO PINTO

UNIVERSIDAD DE LA AMAZONIA

FACULTAD DE INGENIERÍA

INGENIERÍA DE SISTEMAS

FLORENCIA-CAQUETÁ

2023
 TABLA DE ILUSTRACIONES
Ilustración 1, Librerías Necesarias......................................................................................................3
Ilustración 2, ScreenManager............................................................................................................4
Ilustración 3, Clase Principal...............................................................................................................4
Ilustración 4, Inicialización de aplicación............................................................................................4
Ilustración 5, Cambios de Estilo..........................................................................................................4
Ilustración 6, Comparación de videos................................................................................................6
Ilustración 7, Bucle de videos.............................................................................................................6
Ilustración 8, Fin de lectura de cuadros.............................................................................................6
Ilustración 9, Comparación de poses.................................................................................................7
Ilustración 10, Resultados en Consola................................................................................................7
Ilustración 11, Comparación por puntos............................................................................................8
Ilustración 12, Abrir videos................................................................................................................8
Ilustración 13 ,Ejecución de MainApp................................................................................................8
Ilustración 14, Importe de librerías....................................................................................................8
Ilustración 15, Template.....................................................................................................................9
Ilustración 16, Template de Escena....................................................................................................9
Ilustración 17, Interfaz.....................................................................................................................10
Ilustración 18, Grid de ordenamiento..............................................................................................11

TABLA DE GRAFICOS
Grafica 1, Pantalla principal..............................................................................................................11
Grafica 2, Interfaz de comparación..................................................................................................12
Grafica 3, Video siendo comparado.................................................................................................13
Grafica 4, Pose errónea....................................................................................................................14
Grafica 5, Posibles bugs....................................................................................................................15
Grafica 6, Caso con dos personas.....................................................................................................16
 INTRODUCCION

La visión computacional se dedica a reproducir en las máquinas la habilidad que nuestros ojos
poseen. Su objetivo consiste en analizar y comprender las imágenes captadas por dispositivos
como cámaras, identificando objetos, entornos y ubicaciones en el espacio (Loyo, 2017).

La tarea de alcanzar una interpretación equiparable a la capacidad humana representa un desafío

de gran complejidad. No obstante, se han logrado avances significativos a lo largo del tiempo en
esta área de estudio.

Mediante algoritmos y técnicas avanzadas, la visión computacional permite a las maquinas

identificar objetos, reconocer patrones, detectar rostros, medir distancias y una amplia gama de
diversas tareas relacionada scon el procesamiento de imágenes.

Esta disciplina tiene aplicaciones en muy diversas áreas, se puede aplicar a casi cualquier aspecto
laboral, como la medicina, la seguridad, la robótica, la realidad aumentada, entre muchas más.
Esta tecnología continúa evolucionando para mejorar la precisión y eficiencia en el analisis de
datos visuales.

En el presente informe, se presenta el desarrollo de una aplicación de visión computacional

especializada en la evaluación de poses de ejercicios de rugby. Esta busca brindar
retroalimentación sobre la técnica de los jugadores. El objetivo principal de este proyecto es
proporcionar una herramienta precisa y efectiva para ayudar a los jugadores, entrenadores y
equipos a mejorar sus habilidades en el rugby.
 PROCEDIMIENTO

Para empezar, vamos a listar las librerías necesarias para desarrollar el ejercicio

Ilustración 1, Librerías Necesarias

 Kivymd.app: Proporciona componentes y estilos Material Design, permite desarrollar

interfaces de usuario atractivas.
 Kivy.uix.screenmanager: Permite gestionar múltiples pantallas en una aplicación, permite
transiciones y facilita la organización y gestión de la interfaz de usuario.
 Kivy.lang: Proporciona utilidades para cargar y procesar archivos KV que ayudan a definir
la estructura y apariencia de la interfaz de usuario en una aplicación Kivi.
 Cv2: Proporciona una amplia gama de funciones y algoritmos de visión computacional
para procesar y analizar imágenes y videos en tiempo real.
 Mediapipe: Proporciona una amplia gama de soluciones y herramientas para el
procesamiento de datos de visión por computadora en tiempo real. Se centra en el análisis
y seguimiento de medios como imágenes o videos.
 Threading: Es un módulo que proporciona herramientas para trabajar con hilos de
ejecución en un programa. Permite ejecutar múltiples hilos dentro de un proceso,
facilitando la programación paralela y asíncrona.

Luego necesitaremos definir algunas clases.

Ilustración 2, ScreenManager

La Ilustración 2, nos muestra la definición de una clase “UI”, que hereda de “ScreenManager”. Esta
clase no tiene funcionalidades adicionales y se utiliza para cargar la interfaz de usuario definida en
un archivo llamado “design.kv”.

Ilustración 3, Clase Principal

Definimos la clase principal que heredara de MDApp.

 Ilustración 4, Inicialización de aplicación

En la Ilustración 4, la línea 15 define el método “Build”, que se llama al iniciar la aplicación, el cual
en las líneas 16 y 17 establece un estilo de colores para la aplicación.

En la línea 18 se carga el archivo que contiene la apariencia y estructura de la aplicación,

finalmente en la línea 19 se crea una instancia de la clase “UI” y la devuelve como la raíz de la
interfaz de usuario.

Ilustración 5, Cambios de Estilo

En la Ilustración 5, en la línea 21 definimos el método “change_style”, que se llama cuando se

cambia el estado de un interruptor en la interfaz de usuario. Este método cambia el estilo del
tema entre “Dark” (Oscuro) y “Ligth” (Claro), que están en las líneas 23 y 25.
 Ilustración 6, Comparación de videos

En la Ilustración 6, en la línea 27 se define el método “compare_videos” que se encargara de

comparar las poses que se muestren en los videos, en la línea 28 se crea una instancia
“drawing_utils” de la librería “Mediapipe” que se utilizara par a dibujar los puntos clave de las
poses en los videos, para después en la línea 29 crear otra instancia de pose que se utilizara para el
seguimiento y analisis de poses en los videos, luego en la línea 31 se hace uso de la instancia
“pose”, configurada para trabajar un flujo de video en tiempo real, con un umbral de confianza y
seguimiento de 0.5, con esto extraemos las poses que se ven en los videos.

En las líneas 33 y 34 se crean las instancias “VideoCapture” de “OpenCV” para el video original y
de prueba, los cuales se comparan para saber si el movimiento deseado se esta realizando
correctamente. Por último, en las líneas 36 y 37 se crean listas vacías para almacenar las poses
detectadas en el video original y de prueba respectivamente.

Ilustración 7, Bucle de videos

En la Ilustración 7, en la línea 37 iniciamos una sentencia “While” que crea un bucle que se ejecuta
mientras ambos videos están abiertos y se pueden leer los cuadros, luego en las líneas 40 y 41 lee
los cuadros del video original y el de prueba.

Ilustración 8, Fin de lectura de cuadros

En la Ilustración 8, en la línea 43 se crea una sentencia “if” que termina el bucle cuando no se
pueden leer mas cuadros de alguno de los videos.

Después, en las líneas 46 y 47 convierte los cuadros de los videos del formato BGR al formato RGB,
debido a que “Mediapipe” solo recibe imágenes en este ultimo formato, luego en las líneas 49 y 50
se procesan las imágenes de los cuadros utilizando la instancia de “pose” para obtener los
resultados de las poses. Luego en las líneas 52 y 53 agrega los puntos de referencia de las poses a
las listas correspondientes.

En las líneas 55 y 57 se crean copias de las imágenes originales para dibujar los puntos clave de las
poses y finalmente en las líneas 56 y 58 se dibujan los puntos clave de las poses en las imágenes
originales y de prueba.

Ilustración 9, Comparación de poses

En la línea 61 se crea un “if” el cual va a comparar las poses guardadas y va a mostrar en la

ventana del video de prueba si la pose esta mal o es correcta, esto se hace en las líneas 62 y 64.

En las líneas 66 y 67 se convierten las imágenes de nuevo al formato BGR para mostrarlas en la
ventana de la línea 70 la cual muestra la imagen de prueba con los puntos clave y el texto en una
ventana.

En la línea 72 se crea otra sentencia “if” que espera la entrada del teclado, si se presiona la tecla
“Q”, se sale del bucle, por último, en las líneas 76 y 77 se liberan los recursos utilizados por el
video de prueba y cierra todas las ventanas.

Ilustración 10, Resultados en Consola

En la Ilustración 10, de las líneas 80 a 91 se comparan las poses cuadro a cuadro entre el video
original y de prueba y refleja los resultados en la consola.

Ilustración 11, Comparación por puntos

En la Ilustración 11, definimos la función “poses_are_different” (línea 93), que compara las poses
basadas en la posición de los puntos de referencia de los videos y devuelve “True” si las poses son
diferentes y “False” en caso de que sean similares.

Ilustración 12, Abrir videos

En la Ilustración 12, en las líneas de la 103 a la 105 se define el método “open_video_window” que
se encarga de abrir los videos en ventanas separadas utilizando hilos para el procesamiento en
segundo plano.

Ilustración 13 ,Ejecución de MainApp

En la Ilustración 13, en las líneas 108 a la 110 se verifica si el archivo es el archivo principal y crea
una instancia MainApp y la ejecuta.

A continuación, veremos el código contenido en el documento “design.kv”, que es donde se

contiene todo el diseño de la aplicación.

Ilustración 14, Importe de librerías

En las líneas 1 y 2 se importan las librerías para las transiciones que hace la aplicación.
 Ilustración 15, Template

Se crea un template que va de la línea 4 a la 20 (Ilustración 15), el cual da diseño a la tarjeta de

selección de poses, esta cuenta con “radius”, “spacing”, entre otros elementos de diseño y
también el “on_release” que es donde va a transición de escenas y el “MDBoxLayout” donde se
concentra la información de la tarjeta.

Ilustración 16, Template de Escena

Desde las líneas 22 a la 43 (Ilustración 16), se conforma un template de escena el cual contiene las
funciones necesarias del diseño, cuenta con “MDLabel” que contiene el texto de cada posición de
rugby, dos “MDFillRoundFlatButton”, uno en la línea 30 que es para comparar videos y este tiene
un “on_release” (líneas 33 y 34) que conecta con la clase “Main.py” que es donde esta la parte
lógica de la aplicación y lleva las rutas de los videos, el segundo botón es el encargado de regresar
a la pantalla anterior, el cual es la línea 38.

Ilustración 17, Interfaz

Después se creo un “UI” el cual va a tener toda la interfaz almacenada, este va a tener el texto de
título (línea 64, Ilustración 17) y en la línea 67 se crea un MDSwitch, que es donde estarán
albergadas las opciones de posiciones de rugby.
 Ilustración 18, Grid de ordenamiento

Finalmente, en el bloque de código de la línea 73 a la 108 de la Ilustración 18, se creo un

MDGridLayout el cual organiza todas las tarjetas de las poses de rugby.

Con esto damos por finalizado el desarrollo del ejercicio.

 RESULTADOS

Grafica 1, Pantalla principal

Esta es la interfaz gráfica final (Grafica 1), cuenta con el título de la aplicación “Rugby
Uniamazonia”, el interruptor para cambiar los temas entre oscuro y claro en la esquina superior
derecha y un grid con las poses principales del Rugby.
 Grafica 2, Interfaz de comparación

Presionando en cualquiera de las opciones de poses, vamos a ser dirigidos a la interfaz de la

Grafica 2, la cual cuenta con dos botones, uno para empezar a comparar video y regresar, si
presionamos comparar nos presentara el video de prueba que va a comprar con el original.
 Grafica 3, Video siendo comparado

En la Grafica 3 podemos ver que al acceder al botón “comparar”, se muestra el video con los
puntos de referencia y un letrero indicando si es correcto, este se compara con el original o los
puntos de referencia del video original, estos deciden si se esta ejecutando bien la pose o no.
 Grafica 4, Pose errónea

En el caso de la Grafica 4, nos indica que la pose se está haciendo mal y no va acorde a la pose
original del video del que se tomaron los puntos de referencia.
 Grafica 5, Posibles bugs

Se pueden presentar casos en el que pequeños errores se hacen presentes, como el de la Grafica 5
donde los puntos de referencia no son capaces de ajustarse a la estructura del modelo.
 Grafica 6, Caso con dos personas

Cuando hay dos o mas cuerpos en el video, el aplicativo tiende a fallar un poco más, pero en este
caso, los puntos de referencia se ajustan lo mejor posible y son capaces de determinar si se esta
haciendo un movimiento correcto.
 BIBLIOGRAFIA

Loyo, A. (2017). Visión Computacional. Https://Sg.Com.Mx/Revista/55/Visi-n-Computacional.