🖼️ ¡Identifica la forma de objetos! | Aplica Instance Segmentation con Ultralytics

¡Hola, hola, Omesitos! En los anteriores tutoriales vimos como usar la detección de objetos. En primer lugar vimos como detectar objetos con los modelos YOLO11 que nos permite usar Ultralytics, que fueron entrenados con el COCO Dataset, pero también vimos como usar dichos modelos para entrenar uno nuevo que pueda detectar cualquier objeto que queramos. Pero, ¿qué te parece si ahora identificamos la forma exacta de los objetos?. En este post veremos como hacerlo. Así que, ¡vamos a por ello!

¿Qué es la segmentación de instancias?

Es una técnica que permite identificar y delinear objetos en una imagen, asignándoles una etiqueta y una forma precisa. A diferencia de la detección clásica, no solo sabrás dónde está el objeto, sino también cómo se ve su contorno real.

🔧 Instalación de Ultralytics

Para llevar a cabo esta práctica debemos instalar Ultralytics, a través de:

pip install ultralytics

Puedes verificar su instalación y versión con: pip freeze

Nota: A continuación te dejo la programación usada en el video. Si quieres ver el paso a paso explicado con más detalle, ¡no te pierdas el video completo!

🖼️ Segmentación de instancias sobre imágenes con YOLOv11 de Ultralytics

from ultralytics import YOLO

# Cargamos el modelo YOLO
model = YOLO("yolo11s-seg.pt")

# Cargamos la imagen
image = "./Inputs/image.jpg"
#images = "C:/path/Gaby/*.jpg"

# Realizamos la inferencia de YOLO
results = model(image)
print(results)

# Visualizar los resultados
#results[0].show()
for res in results:
    res.show()

🖼️ Segmentación de instancias sobre imágenes leídas con OpenCV con YOLOv11 de Ultralytics

Trabajando con las máscaras de segmentación:

from ultralytics import YOLO
import cv2
import numpy as np

# Cargamos la imagen de entrada
image = cv2.imread("./Inputs/000_image.jpg")

# Cargamos el modelo YOLO
model = YOLO("yolo11s-seg.pt")

# Realizamos la inferencia sobre la imagen
results = model(image, conf=0.25)
#results[0].show()
#print(results)
for r in results:
    #print(r.boxes)
    print(r.masks)

    # Visualizar cada una de las máscaras
    for i, mask in enumerate(r.masks.data):
        # Transformar el tensor en un array de numpy
        mask_np = mask.numpy()
        cv2.imshow(f"Mask {i}", mask_np)

        print(f" --- Mask {i} ---")
        print(f"- Data type: {mask_np.dtype}")
        print(f"- Shape: {mask_np.shape}")
        print(f"- Min: {mask_np.min()}")
        print(f"- Max: {mask_np.max()}")
        print("Valores únicos en la máscara:", np.unique(mask_np))
        #print(f"Imagen de entrada: {image.shape}")

        # Convertir la máscara a uint8 y escala 0-255
        binary_mask = (mask_np * 255).astype("uint8")

        # Redimensionar la máscara al tamaño de la imagen de entrada
        binary_mask_resized = cv2.resize(binary_mask, (image.shape[1], image.shape[0]))

        # Aplicar máscara
        segmented_object = cv2.bitwise_and(image, image, mask=binary_mask_resized)
        cv2.imshow(f"Objeto sin fondo {i}", segmented_object)

cv2.imshow("Image", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

Trabajando con los contornos de los objetos:

from ultralytics import YOLO
import cv2
import numpy as np

# Cargamos la imagen de entrada
image = cv2.imread("./Inputs/000_image.jpg")

# Cargamos el modelo YOLO
model = YOLO("yolo11s-seg.pt")

# Realizamos la inferencia sobre la imagen
results = model(image, conf=0.25)
#results[0].show()
#print(results)
for r in results:
    #print(r.boxes)
    print(r.masks)
    
    # Dibujar contornos en la imagen de entrada
    for contour in r.masks.xy:
        contour_int = contour.astype("int32")

        color = tuple(np.random.randint(0, 256, size=3).tolist())
        cv2.drawContours(image, [contour_int], -1, color, thickness=2)
        cv2.imshow('Image', image)
        cv2.waitKey(0)

cv2.imshow("Image", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

🎞️ Segmentación de instancias sobre videos con YOLOv11 de Ultralytics

from ultralytics import YOLO
import cv2

# Cargamos el modelo YOLO
model = YOLO("yolo11s-seg.pt")

# Cargamos el video de entrada
#video_path = "./Inputs/000_video.mp4"
cap = cv2.VideoCapture(0)

while cap.isOpened():
    # Leemos el frame del video
    ret, frame = cap.read()
    if not ret:
        break

    # Realizamos la inferencia de YOLO sobre el frame
    results = model(frame)

    # Extraemos los resultados
    annotated_frame = results[0].plot()

    # Visualizamos los resultados
    cv2.imshow("YOLO Inference", annotated_frame)

    # El ciclo se rompe al presionar "Esc"
    if cv2.waitKey(1) & 0xFF == 27:
        break

cap.release()
cv2.destroyAllWindows()

Y eso ha sido todo por este post, Omesitos.
Espero que les haya resultado útil y que se animen a probar la segmentación de instancias con los modelos de Ultralytics usando YOLOv11.
📌 No olviden revisar el video si quieren ver todo el paso a paso en acción.

¡Nos vemos en el siguiente post!