Melhorar as aplicações de visão computacional com visualizações

Passo 1: Configurar o ambiente

Depois de escolher o seu ambiente preferido, o próximo passo é configurá-lo para executar previsões e visualizar os resultados. Pode utilizar qualquer um dos ambientes mencionados acima, dependendo do que lhe for mais conveniente.

Se estiver a trabalhar no Google Colab, lembre-se de que este utiliza uma CPU por predefinição, o que pode tornar o desempenho mais lento. Para acelerar o processo, mude para uma GPU indo ao menu "Tempo de execução", selecionando "Alterar tipo de tempo de execução" e definindo o acelerador de hardware para GPU (idealmente um T4).

Para preparar o seu ambiente, terá de instalar o pacote Ultralytics Python utilizando o comando mencionado abaixo. Em ferramentas baseadas em notebook, como Colab ou Jupyter, certifique-se de adicionar um ponto de exclamação (!) antes do comando.

pip install ultralytics

Passo 2: Transferir um ficheiro de vídeo

De seguida, precisamos de um vídeo para trabalhar. Pode facilmente descarregar um vídeo de um site de stock gratuito como o Pexels. Certifique-se de que escolhe um vídeo que inclua objectos que o YOLO11 consiga detetar. Como o modelo é pré-treinado no conjunto de dados COCO, ele pode reconhecer objetos comuns, como pessoas, carros e bicicletas. 

Para este tutorial, vamos utilizar um vídeo de manuseamento de bagagens num terminal de aeroporto movimentado. Pode utilizar o mesmo vídeo ou escolher um diferente que se adeqúe ao seu projeto.

‍

Passo 3: Importação de pacotes

Em seguida, podemos importar as bibliotecas necessárias e carregar o vídeo de entrada.

Começaremos por importar o OpenCV (cv2), que é uma biblioteca muito utilizada para trabalhar com imagens e vídeo em visão computacional. Também vamos importar a biblioteca Ultralytics, que nos ajuda a executar a deteção de objectos e a gerar análises a partir do vídeo.

Depois, vamos tentar abrir o ficheiro de vídeo especificando o seu caminho. Certifique-se de que substitui "path/to/video.mp4" pela localização real do ficheiro de vídeo transferido. 

Além disso, o fragmento de código abaixo inclui uma verificação simples para garantir que o vídeo é carregado corretamente. Se o caminho estiver errado ou o ficheiro estiver corrompido, o programa pára e mostra uma mensagem de erro: "Erro ao ler o ficheiro de vídeo".

import cv2

from ultralytics import solutions

cap = cv2.VideoCapture("path/to/video.mp4")
assert cap.isOpened(), "Error reading video file"

Passo 4: Preparar o gravador de vídeo

Em seguida, configuraremos um gravador de vídeo para salvar a saída. Quando executarmos a análise, esta parte do código criará um novo ficheiro de vídeo que regista os gráficos actualizados gerados a partir de cada fotograma do vídeo original.

No trecho de código abaixo, primeiro extraímos as principais propriedades do vídeo de entrada - sua largura, altura e quadros por segundo (fps). Estes valores são retirados diretamente do vídeo e convertidos em números inteiros para garantir que estão no formato correto para escrever a saída.

Em seguida, utilizamos a função cv2.VideoWriter para criar um novo ficheiro de vídeo, com o nome "analytics_output.avi" (pode mudar-lhe o nome conforme necessário). O vídeo é guardado utilizando o formato MJPG, que é um método de compressão de vídeo comum. A resolução de saída é definida para 1280×720 pixéis, independentemente do tamanho do vídeo original.

w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
out = cv2.VideoWriter(
    "analytics_output.avi",
    cv2.VideoWriter_fourcc(*"MJPG"),
    fps,
    (1280, 720), 
)

Etapa 5: Configurar a solução Ultralytics Analytics

Agora, vamos configurar a solução Ultralytics Analytics para gerar gráficos a partir do vídeo. Pode escolher a forma como os dados são apresentados, como um gráfico de linhas, tartes, áreas ou barras, e qual o modelo YOLO a utilizar. Neste exemplo, utilizaremos o modelo leve "yolo11n.pt" e mostraremos os resultados como um gráfico de área.

analytics = solutions.Analytics(
    show=True, 
    analytics_type="area", 
    model="yolo11n.pt",   
)

Passo 6: Processamento do vídeo de entrada

A parte final do código executa um loop que processa o vídeo um quadro de cada vez. Cada quadro é passado para a ferramenta de análise, que atualiza o gráfico em tempo real. O gráfico atualizado é então gravado no vídeo de saída. Se um quadro não puder ser lido, o loop pára. Depois de todos os fotogramas serem processados, o vídeo é guardado e todas as janelas abertas são fechadas.

frame_count = 0
while cap.isOpened():
    success, im0 = cap.read()
    if success:
        frame_count += 1
        results = analytics(im0, frame_count) 

        out.write(results.plot_im) 
    else:
        break
cap.release()
out.release()
cv2.destroyAllWindows()

Etapa 7: Juntar tudo

Finalmente, vamos juntar tudo. Com apenas algumas linhas de código extra, podemos gerar dois vídeos de saída: um que mostra os resultados da deteção de objectos YOLO11 com caixas delimitadoras e etiquetas, e outro que mostra os gráficos analíticos em tempo real.

Para o fazer, vamos configurar duas instâncias VideoWriter - uma para guardar o vídeo de previsão e outra para a análise. Esta versão do código inclui o rastreio de objectos e a geração de gráficos, para que possa ver os resultados da deteção juntamente com as informações visuais.

Aqui está o código completo, juntamente com exemplos dos resultados da previsão e da análise.

import cv2
from ultralytics import YOLO, solutions

# Load model and video
model = YOLO('yolo11n.pt')
cap = cv2.VideoCapture('path/to/video.mp4')
assert cap.isOpened(), "Error opening video"

# Get properties
w, h = int(cap.get(3)), int(cap.get(4))
fps = cap.get(5)
analytics_res = (1280, 720)

# Writers for prediction and analytics videos
out_pred = cv2.VideoWriter('output_predictions.avi', cv2.VideoWriter_fourcc(*'MJPG'), fps, (w, h))
out_ana = cv2.VideoWriter('output_analytics.avi', cv2.VideoWriter_fourcc(*'MJPG'), fps, analytics_res)

# Analytics setup
analytics = solutions.Analytics(show=True, analytics_type="area", model='yolo11n.pt')

# Process frames
frame_count = 0
while cap.isOpened():
    ret, frame = cap.read()
    if not ret:
        break

    frame_count += 1
    pred_frame = model.track(frame, persist=True)[0].plot()
    out_pred.write(pred_frame)

    resized = cv2.resize(pred_frame, analytics_res)
    out_ana.write(analytics(resized, frame_count).plot_im)

cap.release(), out_pred.release(), out_ana.release(), cv2.destroyAllWindows()

Quando o código acima for executado com êxito, ele gerará dois vídeos de saída. O ficheiro "output_predictions.avi" apresentará os resultados da deteção de objectos com caixas delimitadoras e etiquetas, enquanto o ficheiro "output_analytics.avi" apresentará os gráficos analíticos em tempo real com base nas detecções.

‍

Aqui está um quadro da saída de análise com base nas previsões. Utilizando o gráfico de área, podemos obter informações como flutuações na contagem de malas ao longo do tempo, como um pico em torno do fotograma 268, indicando movimento ou atividade de malas nessa parte do vídeo.

‍