Como fazer deteção de objetos em vídeo com Azure AI Vision: passo a passo

Este tutorial mostra como fazer deteção de objetos em vídeo usando Azure AI Vision para identificar e anotar objetos em frames de vídeo. É útil para vigilância, análise de tráfico ou controlo de qualidade, quando necessita de automatizar a identificação de objetos em streaming ou ficheiros de vídeo.

Pré-requisitos

• Conta Azure com subscrição e permissão para criar recursos.
• Instância de Azure AI Vision (resource key e endpoint) ou Azure Cognitive Services com Vision habilitado.
• Python 3.8+ instalado e pip.
• Bibliotecas: azure-ai-vision, opencv-python, numpy.
• Ficheiro de vídeo (MP4) ou câmara disponível para teste.

Passo 1: Criar o recurso Azure AI Vision

No portal Azure crie um recurso Azure AI Vision (ou Cognitive Services se preferir). Guarde o endpoint e a chave (resource key) — vão ser necessárias para autenticar as chamadas de inferência.

Passo 2: Instalar dependências e configurar ambiente

Instale as bibliotecas necessárias num ambiente virtual. Aqui usamos a SDK azure-ai-vision, OpenCV e numpy para ler vídeo e desenhar caixas.

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

Passo 3: Código básico para ler vídeo e enviar frames para Azure AI Vision

Dividimos o vídeo em frames (por exemplo, 1 frame por segundo) e chamamos a API de deteção de objetos. Este exemplo assume que usa o endpoint do serviço de Vision com a operação detectObjects.

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

# Configurar credenciais
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()

Passo 4: Ajustar frequência, resolução e filtragem de classes

Para otimizar custo e latência, envie menos frames, redimensione para uma resolução mais baixa e filtre por classes de interesse (por exemplo, "car" ou "person"). Pode também usar um limiar na confiança para reduzir 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

Passo 5: Guardar resultados e gerar relatórios

Guarde as anotações em CSV ou JSON com o tempo do frame, classe e confiança para análise posterior ou integração com alertas. Isto permite criar dashboards em Power BI ou pipelines 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 o resultado

Execute o script e verifique se as caixas aparecem nos objetos esperados, se a taxa de falsos positivos é aceitável e se o ficheiro CSV tem registos coerentes. Teste com vídeos de validação e altere min_conf, resolução e intervalos de frames para aferir desempenho e custo.

Conclusão

Com Azure AI Vision e um cliente Python simples é possível criar uma pipeline de deteção de objetos em vídeo para vigilância, análise de tráfico ou controlo de qualidade. Próximos passos: integrar streaming em tempo real (Azure Media Services), usar modelos Custom Vision para classes específicas, ou disponibilizar resultados via Azure Functions. Dica: registe métricas (latência, taxa de deteção) desde cedo para otimizar custo e precisão.