Contagem de objectos utilizando Ultralytics YOLO11

O que é a contagem de objectos?

A contagem de objectos com Ultralytics YOLO11 envolve a identificação e contagem precisas de objectos específicos em vídeos e fluxos de câmaras. O YOLO11 destaca-se em aplicações em tempo real, fornecendo uma contagem de objectos eficiente e precisa para vários cenários, como a análise de multidões e a vigilância, graças aos seus algoritmos de ponta e capacidades de aprendizagem profunda.

Ver: Contagem de objectos por classe utilizando Ultralytics YOLOv8

Vantagens da contagem de objectos

• Otimização de recursos: A contagem de objectos facilita a gestão eficiente de recursos ao fornecer contagens precisas, optimizando a atribuição de recursos em aplicações como a gestão de inventário.
• Segurança melhorada: A contagem de objectos melhora a segurança e a vigilância ao localizar e contar entidades com precisão, ajudando na deteção proactiva de ameaças.
• Tomada de decisões informada: A contagem de objectos oferece informações valiosas para a tomada de decisões, optimizando processos no comércio a retalho, na gestão de tráfego e em vários outros domínios.

Aplicações no mundo real

Logística	Aquacultura
Contagem de pacotes de correia transportadora usando Ultralytics YOLO11	Contagem de peixes no mar usando Ultralytics YOLO11

# Run a counting example
yolo solutions count show=True

# Pass a source video
yolo solutions count source="path/to/video.mp4"

# Pass region coordinates
yolo solutions count region="[(20, 400), (1080, 400), (1080, 360), (20, 360)]"

import cv2

from ultralytics import solutions

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

# region_points = [(20, 400), (1080, 400)]                                      # line counting
region_points = [(20, 400), (1080, 400), (1080, 360), (20, 360)]  # rectangle region
# region_points = [(20, 400), (1080, 400), (1080, 360), (20, 360), (20, 400)]   # polygon region

# Video writer
w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
video_writer = cv2.VideoWriter("object_counting_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Initialize object counter object
counter = solutions.ObjectCounter(
    show=True,  # display the output
    region=region_points,  # pass region points
    model="yolo11n.pt",  # model="yolo11n-obb.pt" for object counting with OBB model.
    # classes=[0, 2],  # count specific classes i.e. person and car with COCO pretrained model.
    # tracker="botsort.yaml",  # choose trackers i.e "bytetrack.yaml"
)

# Process video
while cap.isOpened():
    success, im0 = cap.read()

    if not success:
        print("Video frame is empty or processing is complete.")
        break

    results = counter(im0)

    # print(results)  # access the output

    video_writer.write(results.plot_im)  # write the processed frame.

cap.release()
video_writer.release()
cv2.destroyAllWindows()  # destroy all opened windows

ObjectCounter Argumentos

Aqui está uma tabela com os ObjectCounter argumentos:

O ObjectCounter A solução permite a utilização de vários track argumentos:

Além disso, os argumentos de visualização listados abaixo são suportados:

FAQ

Como contar objectos num vídeo utilizando Ultralytics YOLO11 ?

Para contar objectos num vídeo utilizando Ultralytics YOLO11 , pode seguir estes passos:

1. Importar as bibliotecas necessárias (cv2, ultralytics).
2. Definir a região de contagem (por exemplo, um polígono, uma linha, etc.).
3. Configurar a captura de vídeo e inicializar o contador de objectos.
4. Processar cada fotograma para localizar objectos e contá-los dentro da região definida.

Eis um exemplo simples de contagem numa região:

import cv2

from ultralytics import solutions


def count_objects_in_region(video_path, output_video_path, model_path):
    """Count objects in a specific region within a video."""
    cap = cv2.VideoCapture(video_path)
    assert cap.isOpened(), "Error reading video file"
    w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
    video_writer = cv2.VideoWriter(output_video_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

    region_points = [(20, 400), (1080, 400), (1080, 360), (20, 360)]
    counter = solutions.ObjectCounter(show=True, region=region_points, model=model_path)

    while cap.isOpened():
        success, im0 = cap.read()
        if not success:
            print("Video frame is empty or processing is complete.")
            break
        results = counter(im0)
        video_writer.write(results.plot_im)

    cap.release()
    video_writer.release()
    cv2.destroyAllWindows()


count_objects_in_region("path/to/video.mp4", "output_video.avi", "yolo11n.pt")

Para configurações e opções mais avançadas, consulte a solução RegionCounter para contar objectos em várias regiões simultaneamente.

Quais são as vantagens de utilizar Ultralytics YOLO11 para a contagem de objectos?

A utilização de Ultralytics YOLO11 para a contagem de objectos oferece várias vantagens:

1. Otimização de recursos: Facilita a gestão eficiente de recursos ao fornecer contagens precisas, ajudando a otimizar a atribuição de recursos em indústrias como a gestão de inventário.
2. Segurança melhorada: Melhora a segurança e a vigilância através do rastreio e contagem precisos de entidades, ajudando na deteção proactiva de ameaças e nos sistemas de segurança.
3. Tomada de decisões informada: Oferece informações valiosas para a tomada de decisões, optimizando os processos em domínios como o retalho, a gestão do tráfego e muito mais.
4. Processamento em tempo real: A arquitetura do YOLO11 permite a inferência em tempo real, tornando-o adequado para fluxos de vídeo em direto e aplicações sensíveis ao tempo.

Para exemplos de implementação e aplicações práticas, explore a solução TrackZone para o seguimento de objectos em zonas específicas.

Como é que posso contar classes específicas de objectos utilizando Ultralytics YOLO11 ?

Para contar classes específicas de objectos utilizando Ultralytics YOLO11 , é necessário especificar as classes em que está interessado durante a fase de rastreio. Abaixo está um exemplo de Python :

import cv2

from ultralytics import solutions


def count_specific_classes(video_path, output_video_path, model_path, classes_to_count):
    """Count specific classes of objects in a video."""
    cap = cv2.VideoCapture(video_path)
    assert cap.isOpened(), "Error reading video file"
    w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH, cv2.CAP_PROP_FRAME_HEIGHT, cv2.CAP_PROP_FPS))
    video_writer = cv2.VideoWriter(output_video_path, cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

    line_points = [(20, 400), (1080, 400)]
    counter = solutions.ObjectCounter(show=True, region=line_points, model=model_path, classes=classes_to_count)

    while cap.isOpened():
        success, im0 = cap.read()
        if not success:
            print("Video frame is empty or processing is complete.")
            break
        results = counter(im0)
        video_writer.write(results.plot_im)

    cap.release()
    video_writer.release()
    cv2.destroyAllWindows()


count_specific_classes("path/to/video.mp4", "output_specific_classes.avi", "yolo11n.pt", [0, 2])

Neste exemplo, classes_to_count=[0, 2] significa que conta os objectos da classe 0 e 2 (por exemplo, pessoa e carro no conjunto de dados COCO). Pode encontrar mais informações sobre índices de classe na secção Documentação do conjunto de dados COCO.

Por que razão devo utilizar YOLO11 em vez de outros modelos de deteção de objectos para aplicações em tempo real?

Ultralytics YOLO11 oferece várias vantagens em relação a outros modelos de deteção de objectos como o Faster R-CNN, SSD e versões anteriores YOLO :

1. Velocidade e eficiência: YOLO11 oferece capacidades de processamento em tempo real, tornando-o ideal para aplicações que requerem inferência a alta velocidade, como a vigilância e a condução autónoma.
2. Precisão: Proporciona uma precisão de ponta para tarefas de deteção e seguimento de objectos, reduzindo o número de falsos positivos e melhorando a fiabilidade geral do sistema.
3. Facilidade de integração: YOLO11 oferece uma integração perfeita com várias plataformas e dispositivos, incluindo dispositivos móveis e de ponta, o que é crucial para as aplicações modernas de IA.
4. Flexibilidade: Suporta várias tarefas como a deteção, segmentação e seguimento de objectos com modelos configuráveis para satisfazer requisitos específicos de casos de utilização.

Consulte Ultralytics YOLO11 Documentation para obter uma análise mais aprofundada das suas funcionalidades e comparações de desempenho.

Posso utilizar o YOLO11 para aplicações avançadas como a análise de multidões e a gestão do tráfego?

Sim, o Ultralytics YOLO11 é perfeitamente adequado para aplicações avançadas, como a análise de multidões e a gestão de tráfego, devido às suas capacidades de deteção em tempo real, escalabilidade e flexibilidade de integração. As suas funcionalidades avançadas permitem o seguimento, contagem e classificação de objectos com elevada precisão em ambientes dinâmicos. Exemplos de casos de utilização incluem:

• Análise de multidões: Monitorizar e gerir grandes ajuntamentos, garantindo a segurança e optimizando o fluxo de multidões com contagens baseadas na região.
• Gestão de tráfego: Seguir e contar veículos, analisar padrões de tráfego e gerir o congestionamento em tempo real com capacidades de estimativa de velocidade.
• Análise de retalho: Analisar os padrões de movimento dos clientes e as interações com os produtos para otimizar a disposição das lojas e melhorar a experiência do cliente.
• Automação industrial: Contar produtos em correias transportadoras e monitorizar linhas de produção para controlo de qualidade e melhorias de eficiência.

Para aplicações mais especializadas, explore as SoluçõesUltralytics para um conjunto abrangente de ferramentas concebidas para desafios reais de visão computacional.

📅C riado há 1 ano ✏️ Atualizado há 6 dias

Comentários