Python OpenCV – Estimación de poses

¿Qué es la estimación de pose?

La estimación de pose es una técnica de visión artificial que se utiliza para predecir la configuración del cuerpo (POSE) a partir de una imagen. La razón de su importancia es la abundancia de aplicaciones que pueden beneficiarse de la tecnología. 

La estimación de la postura humana localiza los puntos clave del cuerpo para reconocer con precisión las posturas de las personas a las que se les da una imagen. Estas estimaciones se realizan en 3D o 2D. 

El proceso principal de estimación de la pose humana incluye dos pasos básicos: i) localizar las articulaciones/puntos clave del cuerpo humano ii) agrupar esas articulaciones en una configuración de pose humana válida

En el primer paso, el enfoque principal es encontrar la ubicación de cada punto clave de los seres humanos. Por ejemplo, cabeza, hombro, brazo, mano, rodilla, tobillo. El segundo paso es agrupar esas articulaciones en una configuración de pose humana válida que determina los términos por pares entre las partes del cuerpo.

La figura (b) representa la detección de los puntos clave y la figura (a) representa la agrupación de puntos clave

¿Qué es OpenCV ?

OpenCV Python es una biblioteca de enlaces de Python diseñada para resolver problemas de visión por computadora. Se enfoca principalmente en el procesamiento de imágenes, la captura y el análisis de videos, incluidas funciones como la detección de rostros y la detección de objetos.  

Uso de OpenCV en python:

OpenCV Python no es más que una clase contenedora para la biblioteca C++ original que se utilizará con Python. Con esto, todas las estructuras de array de OpenCV se convierten a/desde arrays NumPy. Esto facilita la integración con otras bibliotecas que usan NumPy. Por ejemplo, bibliotecas como SciPy y Matplotlib.

Para saber más sobre OpenCV, https://opencv.org/about/

Conjuntos de datos que puede utilizar:

En la selección de conjuntos de datos, COCO y MPII son selecciones predeterminadas en casos recientes. Especialmente, COCO es un conjunto de datos famoso por su propiedad de tener poses humanas muy amplias y una enorme cantidad de imágenes. Los conjuntos de datos LSP y FLIC también se utilizan junto con COCO y MPII.

• http://cocodataset.org/#keypoints-2018
• http://human-pose.mpi-inf.mpg.de/
• http://www.robots.ox.ac.uk/~vgg/data/pose_evaluacion/

Puede descargar los archivos de peso del modelo utilizando los scripts proporcionados en esta ubicación .

Código para la estimación de la pose humana en OpenCV

En esta sección, veremos cómo cargar los modelos entrenados en OpenCV y comprobar los resultados. Discutiremos el código para la estimación de la pose de una sola persona para simplificar las cosas. Estas salidas se pueden usar para encontrar la pose de cada persona en un cuadro si hay varias personas presentes. Cubriremos el caso de varias personas en una publicación futura.

Primero, descargue el código y los archivos del modelo de abajo. Hay archivos separados para las entradas de imagen y video. Revise el archivo README si encuentra alguna dificultad para ejecutar el código.

Paso 1: Descargue los pesos del modelo

Utilice el archivo getModels.sh proporcionado con el código para descargar todos los pesos de los modelos en las carpetas respectivas. Tenga en cuenta que los archivos de los prototipos de configuración ya están presentes en las carpetas.

sudo chmod a+x getModels.sh
./getModels.sh

Verifique las carpetas para asegurarse de que se hayan descargado los archivos binarios del modelo (archivos .caffemodel ). Si no puede ejecutar el script anterior, puede descargar el modelo haciendo clic aquí para el modelo MPII y aquí para el modelo COCO.

Paso 2: Red de carga

Estamos utilizando modelos entrenados en Caffe Deep Learning Framework. Los modelos Caffe tienen 2 archivos:

1. archivo prototxt que especifica la arquitectura de la red neuronal: cómo se organizan las diferentes capas, etc.
2. archivo caffemodel que almacena los pesos del modelo entrenado

Usaremos estos dos archivos para cargar la red en la memoria.

# Specify the paths for the 2 files
protoFile = "pose/mpi/pose_deploy_linevec_faster_4_stages.prototxt"
weightsFile = "pose/mpi/pose_iter_160000.caffemodel"
# Read the network into Memory
net = cv2.dnn.readNetFromCaffe(protoFile, weightsFile)

Paso 3: Lea la imagen y prepare la entrada a la red

El marco de entrada que leemos usando OpenCV debe convertirse en un blob de entrada (como Caffe) para que pueda alimentarse a la red. Esto se hace usando la función blobFromImage que convierte la imagen del formato OpenCV al formato Caffe blob.

Los parámetros deben proporcionarse en la función blobFromImage. Primero, normalizamos los valores de píxel para que estén en (0,1). Luego especificamos las dimensiones de la imagen. A continuación, el valor medio a restar, que es (0,0,0). No es necesario intercambiar los canales R y B, ya que tanto OpenCV como Caffe utilizan el formato RGB.

# Read image
frame = cv2.imread("single.jpg")
  
# Specify the input image dimensions
inWidth = 368
inHeight = 368
  
# Prepare the frame to be fed to the network
inpBlob = cv2.dnn.blobFromImage(
    frame, 1.0 / 255, (inWidth, inHeight), (0, 0, 0), swapRB=False, crop=False)
  
# Set the prepared object as the input blob of the network
net.setInput(inpBlob)

Paso 4: Hacer predicciones y analizar puntos clave

output = net.forward()

La salida es una array 4D:

1. La primera dimensión es la identificación de la imagen (en caso de que pase más de una imagen a la red).
2. La segunda dimensión indica el índice de un punto clave. El modelo produce mapas de confianza y mapas de afinidad de piezas que están todos concatenados. Para el modelo COCO consta de 57 partes: 18 mapas de confianza de puntos clave + 1 fondo + 19*2 mapas de afinidad de partes. De manera similar, para MPII, produce 44 puntos. Usaremos solo los primeros puntos que corresponden a los puntos clave.
3. La tercera dimensión es la altura del mapa de salida.
4. La cuarta dimensión es el ancho del mapa de salida.

Una vez que se detectan los puntos clave, simplemente los trazamos en la imagen.

H = out.shape[2]
W = out.shape[3]
# Empty list to store the detected keypoints
points = []
for i in range(len()):
    # confidence map of corresponding body's part.
    probMap = output[0, i, :, :]
  
    # Find global maxima of the probMap.
    minVal, prob, minLoc, point = cv2.minMaxLoc(probMap)
  
    # Scale the point to fit on the original image
    x = (frameWidth * point[0]) / W
    y = (frameHeight * point[1]) / H
  
    if prob > threshold:
        cv2.circle(frame, (int(x), int(y)), 15, (0, 255, 255),
                   thickness=-1, lineType=cv.FILLED)
        cv2.putText(frame, "{}".format(i), (int(x), int(
            y)), cv2.FONT_HERSHEY_SIMPLEX, 1.4, (0, 0, 255), 3, lineType=cv2.LINE_AA)
  
        # Add the point to the list if the probability is greater than the threshold
        points.append((int(x), int(y)))
    else:
        points.append(None)
  
cv2.imshow("Output-Keypoints", frame)
cv2.waitKey(0)
cv2.destroyAllWindows()

La figura (a) muestra los puntos clave trazados utilizando el modelo COCO. La figura (b) muestra los puntos clave trazados utilizando el modelo MPII.

Paso 5: Dibujar esqueleto

Esta figura muestra el esqueleto formado por todos los puntos clave unidos

for pair in POSE_PAIRS:
    partA = pair[0]
    partB = pair[1]
  
    if points[partA] and points[partB]:
        cv2.line(frameCopy, points[partA], points[partB], (0, 255, 0), 3)

Encontramos que el modelo COCO es 1.5 veces más lento que el modelo MPI. 

Aplicaciones de la estimación de pose:

• Lenguas de signos para ayudar a las personas con discapacidad.
• Seguimiento humano
• Juego de azar
• Video vigilancia
• Sistemas Avanzados de Asistencia al Conductor (ADAS)
• Reconocimiento de acciones

REFERENCIAS:

• https://github.com/CMU-Perceptual-Computing-Lab/openpose  
• https://learnopencv.com/deep-learning-based-human-pose-estimation-using-opencv-cpp-python/    
• https://ieeexplore.ieee.org/document/9144178