Cómo hacer detección de objetos en vídeo con Azure AI Vision: paso a paso

Este tutorial muestra cómo hacer detección de objetos en vídeo usando Azure AI Vision para identificar y anotar objetos en fotogramas de vídeo. Es útil para vigilancia, análisis de tráfico o control de calidad, cuando necesita automatizar la identificación de objetos en streaming o archivos de vídeo.

Requisitos previos

• Cuenta Azure con suscripción y permiso para crear recursos.
• Instancia de Azure AI Vision (resource key y endpoint) o Azure Cognitive Services con Vision habilitado.
• Python 3.8+ instalado y pip.
• Bibliotecas: azure-ai-vision, opencv-python, numpy.
• Archivo de vídeo (MP4) o cámara disponible para prueba.

Paso 1: Crear el recurso Azure AI Vision

En el portal Azure cree un recurso Azure AI Vision (o Cognitive Services si lo prefiere). Guarde el endpoint y la clave (resource key): serán necesarios para autenticar las llamadas de inferencia.

Paso 2: Instalar dependencias y configurar entorno

Instale las bibliotecas necesarias en un entorno virtual. Aquí usamos el SDK azure-ai-vision, OpenCV y numpy para leer vídeo y dibujar cajas.

python -m venv venv
source venv/bin/activate   # ou venv\Scripts\activate no Windows
pip install azure-ai-vision opencv-python numpy

Paso 3: Código básico para leer vídeo y enviar fotogramas a Azure AI Vision

Dividimos el vídeo en fotogramas (por ejemplo, 1 fotograma por segundo) y llamamos a la API de detección de objetos. Este ejemplo asume que usa el endpoint del servicio de Vision con la operación detectObjects.

import cv2
import numpy as np
from azure.ai.vision import VisionClient, VisionServiceOptions
from azure.core.credentials import AzureKeyCredential

# Configurar credenciales
endpoint = "https://SEU_ENDPOINT"
key = "SUA_CHAVE"
client = VisionClient(endpoint=endpoint, credential=AzureKeyCredential(key))

# Abrir vídeo
cap = cv2.VideoCapture('exemplo.mp4')
fps = cap.get(cv2.CAP_PROP_FPS)
frame_interval = int(fps)  # 1 frame por segundo
frame_idx = 0

while True:
    ret, frame = cap.read()
    if not ret:
        break
    if frame_idx % frame_interval == 0:
        # Converter frame para JPEG em memória
        ret2, buf = cv2.imencode('.jpg', frame)
        jpg_bytes = buf.tobytes()

        # Chamada de deteção de objetos (exemplo conceptual)
        response = client.detect_objects(image=jpg_bytes)
        # A resposta terá uma lista de boxes: cada box tem left, top, width, height e tagName/confidence
        for obj in response.objects:
            x = int(obj.bounding_box.x)
            y = int(obj.bounding_box.y)
            w = int(obj.bounding_box.w)
            h = int(obj.bounding_box.h)
            label = f"{obj.tag_name}: {obj.confidence:.2f}"
            cv2.rectangle(frame, (x, y), (x+w, y+h), (0,255,0), 2)
            cv2.putText(frame, label, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,255,0), 1)

        # Mostrar frame anotado
        cv2.imshow('Deteção', frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    frame_idx += 1

cap.release()
cv2.destroyAllWindows()

Paso 4: Ajustar frecuencia, resolución y filtrado de clases

Para optimizar coste y latencia, envíe menos fotogramas, redimensione a una resolución más baja y filtre por clases de interés (por ejemplo, "car" o "person"). También puede usar un umbral en la confianza para reducir falsos positivos.

# Exemplo de filtragem e resize antes da chamada
target_w = 640
h, w = frame.shape[:2]
scale = target_w / w
frame_small = cv2.resize(frame, (target_w, int(h*scale)))
# converter e enviar frame_small em vez do original

# Ao processar resposta:
min_conf = 0.6
for obj in response.objects:
    if obj.confidence < min_conf:
        continue
    if obj.tag_name not in ('person','car'):
        continue
    # desenhar box como antes

Paso 5: Guardar resultados y generar informes

Guarde las anotaciones en CSV o JSON con el tiempo del fotograma, clase y confianza para análisis posterior o integración con alertas. Esto permite crear paneles en Power BI o canalizaciones ETL.

import csv
with open('detecoes.csv', 'w', newline='') as f:
    writer = csv.writer(f)
    writer.writerow(['frame_time_s','class','confidence','x','y','w','h'])
    # para cada deteção: writer.writerow([time_sec, obj.tag_name, obj.confidence, x, y, w, h])

Verificar el resultado

Ejecute el script y verifique si las cajas aparecen en los objetos esperados, si la tasa de falsos positivos es aceptable y si el archivo CSV tiene registros coherentes. Pruebe con vídeos de validación y cambie min_conf, resolución e intervalos de fotogramas para calibrar rendimiento y coste.

Conclusión

Con Azure AI Vision y un cliente Python simple es posible crear una canalización de detección de objetos en vídeo para vigilancia, análisis de tráfico o control de calidad. Próximos pasos: integrar streaming en tiempo real (Azure Media Services), usar modelos Custom Vision para clases específicas, o exponer resultados vía Azure Functions. Consejo: registre métricas (latencia, tasa de detección) desde el inicio para optimizar coste y precisión.