Aprenda a identificar y rastrear manos con OpenCV y Python

2023/01/30

El seguimiento de manos es el proceso de utilizar la visión artificial para detectar y seguir los movimientos de la mano de una persona en tiempo real. La aplicación más dominante del seguimiento de manos se encuentra en los cascos de realidad virtual. Los auriculares le permiten usar sus manos como entrada en lugar de los controladores táctiles. Esto a su vez hace que la experiencia sea más inmersiva.

Descubra cómo rastrear las manos de una persona usando Python, OpenCV para visión por computadora y MediaPipe.

¿Cómo rastrea las manos MediaPipe Framework?

Google desarrolló el marco MediaPipe, que contiene muchas soluciones de aprendizaje automático. Una de las soluciones es la solución de seguimiento de manos y dedos llamada MediaPipe Hands . Para realizar un seguimiento de las manos, MediaPipe Hands realiza dos procesos: detección de la palma y detección de puntos de referencia.

Detección de la palma de la mano

MediaPipe comienza identificando dónde están las palmas en la imagen de entrada. Dado que estimar cuadros delimitadores para objetos rígidos es más simple que identificar manos con dedos articulados.

Detección de puntos de referencia de mano

Después de la detección de la palma, MediaPipe realiza la detección de puntos de referencia de la mano. El modelo de puntos de referencia de la mano puede predecir 21 coordenadas precisas de la ubicación de cada punto de referencia de la mano.

Una mano con puntos de referencia con nombre

Los números representan un identificador único para cada punto de referencia.

Configuración de su entorno

Para continuar con este proyecto, debe estar familiarizado con los conceptos básicos de Python. Instale las siguientes bibliotecas en su entorno:

OpenCV: usará esta biblioteca para la visión por computadora y para realizar técnicas de procesamiento de imágenes en la imagen de entrada.
MediaPipe: utilizará esta biblioteca para realizar la detección manual y el seguimiento de la imagen de entrada.
imutils: usará esta biblioteca para cambiar el tamaño del cuadro de video de la entrada.

Ejecute el siguiente comando en su terminal para instalar las bibliotecas OpenCV, MediaPipe e imutils. Instale pip, el administrador de paquetes de Python, si es necesario. Asegúrese de pasar las bibliotecas como una lista delimitada por espacios.

pip install OpenCV-Python MediaPipe imutils

Cuando se completa la actualización, el entorno está listo para que comience a codificar.

Importación de las bibliotecas requeridas

Deberá importar las bibliotecas que instaló para poder usarlas. Abra cualquier IDE de Python, cree un archivo de Python y agregue las siguientes importaciones:

import cv2 import mediapipe as mp import imutils

Asegúrese de importar OpenCV como cv2 y MediaPipe en minúsculas. Si no lo hace, arrojará un error.

Creación de los objetos de MediaPipe que utilizará durante el seguimiento

Usará mpHands para llamar a la solución de manos de MediaPipe y el objeto de manos para detectar y rastrear la entrada de la mano. Utilizará el objeto mpDraw para dibujar las conexiones entre los puntos de referencia de las manos identificadas.

mpHands = mp.solutions.hands hands = mpHands.Hands() mpDraw = mp.solutions.drawing_utils

Puede ajustar el modelo de manos de MediaPipe pasando varios parámetros al constructor Hands(). Los valores predeterminados son lo suficientemente buenos para este proyecto, pero puede experimentar con ellos para ver cómo afectan al modelo:

Pycharm IDE que muestra los parámetros predeterminados de MediaPipe Hands

Debe dejar static_image_mode como False para asegurarse de que el modelo detecte las manos una vez antes de comenzar a rastrearlas. Solo repite el proceso de seguimiento si la confianza de detección cae por debajo del parámetro declarado, lo que hace que el procesamiento de entrada general sea más rápido.

Realización de seguimiento de manos

Necesita tres funciones para realizar el seguimiento de la mano: una para procesar la entrada, otra para dibujar las conexiones de puntos de referencia de la mano y una función principal para controlar el flujo del programa.

Función de procesamiento de entrada

Esta función toma la entrada, la convierte a escala de grises y la pasa al modelo de manos de MediaPipe para detectar y rastrear las manos en la entrada.

# Processing the input image def process_image(img): # Converting the input to grayscale gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) results = hands.process(gray_image)

# Returning the detected hands to calling function return results

La función devuelve los resultados sobre si se detectaron manos en la entrada.

La función de dibujo de conexiones de puntos de referencia de mano

Esta función verifica si la función de procesamiento de entrada detectó alguna mano. Si hay manos detectadas, recorre cada punto de referencia y dibuja un círculo a su alrededor, realizando un seguimiento del punto de referencia mediante la función de enumeración de Python. Luego dibuja las conexiones entre los puntos de referencia en la entrada de video original.

# Drawing landmark connections def draw_hand_connections(img, results): if results.multi_hand_landmarks: for handLms in results.multi_hand_landmarks: for id, lm in enumerate(handLms.landmark): h, w, c = img.shape

# Finding the coordinates of each landmark cx, cy = int(lm.x * w), int(lm.y * h)


                # Printing each landmark ID and coordinates
                # on the terminal
                print(id, cx, cy)
                # Creating a circle around each landmark
                cv2.circle(img, (cx, cy), 10, (0, 255, 0),
                           cv2.FILLED)
                # Drawing the landmark connections
                mpDraw.draw_landmarks(img, handLms,
                                      mpHands.HAND_CONNECTIONS)

return img

La función comienza encerrando en un círculo cada punto de referencia:

Salida de un programa con cada hito en un círculo

Luego dibuja las conexiones manuales:

Salida de un programa de seguimiento de manos.

Finalmente devuelve su salida a la función de llamada.

La función principal

Cree una función principal que controlará el flujo de su programa. Tomará la entrada y cambiará el tamaño del cuadro de video para garantizar la consistencia de la salida. Pase la entrada a la función de procesamiento que luego detectará y rastreará las manos. Lleve los resultados devueltos a la función de dibujo de conexión de puntos de referencia de la mano que dibujará la conexión en la entrada de video original. Finalmente mostrará la salida al usuario.

def main(): # Replace 0 with the video path to use a # pre-recorded video cap = cv2.VideoCapture(0)

while True: # Taking the input success, image = cap.read() image = imutils.resize(image, width=500, height=500) results = process_image(image) draw_hand_connections(image, results)


        # Displaying the output
        cv2.imshow("Hand tracker", image)

# Program terminates when q key is pressed if cv2.waitKey(1) == ord('q'): cap.release() cv2.destroyAllWindows()

El último paso es ejecutar su programa. El siguiente código asegura que cuando ejecuta el programa, la función principal se ejecuta primero.

if __name__ == "__main__": main()

Cuando el programa se ejecuta, produce una salida como esta:

El programa rastrea las manos en tiempo real.

Seguimiento manual para realidad virtual inmersiva

El seguimiento manual en realidad virtual hace que la tecnología sea más atractiva. Los cascos de realidad virtual han comenzado a introducir el seguimiento manual, lo que brinda una sensación de realidad aumentada al mundo virtual. Los auriculares permiten al usuario ingresar comandos usando una mano virtual.

El seguimiento de manos en auriculares virtuales es solo una aplicación de esta tecnología. Puede incorporar el seguimiento manual en cualquier área aplicable de su agrado.