Visualización de bounding boxes en el dataset de object detection

Clase 11 de 31 • Curso de Detección y Segmentación de Objetos con TensorFlow

Contenido del curso

Introducción a Computer Vision

1
¿Qué es la visión computarizada y cuáles son sus tipos?
08:35 min

Detección de objetos

Segmentación de objetos

Un paso más allá

Tomar examen

Comentarios

Marlon Menendez

student•

Aqui una alternativa para mostrar todos los bounding boxes:

Primero definamos un diccionario con todas las classes:

CLASS_LABELS = {
    1: "Cars",
    2: "Truck",
    3: "Pedestrian",
    4: "Bicyclist",
    5: "Light"
}

Luego modificamos los gt_boxes para incluir los labels de las classes:

y_val, x_val, _ = np.array(img).shape
gt_boxes = {}
for idx, row in df_train.iterrows():
    bbox = np.array(
        [
            [
                row["ymin"] / y_val,
                row["xmin"] / x_val,
                row["ymax"] / y_val,
                row["xmax"] / x_val,
            ]
        ],
        dtype=np.float32,
    )
    frame = row["frame"]
    label = row["class_id"]
    if frame in gt_boxes:
        gt_boxes[frame] = {
            "boxes": np.append(gt_boxes[frame]["boxes"], np.array(bbox), axis=0),
            "id": np.append(gt_boxes[frame]["id"], np.array([label]), axis=0)
        }
    else:
        gt_boxes[frame] = {"boxes": np.array(bbox), "id": np.array([label])}

Tambien debemos modificar el diccionario category_index:

category_index = {i: {"id": i, "name": k} for i, k in CLASS_LABELS.items()}

Por ultimo, modificamos el código que nos permite visualizar las imagenes con los boxes:

num_examples = 20
idx = 0

plt.figure(figsize=(30, 30))
for key, value in islice(gt_boxes.items(), num_examples):
    boxes = value["boxes"]
    labels = value["id"]
    im = np.array(Image.open(my_path + key))
    dummy_scores = np.ones(shape=[boxes.shape[0]], dtype=np.float32)
    plt.subplot(4, 5, idx + 1)
    plot_detections(
        im,
        boxes,
        labels,
        dummy_scores,
        category_index
    )
    idx += 1

plt.show()

Marlon Menendez

student•

la funcion islice() es de la libreria itertools, por lo que deben hacer un import addicional:

from itertools import islice

Mario Alexander Vargas Celis

student•

Para visualizar las *bounding boxes* en un dataset de detección de objetos, necesitas cargar las imágenes junto con sus anotaciones y superponer las cajas sobre las imágenes. Aquí tienes un ejemplo general de cómo hacerlo en Python usando matplotlib y PIL:

### Paso a paso para la visualización

1. **Cargar las imágenes y las anotaciones**: Dependiendo del dataset, las anotaciones pueden estar en diferentes formatos (JSON para COCO, XML para PASCAL VOC, etc.).

2. **Dibujar las *bounding boxes* en las imágenes**: Usar matplotlib.patches.Rectangle para superponer las cajas en las imágenes.

### Ejemplo de código para visualizar *bounding boxes*

Este ejemplo asume que tienes un archivo JSON con anotaciones (como en el formato COCO) y que las imágenes están en una carpeta.


import json

import matplotlib.pyplot as plt

import matplotlib.patches as patches

from PIL import Image



\# Ruta del archivo de anotaciones y de las imágenes

annotations\_path = 'path/to/annotations.json'

images\_path = 'path/to/images/'



\# Cargar archivo de anotaciones

with open(annotations\_path, 'r') as f:

&#x20;   annotations = json.load(f)



\# Diccionario para mapear IDs de imágenes a rutas

image\_id\_to\_path = {img\['id']: img\['file\_name'] for img in annotations\['images']}



\# Visualizar una imagen con sus anotaciones de \*bounding boxes\*

image\_id = annotations\['annotations']\[0]\['image\_id']  # ID de ejemplo

image\_file = image\_id\_to\_path\[image\_id]

image\_path = images\_path + image\_file



\# Cargar la imagen

image = Image.open(image\_path)



\# Dibujar la imagen y las cajas

fig, ax = plt.subplots(figsize=(12, 12))

ax.imshow(image)



\# Agregar las \*bounding boxes\*

for ann in annotations\['annotations']:

&#x20;   if ann\['image\_id'] == image\_id:

&#x20;       bbox = ann\['bbox']  # Formato \[x\_min, y\_min, ancho, alto]

&#x20;       rect = patches.Rectangle(

&#x20;           (bbox\[0], bbox\[1]), bbox\[2], bbox\[3], linewidth=2, edgecolor='r', facecolor='none'

&#x20;       )

&#x20;       ax.add\_patch(rect)



plt.show()

### Explicación de las anotaciones

- **COCO**: Las cajas están en el formato \[x\_min, y\_min, width, height].

- **PASCAL VOC**: Generalmente usan \[x\_min, y\_min, x\_max, y\_max], por lo que deberías adaptar el código para calcular el ancho y alto si es necesario.

### Personalización

- **Colores**: Puedes cambiar el color de las cajas con edgecolor.

- **Etiquetas**: Puedes agregar texto a las cajas para mostrar la clase de cada objeto usando ax.text.

### Visualización mejorada

Si trabajas con imágenes grandes o muchas cajas, considera agregar una leyenda o ajustar la transparencia (alpha) de las cajas para facilitar la visualización.

Este método es útil para verificar visualmente si las anotaciones están correctamente alineadas con los objetos en las imágenes antes de entrenar un modelo de detección de objetos.

Karla Margarita Muñoz Rico

student•

me arroja un error al correr el código: 'ImageFont' object has no attribute 'getbbox', no me permite visualizar la imagen

Sergio Paniego

teacher•

Hola!

Es posible que el error venga de alguna librería que está en una versión más actual de la usada en el notebook. Te recomendo revisar las versiones de las librerías utilizadas, encontrar la que está devolviendo el error y probar con otra versión de la misma.

Ánimo!

Nicolas Cordoba

student•

Usando viz_utils se pasan las imagenes de manera normal pero los bbx normalizados? no me quedó claro eso, es la forma en la que entra?

Brandon F Vargas Garcia

student•

Sin usar viz_utils, la funcion quedaría mas o menos así:```python import matplotlib.patches as patches def plot_detection(imagen_np, bboxes, classes, scores, category_index, min_score_thresh=0.5): img_height, img_width, _ = imagen_np.shape image_np_with_annotations = imagen_np.copy()

fig, ax = plt.subplots()
ax.imshow(image_np_with_annotations)

for i in range(len(bboxes)):
    if scores[i] > min_score_thresh:
        ymin, xmin, ymax, xmax = bboxes[i]
        # Convertir coordenadas normalizadas a píxeles
        (left, right, top, bottom) = (xmin * img_width, xmax * img_width,
                                      ymin * img_height, ymax * img_height)
        width = right - left
        height = bottom - top
        class_id = int(classes[i])
        class_name = category_index.get(class_id, {'name': 'N/A'})['name']
        score = scores[i]
        
        # Visualizar
        rect = patches.Rectangle(
        (left, top), width, height,
        linewidth=2, edgecolor='g', facecolor='none'
        )
        ax.add_patch(rect)
        ax.text(
        left, top - 5, class_name + str(score),
        color='white', fontsize=5, weight='bold',
        bbox=dict(facecolor='green', alpha=0.5)
        )
plt.axis('off')
plt.show()

que se viene usando dentro del bucle for como:js for idx in range(0,25): bboxes = list(gt_boxes.values())[idx] dummy_score = np.ones(shape=[bboxes.shape[0]], dtype=np.float32) plot_detection( train_images_np[idx], bboxes, np.ones(shape=[bboxes.shape[0]], dtype=np.int32), dummy_score, category_index )

Brandon F Vargas Garcia

student•

Me equivoqué editando:

def plot_detection(imagen_np, bboxes, classes, scores, category_index, min_score_thresh=0.5):
    img_height, img_width, _ = imagen_np.shape
    image_np_with_annotations = imagen_np.copy()

    fig, ax = plt.subplots()
    ax.imshow(image_np_with_annotations)
    
    for i in range(len(bboxes)):
        if scores[i] > min_score_thresh:
            ymin, xmin, ymax, xmax = bboxes[i]
            # Convertir coordenadas normalizadas a píxeles
            (left, right, top, bottom) = (xmin * img_width, xmax * img_width,
                                          ymin * img_height, ymax * img_height)
            width = right - left
            height = bottom - top
            class_id = int(classes[i])
            class_name = category_index.get(class_id, {'name': 'N/A'})['name']
            score = scores[i]
            
            # Visualizar
            rect = patches.Rectangle(
            (left, top), width, height,
            linewidth=2, edgecolor='g', facecolor='none'
            )
            ax.add_patch(rect)
            ax.text(
            left, top - 5, class_name + str(score),
            color='white', fontsize=5, weight='bold',
            bbox=dict(facecolor='green', alpha=0.5)
            )
    plt.axis('off')
    plt.show()


for idx in range(0,25):
    bboxes = list(gt_boxes.values())[idx]
    dummy_score = np.ones(shape=[bboxes.shape[0]], dtype=np.float32)
    #plt.subplot(5, 4, idx+1)
    plot_detection(
        train_images_np[idx],
        bboxes,
        np.ones(shape=[bboxes.shape[0]], dtype=np.int32),
        dummy_score,
        category_index
    )

Mauricio Hurtado

student•

Me arroja el error " 'float' object is not iterable" al usar la función plot_detections y no me permite visualizar.

MICHAEL LEONARDO AGUAS MURILLO

student•

Hola, aquí una alternativa.def plot_detections(image_np, boxes, classes, scores, category_index): image_np_with_annotations = image_np.copy() # Convert boxes to a NumPy array boxes_np = np.array(boxes) viz_utils.visualize_boxes_and_labels_on_image_array( image_np_with_annotations, boxes_np, # Pass the NumPy array of boxes classes, scores, category_index, use_normalized_coordinates = True, min_score_thresh= 0.5 ) plt.imshow(image_np_with_annotations) plt.figure(figsize = (30, 30))for idx in range (20): bboxes = list(gt_boxes.values())[idx] # Reshape bboxes to a 2D array where each row is a bounding box bboxes = bboxes.reshape(-1, 4) dummy_score = np.ones(shape = [bboxes.shape[0]], dtype = np.float32) plt.subplot(5, 4, idx+1) plot_detections(train_images_np[idx], bboxes, np.ones(shape = [bboxes.shape[0]], dtype = np.int32 ), dummy_score, category_index)plt.show()

bboxes debe ser de tipo numpy array.

def plot_detections(image_np, boxes, classes, scores, category_index):
  image_np_with_annotations = image_np.copy()
  # Convert boxes to a NumPy array
  boxes_np = np.array(boxes)  
  viz_utils.visualize_boxes_and_labels_on_image_array(
      image_np_with_annotations,
      boxes_np,  # Pass the NumPy array of boxes
      classes,
      scores,
      category_index,
      use_normalized_coordinates = True,
      min_score_thresh= 0.5
  )
  plt.imshow(image_np_with_annotations)

plt.figure(figsize = (30, 30))
for idx in range (20):
  bboxes = list(gt_boxes.values())[idx]
  # Reshape bboxes to a 2D array where each row is a bounding box
  bboxes = bboxes.reshape(-1, 4)  
  dummy_score = np.ones(shape = [bboxes.shape[0]], dtype = np.float32)
  plt.subplot(5, 4, idx+1)
  plot_detections(train_images_np[idx], bboxes, np.ones(shape = [bboxes.shape[0]], dtype = np.int32 ), dummy_score, category_index)
plt.show()

MICHAEL LEONARDO AGUAS MURILLO

student•

Hola hola. Te muestro una alternativa.def plot_detections(image_np, boxes, classes, scores, category_index): image_np_with_annotations = image_np.copy() # Convert boxes to a NumPy array boxes_np = np.array(boxes) viz_utils.visualize_boxes_and_labels_on_image_array( image_np_with_annotations, boxes_np, # Pass the NumPy array of boxes classes, scores, category_index, use_normalized_coordinates = True, min_score_thresh= 0.5 ) plt.imshow(image_np_with_annotations) plt.figure(figsize = (30, 30))for idx in range (20): bboxes = list(gt_boxes.values())[idx] # Reshape bboxes to a 2D array where each row is a bounding box bboxes = bboxes.reshape(-1, 4) dummy_score = np.ones(shape = [bboxes.shape[0]], dtype = np.float32) plt.subplot(5, 4, idx+1) plot_detections(train_images_np[idx], bboxes, np.ones(shape = [bboxes.shape[0]], dtype = np.int32 ), dummy_score, category_index)plt.show()

bbboxes se converte a numpy array.

def plot_detections(image_np, boxes, classes, scores, category_index):
  image_np_with_annotations = image_np.copy()
  # Convert boxes to a NumPy array
  boxes_np = np.array(boxes)  
  viz_utils.visualize_boxes_and_labels_on_image_array(
      image_np_with_annotations,
      boxes_np,  # Pass the NumPy array of boxes
      classes,
      scores,
      category_index,
      use_normalized_coordinates = True,
      min_score_thresh= 0.5
  )
  plt.imshow(image_np_with_annotations)

plt.figure(figsize = (30, 30))
for idx in range (20):
  bboxes = list(gt_boxes.values())[idx]
  # Reshape bboxes to a 2D array where each row is a bounding box
  bboxes = bboxes.reshape(-1, 4)  
  dummy_score = np.ones(shape = [bboxes.shape[0]], dtype = np.float32)
  plt.subplot(5, 4, idx+1)
  plot_detections(train_images_np[idx], bboxes, np.ones(shape = [bboxes.shape[0]], dtype = np.int32 ), dummy_score, category_index)
plt.show()

y_val, x_val, _ = np.array(img).shape
gt_boxes = {}
for idx, row in df_train.iterrows():
    bbox = np.array(
        [
            [
                row["ymin"] / y_val,
                row["xmin"] / x_val,
                row["ymax"] / y_val,
                row["xmax"] / x_val,
            ]
        ],
        dtype=np.float32,
    )
    frame = row["frame"]
    label = row["class_id"]
    if frame in gt_boxes:
        gt_boxes[frame] = {
            "boxes": np.append(gt_boxes[frame]["boxes"], np.array(bbox), axis=0),
            "id": np.append(gt_boxes[frame]["id"], np.array([label]), axis=0)
        }
    else:
        gt_boxes[frame] = {"boxes": np.array(bbox), "id": np.array([label])}

num_examples = 20
idx = 0

plt.figure(figsize=(30, 30))
for key, value in islice(gt_boxes.items(), num_examples):
    boxes = value["boxes"]
    labels = value["id"]
    im = np.array(Image.open(my_path + key))
    dummy_scores = np.ones(shape=[boxes.shape[0]], dtype=np.float32)
    plt.subplot(4, 5, idx + 1)
    plot_detections(
        im,
        boxes,
        labels,
        dummy_scores,
        category_index
    )
    idx += 1

plt.show()

import json

import matplotlib.pyplot as plt

import matplotlib.patches as patches

from PIL import Image

\# Ruta del archivo de anotaciones y de las imágenes

annotations\_path = 'path/to/annotations.json'

images\_path = 'path/to/images/'

\# Cargar archivo de anotaciones

with open(annotations\_path, 'r') as f:

&#x20;   annotations = json.load(f)

\# Diccionario para mapear IDs de imágenes a rutas

image\_id\_to\_path = {img\['id']: img\['file\_name'] for img in annotations\['images']}

\# Visualizar una imagen con sus anotaciones de \*bounding boxes\*

image\_id = annotations\['annotations']\[0]\['image\_id']  # ID de ejemplo

image\_file = image\_id\_to\_path\[image\_id]

image\_path = images\_path + image\_file

\# Cargar la imagen

image = Image.open(image\_path)

\# Dibujar la imagen y las cajas

fig, ax = plt.subplots(figsize=(12, 12))

ax.imshow(image)

\# Agregar las \*bounding boxes\*

for ann in annotations\['annotations']:

&#x20;   if ann\['image\_id'] == image\_id:

&#x20;       bbox = ann\['bbox']  # Formato \[x\_min, y\_min, ancho, alto]

&#x20;       rect = patches.Rectangle(

&#x20;           (bbox\[0], bbox\[1]), bbox\[2], bbox\[3], linewidth=2, edgecolor='r', facecolor='none'

&#x20;       )

&#x20;       ax.add\_patch(rect)

plt.show()

fig, ax = plt.subplots()
ax.imshow(image_np_with_annotations)

for i in range(len(bboxes)):
    if scores[i] > min_score_thresh:
        ymin, xmin, ymax, xmax = bboxes[i]
        # Convertir coordenadas normalizadas a píxeles
        (left, right, top, bottom) = (xmin * img_width, xmax * img_width,
                                      ymin * img_height, ymax * img_height)
        width = right - left
        height = bottom - top
        class_id = int(classes[i])
        class_name = category_index.get(class_id, {'name': 'N/A'})['name']
        score = scores[i]
        
        # Visualizar
        rect = patches.Rectangle(
        (left, top), width, height,
        linewidth=2, edgecolor='g', facecolor='none'
        )
        ax.add_patch(rect)
        ax.text(
        left, top - 5, class_name + str(score),
        color='white', fontsize=5, weight='bold',
        bbox=dict(facecolor='green', alpha=0.5)
        )
plt.axis('off')
plt.show()

def plot_detection(imagen_np, bboxes, classes, scores, category_index, min_score_thresh=0.5):
    img_height, img_width, _ = imagen_np.shape
    image_np_with_annotations = imagen_np.copy()

    fig, ax = plt.subplots()
    ax.imshow(image_np_with_annotations)
    
    for i in range(len(bboxes)):
        if scores[i] > min_score_thresh:
            ymin, xmin, ymax, xmax = bboxes[i]
            # Convertir coordenadas normalizadas a píxeles
            (left, right, top, bottom) = (xmin * img_width, xmax * img_width,
                                          ymin * img_height, ymax * img_height)
            width = right - left
            height = bottom - top
            class_id = int(classes[i])
            class_name = category_index.get(class_id, {'name': 'N/A'})['name']
            score = scores[i]
            
            # Visualizar
            rect = patches.Rectangle(
            (left, top), width, height,
            linewidth=2, edgecolor='g', facecolor='none'
            )
            ax.add_patch(rect)
            ax.text(
            left, top - 5, class_name + str(score),
            color='white', fontsize=5, weight='bold',
            bbox=dict(facecolor='green', alpha=0.5)
            )
    plt.axis('off')
    plt.show()


for idx in range(0,25):
    bboxes = list(gt_boxes.values())[idx]
    dummy_score = np.ones(shape=[bboxes.shape[0]], dtype=np.float32)
    #plt.subplot(5, 4, idx+1)
    plot_detection(
        train_images_np[idx],
        bboxes,
        np.ones(shape=[bboxes.shape[0]], dtype=np.int32),
        dummy_score,
        category_index
    )
    
            

def plot_detections(image_np, boxes, classes, scores, category_index):
  image_np_with_annotations = image_np.copy()
  # Convert boxes to a NumPy array
  boxes_np = np.array(boxes)  
  viz_utils.visualize_boxes_and_labels_on_image_array(
      image_np_with_annotations,
      boxes_np,  # Pass the NumPy array of boxes
      classes,
      scores,
      category_index,
      use_normalized_coordinates = True,
      min_score_thresh= 0.5
  )
  plt.imshow(image_np_with_annotations)

plt.figure(figsize = (30, 30))
for idx in range (20):
  bboxes = list(gt_boxes.values())[idx]
  # Reshape bboxes to a 2D array where each row is a bounding box
  bboxes = bboxes.reshape(-1, 4)  
  dummy_score = np.ones(shape = [bboxes.shape[0]], dtype = np.float32)
  plt.subplot(5, 4, idx+1)
  plot_detections(train_images_np[idx], bboxes, np.ones(shape = [bboxes.shape[0]], dtype = np.int32 ), dummy_score, category_index)
plt.show()

def plot_detections(image_np, boxes, classes, scores, category_index):
  image_np_with_annotations = image_np.copy()
  # Convert boxes to a NumPy array
  boxes_np = np.array(boxes)  
  viz_utils.visualize_boxes_and_labels_on_image_array(
      image_np_with_annotations,
      boxes_np,  # Pass the NumPy array of boxes
      classes,
      scores,
      category_index,
      use_normalized_coordinates = True,
      min_score_thresh= 0.5
  )
  plt.imshow(image_np_with_annotations)

plt.figure(figsize = (30, 30))
for idx in range (20):
  bboxes = list(gt_boxes.values())[idx]
  # Reshape bboxes to a 2D array where each row is a bounding box
  bboxes = bboxes.reshape(-1, 4)  
  dummy_score = np.ones(shape = [bboxes.shape[0]], dtype = np.float32)
  plt.subplot(5, 4, idx+1)
  plot_detections(train_images_np[idx], bboxes, np.ones(shape = [bboxes.shape[0]], dtype = np.int32 ), dummy_score, category_index)
plt.show()

Visualización de bounding boxes en el dataset de object detection

Introducción a Computer Vision

¿Qué es la visión computarizada y cuáles son sus tipos?

Detección de objetos

Introducción a object detection: sliding window y bounding box

Generando video de sliding window

Introducción a object detection: backbone, non-max suppression y métricas

Visualización de IoU en object detection

Tipos de arquitecturas en detección de objetos

Arquitecturas relevantes en object detection

Utilizando un dataset de object detection

Carga de dataset de object detection

Exploración del dataset de object detection