Mapeamento de objectos VisionEye View utilizando Ultralytics YOLO11 🚀
O que é o mapeamento de objectos VisionEye?
Ultralytics YOLO11 O VisionEye oferece a capacidade de os computadores identificarem e localizarem objectos, simulando a precisão de observação do olho humano. Esta funcionalidade permite aos computadores discernir e focar objectos específicos, de forma muito semelhante à forma como o olho humano observa os detalhes de um determinado ponto de vista.
Amostras
| VisionEye View | VisionEye View com seguimento de objectos | VisionEye View com cálculo da distância |
|---|---|---|
 |
 |
 |
| VisionEye Ver mapeamento de objectos utilizando Ultralytics YOLO11 | VisionEye View Mapeamento de objectos com seguimento de objectos utilizando Ultralytics YOLO11 | VisionEye View com cálculo de distância utilizando Ultralytics YOLO11 |
Mapeamento de objectos VisionEye utilizando YOLO11
import cv2
from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors
model = YOLO("yolo11n.pt")
names = model.model.names
cap = cv2.VideoCapture("path/to/video/file.mp4")
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("visioneye-pinpoint.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))
center_point = (-10, h)
while True:
ret, im0 = cap.read()
if not ret:
print("Video frame is empty or video processing has been successfully completed.")
break
results = model.predict(im0)
boxes = results[0].boxes.xyxy.cpu()
clss = results[0].boxes.cls.cpu().tolist()
annotator = Annotator(im0, line_width=2)
for box, cls in zip(boxes, clss):
annotator.box_label(box, label=names[int(cls)], color=colors(int(cls)))
annotator.visioneye(box, center_point)
out.write(im0)
cv2.imshow("visioneye-pinpoint", im0)
if cv2.waitKey(1) & 0xFF == ord("q"):
break
out.release()
cap.release()
cv2.destroyAllWindows()
import cv2
from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors
model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
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("visioneye-pinpoint.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))
center_point = (-10, h)
while True:
ret, im0 = cap.read()
if not ret:
print("Video frame is empty or video processing has been successfully completed.")
break
annotator = Annotator(im0, line_width=2)
results = model.track(im0, persist=True)
boxes = results[0].boxes.xyxy.cpu()
if results[0].boxes.id is not None:
track_ids = results[0].boxes.id.int().cpu().tolist()
for box, track_id in zip(boxes, track_ids):
annotator.box_label(box, label=str(track_id), color=colors(int(track_id)))
annotator.visioneye(box, center_point)
out.write(im0)
cv2.imshow("visioneye-pinpoint", im0)
if cv2.waitKey(1) & 0xFF == ord("q"):
break
out.release()
cap.release()
cv2.destroyAllWindows()
import math
import cv2
from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator
model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("Path/to/video/file.mp4")
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("visioneye-distance-calculation.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))
center_point = (0, h)
pixel_per_meter = 10
txt_color, txt_background, bbox_clr = ((0, 0, 0), (255, 255, 255), (255, 0, 255))
while True:
ret, im0 = cap.read()
if not ret:
print("Video frame is empty or video processing has been successfully completed.")
break
annotator = Annotator(im0, line_width=2)
results = model.track(im0, persist=True)
boxes = results[0].boxes.xyxy.cpu()
if results[0].boxes.id is not None:
track_ids = results[0].boxes.id.int().cpu().tolist()
for box, track_id in zip(boxes, track_ids):
annotator.box_label(box, label=str(track_id), color=bbox_clr)
annotator.visioneye(box, center_point)
x1, y1 = int((box[0] + box[2]) // 2), int((box[1] + box[3]) // 2) # Bounding box centroid
distance = (math.sqrt((x1 - center_point[0]) ** 2 + (y1 - center_point[1]) ** 2)) / pixel_per_meter
text_size, _ = cv2.getTextSize(f"Distance: {distance:.2f} m", cv2.FONT_HERSHEY_SIMPLEX, 1.2, 3)
cv2.rectangle(im0, (x1, y1 - text_size[1] - 10), (x1 + text_size[0] + 10, y1), txt_background, -1)
cv2.putText(im0, f"Distance: {distance:.2f} m", (x1, y1 - 5), cv2.FONT_HERSHEY_SIMPLEX, 1.2, txt_color, 3)
out.write(im0)
cv2.imshow("visioneye-distance-calculation", im0)
if cv2.waitKey(1) & 0xFF == ord("q"):
break
out.release()
cap.release()
cv2.destroyAllWindows()
visioneye Argumentos
| Nome | Tipo | Predefinição | Descrição |
|---|---|---|---|
color |
tuple |
(235, 219, 11) |
Cor do centróide da linha e do objeto |
pin_color |
tuple |
(255, 0, 255) |
VisionEye cor exacta |
Nota
Para quaisquer questões, não hesite em colocar as suas perguntas na secção de questõesUltralytics ou na secção de discussão mencionada abaixo.
FAQ
Como é que começo a utilizar o mapeamento de objectos do VisionEye com Ultralytics YOLO11 ?
Para começar a usar o mapeamento de objetos do VisionEye com Ultralytics YOLO11 , primeiro, é necessário instalar o pacote Ultralytics YOLO via pip. Em seguida, pode utilizar o código de exemplo fornecido na documentação para configurar a deteção de objectos com o VisionEye. Aqui está um exemplo simples para começar:
import cv2
from ultralytics import YOLO
model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
while True:
ret, frame = cap.read()
if not ret:
break
results = model.predict(frame)
for result in results:
# Perform custom logic with result
pass
cv2.imshow("visioneye", frame)
if cv2.waitKey(1) & 0xFF == ord("q"):
break
cap.release()
cv2.destroyAllWindows()
Quais são as principais caraterísticas da capacidade de seguimento de objectos da VisionEye utilizando Ultralytics YOLO11 ?
O rastreio de objectos do VisionEye com Ultralytics YOLO11 permite aos utilizadores seguir o movimento de objectos num quadro de vídeo. As principais caraterísticas incluem:
- Seguimento de objectos em tempo real: Acompanha os objectos à medida que estes se movem.
- Identificação de objectos: Utiliza os poderosos algoritmos de deteção do YOLO11.
- Cálculo de distâncias: Calcula as distâncias entre objectos e pontos especificados.
- Anotação e visualização: Fornece marcadores visuais para objectos seguidos.
Segue-se um breve excerto de código que demonstra o rastreio com o VisionEye:
import cv2
from ultralytics import YOLO
model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
while True:
ret, frame = cap.read()
if not ret:
break
results = model.track(frame, persist=True)
for result in results:
# Annotate and visualize tracking
pass
cv2.imshow("visioneye-tracking", frame)
if cv2.waitKey(1) & 0xFF == ord("q"):
break
cap.release()
cv2.destroyAllWindows()
Para obter um guia completo, visite o VisionEye Object Mapping with Object Tracking.
Como é que posso calcular distâncias com o modelo YOLO11 do VisionEye?
O cálculo da distância com o VisionEye e Ultralytics YOLO11 envolve a determinação da distância dos objectos detectados a partir de um ponto especificado na imagem. Melhora as capacidades de análise espacial, úteis em aplicações como a condução autónoma e a vigilância.
Eis um exemplo simplificado:
import math
import cv2
from ultralytics import YOLO
model = YOLO("yolo11n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
center_point = (0, 480) # Example center point
pixel_per_meter = 10
while True:
ret, frame = cap.read()
if not ret:
break
results = model.track(frame, persist=True)
for result in results:
# Calculate distance logic
distances = [
(math.sqrt((box[0] - center_point[0]) ** 2 + (box[1] - center_point[1]) ** 2)) / pixel_per_meter
for box in results
]
cv2.imshow("visioneye-distance", frame)
if cv2.waitKey(1) & 0xFF == ord("q"):
break
cap.release()
cv2.destroyAllWindows()
Para obter instruções detalhadas, consulte o VisionEye com cálculo de distância.
Por que razão devo utilizar Ultralytics YOLO11 para mapeamento e localização de objectos?
Ultralytics YOLO11 é conhecido pela sua velocidade, precisão e facilidade de integração, tornando-o uma escolha de topo para mapeamento e localização de objectos. As principais vantagens incluem:
- Desempenho topo de gama: Proporciona uma elevada precisão na deteção de objectos em tempo real.
- Flexibilidade: Suporta várias tarefas, como a deteção, o seguimento e o cálculo de distâncias.
- Comunidade e suporte: Documentação extensa e comunidade GitHub ativa para resolução de problemas e melhorias.
- Facilidade de utilização: A API intuitiva simplifica tarefas complexas, permitindo uma rápida implementação e iteração.
Para mais informações sobre aplicações e benefícios, consulte a documentaçãoUltralytics YOLO11 .
Como é que posso integrar o VisionEye com outras ferramentas de aprendizagem automática, como Comet ou ClearML?
Ultralytics YOLO11 pode integrar-se perfeitamente com várias ferramentas de aprendizagem automática, como Comet e ClearML, melhorando o acompanhamento, a colaboração e a reprodutibilidade das experiências. Siga os guias detalhados sobre como utilizar YOLOv5 com Comet e integrar YOLO11 com ClearML para começar.
Para mais explorações e exemplos de integração, consulte o nosso Ultralytics Integrations Guide.
