Oct 26 2024
0

Segmentación de imágenes con MediaPipe (Selfie Segmentation) – Python

Por Administrador

¡Hola, hola Omesitos!.

Vamos con la siguiente tarea de Mediapipe: Image Segmentation. Dado que Mediapipe nos proporciona distintos modelos, en este tutorial nos centraremos en: Selfie segmentation model, y los demás los iremos viendo en próximos blog posts. Así que… ¡Vamos a por ello!.

CONTENIDO

  • ¿Qué es la segmentación de imágenes?
  • ¿Cómo usar la segmentación de imágenes en Mediapipe?
  • Selfie segmentation model
  • ¿Cómo segmentar imágenes con Mediapipe Selfie Segmentation en Python?
  • ¿Cómo segmentar videos con Mediapipe Selfie Segmentation en Python?
  • ¿Cómo usar la segmentación de imágenes en video streaming con Mediapipe en Python?

¿Qué es la segmentación de imágenes?

La segmentación de imágenes es una técnica de visión artificial que se enfoca en dividir a la imagen en regiones más pequeñas llamadas segmentos, de este modo se simplifica la representación de una imagen y es más fácil de analizar. Cabe destacar que estos segmentos o agrupación de pixeles comparten características similares, ya sea en cuanto al color, textura, entre otros.

¿Cómo usar la segmentación de imágenes en Mediapipe?

Para empezar a usar las soluciones y modelos de Mediapipe, debemos instalar este framework, así que para ello nos ayudaremos de pip:

pip install mediapipe

Una vez que sabemos lo que es la segmentación de imágenes podremos explorar lo que nos ofrece. De hecho su documentación oficial nos dice lo siguiente:

“La tarea de Segmentación de Imágenes de MediaPipe permite dividir imágenes en regiones basadas en categorías predefinidas. Podemos utilizar esta funcionalidad para identificar objetos o texturas específicas y luego aplicar efectos visuales, como desenfoque de fondo. Esta tarea incluye varios modelos entrenados específicamente para segmentar personas y sus características dentro de los datos de la imagen, incluyendo:

  • Persona y fondo
  • Solo el cabello de la persona
  • Cabello, rostro, piel, ropa y accesorios de la persona

Esta tarea opera sobre datos de imágenes utilizando un modelo de aprendizaje automático (ML) con imágenes individuales o una transmisión continua de video. Genera una lista de regiones segmentadas, que representan objetos o áreas en una imagen, dependiendo del modelo que se elija.”

En su documentación se describe tambien la disponibilidad de varios modelos como:

  • Selfie segmentation model (este es el que veremos en este blog post)
  • Hair segmentation model
  • Multi-class selfie segmentation model
  • DeepLab-v3 model

En un momento veremos como aplicar la segmentación en Python, pero lo que debemos tener en cuenta es que estos modelos nos van a devolver predicciones sobre cada pixel de la imagen de entrada. En sí debemos tener en claro las siguientes salidas:

CATEGORY_MASK: Lista que contiene una máscara segmentada en formato uint8. Cada valor de píxel indica si es parte de una categoría de segmento específica.

CONFIDENCE_MASK: Lista de canales que contiene una máscara segmentada con valores de píxel en formato float32. Cada valor de píxel indica el nivel de confianza de que es parte de una categoría específica.

Si esto aún no lo tenemos del todo claro, en cuanto lleguemos a la programación lo conseguiremos entender mejor. ????

Selfie segmentation model

Mediapipe nos otorga diferentes modelos para aplicar segmentación de imágenes, en esta ocasión vamos a probar el modelo de segmentación Selfie. Este modelo permite segmentar el retrato de una persona o personas del fondo, así que podría ser usado para reemplazar por ejemplo, el fondo de la imagen.

Tenemos dos modelos que podemos aplicar, uno para imágenes rectangulares y otro para imágenes en horizontal. Este último es ideal para videollamadas, efectos en videos y realidad aumentada, donde se necesita identificar y manipular solo a la persona o cambiar el fondo.

Por cierto, puedes conocer más sobre los modelos a través de su Model Card, en donde se especifican detalles cómo: la arquitectura que se usó para entrenarlos, entradas, salidas, aplicaciones, limitaciones, consideraciones éticas, entre otros. Sería genial si le echas un vistazo.

NOTA: En el canal de youtube y en este blog, tenemos tutoriales sobre el uso de la segmentación selfie en una versión antigua de Mediapipe y también tenemos un tutorial de como cambiar el fondo de una imagen con esta misma herramienta. Te las dejo en este párrafo, por si tienes curiosidad por ello. ????

Y bien, para descargar estos modelos, simplemente tendremos que hacer clic sobre ellos. Una vez que los tenemos, es hora de pasar a la programación…

¿Cómo segmentar imágenes con Mediapipe Selfie Segmentation en Python?

Vamos a crear un nuevo archivo de python. Y vamos a empezar por la importación de las librerías.

import mediapipe as mp
from mediapipe.tasks.python import vision
from mediapipe.tasks.python import BaseOptions
import cv2

Lo primero que haremos es importar mediapipe, luego de mediapipe.task.python importaremos vision, ya que estaremos empleado una tarea de visión por computador, la cual nos permitirá manejar imágenes o videos. Luego importaremos BaseOptions que permitirá básicamente leer el modelo que se usará, así como configurarlo y finalmente importamos OpenCV.

# Especificar las opciones de configuración
options = vision.ImageSegmenterOptions(
    base_options=BaseOptions(model_asset_path="/path/selfie_segmenter_landscape.tflite"),
    output_category_mask=True,
    running_mode=vision.RunningMode.IMAGE)
segmenter = vision.ImageSegmenter.create_from_options(options)

Y precisamente vamos a empezar con las opciones de configuración a través de vision.ImageSegmenterOptions. En primer lugar vamos a establecer el path del modelo que estaremos usando, en este caso selfie_segmenter_landscape.tflite pero también podemos usar selfie_segmenter.tflite, el modelo que necesita como entrada una imagen cuadrada. Luego tenemos a output_category_mask que estableceremos como True, y nos permitirá obtener una máscara de segmentación como una imagen uint8, donde cada valor de píxel indica la categoría ganadora.

Finalmente en running_mode vamos a ubicar vision.RunningMode.IMAGE, debido a que vamos a estar usando una imagen como entrada.

Una vez que tenemos las opciones de configuración, vamos a pasarlas al segmentador, para ello usamos vision.ImageSegmenter.create_from_options(options).

NOTA: Para más información sobre las opciones de configuración, no olvides echarle un vistazo a la sección Configuration Options de Mediapipe.

# Leer la imagen de entrada
image = cv2.imread("./Inputs/image.jpg")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image_rgb = mp.Image(image_format=mp.ImageFormat.SRGB, data=image_rgb)

Ahora vamos a leer la imagen de entrada, para ello usaremos cv2.imread. Tendremos que especificar su ubicación o simplemente su nombre junto con su extensión si se encuentra en el mismo directorio que el archivo de Python en el que estamos trabajando.

Vamos a proceder a cambiar el orden de los canales de la imagen de entrada, transformaremos de BGR a RGB. Y además tendremos que convertir la imagen a un objeto mediapipe.Image. Para ello especificamos mp.ImageFormat.SRGB y data=image_rgb.

# Obtener los resultados del segmentador
segmentation_result = segmenter.segment(image_rgb)

Para empezar con la segmentación tendremos que usar segmenter.segment, y especificar la imagen que deseamos analizar.

category_mask = segmentation_result.category_mask
confidence_mask = segmentation_result.confidence_masks[0]

segmentation_result.category_mask, nos permitirá extraer la máscara de categorías (category_mask) del resultado de la segmentación. Esta máscara es una imagen en formato uint8, donde cada valor de píxel indica la categoría de segmento a la que pertenece.

segmentation_result.confidence_masks[0], nos permitirá extraer el primer canal de la máscara de confianza del resultado de segmentación. Para este caso solo accedemos al primer canal, ya que allí estará la confianza tanto de las personas, como del fondo. Sin embargo, para otros modelos, obtendremos más de un canal o más de una máscara, esto dependerá de la cantidad de segmentos que puedan extraer).

# Convertir la máscara en una vista de numpy
category_mask_np = category_mask.numpy_view()
confidence_mask_np = confidence_mask.numpy_view()

print(f"category_mask_np: {category_mask_np.shape} - {category_mask_np.dtype} -> {category_mask_np}")
print(f"confidence_mask_np: {confidence_mask_np.shape} - {confidence_mask_np.dtype} -> {confidence_mask_np}")

Tanto para category_mask como para confidence_mask les aplicaremos numpy_view(). Esto para convertir a ambos en arrays de numpy. Este es un paso fundamental ya que nos permitirá manipular, analizar y visualizar las imágenes y datos de salida.

Es más, podremos imprimir los resultados de estas dos nuevas variables y analizar sus resultados.

# Imágenes a partir de las máscaras
bg = cv2.bitwise_and(image, image, mask=category_mask_np)
inv_mask = cv2.bitwise_not(category_mask_np)
fg = cv2.bitwise_and(image, image, mask=inv_mask)

De la línea 33 a la 35 nos servirán para hacer un ejercicio de visualización. Ya que vamos a apoyarnos de las máscaras, para visualizar solo el fondo a color, esto estará en bg. Y unicamente el primer plano a color y el fondo en negro, que estará en fg.

cv2.imshow("category_mask_np", category_mask_np)
cv2.imshow("confidence_mask_np", confidence_mask_np)
cv2.imshow("bg", bg)
cv2.imshow("fg", fg)
cv2.imshow("Image", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

Finalmente desde la línea 37, visualizaremos los resultados. Así que vamos a verlos, tanto para el modelo que permite una imagen cuadrada de entrada, como el que permite una imagen rectangular.

Resultados, aplicando SelfieSegmenter (square)

Para esta prueba se usará la siguiente imagen de entrada:

A continuación visualizaremos lo que obtenemos en category_mask_np y confidence_mask_np:

En la imagen de la izquierda tenemos el category mask, en donde podemos ver que en color blanco (255) se representa el fondo de la imagen, mientras que en negro (0) a las personas. Recordemos que el category mask nos devuelve un array uint8 cuyos valores representan a las categorías segmentadas.

La imagen de la derecha en cambio representa el confidence_mask. Este array contiene valores de 0 a 1, en donde aquellos más cercanos a 0 representan al fondo y los más cercanos a 1 a las personas. De hecho este array es muy importante, porque de estos valores de confianza podríamos construir la máscara para cada una de las categorías, aplicando algún umbral.

En la línea 33 construímos la imagen de la izquierda, en donde ubicamos a color el fondo de la imagen, mientras que las personas se mantenían en negro.

En la línea 35 en cambio construimos la imagen de la derecha, en donde visualizamos a color a las personas, y el fondo en negro. Podríamos jugar un poco con estas imágenes y cambiar a cualquier otro fondo, por ejemplo.

Ahora vamos a ver otro ejemplo aplicando el mismo modelo (que recibe como entrada imágenes cuadradas):

Y como podemos ver, empezando desde la ziquierda a la derecha. Tenemos a la imagen de entrada, al fondo a color y finalmente a la persona a color.

Resultados, aplicando SelfieSegmenter (landscape)

Vamos a visualizar algunos ejemplos de imágenes en donde se aplicó el procedimiento anterior, pero usando el segmentador para imágenes rectangulares (tendremos la imagen de entrada, el fondo a color y la persona a color):

A continuación tenemos el programa completo sobre la segmentación de imágenes sobre una imagen:

import mediapipe as mp
from mediapipe.tasks.python import vision
from mediapipe.tasks.python import BaseOptions
import cv2

# Especificar las opciones de configuración
options = vision.ImageSegmenterOptions(
    base_options=BaseOptions(model_asset_path="/path/selfie_segmenter_landscape.tflite"),
    output_category_mask=True,
    running_mode=vision.RunningMode.IMAGE)
segmenter = vision.ImageSegmenter.create_from_options(options)

# Leer la imagen de entrada
image = cv2.imread("./path/image.jpg")
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
image_rgb = mp.Image(image_format=mp.ImageFormat.SRGB, data=image_rgb)

# Obtener los resultados del segmentador
segmentation_result = segmenter.segment(image_rgb)
print(f"segmentation_result: {segmentation_result}")

category_mask = segmentation_result.category_mask
confidence_mask = segmentation_result.confidence_masks[0]

# Convertir la máscara en una vista de numpy
category_mask_np = category_mask.numpy_view()
confidence_mask_np = confidence_mask.numpy_view()

print(f"category_mask_np: {category_mask_np.shape} - {category_mask_np.dtype} -> {category_mask_np}")
print(f"confidence_mask_np: {confidence_mask_np.shape} - {confidence_mask_np.dtype} -> {confidence_mask_np}")

# Imágenes a partir de las máscaras
bg = cv2.bitwise_and(image, image, mask=category_mask_np)
inv_mask = cv2.bitwise_not(category_mask_np)
fg = cv2.bitwise_and(image, image, mask=inv_mask)

cv2.imshow("category_mask_np", category_mask_np)
cv2.imshow("confidence_mask_np", confidence_mask_np)
cv2.imshow("bg", bg)
cv2.imshow("fg", fg)
cv2.imshow("Image", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

¿Cómo segmentar videos con Mediapipe Selfie Segmentation en Python?

Debido a que el programa para la segmentación en video presenta similitudes con la segmentación de imágenes sobre una imagen, procederemos a explicar sus diferencias, así que vamos a por ello.

import cv2
import mediapipe as mp
from mediapipe.tasks.python import vision
from mediapipe.tasks.python import BaseOptions

# Especificar la configuración del ImageSegmenter
options = vision.ImageSegmenterOptions(
     base_options=BaseOptions(model_asset_path="./path/selfie_segmenter_landscape.tflite"),
     output_category_mask=True,
     running_mode=vision.RunningMode.VIDEO)
segmenter = vision.ImageSegmenter.create_from_options(options)

La principal diferencia con el código anterior está presente en la línea 10, ya que en running_mode debemos especificar vision.RunningMode.VIDEO, puesto a que el análisis se llevará a cabo en un video de entrada. Además ahora estamos usando el modelo selfie_segmenter_landscape.tflite (recuerda que puedes usar el otro modelo para selfie segmentation).

# Leer el video de entrada
cap = cv2.VideoCapture("./path/video.mp4")
frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT)
fps = cap.get(cv2.CAP_PROP_FPS)

Con cap.get(cv2.CAP_PROP_FRAME_COUNT), obtendremos la cantidad total de fotogramas que posee el video de entrada. Mientras que con cap.get(cv2.CAP_PROP_FPS) obtendremos los fps del video. Estos datos los usaremos más adelante.

for frame_index in range(int(frame_count)):
     ret, frame = cap.read()
     if ret == False:
          break

     frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
     frame_rgb = mp.Image(image_format=mp.ImageFormat.SRGB, data=frame_rgb)

     # Calcular la marca temporal del frame actual (en milisegundos)
     frame_timestamp_ms = int(1000 * frame_index / fps)

     # Obtener los resultados del segmentador
     segmentation_result  = segmenter.segment_for_video(frame_rgb, frame_timestamp_ms)
     print("segmentation_result", segmentation_result)

     category_mask = segmentation_result.category_mask
     confidence_mask = segmentation_result.confidence_masks[0]

     # Convertir la máscara en una vista de numpy
     category_mask_np = category_mask.numpy_view()
     confidence_mask_np = confidence_mask.numpy_view()

     # Imágenes a partir de máscaras
     bg = cv2.bitwise_and(frame, frame, mask=category_mask_np)
     inv_mask = cv2.bitwise_not(category_mask_np)
     fg = cv2.bitwise_and(frame, frame, mask=inv_mask)

     # Visualización de las imágenes
     #cv2.imshow("category_mask_np", category_mask_np)
     #cv2.imshow("confidence_mask_np", confidence_mask_np)
     cv2.imshow("Fondo", bg)
     cv2.imshow("Primer plano", fg)
     cv2.imshow("Frame", frame)

     if cv2.waitKey(10) & 0xFF == 27:
          break
cap.release()
cv2.destroyAllWindows()

Vamos a recorrer cada uno de los fotogramas del video, y como lo podemos ver en la línea 23 y 24, también tendremos que transformar cada frame de BGR a RGB y lo convertimos en un objeto mediapipe.Image.

Lo nuevo viene en la línea 27, con el cálculo de frame_timestamp_ms, que es una marca temporal en milisegundos. Esta irá incrementando conforme pase cada fotograma, esto le ayudará a mediapipe a manejar correctamente el flujo de video, de tal forma que los datos estén correctamente ordenados. (Puedes echarle un vistazo a este link para más información).

Entonces en la línea 30, tendemos que usar segmenter.segment_for_video y a este entregarle el fotograma y la marca de tiempo calculada.

Una vez terminado el programa, probemos el modelo con un video:

A continuación tenemos el programa completo sobre la Image Segmentation en un video:

import cv2
import mediapipe as mp
from mediapipe.tasks.python import vision
from mediapipe.tasks.python import BaseOptions

# Especificar la configuración del ImageSegmenter
options = vision.ImageSegmenterOptions(
     base_options=BaseOptions(model_asset_path="./path/selfie_segmenter_landscape.tflite"),
     output_category_mask=True,
     running_mode=vision.RunningMode.VIDEO)
segmenter = vision.ImageSegmenter.create_from_options(options)

# Leer el video de entrada
cap = cv2.VideoCapture("./path/video.mp4")
frame_count = cap.get(cv2.CAP_PROP_FRAME_COUNT)
fps = cap.get(cv2.CAP_PROP_FPS)

for frame_index in range(int(frame_count)):
     ret, frame = cap.read()
     if ret == False:
          break

     frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
     frame_rgb = mp.Image(image_format=mp.ImageFormat.SRGB, data=frame_rgb)

     # Calcular la marca temporal del frame actual (en milisegundos)
     frame_timestamp_ms = int(1000 * frame_index / fps)

     # Obtener los resultados del segmentador
     segmentation_result  = segmenter.segment_for_video(frame_rgb, frame_timestamp_ms)
     print("segmentation_result", segmentation_result)

     category_mask = segmentation_result.category_mask
     confidence_mask = segmentation_result.confidence_masks[0]

     # Convertir la máscara en una vista de numpy
     category_mask_np = category_mask.numpy_view()
     confidence_mask_np = confidence_mask.numpy_view()

     # Imágenes a partir de máscaras
     bg = cv2.bitwise_and(frame, frame, mask=category_mask_np)
     inv_mask = cv2.bitwise_not(category_mask_np)
     fg = cv2.bitwise_and(frame, frame, mask=inv_mask)

     # Visualización de las imágenes
     #cv2.imshow("category_mask_np", category_mask_np)
     #cv2.imshow("confidence_mask_np", confidence_mask_np)
     cv2.imshow("Fondo", bg)
     cv2.imshow("Primer plano", fg)
     cv2.imshow("Frame", frame)

     if cv2.waitKey(10) & 0xFF == 27:
          break
cap.release()
cv2.destroyAllWindows()

¿Cómo usar la segmentación de imágenes en video streaming con Mediapipe en Python?

Finalmente veremos como podemos aplicar la segmentación de imágenes sobre un video streaming o video en directo. Para ello tendremos que hacer unas cuantas modificaciones al programa anterior, veamos:

import cv2
import mediapipe as mp
from mediapipe.tasks.python import vision
from mediapipe.tasks.python import BaseOptions
import time

segmentation_result_list = []

# Función callback para procesar los resultados
def segmentation_callback(result, output_image, timestamp_ms):
     segmentation_result_list.append(result)

En la línea 7 definiremos una lista vacía que nos ayudará más adelante a almacenar los resultados de la segmentación. Mientras que en la línea 10, tenemos la definición de una función callback, la cual nos ayudará a procesar los mismos. Esta se llama automáticamente cada vez que el segmentador produce un nuevo resultado.

# Especificar la configuración del ImageSegmenter
options = vision.ImageSegmenterOptions(
     base_options=BaseOptions(model_asset_path="./path/selfie_segmenter_landscape.tflite"),
     output_category_mask=True,
     running_mode=vision.RunningMode.LIVE_STREAM, 
     result_callback=segmentation_callback)
segmenter = vision.ImageSegmenter.create_from_options(options)

En el apartado de opciones de configuración, tendremos que definir vision.RunningMode.LIVE_STREAM para el running_mode, y en result_callback especificamos la función que habíamos creado recientemente, esta nos permitirá manejar los resultados de las predicciones.

# Leer el video de entrada
cap = cv2.VideoCapture(0)

while True:
     ret, frame = cap.read()
     if ret == False:
          break

     frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
     frame_rgb = mp.Image(image_format=mp.ImageFormat.SRGB, data=frame_rgb)

     # Obtener los resultados del segmentador
     segmenter.segment_async(frame_rgb, time.time_ns() // 1_000_000)

     if len(segmentation_result_list) > 0:
          print(f"segmentation_result_list: {segmentation_result_list}")
          segmentation_result = segmentation_result_list[0]
          category_mask = segmentation_result.category_mask
          confidence_mask = segmentation_result.confidence_masks[0]

          # Convertir la máscara en una vista de numpy
          category_mask_np = category_mask.numpy_view()
          confidence_mask_np = confidence_mask.numpy_view()

          # Imágenes a partir de máscaras
          bg = cv2.bitwise_and(frame, frame, mask=category_mask_np)
          inv_mask = cv2.bitwise_not(category_mask_np)
          fg = cv2.bitwise_and(frame, frame, mask=inv_mask)

          # Visualización de las imágenes
          #cv2.imshow("category_mask_np", category_mask_np)
          #cv2.imshow("confidence_mask_np", confidence_mask_np)
          cv2.imshow("Fondo", bg)
          cv2.imshow("Primer plano", fg)
     segmentation_result_list.clear()
     cv2.imshow("Frame", frame)

     if cv2.waitKey(1) & 0xFF == 27:
          break
cap.release()
cv2.destroyAllWindows()

En la línea 33 vamos a llamar al modelo para realizar las predicciones. Para ello usaremos segmenter.segment_async, al cual tendremos que darle el frame que va a analizar junto con la marca de tiempo en milisegundos.

En la línea 35 simplemente realizamos una comparación de si existen resultados para visualizar las imágenes de salida.

Y en la línea 55 tendremos que asegurarnos de limpiar la lista de resultados

IMPORTANTE: La descripción en cuanto a la segmentación de imágenes en un videostreming nos dice lo siguiente: «El método segment_async envía datos de imagen en vivo (una imagen con una marca de tiempo única) para realizar la segmentación de imágenes… El método segment_async está diseñado para procesar datos de transmisión en vivo, como la entrada de una cámara. Para reducir la latencia general, el segmentador de imágenes puede descartar imágenes de entrada si es necesario. En otras palabras, no se garantiza que haya una salida para cada imagen de entrada». (Fuente)

Veamos la aplicación de Selfie Segmentation model sobre un videostreaming:

Y por último, el progrma completo para aplicar el Selfie Segmentation sobre un video streaming:

import cv2
import mediapipe as mp
from mediapipe.tasks.python import vision
from mediapipe.tasks.python import BaseOptions
import time

segmentation_result_list = []

# Función callback para procesar los resultados
def segmentation_callback(result, output_image, timestamp_ms):
     segmentation_result_list.append(result)

# Especificar la configuración del ImageSegmenter
options = vision.ImageSegmenterOptions(
     base_options=BaseOptions(model_asset_path="./path/selfie_segmenter_landscape.tflite"),
     output_category_mask=True,
     running_mode=vision.RunningMode.LIVE_STREAM, 
     result_callback=segmentation_callback)
segmenter = vision.ImageSegmenter.create_from_options(options)

# Leer el video de entrada
cap = cv2.VideoCapture(0)

while True:
     ret, frame = cap.read()
     if ret == False:
          break

     frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
     frame_rgb = mp.Image(image_format=mp.ImageFormat.SRGB, data=frame_rgb)

     # Obtener los resultados del segmentador
     segmenter.segment_async(frame_rgb, time.time_ns() // 1_000_000)

     if len(segmentation_result_list) > 0:
          print(f"segmentation_result_list: {segmentation_result_list}")
          segmentation_result = segmentation_result_list[0]
          category_mask = segmentation_result.category_mask
          confidence_mask = segmentation_result.confidence_masks[0]

          # Convertir la máscara en una vista de numpy
          category_mask_np = category_mask.numpy_view()
          confidence_mask_np = confidence_mask.numpy_view()

          # Imágenes a partir de máscaras
          bg = cv2.bitwise_and(frame, frame, mask=category_mask_np)
          inv_mask = cv2.bitwise_not(category_mask_np)
          fg = cv2.bitwise_and(frame, frame, mask=inv_mask)

          # Visualización de las imágenes
          #cv2.imshow("category_mask_np", category_mask_np)
          #cv2.imshow("confidence_mask_np", confidence_mask_np)
          cv2.imshow("Fondo", bg)
          cv2.imshow("Primer plano", fg)
     segmentation_result_list.clear()
     cv2.imshow("Frame", frame)

     if cv2.waitKey(1) & 0xFF == 27:
          break
cap.release()
cv2.destroyAllWindows()

Y bien, hemos llegado al final de este turorial. ¡Espero que les haya gustado!. Nos vemos en un siguiente post. ????

Referencias

Publicado enBlog MediaPipe

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *