Ultralytics-中文文档-十-Ultralytics 中文文档（十）使用 Ultralytics YOLOv8

Ultralytics 中文文档（十）

使用 Ultralytics YOLOv8 进行对象裁剪

原文：docs.ultralytics.com/guides/object-cropping/

什么是对象裁剪？

使用Ultralytics YOLOv8进行对象裁剪涉及从图像或视频中隔离和提取特定检测到的对象。 YOLOv8 模型的能力被用来准确识别和描绘对象，实现精确裁剪以供进一步分析或操作。

www.youtube.com/embed/ydGdibB5Mds

注意: 使用 Ultralytics YOLOv8 进行对象裁剪

对象裁剪的优势？

重点分析: YOLOv8 支持针对对象的目标裁剪，允许深入检查或处理场景中的个体项目。
减少数据量: 通过仅提取相关对象，对象裁剪有助于最小化数据大小，使其在存储、传输或后续计算任务中更为高效。
增强精度: YOLOv8 的目标检测精度确保裁剪后的对象保持它们的空间关系，保留视觉信息的完整性，以进行详细分析。

视觉

机场行李

使用 Ultralytics YOLOv8 在机场行李传送带上裁剪手提箱

使用 YOLOv8 进行对象裁剪的示例

import os

import cv2

from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors

model = YOLO("yolov8n.pt")
names = model.names

cap = cv2.VideoCapture("path/to/video/file.mp4")
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))

crop_dir_name = "ultralytics_crop"
if not os.path.exists(crop_dir_name):
    os.mkdir(crop_dir_name)

# Video writer
video_writer = cv2.VideoWriter("object_cropping_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

idx = 0
while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    results = model.predict(im0, show=False)
    boxes = results[0].boxes.xyxy.cpu().tolist()
    clss = results[0].boxes.cls.cpu().tolist()
    annotator = Annotator(im0, line_width=2, example=names)

    if boxes is not None:
        for box, cls in zip(boxes, clss):
            idx += 1
            annotator.box_label(box, color=colors(int(cls), True), label=names[int(cls)])

            crop_obj = im0[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])]

            cv2.imwrite(os.path.join(crop_dir_name, str(idx) + ".png"), crop_obj)

    cv2.imshow("ultralytics", im0)
    video_writer.write(im0)

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

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

参数 `model.predict`

参数	类型	默认	描述
`source`	`str`	`'ultralytics/assets'`	指定推断的数据源。可以是图像路径、视频文件、目录、URL 或设备 ID 用于实时数据源。支持多种格式和来源，适用于不同类型的输入。
`conf`	`float`	`0.25`	设置检测的最小置信度阈值。置信度低于此阈值的检测对象将被忽略。调整此值有助于减少误报。
`iou`	`float`	`0.7`	非极大值抑制（NMS）的交并比（IoU）阈值。较低的值通过消除重叠框来减少检测，有助于减少重复检测。
`imgsz`	`int 或 tuple`	`640`	定义推断的图像大小。可以是单个整数 `640` 用于方形调整，或 (height, width) 元组。适当的大小可以提高检测的准确性和处理速度。
`half`	`bool`	`False`	启用半精度（FP16）推断，可在支持的 GPU 上加速模型推断，对准确性影响较小。
`device`	`str`	`None`	指定推断的设备（例如 `cpu`、`cuda:0` 或 `0`）。允许用户选择在 CPU、特定 GPU 或其他计算设备上执行模型。
`max_det`	`int`	`300`	每个图像允许的最大检测数。限制模型单次推理中可以检测到的对象总数，防止在密集场景中产生过多输出。
`vid_stride`	`int`	`1`	视频输入的帧跨度。允许在视频中跳过帧以加快处理速度，但会牺牲时间分辨率。值为 1 表示处理每一帧，更高的值会跳过帧。
`stream_buffer`	`bool`	`False`	确定处理视频流时是否应缓冲所有帧（`True`），还是模型应返回最新的帧（`False`）。对实时应用非常有用。
`visualize`	`bool`	`False`	在推理期间激活模型特征的可视化，提供对模型“看到”内容的洞察。用于调试和模型解释非常有用。
`augment`	`bool`	`False`	启用测试时增强（TTA）以进行预测，可能会提高检测的鲁棒性，但会降低推理速度。
`agnostic_nms`	`bool`	`False`	启用无类别非极大值抑制（NMS），合并不同类别之间重叠的框。在多类检测场景中，当类别重叠时非常有用。
`classes`	`list[int]`	`None`	将预测过滤到一组类别 ID。只返回属于指定类别的检测结果。在多类检测任务中专注于相关对象非常有用。
`retina_masks`	`bool`	`False`	如果模型可用，则使用高分辨率分割掩码。这可以增强分割任务中的掩码质量，提供更细致的细节。
`embed`	`list[int]`	`None`	指定要从中提取特征向量或嵌入的层。对于后续的聚类或相似性搜索等任务非常有用。

常见问题

Ultralytics YOLOv8 中的对象裁剪是什么，它如何工作？

使用 Ultralytics YOLOv8 进行对象裁剪涉及根据 YOLOv8 的检测能力从图像或视频中隔离和提取特定对象。这一过程通过利用 YOLOv8 高精度地识别和相应地裁剪对象，允许进行专注分析、减少数据量并提升精度。详细教程请参阅对象裁剪示例。

为什么应该使用 Ultralytics YOLOv8 进行对象裁剪，而不是其他解决方案？

Ultralytics YOLOv8 以其精确性、速度和易用性脱颖而出。它允许详细和准确的对象检测和裁剪，对于需要高数据完整性的专注分析和应用至关重要。此外，YOLOv8 与 OpenVINO 和 TensorRT 等工具无缝集成，适用于需要实时能力和多样硬件优化的部署。在模型导出指南中探索其优势。

如何使用对象裁剪减少数据集的数据量？

使用 Ultralytics YOLOv8 仅裁剪图像或视频中相关的对象，可以显著减少数据大小，使其在存储和处理上更高效。该过程涉及训练模型以检测特定对象，然后使用结果仅裁剪并保存这些部分。有关利用 Ultralytics YOLOv8 功能的更多信息，请访问我们的快速入门指南。

可以使用 Ultralytics YOLOv8 进行实时视频分析和对象裁剪吗？

是的，Ultralytics YOLOv8 可以处理实时视频流，动态检测和裁剪对象。该模型的高速推理能力使其非常适合实时应用，例如监控、体育分析和自动检验系统。查看跟踪和预测模式，了解如何实现实时处理。

有效运行 YOLOv8 进行对象裁剪的硬件要求是什么？

Ultralytics YOLOv8 经过优化，适用于 CPU 和 GPU 环境，但为了实现最佳性能，尤其是实时或高负载推理，建议使用专用 GPU（例如 NVIDIA Tesla、RTX 系列）。对于在轻量设备上部署，请考虑在 iOS 上使用 CoreML 或在 Android 上使用 TFLite。有关支持的设备和格式的详细信息，请查看我们的模型部署选项。

使用 Ultralytics YOLOv8 进行对象模糊 🚀

原文：docs.ultralytics.com/guides/object-blurring/

什么是对象模糊？

使用Ultralytics YOLOv8进行对象模糊处理涉及对图像或视频中特定检测到的对象应用模糊效果。利用 YOLOv8 模型的能力来识别和操作给定场景中的对象，从而实现此目的。

www.youtube.com/embed/ydGdibB5Mds

观看： 使用 Ultralytics YOLOv8 进行对象模糊

对象模糊的优势？

隐私保护：对象模糊是通过在图像或视频中隐藏敏感或个人可识别信息来有效保护隐私的工具。
选择性焦点：YOLOv8 允许选择性模糊，使用户能够针对特定对象进行模糊处理，从而在隐私保护和保留相关视觉信息之间取得平衡。
实时处理：YOLOv8 的高效性使其能够在实时中进行对象模糊处理，适用于需要在动态环境中进行即时隐私增强的应用。

使用 YOLOv8 示例进行对象模糊处理

import cv2

from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors

model = YOLO("yolov8n.pt")
names = model.names

cap = cv2.VideoCapture("path/to/video/file.mp4")
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))

# Blur ratio
blur_ratio = 50

# Video writer
video_writer = cv2.VideoWriter("object_blurring_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    results = model.predict(im0, show=False)
    boxes = results[0].boxes.xyxy.cpu().tolist()
    clss = results[0].boxes.cls.cpu().tolist()
    annotator = Annotator(im0, line_width=2, example=names)

    if boxes is not None:
        for box, cls in zip(boxes, clss):
            annotator.box_label(box, color=colors(int(cls), True), label=names[int(cls)])

            obj = im0[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])]
            blur_obj = cv2.blur(obj, (blur_ratio, blur_ratio))

            im0[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])] = blur_obj

    cv2.imshow("ultralytics", im0)
    video_writer.write(im0)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

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

参数 `model.predict`

名称	类型	默认值	描述
`source`	`str`	`'ultralytics/assets'`	图像或视频的源目录
`conf`	`float`	`0.25`	检测的对象置信度阈值
`iou`	`float`	`0.7`	NMS 的交并比（IoU）阈值
`imgsz`	`int or tuple`	`640`	图像大小，可以是标量或（h, w）列表，例如（640, 480）
`half`	`bool`	`False`	使用半精度（FP16）
`device`	`None or str`	`None`	运行设备，例如 cuda device=0/1/2/3 或 device=cpu
`max_det`	`int`	`300`	每张图像的最大检测数
`vid_stride`	`bool`	`False`	视频帧率步进
`stream_buffer`	`bool`	`False`	缓冲所有流帧（True），或返回最近的帧（False）
`visualize`	`bool`	`False`	可视化模型特征
`augment`	`bool`	`False`	对预测来源应用图像增强
`agnostic_nms`	`bool`	`False`	无类别 NMS
`classes`	`list[int]`	`None`	按类别过滤结果，例如 classes=0 或 classes=[0,2,3]
`retina_masks`	`bool`	`False`	使用高分辨率分割掩模
`embed`	`list[int]`	`None`	返回指定层的特征向量/嵌入

常见问题解答

什么是使用 Ultralytics YOLOv8 的对象模糊？

使用Ultralytics YOLOv8进行对象模糊涉及自动检测并对图像或视频中的特定对象应用模糊效果。此技术通过隐藏敏感信息同时保留相关视觉数据，增强隐私。YOLOv8 的实时处理能力使其适用于需要动态环境中即时隐私增强和选择性聚焦调整的应用。

如何使用 YOLOv8 实现实时物体模糊？

要使用 YOLOv8 实现实时物体模糊，请参考提供的 Python 示例。这涉及使用 YOLOv8 进行物体检测和 OpenCV 应用模糊效果。以下是简化版本：

import cv2

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break

    results = model.predict(im0, show=False)
    for box in results[0].boxes.xyxy.cpu().tolist():
        obj = im0[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])]
        im0[int(box[1]) : int(box[3]), int(box[0]) : int(box[2])] = cv2.blur(obj, (50, 50))

    cv2.imshow("YOLOv8 Blurring", im0)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
cv2.destroyAllWindows()

使用 Ultralytics 的 YOLOv8 进行物体模糊的好处是什么？

Ultralytics 的 YOLOv8 在物体模糊方面具有多个优势：

隐私保护：有效模糊敏感或可识别信息。
选择性焦点：针对特定物体进行模糊，保持基本的视觉内容。
实时处理：在动态环境中高效执行物体模糊，适合即时隐私增强。

欲了解更详细的应用，请查看物体模糊部分的优势。

我可以使用 Ultralytics 的 YOLOv8 在视频中模糊面部以保护隐私吗？

是的，Ultralytics 的 YOLOv8 可以配置为检测和模糊视频中的面部以保护隐私。通过训练或使用预训练模型来专门识别面部，检测结果可以通过 OpenCV 处理以应用模糊效果。请参考我们关于使用 YOLOv8 进行物体检测的指南，并修改代码以针对面部检测。

YOLOv8 与其他物体检测模型（如 Faster R-CNN）在物体模糊方面有何区别？

Ultralytics 的 YOLOv8 通常在速度方面优于 Faster R-CNN 等模型，使其更适合实时应用。虽然两种模型都提供准确的检测，但 YOLOv8 的架构针对快速推断进行了优化，这对于实时物体模糊等任务至关重要。详细了解技术差异和性能指标，请参阅我们的YOLOv8 文档。

使用 Ultralytics YOLOv8 进行训练监控

原文：docs.ultralytics.com/guides/workouts-monitoring/

通过姿势估计监控训练，使用Ultralytics YOLOv8准确跟踪关键身体标志和关节，实时提供运动形式反馈，跟踪训练路线并测量性能指标，优化用户和训练师的训练会话。

www.youtube.com/embed/LGGxqLZtvuw

Watch: 使用 Ultralytics YOLOv8 进行训练监控 | 俯卧撑、引体向上、腹部训练

训练监控的优势？

优化性能: 根据监控数据调整训练，以获得更好的效果。
目标达成: 跟踪和调整健身目标，实现可量化的进展。
个性化: 根据个人数据定制训练计划，以提高效果。
健康意识: 提前发现指示健康问题或过度训练的模式。
理性决策: 基于数据的决策，调整日常训练并设定实际目标。

现实世界的应用

训练监控	训练监控

俯卧撑计数	引体向上计数

训练监控示例

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n-pose.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
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))

gym_object = solutions.AIGym(
    line_thickness=2,
    view_img=True,
    pose_type="pushup",
    kpts_to_check=[6, 8, 10],
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    results = model.track(im0, verbose=False)  # Tracking recommended
    # results = model.predict(im0)  # Prediction also supported
    im0 = gym_object.start_counting(im0, results)

cv2.destroyAllWindows()

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n-pose.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
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("workouts.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

gym_object = solutions.AIGym(
    line_thickness=2,
    view_img=True,
    pose_type="pushup",
    kpts_to_check=[6, 8, 10],
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    results = model.track(im0, verbose=False)  # Tracking recommended
    # results = model.predict(im0)  # Prediction also supported
    im0 = gym_object.start_counting(im0, results)
    video_writer.write(im0)

cv2.destroyAllWindows()
video_writer.release()

支持

支持"pushup"、"pullup"和"abworkout"

关键点映射

Ultralytics YOLOv8 姿势关键点顺序

`AIGym`参数

名称	类型	默认	描述
`kpts_to_check`	`list`	`None`	三个关键点索引的列表，用于计算特定训练，后跟关键点映射
`line_thickness`	`int`	`2`	绘制线条的粗细。
`view_img`	`bool`	`False`	是否显示图像的标志。
`pose_up_angle`	`float`	`145.0`	'上'姿势的角度阈值。
`pose_down_angle`	`float`	`90.0`	'下'姿势的角度阈值。
`pose_type`	`str`	`pullup`	要检测的姿势类型（'pullup'，'pushup'，'abworkout'，'squat'）。

`model.predict`参数

名称	类型	默认	描述
`source`	`str`	`'ultralytics/assets'`	图像或视频的源目录。
`conf`	`float`	`0.25`	检测的对象置信度阈值。
`iou`	`float`	`0.7`	NMS（非极大值抑制）的交并比阈值。
`imgsz`	`int or tuple`	`640`	图像大小，可以是标量或(h, w)列表，例如(640, 480)
`half`	`bool`	`False`	使用半精度（FP16）。
`device`	`None or str`	`None`	运行设备，例如 cuda 设备=0/1/2/3 或 device=cpu
`max_det`	`int`	`300`	每张图像的最大检测数。
`vid_stride`	`bool`	`False`	视频帧率跨度
`stream_buffer`	`bool`	`False`	缓冲所有流帧（True）或返回最近的帧（False）
`visualize`	`bool`	`False`	可视化模型特征
`augment`	`bool`	`False`	对预测源应用图像增强
`agnostic_nms`	`bool`	`False`	类别不可知的 NMS
`classes`	`list[int]`	`None`	按类过滤结果，例如 classes=0，或 classes=[0,2,3]
`retina_masks`	`bool`	`False`	使用高分辨率分割掩模
`embed`	`list[int]`	`None`	从给定层返回特征向量/嵌入

参数`model.track`

名称	类型	默认值	描述
`source`	`im0`	`None`	图像或视频的源目录
`persist`	`bool`	`False`	在帧之间持续跟踪轨迹
`tracker`	`str`	`botsort.yaml`	跟踪方法为'bytetrack'或'botsort'
`conf`	`float`	`0.3`	置信阈值
`iou`	`float`	`0.5`	IOU 阈值
`classes`	`list`	`None`	按类过滤结果，例如 classes=0，或 classes=[0,2,3]
`verbose`	`bool`	`True`	显示对象跟踪结果

常见问题解答

如何使用 Ultralytics YOLOv8 监控我的锻炼？

要使用 Ultralytics YOLOv8 监控您的锻炼，您可以利用姿势估计能力实时跟踪和分析关键身体标志物和关节。这使您可以即时获得有关您的锻炼形式、计数重复次数和测量性能指标的反馈。您可以从提供的示例代码开始进行俯卧撑、引体向上或腹部训练，如下所示：

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n-pose.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
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))

gym_object = solutions.AIGym(
    line_thickness=2,
    view_img=True,
    pose_type="pushup",
    kpts_to_check=[6, 8, 10],
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    results = model.track(im0, verbose=False)
    im0 = gym_object.start_counting(im0, results)

cv2.destroyAllWindows()

欲了解更多定制和设置，请参阅文档中的 AIGym 部分。

使用 Ultralytics YOLOv8 进行锻炼监控的好处是什么？

使用 Ultralytics YOLOv8 监控锻炼带来了几个关键的好处：

优化性能： 通过根据监控数据调整训练，您可以获得更好的结果。
目标实现： 轻松跟踪并调整适合度目标，实现可衡量的进步。
个性化： 基于个人数据为您量身定制的锻炼计划，以实现最佳效果。
健康意识： 提前发现指示潜在健康问题或过度训练的模式。
明智的决策： 基于数据做出决策，调整日常训练并设定实际目标。

您可以观看一个YouTube 视频演示来看到这些优点的实际效果。

Ultralytics YOLOv8 在检测和跟踪锻炼方面的准确性如何？

由于其先进的姿势估计能力，Ultralytics YOLOv8 在检测和跟踪锻炼方面具有高度准确性。它能准确跟踪关键的身体标志和关节，提供关于锻炼形式和性能指标的实时反馈。该模型的预训练权重和强大的架构确保高精度和可靠性。有关实际示例，请查看文档中的实际应用部分，展示俯卧撑和引体向上的计数。

我可以使用 Ultralytics YOLOv8 进行自定义的锻炼例程吗？

是的，Ultralytics YOLOv8 可以适应自定义的锻炼例程。AIGym类支持不同的姿势类型，如“俯卧撑”、“引体向上”和“腹部锻炼”。您可以指定关键点和角度以检测特定的锻炼动作。以下是一个示例设置：

from ultralytics import solutions

gym_object = solutions.AIGym(
    line_thickness=2,
    view_img=True,
    pose_type="squat",
    kpts_to_check=[6, 8, 10],
)

关于设置参数的详细信息，请参阅参数AIGym部分。这种灵活性使您能够监控各种锻炼并根据需要定制例程。

如何使用 Ultralytics YOLOv8 保存训练监控输出？

要保存训练监控输出，您可以修改代码以包含保存处理帧的视频写入器。以下是一个示例：

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n-pose.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
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("workouts.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

gym_object = solutions.AIGym(
    line_thickness=2,
    view_img=True,
    pose_type="pushup",
    kpts_to_check=[6, 8, 10],
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    results = model.track(im0, verbose=False)
    im0 = gym_object.start_counting(im0, results)
    video_writer.write(im0)

cv2.destroyAllWindows()
video_writer.release()

这个设置将监控视频写入输出文件。有关详细信息，请参阅保存输出的训练监控部分。

使用 Ultralytics YOLOv8 进行不同区域的对象计数 🚀

原文：docs.ultralytics.com/guides/region-counting/

什么是区域内对象计数？

使用Ultralytics YOLOv8在区域内进行对象计数，通过先进的计算机视觉精确确定指定区域内的对象数量。这种方法对于优化流程、增强安全性以及提高各种应用程序的效率具有重要价值。

www.youtube.com/embed/okItf1iHlV8

观看： Ultralytics YOLOv8 多个可移动区域中的对象计数

区域内对象计数的优势？

精确度和准确性： 高级计算机视觉中的区域内对象计数确保了精确和准确的计数，最大限度地减少了手动计数常见的误差。
效率提升： 自动化对象计数提高了操作效率，提供实时结果，并简化了不同应用程序中的流程。
多功能和应用： 区域内对象计数的多功能性使其适用于各种领域，从制造和监控到交通监测，为其广泛的实用性和效果做出贡献。

现实世界的应用

零售	市场街道

使用 Ultralytics YOLOv8 在不同区域进行人数计数	使用 Ultralytics YOLOv8 在不同区域进行群体计数

运行步骤

步骤 1：安装所需的库

首先克隆 Ultralytics 存储库，安装依赖项，并使用步骤 2 中提供的命令导航到本地目录。

# Clone Ultralytics repo
git  clone  https://github.com/ultralytics/ultralytics

# Navigate to the local directory
cd  ultralytics/examples/YOLOv8-Region-Counter

步骤 2：使用 Ultralytics YOLOv8 运行区域计数

执行以下基本命令进行推断。

区域是可移动的

在视频播放期间，您可以通过单击并拖动左键来交互地移动视频中的区域。

# Save results
python  yolov8_region_counter.py  --source  "path/to/video.mp4"  --save-img

# Run model on CPU
python  yolov8_region_counter.py  --source  "path/to/video.mp4"  --device  cpu

# Change model file
python  yolov8_region_counter.py  --source  "path/to/video.mp4"  --weights  "path/to/model.pt"

# Detect specific classes (e.g., first and third classes)
python  yolov8_region_counter.py  --source  "path/to/video.mp4"  --classes  0  2

# View results without saving
python  yolov8_region_counter.py  --source  "path/to/video.mp4"  --view-img

可选参数

名称	类型	默认	描述
`--source`	`str`	`None`	视频文件路径，例如 Webcam 0
`--line_thickness`	`int`	`2`	边界框粗细
`--save-img`	`bool`	`False`	保存预测的视频/图像
`--weights`	`str`	`yolov8n.pt`	权重文件路径
`--classes`	`list`	`None`	检测特定类别，例如 --classes 0 2
`--region-thickness`	`int`	`2`	区域框粗细
`--track-thickness`	`int`	`2`	跟踪线条粗细

常见问题解答

什么是使用 Ultralytics YOLOv8 在指定区域进行对象计数？

使用Ultralytics YOLOv8进行指定区域内的物体计数涉及使用先进的计算机视觉技术检测和统计定义区域内物体的数量。这种精确的方法提高了制造业、监控和交通监测等各种应用的效率和准确性。

如何使用 Ultralytics YOLOv8 运行物体计数脚本？

按照以下步骤运行 Ultralytics YOLOv8 中的物体计数：

克隆 Ultralytics 存储库并导航至目录：

git  clone  https://github.com/ultralytics/ultralytics
cd  ultralytics/examples/YOLOv8-Region-Counter

执行区域计数脚本：

python  yolov8_region_counter.py  --source  "path/to/video.mp4"  --save-img

欲了解更多选项，请访问运行区域计数部分。

为什么应该在区域内使用 Ultralytics YOLOv8 进行物体计数？

使用 Ultralytics YOLOv8 进行区域内物体计数具有多个优势：

精确性和准确性： 减少手动计数中常见的错误。
效率提升： 提供实时结果并简化流程。
多功能性和应用： 适用于各个领域，增强其实用性。

在优势部分探索更深层次的好处。

在视频播放过程中是否可以调整定义的区域？

是的，使用 Ultralytics YOLOv8，可以在视频播放过程中交互地移动区域。只需使用鼠标左键单击和拖动即可重新定位区域。此功能增强了动态环境的灵活性。在可移动区域的提示部分了解更多信息。

区域内物体计数的一些真实应用是什么？

使用 Ultralytics YOLOv8 进行物体计数可以应用于许多现实场景：

零售： 用于人流量分析的人员计数。
市场街道： 人群密度管理。

在实际应用部分探索更多示例。

使用 Ultralytics YOLOv8 的安全警报系统项目

原文：docs.ultralytics.com/guides/security-alarm-system/

安全警报系统

使用 Ultralytics YOLOv8 的安全警报系统项目集成了先进的计算机视觉能力，以增强安全措施。Ultralytics 开发的 YOLOv8 提供实时对象检测，使系统能够及时识别和应对潜在的安全威胁。该项目提供了几个优势：

实时检测： YOLOv8 的效率使安全警报系统能够实时检测和响应安全事件，最大限度地减少响应时间。
准确性： YOLOv8 以其在对象检测中的准确性而闻名，减少误报，提高安全警报系统的可靠性。
集成能力： 该项目可以无缝集成到现有的安全基础设施中，提供一层升级的智能监控。

www.youtube.com/embed/_1CmwUzoxY4

观看： 使用 Ultralytics YOLOv8 对象检测的安全警报系统项目

代码

设置消息的参数

注意

应用程序密码生成是必要的

转到应用程序密码生成器，指定一个如“安全项目”之类的应用程序名称，并获取一个 16 位密码。将此密码复制并按照指示粘贴到指定的密码字段中。

password = ""
from_email = ""  # must match the email used to generate the password
to_email = ""  # receiver email

服务器创建和身份验证

import smtplib

server = smtplib.SMTP("smtp.gmail.com: 587")
server.starttls()
server.login(from_email, password)

电子邮件发送功能

from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

def send_email(to_email, from_email, object_detected=1):
  """Sends an email notification indicating the number of objects detected; defaults to 1 object."""
    message = MIMEMultipart()
    message["From"] = from_email
    message["To"] = to_email
    message["Subject"] = "Security Alert"
    # Add in the message body
    message_body = f"ALERT - {object_detected} objects has been detected!!"

    message.attach(MIMEText(message_body, "plain"))
    server.sendmail(from_email, to_email, message.as_string())

对象检测和警报发送器

from time import time

import cv2
import torch

from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors

class ObjectDetection:
    def __init__(self, capture_index):
  """Initializes an ObjectDetection instance with a given camera index."""
        self.capture_index = capture_index
        self.email_sent = False

        # model information
        self.model = YOLO("yolov8n.pt")

        # visual information
        self.annotator = None
        self.start_time = 0
        self.end_time = 0

        # device information
        self.device = "cuda" if torch.cuda.is_available() else "cpu"

    def predict(self, im0):
  """Run prediction using a YOLO model for the input image `im0`."""
        results = self.model(im0)
        return results

    def display_fps(self, im0):
  """Displays the FPS on an image `im0` by calculating and overlaying as white text on a black rectangle."""
        self.end_time = time()
        fps = 1 / round(self.end_time - self.start_time, 2)
        text = f"FPS: {int(fps)}"
        text_size = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 1.0, 2)[0]
        gap = 10
        cv2.rectangle(
            im0,
            (20 - gap, 70 - text_size[1] - gap),
            (20 + text_size[0] + gap, 70 + gap),
            (255, 255, 255),
            -1,
        )
        cv2.putText(im0, text, (20, 70), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 0, 0), 2)

    def plot_bboxes(self, results, im0):
  """Plots bounding boxes on an image given detection results; returns annotated image and class IDs."""
        class_ids = []
        self.annotator = Annotator(im0, 3, results[0].names)
        boxes = results[0].boxes.xyxy.cpu()
        clss = results[0].boxes.cls.cpu().tolist()
        names = results[0].names
        for box, cls in zip(boxes, clss):
            class_ids.append(cls)
            self.annotator.box_label(box, label=names[int(cls)], color=colors(int(cls), True))
        return im0, class_ids

    def __call__(self):
  """Run object detection on video frames from a camera stream, plotting and showing the results."""
        cap = cv2.VideoCapture(self.capture_index)
        assert cap.isOpened()
        cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
        cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
        frame_count = 0
        while True:
            self.start_time = time()
            ret, im0 = cap.read()
            assert ret
            results = self.predict(im0)
            im0, class_ids = self.plot_bboxes(results, im0)

            if len(class_ids) > 0:  # Only send email If not sent before
                if not self.email_sent:
                    send_email(to_email, from_email, len(class_ids))
                    self.email_sent = True
            else:
                self.email_sent = False

            self.display_fps(im0)
            cv2.imshow("YOLOv8 Detection", im0)
            frame_count += 1
            if cv2.waitKey(5) & 0xFF == 27:
                break
        cap.release()
        cv2.destroyAllWindows()
        server.quit()

调用对象检测类并运行推断

detector = ObjectDetection(capture_index=0)
detector()

就是这样！当您执行该代码时，如果检测到任何对象，您将在电子邮件中收到单个通知。通知会立即发送，不会重复。但是，可以根据项目需求自由定制代码。

收到的电子邮件示例

常见问题解答

Ultralytics YOLOv8 如何提高安全警报系统的准确性？

Ultralytics YOLOv8 通过提供高精度、实时的对象检测来增强安全警报系统。其先进的算法显著降低误报率，确保系统只对真正的威胁做出响应。这种增强的可靠性可以无缝集成到现有的安全基础设施中，提升整体监控质量。

我能将 Ultralytics YOLOv8 与现有的安全基础设施集成吗？

是的，Ultralytics YOLOv8 可以与您现有的安全基础设施无缝集成。该系统支持多种模式，并提供定制的灵活性，使您能够通过先进的目标检测能力增强现有设置。有关在您的项目中集成 YOLOv8 的详细说明，请访问集成部分。

运行 Ultralytics YOLOv8 的存储要求是什么？

在标准配置下运行 Ultralytics YOLOv8 通常需要大约 5GB 的可用磁盘空间。这包括存储 YOLOv8 模型和任何额外依赖项的空间。对于基于云的解决方案，Ultralytics HUB 提供高效的项目管理和数据集处理，可以优化存储需求。了解更多关于 Pro Plan 的信息，以获取包括扩展存储在内的增强功能。

Ultralytics YOLOv8 与其他目标检测模型如 Faster R-CNN 或 SSD 有什么不同？

Ultralytics YOLOv8 在实时检测能力和更高准确性方面优于 Faster R-CNN 或 SSD 等模型。其独特的架构使其能够在不妥协精度的情况下更快地处理图像，非常适合时间敏感的应用，如安全报警系统。有关目标检测模型的全面比较，您可以查看我们的指南。

如何使用 Ultralytics YOLOv8 减少我安全系统中的误报频率？

为了减少误报，请确保您的 Ultralytics YOLOv8 模型经过充分训练，使用多样化且标注良好的数据集。微调超参数并定期用新数据更新模型可以显著提高检测准确性。有关详细的超参数调优技术，请参阅我们的超参数调优指南。

高级数据可视化：使用 Ultralytics YOLOv8 的热力图 🚀

原文：docs.ultralytics.com/guides/heatmaps/

热力图简介

使用 Ultralytics YOLOv8 生成的热力图将复杂数据转化为生动的、颜色编码的矩阵。这个视觉工具使用一系列颜色来表示不同的数据值，其中较暖的色调表示较高的强度，而较冷的色调则表示较低的值。热力图在可视化复杂的数据模式、相关性和异常方面表现出色，为各个领域的数据解读提供了一种易于接触和引人入胜的方法。

www.youtube.com/embed/4ezde5-nZZw

观看： 使用 Ultralytics YOLOv8 的热力图

为什么选择热力图进行数据分析？

直观的数据分布可视化： 热力图简化了数据集中和分布的理解，将复杂的数据集转换为易于理解的视觉格式。
高效的模式检测： 通过以热力图格式可视化数据，更容易发现趋势、聚类和异常值，从而促进更快的分析和洞察。
增强的空间分析和决策制定： 热力图在说明空间关系方面发挥着重要作用，帮助在商业智能、环境研究和城市规划等领域的决策过程中。

现实世界的应用

交通	零售

Ultralytics YOLOv8 交通热力图	Ultralytics YOLOv8 零售热力图

热力图配置

heatmap_alpha：确保该值在 (0.0 - 1.0) 范围内。
decay_factor：用于在物体不再出现在画面中时移除热力图，其值应在 (0.0 - 1.0) 范围内。

使用 Ultralytics YOLOv8 的热力图示例

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
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
video_writer = cv2.VideoWriter("heatmap_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init heatmap
heatmap_obj = solutions.Heatmap(
    colormap=cv2.COLORMAP_PARULA,
    view_img=True,
    shape="circle",
    names=model.names,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    tracks = model.track(im0, persist=True, show=False)

    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    video_writer.write(im0)

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

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
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
video_writer = cv2.VideoWriter("heatmap_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

line_points = [(20, 400), (1080, 404)]  # line for object counting

# Init heatmap
heatmap_obj = solutions.Heatmap(
    colormap=cv2.COLORMAP_PARULA,
    view_img=True,
    shape="circle",
    count_reg_pts=line_points,
    names=model.names,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    tracks = model.track(im0, persist=True, show=False)
    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    video_writer.write(im0)

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

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
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
video_writer = cv2.VideoWriter("heatmap_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Define polygon points
region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360), (20, 400)]

# Init heatmap
heatmap_obj = solutions.Heatmap(
    colormap=cv2.COLORMAP_PARULA,
    view_img=True,
    shape="circle",
    count_reg_pts=region_points,
    names=model.names,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    tracks = model.track(im0, persist=True, show=False)
    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    video_writer.write(im0)

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

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
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
video_writer = cv2.VideoWriter("heatmap_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Define region points
region_points = [(20, 400), (1080, 404), (1080, 360), (20, 360)]

# Init heatmap
heatmap_obj = solutions.Heatmap(
    colormap=cv2.COLORMAP_PARULA,
    view_img=True,
    shape="circle",
    count_reg_pts=region_points,
    names=model.names,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    tracks = model.track(im0, persist=True, show=False)
    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    video_writer.write(im0)

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

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8s.pt")  # YOLOv8 custom/pretrained model

im0 = cv2.imread("path/to/image.png")  # path to image file
h, w = im0.shape[:2]  # image height and width

# Heatmap Init
heatmap_obj = solutions.Heatmap(
    colormap=cv2.COLORMAP_PARULA,
    view_img=True,
    shape="circle",
    names=model.names,
)

results = model.track(im0, persist=True)
im0 = heatmap_obj.generate_heatmap(im0, tracks=results)
cv2.imwrite("ultralytics_output.png", im0)

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
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
video_writer = cv2.VideoWriter("heatmap_output.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

classes_for_heatmap = [0, 2]  # classes for heatmap

# Init heatmap
heatmap_obj = solutions.Heatmap(
    colormap=cv2.COLORMAP_PARULA,
    view_img=True,
    shape="circle",
    names=model.names,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break
    tracks = model.track(im0, persist=True, show=False, classes=classes_for_heatmap)

    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    video_writer.write(im0)

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

参数 `Heatmap()`

名称	类型	默认值	描述
`names`	`list`	`None`	类别名称的字典。
`imw`	`int`	`0`	图像宽度。
`imh`	`int`	`0`	图像高度。
`colormap`	`int`	`cv2.COLORMAP_JET`	用于热力图的颜色映射。
`heatmap_alpha`	`float`	`0.5`	热力图叠加的 alpha 混合值。
`view_img`	`bool`	`False`	是否显示带有热力图叠加的图像。
`view_in_counts`	`bool`	`True`	是否显示进入该区域的物体计数。
`view_out_counts`	`bool`	`True`	是否显示离开该区域的物体计数。
`count_reg_pts`	`list` 或 `None`	`None`	定义计数区域的点（可以是线或多边形）。
`count_txt_color`	`tuple`	`(0, 0, 0)`	显示计数的文本颜色。
`count_bg_color`	`tuple`	`(255, 255, 255)`	显示计数的背景颜色。
`count_reg_color`	`tuple`	`(255, 0, 255)`	计数区域的颜色。
`region_thickness`	`int`	`5`	区域线条的厚度。
`line_dist_thresh`	`int`	`15`	基于线条的计数距离阈值。
`line_thickness`	`int`	`2`	绘制中使用的线条厚度。
`decay_factor`	`float`	`0.99`	用于减少热图强度随时间衰减的因子。
`shape`	`str`	`"circle"`	热图斑点的形状（'circle'或'rect'）。

Arguments `model.track`

名称	类型	默认值	描述
`source`	`im0`	`None`	图像或视频的源目录
`persist`	`bool`	`False`	在帧间持续跟踪
`tracker`	`str`	`botsort.yaml`	追踪方法为'bytetrack'或'botsort'
`conf`	`float`	`0.3`	置信度阈值
`iou`	`float`	`0.5`	IOU 阈值
`classes`	`list`	`None`	按类别过滤结果，例如 classes=0 或 classes=[0,2,3]

热图色彩地图

色彩地图名称	描述
`cv::COLORMAP_AUTUMN`	Autumn 色彩地图
`cv::COLORMAP_BONE`	Bone 色彩地图
`cv::COLORMAP_JET`	Jet 色彩地图
`cv::COLORMAP_WINTER`	Winter 色彩地图
`cv::COLORMAP_RAINBOW`	Rainbow 色彩地图
`cv::COLORMAP_OCEAN`	Ocean 色彩地图
`cv::COLORMAP_SUMMER`	Summer 色彩地图
`cv::COLORMAP_SPRING`	Spring 色彩地图
`cv::COLORMAP_COOL`	Cool 色彩地图
`cv::COLORMAP_HSV`	HSV（色相、饱和度、明度）色彩地图
`cv::COLORMAP_PINK`	Pink 色彩地图
`cv::COLORMAP_HOT`	Hot 色彩地图
`cv::COLORMAP_PARULA`	Parula 色彩地图
`cv::COLORMAP_MAGMA`	Magma 色彩地图
`cv::COLORMAP_INFERNO`	炼狱色彩地图
`cv::COLORMAP_PLASMA`	Plasma 色彩地图
`cv::COLORMAP_VIRIDIS`	Viridis 色彩地图
`cv::COLORMAP_CIVIDIS`	Cividis 色彩地图
`cv::COLORMAP_TWILIGHT`	Twilight 色彩地图
`cv::COLORMAP_TWILIGHT_SHIFTED`	Shifted Twilight 色彩地图
`cv::COLORMAP_TURBO`	Turbo 色彩地图
`cv::COLORMAP_DEEPGREEN`	Deep Green 色彩地图

这些色彩地图通常用于不同颜色表示的数据可视化。

FAQ

Ultralytics YOLOv8 如何生成热图及其优点？

Ultralytics YOLOv8 通过将复杂数据转换为彩色矩阵生成热图，不同色调代表数据强度。热图能够更直观地展示数据分布、有效检测模式，并增强空间分析能力，有助于决策过程中的数据可视化。温暖的色调表示较高数值，而冷色调表示较低数值。详细信息和配置选项，请参考热图配置部分。

我可以同时使用 Ultralytics YOLOv8 进行对象追踪和生成热图吗？

是的，Ultralytics YOLOv8 支持对象跟踪和热图生成同时进行。这可以通过其与对象跟踪模型集成的Heatmap解决方案来实现。为此，你需要初始化热图对象并使用 YOLOv8 的跟踪功能。以下是一个简单的示例：

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
heatmap_obj = solutions.Heatmap(colormap=cv2.COLORMAP_PARULA, view_img=True, shape="circle", names=model.names)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break
    tracks = model.track(im0, persist=True, show=False)
    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    cv2.imshow("Heatmap", im0)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
cv2.destroyAllWindows()

有关进一步的指导，请查看跟踪模式页面。

Ultralytics YOLOv8 热图与 OpenCV 或 Matplotlib 等其他数据可视化工具有什么不同？

Ultralytics YOLOv8 热图专为与其对象检测和跟踪模型集成而设计，提供实时数据分析的端到端解决方案。与 OpenCV 或 Matplotlib 等通用可视化工具不同，YOLOv8 热图经过优化以提高性能和自动处理，支持持久跟踪、衰减因子调整和实时视频叠加等功能。有关 YOLOv8 独特功能的更多信息，请访问Ultralytics YOLOv8 介绍。

如何使用 Ultralytics YOLOv8 仅在热图中可视化特定的对象类别？

你可以通过在 YOLO 模型的track()方法中指定所需的类别来可视化特定的对象类别。例如，如果你只想可视化汽车和人（假设它们的类别索引为 0 和 2），你可以相应地设置classes参数。

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
cap = cv2.VideoCapture("path/to/video/file.mp4")
heatmap_obj = solutions.Heatmap(colormap=cv2.COLORMAP_PARULA, view_img=True, shape="circle", names=model.names)

classes_for_heatmap = [0, 2]  # Classes to visualize
while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break
    tracks = model.track(im0, persist=True, show=False, classes=classes_for_heatmap)
    im0 = heatmap_obj.generate_heatmap(im0, tracks)
    cv2.imshow("Heatmap", im0)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

cap.release()
cv2.destroyAllWindows()

为什么企业应该选择 Ultralytics YOLOv8 进行数据分析中的热图生成？

Ultralytics YOLOv8 提供先进的对象检测与实时热图生成的无缝集成，使其成为希望更有效地可视化数据的企业的理想选择。主要优势包括直观的数据分布可视化、高效的模式检测和增强的空间分析，以便更好地决策。此外，YOLOv8 的尖端功能，如持久跟踪、可定制的颜色映射和对各种导出格式的支持，使其在全面数据分析方面优于 TensorFlow 和 OpenCV 等其他工具。了解更多商业应用，请访问Ultralytics 计划。

使用 Ultralytics YOLOv8 进行实例分割和跟踪 🚀

原文：docs.ultralytics.com/guides/instance-segmentation-and-tracking/

什么是实例分割？

Ultralytics YOLOv8的实例分割涉及识别和轮廓化图像中的个别对象，提供对空间分布的详细理解。与语义分割不同，它独特地标记并精确勾画每个对象，对于诸如物体检测和医学成像等任务至关重要。

Ultralytics 包中有两种可用的实例分割跟踪类型：

具有类对象的实例分割： 每个类对象分配一个独特的颜色，以便清晰地视觉分离。
带有对象跟踪的实例分割： 每个跟踪用不同的颜色表示，便于识别和跟踪。

www.youtube.com/embed/75G_S1Ngji8

观看： 使用 Ultralytics YOLOv8 进行对象跟踪的实例分割

样例

实例分割	实例分割 + 对象跟踪

Ultralytics 实例分割 😍	Ultralytics 带对象跟踪的实例分割 🔥

实例分割和跟踪

import cv2

from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors

model = YOLO("yolov8n-seg.pt")  # segmentation model
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("instance-segmentation.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, 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)
    annotator = Annotator(im0, line_width=2)

    if results[0].masks is not None:
        clss = results[0].boxes.cls.cpu().tolist()
        masks = results[0].masks.xy
        for mask, cls in zip(masks, clss):
            color = colors(int(cls), True)
            txt_color = annotator.get_txt_color(color)
            annotator.seg_bbox(mask=mask, mask_color=color, label=names[int(cls)], txt_color=txt_color)

    out.write(im0)
    cv2.imshow("instance-segmentation", im0)

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

out.release()
cap.release()
cv2.destroyAllWindows()

from collections import defaultdict

import cv2

from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors

track_history = defaultdict(lambda: [])

model = YOLO("yolov8n-seg.pt")  # segmentation model
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("instance-segmentation-object-tracking.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, 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)

    if results[0].boxes.id is not None and results[0].masks is not None:
        masks = results[0].masks.xy
        track_ids = results[0].boxes.id.int().cpu().tolist()

        for mask, track_id in zip(masks, track_ids):
            color = colors(int(track_id), True)
            txt_color = annotator.get_txt_color(color)
            annotator.seg_bbox(mask=mask, mask_color=color, label=str(track_id), txt_color=txt_color)

    out.write(im0)
    cv2.imshow("instance-segmentation-object-tracking", im0)

    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

out.release()
cap.release()
cv2.destroyAllWindows()

`seg_bbox` 参数

名称	类型	默认	描述
`mask`	`array`	`None`	分割蒙版坐标
`mask_color`	`RGB`	`(255, 0, 255)`	每个分割框的蒙版颜色
`label`	`str`	`None`	用于分割对象的标签
`txt_color`	`RGB`	`None`	用于分割和跟踪对象的标签颜色

注意

如有任何疑问，请随时在Ultralytics 问题区或下面提到的讨论区发表您的问题。

常见问题

如何使用 Ultralytics YOLOv8 进行实例分割？

要使用 Ultralytics YOLOv8 进行实例分割，需使用 YOLOv8 的分割版本初始化模型，并通过其处理视频帧。以下是一个简化的代码示例：

示例

import cv2

from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors

model = YOLO("yolov8n-seg.pt")  # segmentation model
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("instance-segmentation.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

while True:
    ret, im0 = cap.read()
    if not ret:
        break

    results = model.predict(im0)
    annotator = Annotator(im0, line_width=2)

    if results[0].masks is not None:
        clss = results[0].boxes.cls.cpu().tolist()
        masks = results[0].masks.xy
        for mask, cls in zip(masks, clss):
            annotator.seg_bbox(mask=mask, mask_color=colors(int(cls), True), det_label=model.model.names[int(cls)])

    out.write(im0)
    cv2.imshow("instance-segmentation", im0)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

out.release()
cap.release()
cv2.destroyAllWindows()

了解更多关于实例分割的内容，请参阅 Ultralytics YOLOv8 指南。

Ultralytics YOLOv8 中实例分割和对象跟踪有何区别？

实例分割识别并轮廓化图像中的个别对象，为每个对象分配唯一标签和蒙版。对象跟踪通过为视频帧中的对象分配一致的标签，实现对同一对象持续跟踪，进一步扩展了这一功能。了解更多关于 Ultralytics YOLOv8 文档中的区别。

为什么我应该使用 Ultralytics YOLOv8 进行实例分割和跟踪，而不是像 Mask R-CNN 或 Faster R-CNN 这样的其他模型？

Ultralytics YOLOv8 提供了与 Mask R-CNN 或 Faster R-CNN 等其他模型相比的实时性能、卓越的准确性和易用性。YOLOv8 与 Ultralytics HUB 无缝集成，使用户能够高效管理模型、数据集和训练流程。在Ultralytics 博客中了解更多关于 YOLOv8 的优势。

如何使用 Ultralytics YOLOv8 实现对象跟踪？

要实现对象跟踪，使用model.track方法，并确保每个对象的 ID 在各帧之间保持一致。以下是一个简单的示例：

示例

from collections import defaultdict

import cv2

from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors

track_history = defaultdict(lambda: [])

model = YOLO("yolov8n-seg.pt")  # segmentation model
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("instance-segmentation-object-tracking.avi", cv2.VideoWriter_fourcc(*"MJPG"), fps, (w, h))

while True:
    ret, im0 = cap.read()
    if not ret:
        break

    annotator = Annotator(im0, line_width=2)
    results = model.track(im0, persist=True)

    if results[0].boxes.id is not None and results[0].masks is not None:
        masks = results[0].masks.xy
        track_ids = results[0].boxes.id.int().cpu().tolist()

        for mask, track_id in zip(masks, track_ids):
            annotator.seg_bbox(mask=mask, mask_color=colors(track_id, True), track_label=str(track_id))

    out.write(im0)
    cv2.imshow("instance-segmentation-object-tracking", im0)
    if cv2.waitKey(1) & 0xFF == ord("q"):
        break

out.release()
cap.release()
cv2.destroyAllWindows()

在实例分割和跟踪部分查找更多信息。

Ultralytics 提供的数据集是否适用于训练 YOLOv8 模型进行实例分割和跟踪？

是的，Ultralytics 提供了多个适用于训练 YOLOv8 模型的数据集，包括分割和跟踪数据集。可以在Ultralytics 数据集文档中找到数据集示例、结构和使用说明。

使用 Ultralytics YOLOv8 进行 VisionEye 视图对象映射 🚀

原文：docs.ultralytics.com/guides/vision-eye/

什么是 VisionEye 对象映射？

Ultralytics YOLOv8 VisionEye 提供了计算机识别和定位物体的能力，模拟人眼观察的精确性。该功能使计算机能够像人眼一样分辨并集中注意特定对象的细节。

示例

VisionEye 视图	带对象跟踪的 VisionEye 视图	带距离计算的 VisionEye 视图

使用 Ultralytics YOLOv8 进行 VisionEye 视图对象映射	使用 Ultralytics YOLOv8 进行带对象跟踪的 VisionEye 视图对象映射	使用 Ultralytics YOLOv8 进行带距离计算的 VisionEye 视图

使用 YOLOv8 进行 VisionEye 对象映射

import cv2

from ultralytics import YOLO
from ultralytics.utils.plotting import Annotator, colors

model = YOLO("yolov8n.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("yolov8n.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("yolov8s.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` 参数

名称	类型	默认值	描述
`color`	`tuple`	`(235, 219, 11)`	线条和对象质心的颜色
`pin_color`	`tuple`	`(255, 0, 255)`	VisionEye 的标记颜色

注意

如有任何疑问，请随时在 Ultralytics 问题部分或下面提到的讨论部分发表您的问题。

常见问题解答

如何开始使用 Ultralytics YOLOv8 进行 VisionEye 对象映射？

要开始使用 Ultralytics YOLOv8 进行 VisionEye 对象映射，首先需要通过 pip 安装 Ultralytics YOLO 包。然后，可以使用文档中提供的示例代码设置 VisionEye 的对象检测。以下是一个简单的示例，帮助您入门：

import cv2

from ultralytics import YOLO

model = YOLO("yolov8n.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()

使用 Ultralytics YOLOv8 的 VisionEye 对象跟踪功能的关键特性是什么？

VisionEye 使用 Ultralytics YOLOv8 的对象跟踪功能允许用户在视频帧内跟踪物体的移动。关键功能包括：

实时对象跟踪：跟踪物体移动的过程。
对象识别：利用 YOLOv8 强大的检测算法。
距离计算：计算对象和指定点之间的距离。
注释和可视化：为被跟踪的对象提供视觉标记。

这里是演示使用 VisionEye 进行跟踪的简短代码片段：

import cv2

from ultralytics import YOLO

model = YOLO("yolov8n.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()

对于全面的指南，请访问 VisionEye 对象映射与对象跟踪。

如何使用 VisionEye 的 YOLOv8 模型计算距离？

VisionEye 和 Ultralytics YOLOv8 的距离计算涉及确定帧中检测到的对象与指定点的距离。它增强了空间分析能力，在自动驾驶和监控等应用中非常有用。

这里有一个简化的例子：

import math

import cv2

from ultralytics import YOLO

model = YOLO("yolov8s.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()

详细指南，请参阅带有距离计算的 VisionEye。

我为什么要使用 Ultralytics YOLOv8 进行对象映射和跟踪？

Ultralytics YOLOv8 以其速度、准确性和易集成性而闻名，成为对象映射和跟踪的首选。主要优势包括：

最先进的性能：在实时物体检测中提供高精度。
灵活性：支持检测、跟踪和距离计算等各种任务。
社区与支持：提供广泛的文档和活跃的 GitHub 社区，用于故障排除和增强。
易用性：直观的 API 简化了复杂任务，可以快速部署和迭代。

有关应用和优势的更多信息，请访问Ultralytics YOLOv8 文档。

如何将 VisionEye 与 Comet 或 ClearML 等其他机器学习工具集成？

Ultralytics YOLOv8 可以与 Comet 和 ClearML 等多种机器学习工具无缝集成，增强实验跟踪、协作和可复现性。请查阅如何使用 YOLOv5 与 Comet和将 YOLOv8 与 ClearML 集成的详细指南以开始。

有关进一步探索和集成示例，请查看我们的Ultralytics 集成指南。

使用 Ultralytics YOLOv8 进行速度估算 🚀

原文：docs.ultralytics.com/guides/speed-estimation/

什么是速度估算？

速度估算是在特定背景下计算物体移动速率的过程，常用于计算机视觉应用中。使用Ultralytics YOLOv8，您可以通过物体跟踪结合距离和时间数据计算物体速度，这对于交通和监视等任务至关重要。速度估算的准确性直接影响各种应用程序的效率和可靠性，是智能系统和实时决策过程中的关键组成部分。

www.youtube.com/embed/rCggzXRRSRo

观看： 使用 Ultralytics YOLOv8 进行速度估算

查看我们的博客

欲深入了解速度估算，请查看我们的博客文章：Ultralytics YOLOv8 用于计算机视觉项目中的速度估算

速度估算的优势？

高效的交通控制： 准确的速度估算有助于管理交通流量，增强道路安全，减少拥堵。
精确的自主导航： 在自动驾驶等自主系统中，可靠的速度估算确保车辆导航安全和准确。
增强监视安全性： 在监视分析中进行速度估算有助于识别异常行为或潜在威胁，提升安全措施的效果。

现实世界应用

Transportation	Transportation

使用 Ultralytics YOLOv8 在道路上进行速度估算	使用 Ultralytics YOLOv8 在桥上进行速度估算

使用 YOLOv8 进行速度估算示例

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
names = model.model.names

cap = cv2.VideoCapture("path/to/video/file.mp4")
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
video_writer = cv2.VideoWriter("speed_estimation.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

line_pts = [(0, 360), (1280, 360)]

# Init speed-estimation obj
speed_obj = solutions.SpeedEstimator(
    reg_pts=line_pts,
    names=names,
    view_img=True,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    tracks = model.track(im0, persist=True, show=False)

    im0 = speed_obj.estimate_speed(im0, tracks)
    video_writer.write(im0)

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

速度是估算值

速度将是一个估算值，可能并不完全准确。此外，估算结果可能因 GPU 速度而异。

参数 `SpeedEstimator`

Name	Type	Default	Description
`names`	`dict`	`None`	类名字典。
`reg_pts`	`list`	`[(20, 400), (1260, 400)]`	速度估算的区域点列表。
`view_img`	`bool`	`False`	是否显示带有注释的图像。
`line_thickness`	`int`	`2`	绘制框和轨道线的线条粗细。
`region_thickness`	`int`	`5`	区域线的线条粗细。
`spdl_dist_thresh`	`int`	`10`	速度计算的距离阈值。

参数 `model.track`

名称	类型	默认	描述
`source`	`im0`	`None`	图像或视频的源目录
`persist`	`bool`	`False`	在帧间持续跟踪轨迹
`tracker`	`str`	`botsort.yaml`	跟踪方法 'bytetrack' 或 'botsort'
`conf`	`float`	`0.3`	置信度阈值
`iou`	`float`	`0.5`	IOU 阈值
`classes`	`list`	`None`	根据类别筛选结果，例如 classes=0 或 classes=[0,2,3]
`verbose`	`bool`	`True`	显示对象跟踪结果

常见问题

如何使用 Ultralytics YOLOv8 估算对象速度？

使用 Ultralytics YOLOv8 进行对象速度估算涉及结合物体检测和跟踪技术。首先，您需要使用 YOLOv8 模型在每个帧中检测对象。然后，跟踪这些对象跨帧以计算它们随时间的移动。最后，利用对象在帧间移动的距离和帧率来估算其速度。

示例：

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.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))
video_writer = cv2.VideoWriter("speed_estimation.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Initialize SpeedEstimator
speed_obj = solutions.SpeedEstimator(
    reg_pts=[(0, 360), (1280, 360)],
    names=names,
    view_img=True,
)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        break
    tracks = model.track(im0, persist=True, show=False)
    im0 = speed_obj.estimate_speed(im0, tracks)
    video_writer.write(im0)

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

欲了解更多详细信息，请参阅我们的官方博客文章。

在交通管理中使用 Ultralytics YOLOv8 进行速度估算有哪些好处？

使用 Ultralytics YOLOv8 进行速度估算在交通管理中具有显著优势：

增强安全性：准确估算车辆速度，检测超速，提升道路安全。
实时监控：利用 YOLOv8 的实时对象检测能力有效监控交通流量和拥堵情况。
可扩展性：在各种硬件设置中部署模型，从边缘设备到服务器，确保大规模实施的灵活和可扩展解决方案。

欲了解更多应用程序，请参阅速度估算的优势。

YOLOv8 是否可以与其他 AI 框架（如 TensorFlow 或 PyTorch）集成？

是的，YOLOv8 可以与 TensorFlow 和 PyTorch 等其他 AI 框架集成。Ultralytics 支持将 YOLOv8 模型导出为 ONNX、TensorRT 和 CoreML 等多种格式，确保与其他 ML 框架的平滑互操作性。

将 YOLOv8 模型导出为 ONNX 格式：

yolo  export  --weights  yolov8n.pt  --include  onnx

在我们的导出指南中了解更多关于导出模型的信息。

使用 Ultralytics YOLOv8 进行速度估算的准确性如何？

使用 Ultralytics YOLOv8 进行速度估算的准确性取决于多种因素，包括物体跟踪的质量、视频的分辨率和帧率以及环境变量。虽然速度估算器提供可靠的估算结果，但由于帧处理速度和物体遮挡的变化，可能不是 100%准确。

注意：在可能的情况下，始终考虑误差范围，并使用实际数据验证估算结果。

欲了解更多提高精度的提示，请查看 SpeedEstimator 部分的参数。

为什么选择 Ultralytics YOLOv8 而不是 TensorFlow Object Detection API 等其他物体检测模型？

Ultralytics YOLOv8 相比 TensorFlow 目标检测 API 等其他对象检测模型具有几个优势：

实时性能：YOLOv8 经过优化，可实现实时检测，提供高速和准确性。
易用性：设计有用户友好的界面，YOLOv8 简化了模型训练和部署。
多功能性：支持多种任务，包括对象检测、分割和姿态估计。
社区与支持：YOLOv8 得到活跃社区和详尽文档的支持，确保开发者拥有所需资源。

欲了解更多关于 YOLOv8 的优势，请查看我们详细的模型页面。

使用 Ultralytics YOLOv8 进行距离计算

原文：docs.ultralytics.com/guides/distance-calculation/

什么是距离计算？

在指定空间内测量两个对象之间的间距称为距离计算。在Ultralytics YOLOv8的情况下，使用边界框质心来计算用户突出显示的边界框的距离。

www.youtube.com/embed/LE8am1QoVn4

观看： 使用 Ultralytics YOLOv8 进行距离计算

视觉效果

使用 Ultralytics YOLOv8 进行距离计算

优势的距离计算？

定位精度： 提升计算机视觉任务中的精确空间定位能力。
大小估算： 允许更好地理解物理大小。
场景理解： 为改善决策提供环境的三维理解。

距离计算

单击任意两个边界框使用左鼠标单击进行距离计算

使用 YOLOv8 示例的距离计算

import cv2

from ultralytics import YOLO, solutions

model = YOLO("yolov8n.pt")
names = model.model.names

cap = cv2.VideoCapture("path/to/video/file.mp4")
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
video_writer = cv2.VideoWriter("distance_calculation.avi", cv2.VideoWriter_fourcc(*"mp4v"), fps, (w, h))

# Init distance-calculation obj
dist_obj = solutions.DistanceCalculation(names=names, view_img=True)

while cap.isOpened():
    success, im0 = cap.read()
    if not success:
        print("Video frame is empty or video processing has been successfully completed.")
        break

    tracks = model.track(im0, persist=True, show=False)
    im0 = dist_obj.start_process(im0, tracks)
    video_writer.write(im0)

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

注

鼠标右键点击将删除所有绘制的点
鼠标左键单击可以绘制点

参数 `DistanceCalculation()`

`Name`	`Type`	`Default`	Description
`names`	`dict`	`None`	类名字典。
`pixels_per_meter`	`int`	`10`	像素到米的转换因子。
`view_img`	`bool`	`False`	是否显示视频流的标志位。
`line_thickness`	`int`	`2`	图像上绘制线条的厚度。
`line_color`	`tuple`	`(255, 255, 0)`	图像上绘制线条的颜色（BGR 格式）。
`centroid_color`	`tuple`	`(255, 0, 255)`	绘制的质心颜色（BGR 格式）。

参数 `model.track`

Name	Type	Default	Description
`source`	`im0`	`None`	图像或视频的源目录
`persist`	`bool`	`False`	在帧之间持续跟踪轨迹
`tracker`	`str`	`botsort.yaml`	跟踪方法 'bytetrack' 或 'botsort'
`conf`	`float`	`0.3`	置信阈值
`iou`	`float`	`0.5`	IOU 阈值
`classes`	`list`	`None`	按类别过滤结果，例如 classes=0 或 classes=[0,2,3]
`verbose`	`bool`	`True`	显示对象跟踪结果

常见问题

我如何使用 Ultralytics YOLOv8 计算对象之间的距离？

要使用Ultralytics YOLOv8计算对象之间的距离，您需要识别检测对象的边界框质心。该过程涉及从 Ultralytics 的solutions模块初始化 DistanceCalculation 类，并使用模型的跟踪输出计算距离。您可以参考距离计算示例中的实现。

使用 Ultralytics YOLOv8 进行距离计算的优势是什么？

使用 Ultralytics YOLOv8 进行距离计算具有以下几个优点：

定位精度： 提供对象的准确空间定位。
大小估计： 帮助估计物理尺寸，有助于更好地理解背景信息。
场景理解： 增强 3D 场景理解，有助于改善自动驾驶和监控等应用中的决策制定。

我可以在实时视频流中使用 Ultralytics YOLOv8 进行距离计算吗？

是的，您可以在实时视频流中使用 Ultralytics YOLOv8 进行距离计算。该过程涉及使用 OpenCV 捕获视频帧，运行 YOLOv8 目标检测，并使用DistanceCalculation类计算连续帧中对象之间的距离。有关详细实现，请参阅视频流示例。

如何删除使用 Ultralytics YOLOv8 进行距离计算期间绘制的点？

若要删除使用 Ultralytics YOLOv8 进行距离计算期间绘制的点，您可以使用鼠标右键单击。此操作将清除您绘制的所有点。有关详细信息，请参阅距离计算示例下的注释部分。

初始化 Ultralytics YOLOv8 中 DistanceCalculation 类的关键参数是什么？

初始化 Ultralytics YOLOv8 中 DistanceCalculation 类的关键参数包括：

names: 将类索引映射到类名称的字典。
pixels_per_meter: 像素到米的转换因子。
view_img: 指示是否显示视频流的标志。
line_thickness: 图像上绘制线条的厚度。
line_color: 图像上绘制线条的颜色（BGR 格式）。
centroid_color: 质心的颜色（BGR 格式）。

要查看详尽列表和默认值，请参阅 DistanceCalculation 的参数。

Ultralytics-中文文档-十-