如何使用ROS 2和YOLOv11构建实时物体检测与跟踪系统

感知系统是机器人系统中负责理解机器人周围环境信息的部分。它接收原始的传感器数据（通常是摄像头采集的图像帧），并将其转化为结构化信息：确定物体的位置、种类及其运动方式。

本教程构建的感知系统包含四个层次：

1. 摄像头数据采集：从模拟器中获取原始图像帧，并以ROS 2消息的形式发布出来，以便其他机器人组件能够使用这些数据。

2. 物体检测：对每一帧图像应用YOLOv11算法，识别出物体及其位置，并附带置信度评分。

3. 多物体跟踪：利用ByteTrack技术将不同帧中的物体检测结果关联起来，使每个物体在时间序列中保持稳定的身份标识，而不会将每一帧都视为全新的场景。

4. 验证与优化：添加置信度筛选机制，防止质量较低的检测结果影响后续的导航逻辑；同时将模型导出为ONNX格式，以便在边缘设备上快速进行推理计算。

我们选择CARLA作为模拟器，是因为它能够提供真实的传感器数据、可控制的环境环境，而且其摄像头组件支持Python编程语言，因此非常适合用于自动驾驶车辆和移动机器人的感知系统研究。如果你使用的是其他传感器源，ROS 2的架构是相同的，只需要修改负责发布摄像头数据的节点即可。

项目结构

在编写任何代码之前，了解整个项目的整体结构是非常有帮助的。完成后的工作空间布局如下：

ros2_perception_ws/
├── src/
│   └── perception_stack/
│       ├── perception_stack/
│       │   ├── __init__.py
│       │   ├── camera_publisher.py      # 将CARLA图像帧发布到ROS 2系统中
│       │   ├── perception_node.py       # 多线程YOLO检测节点
│       │   ├── tracker.py               # ByteTrack跟踪模块
│       │   └── validator.py             | 置信度筛选层
│       │   └── export_onnx.py           | ONNX模型导出脚本
│       ├── models/
│       │   └── yolov11n.pt              | 下载的YOLO模型权重文件
│       ├── package.xml
│       ├── setup.py
│       └── setup.cfg
├── requirements.txt
└── README.md

每个文件都承担着特定的功能。对于机器人软件来说，这种模块化的设计尤为重要，因为感知、跟踪和验证等功能的发展速度往往不同，因此需要分别进行测试。

如何设置你的ROS 2工作空间

首先创建工作空间和相应的软件包：

mkdir -p ~/ros2_perception_ws/src
cd ~/ros2_perception_ws/src
ros2 pkg create --build-type ament_python perception_stack
cd ~/ros2_perception_ws
colcon build
source install/setup.bash

colcon build 命令用于编译工作区代码。通过执行 install/setup.bash，ROS 2系统会识别到你新创建的包，这样你就可以使用 ros2 run 命令来运行该包中的节点了。

如何安装依赖项

pip install ultralytics opencv-python-headless cv_bridge \
            torch torchvision onnx onnxruntime-gpu \
            numpy supervision

关于提供者程序的说明：本教程使用了支持GPU功能的ONNX Runtime，具体通过 onnxruntime-gpu 实现。如果你使用的机器没有兼容CUDA的GPU，那么可以将该依赖项替换为 onnxruntime，以便仅使用CPU进行推理。其余配置保持不变，但需要注意的是，使用CPU进行推理时，帧率可能会降低。

如何将相机采集的图像数据发布到ROS 2系统中

第一个节点的作用是打通CARLA的Python API与ROS 2生态系统之间的连接。CARLA采用事件驱动的回调机制，而ROS 2则使用基于类型化消息格式的发布者-订阅者模型。这个节点会将CARLA生成的原始图像数据转换为sensor_msgs/Image类型的消息，任何ROS 2节点都可以订阅这类消息。

创建文件 camera_publisher.py，并编写如下代码：

import carla
import rclpy
from rclpy.node import Node
from sensor_msgs.msg import Image
from cv_bridge import CvBridge
import numpy as np

class CARLACameraNode(Node):
    def __init__(self):
        super().__init '__carla_camera_node')
        self.publisher = self.create_publisher(Image, '/carla/camera/rgb', 10)
        self.bridge = CvBridge()
        self.get_logger().info('CARLA camera node started.')

    def camera_callback(self, image):
        # CARLA生成的原始图像数据为BGRA格式，我们需要将其转换为BGR格式才能被OpenCV处理
        array = np.frombuffer(image.raw_data, dtype=np.uint8)
        array = array.reshape((image.height, image.width, 4))
        bgr = array[:, :, :3]

        msg = self.bridge.cv2_to_imgmsg(bgr, encoding='bgr8')

        # 为消息添加当前ROS 2系统的时钟时间戳
        # 这一点非常重要。因为下游节点（如跟踪系统或SLAM算法）会通过消息之间的时间差来计算物体的运动速度和位移，如果没有准确的时间戳，这些计算就会出错，从而导致系统无法正常工作。
        msg.header.stamp = self.get_clock().now().to_msg()

        self.publisher.publish(msg)

def main():
    rclpy.init()
    node = CARLACameraNode()

    client = carla.Client('localhost', 2000)
    world = client.get_world()
    blueprint_library = world.get_blueprint_library()

    camera_bp = blueprint_library.find('sensor.camera.rgb')
    camera.bp.set_attribute('image_size_x', '1280')
    camera(bp.set_attribute('image_size_y', '720')
    camera bp.set_attribute('fov', '90')

    spawn_point = world.get_map().getspawn_points()[0]
    camera = world.spawn_actor(camera_bp, spawn_point)
    camera.listen(node.camera_callback)

    rclpy.spin(node)
    camera.destroy()
    node.destroy_node()
    rclpy.shutdown()

cv_bridge库负责处理OpenCV数组与ROS 2图像消息之间的转换。bgr8编码方式用于告知后续订阅者应期待何种颜色格式。如果没有这种编码，颜色通道可能会被随意交换，从而导致检测器在接收到完全有效的输入时仍产生错误的结果。

如何构建具有线程推理功能的感知节点

这是整个处理流程中架构上最为重要的节点，在查看代码之前，有必要先了解其设计原理。

默认情况下，ROS 2进程会通过单个执行线程来处理订阅者的回调函数。如果你的YOLO推理操作发生在回调函数内部，那么在整个推理过程中，该线程都会被阻塞，从而导致订阅者无法接收新的消息。

根据队列的大小和帧率的不同，这意味着在推理完成时，你可能已经在处理一些已经过时的帧了。这样一来，跟踪系统接收到的数据流就会变得不连续、时间不一致，而无法保持流畅性。

为了解决这个问题，需要将数据的接收与处理过程分离开来。回调函数的作用仅仅是将新收到的帧放入一个有容量限制的队列中，然后立即返回；另一个独立的线程则会从该队列中取出帧并执行推理操作。

这个队列是有最大容量的。当推理速度跟不上数据生成的速度且队列已满时，新的帧会被直接丢弃，而不会无限期地堆积在队列中。这种设计是经过深思熟虑的：在实时系统中，延迟处理的过时帧往往比被直接丢弃的帧更糟糕，因为它们会使得跟踪系统看到的是过去的状态，而不是当前的实际情况。

创建perception_node.py文件：

import threading
import queue

import rclpy
from rclpy.node import Node
from sensor_msgs.msg import Image
from cv_bridge import CvBridge
from ultralytics import YOLO
import cv2

CONFIDENCE_THRESHOLD = 0.45

class PerceptionNode(Node):
    def __init__(self):
        super().__init '__perception_node')

        self.bridge = CvBridge()
        self.model = YOLO('models/yolov11n.pt')

        # 有容量限制的队列：最大容量为5，可以防止过时帧的堆积。
        # 当队列已满时，image_callback函数会直接丢弃新收到的帧，而不会等待，从而保证数据流的连续性。
        self.frame_queue = queue.Queue(maxsize=5)

        self.subscription = self.create_subscription(
            Image,
            '/carla/camera/rgb',
            self.image_callback,
            10
        )

        self.inference_thread = threading.Thread(
            target=self.run_inference,
            daemon=True
        )
        self.inference_thread.start()
        self.get_logger().info('Perception node ready.')

    def image_callback(self, msg):
        # 如果推理操作跟不上数据生成的速度，就直接丢弃该帧。
        # 我们绝对不能让回调线程被阻塞。
        if not self.frame_queue.full():
            self.frame_queue.put(msg)

    def run_inference(self):
        while rclpy.ok():
            msg = self.frame_queue.get()
            frame = self.bridge.imgmsg_to_cv2(msg, desired_encoding='bgr8')

            results = self.model(frame, conf=CONFIDENCE_THRESHOLD, verbose=False)

            detections = results[0].boxes
            self.get_logger().info(
                f'检测到{len(detections)}个对象，置信度均高于{CONFIDENCE_threshold}'
            )

def main():
    rclpy.init()
    node = PerceptionNode()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()

如何将ByteTrack集成到多目标跟踪系统中

仅通过检测，我们只能知道单帧图像中有哪些物体；而跟踪功能则能帮助我们了解这些物体在时间推移过程中的变化情况：比如哪辆车是哪辆、它正在朝哪个方向移动，以及它是否就是两秒钟前我们看到的那辆车。

ByteTrack通过使用“交并比”（IoU）这一指标来将新的检测结果与现有的跟踪对象关联起来。IoU用于衡量预测的物体位置与新检测到的物体位置之间的边界框重叠程度。

该系统采用了两阶段匹配流程，既能处理高置信度的检测结果，也能处理低置信度的检测结果，因此相比简单的跟踪算法，在物体被其他物体遮挡的情况下，ByteTrack的表现更为稳定。

您最常需要调整的三个参数分别是：

• track_thresh：启动或确认某个跟踪对象所需的最小检测置信度
• match_thresh：使某个检测结果能与现有跟踪对象匹配所需的最小IoU值
• track_buffer：一个跟踪对象在连续多少帧内没有新的检测结果与之关联时，才会被系统删除

创建文件tracker.py：

from supervision import ByteTracker, Detections
import numpy as np

class RoboticsTracker:
    def __init__(self):
        # track_buffer决定了一个跟踪对象在连续多少帧内没有新的检测结果时才会被删除
        # 较高的值可以在物体短暂被遮挡的情况下帮助系统继续进行跟踪，但也会导致一些已经离开场景的物体仍然被保留下来。
        self.tracker = ByteTracker(
            track_thresh=0.45,
            match_thresh=0.8,
            track_buffer=30,
            frame_rate=30
        )

    def update(self, yolo_results, frame_shape):
        boxes = yolo_results[0].boxes

        if len(boxes) == 0:
            return []

        xyxy = boxes.xyxy.cpu().numpy()
        confidence = boxes.conf(cpu().numpy()
        class_ids = boxes.cls.cpu().numpy().astype(int)

        detections = Detections(
            xyxy=xyxy,
            confidence=confidence,
            class_id=class_ids
        )

        tracked = self.tracker.update(
            detections=detections,
            frame_resolution_wh=(frame_shape[1], frame_shape[0])
        )

        # tracked.tracker_id为每个检测结果分配了一个稳定的整数ID，只要这个跟踪对象仍然存在，这个ID就会在不同的帧中保持不变。
        return tracked

CONFIDENCE_THRESHOLD = 0.45
MIN TRACK_AGE = 3        # 一个轨迹必须存在至少3帧才能被认为稳定
JITTER_threshold = 2.0   # 平台允许的最大加速度（米/秒²）

def is_actionable_detection(detection, track_age: int, platform_acceleration: float):
    """
    只有当检测结果通过以下三项检查时，才会返回True：
    1. 模型的置信度高于阈值（从而过滤掉弱检测结果）
    2. 该轨迹已经存在足够长的时间，因此可以被认为是稳定的
       （这样就能排除那些仅在一两帧内被检测到的噪声干扰）
    3. 承载传感器的平台没有发生剧烈振动或加速，以免影响传感器数据的准确性）
    """
    if detection.confidence < CONFIDENCE_THRESHOLD:
        return False, "置信度过低"

    if track_age < MIN TRACK_AGE:
        return False, "轨迹不稳定"

    if platform_acceleration > JITTER_threshold:
        return False, "平台状态不稳定"

    return True, "可采取行动"

from ultralytics import YOLO

def export_perception_model(weights_path: str, output_path: str):
    """
    将YOLOv11模型导出为ONNX格式，以便在边缘设备上使用。

    参数`dynamic Axes`设置为`True`，意味着导出的模型既可以处理单帧数据，也可以处理多帧数据，而无需重新进行导出操作。这对于在基准测试中使用批量输入数据进行测试非常有用。
    """
    model = YOLO(weights_path)

    # 使用Ultralytics内置的ONNX导出功能进行导出
    # 参数`opset=17`是推荐版本，能够保证与TensorRT 8.x及更高版本兼容
    model.export(
        format='onnx',
        imgsz=640,
        opset=17,
        dynamic=True,     # 启用动态批量大小处理
        simplify=True     # 运行ONNX简化工具来优化模型结构
    )

    print(f"模型已成功导出到{output_path}路径")
if __name__ == '__main__':
    export_perception_model(
        weights_path='models/yolov11n.pt',
        output_path='models/perception.onnx'
    )

如果想要使用导出的ONNX模型而不是PyTorch来进行推理，只需将perception_node.py中的YOLO推理代码替换为ONNX Runtime会话即可：

import onnxruntime as ort
import numpy as np
import cv2

session = ort.InferenceSession(
    'models/perception.onnx',
    providers=['CUDAExecutionProvider', 'CPUExecutionProvider']
)

def run_onnx_inference(frame: np.ndarray):
    # 预处理：调整图像尺寸、进行归一化处理、添加批量维度，并将数据类型转换为float32
    img = cv2.resize.frame, (640, 640))
    img = img.astype(np.float32) / 255.0
    img = img.transpose(2, 0, 1)          # 将数据格式从HWC转换为CHW
    img = np.expand_dims(img, axis=0)     # 添加批量维度

    outputs = session.run(None, {'images': img})
    return outputs

providers列表告诉ONNX Runtime在支持GPU加速的情况下优先使用CUDA，如果CUDA不可用，则转而使用CPU。这样一来，相同的推理代码就可以在开发机器和边缘设备上直接使用，而无需进行任何修改。

如何测试整个流程

当所有节点的代码都编写完成后，在两个终端中分别启动这个流程。

在第一个终端中，启动相机发布器：

cd ~/ros2_perception_ws
source install/setup.bash
ros2 run perception_stack camera_publisher

在第二个终端中，启动感知节点：

source install/setup.bash
ros2 run perception_stack perception_node

为了验证数据帧是否能够在各个节点之间正确传输，你可以在第三个终端中查看相关主题信息：

ros2 topic hz /carla/camera/rgb

这条命令会显示相机主题上的消息发送频率。如果帧率为30 FPS，那么你应该能看到每秒钟大约有30条消息被发送；如果这个数字明显偏低，那就说明CARLA回调功能出现了问题，或者节点之间的网络传输已经达到饱和状态。

如果你想直观地查看感知节点检测到了什么内容，可以在run_inference函数中添加代码来发布带有标注的图像信息：

annotated = results[0].plot()  # 在图像上绘制框和标签
annotated_msg = self.bridge.cv2_to_imgmsg(annotated, encoding='bgr8')
annotated_msg.header.stamp = self.get_clock().now().to_msg()
self.annotated_publisher.publish(annotated_msg)

然后，在rqt_image_view中打开这些标注后的图像：

ros2 run rqt_image_view rqt_image_view /perception/annotated

结论

你现在已经构建了一个从传感器开始，一直到生成经过验证且可追踪的检测结果为止的实时机器人感知系统。你所开发的这个系统能够处理图像采集、并行推理、多目标跟踪、基于置信度的检测结果验证，以及针对边缘设备进行优化的模型导出功能。

所有这些内容所传达的核心道理都是一样的：机器人的感知能力其实是一个系统层面的问题，而不是某个具体模型所能解决的问题。一个训练有素的模型固然必不可少，但仅仅拥有这样的模型还不够。在实际应用中，真正重要的是该系统能否正确处理各种时间安排问题、在负载增加时仍能保持稳定的运行状态、是否定义了各种故障情况，以及其架构是否能够清晰地划分各个功能模块，从而便于在现场进行调试和优化。