Aprenda a identificar y rastrear manos con OpenCV y Python

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.

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 Manos. 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.

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

Configuración de su entorno

Para seguir con este proyecto, debe estar familiarizado con el fundamentos 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 lo necesitas. Asegúrese de pasar las bibliotecas como una lista delimitada por espacios.

pip instalar OpenCV-Python MediaPipe imutils

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

El código fuente completo de este proyecto está disponible en su repositorio GitHub.

Importación de las bibliotecas requeridas

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

importar cv2
importar tubo de medios como diputado
importar imutiles

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

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.

mpManos = mp.soluciones.manos
manos = mpManos. Manos()
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:

deberías dejar el modo_imagen_estática como Falso para garantizar 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.

# Procesando la imagen de entrada
definitivamenteimagen_del_proceso(imagen):
# Convirtiendo la entrada a escala de grises
 imagen_gris = cv2.cvtColor (img, cv2.COLOR_BGR2RGB)
 resultados = manos.proceso (imagen_gris)
# Devolver las manos detectadas a la función de llamada
devolver resultados

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 usando Función de enumeración de Python. Luego dibuja las conexiones entre los puntos de referencia en la entrada de video original.

# Dibujar conexiones históricas
definitivamentedibujar_manos_conexiones(imagen, resultados):
si resultados.multi_hand_landmarks:
para manoLms en resultados.multi_hand_landmarks:
para identificación, película en enumerar (handLms.landmark):
 h, w, c = img.forma
# Encontrar las coordenadas de cada punto de referencia
 cx, cy = int (lm.x * w), int (lm.y * h)
# Imprimiendo cada ID y coordenadas de punto de referencia
# en la terminal
 imprimir (id, cx, cy)
# Crear un círculo alrededor de cada punto de referencia
 cv2.círculo (img, (cx, cy), 10, (0, 255, 0),
 cv2.LLENADO)
# Dibujar las conexiones históricas
 mpDraw.draw_landmarks (img, handLms,
 mpManos. CONEXIONES_MANUALES)
devolver imagen

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

Luego dibuja las conexiones manuales:

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.

definitivamenteprincipal():
# Reemplace 0 con la ruta de video para usar un
# video pregrabado
 cap = cv2.VideoCapture(0)
mientrasVerdadero:
# Tomando la entrada
 éxito, imagen = cap.read()
 imagen = imutils.resize (imagen, ancho =500, altura=500)
 resultados = proceso_imagen (imagen)
 draw_hand_connections (imagen, resultados)
# Mostrando la salida
 cv2.imshow("Rastreador de manos", imagen)
# El programa termina cuando se presiona la tecla q
si cv2.esperaClave(1) == orden('q'):
 cap.liberar()
 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.

si __nombre__ == "__principal__":
 principal()

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.