3D点云目标跟踪评价指标与代码详解

3D点云目标跟踪是自动驾驶、机器人导航等前沿领域的核心技术之一。为了精准评估各类跟踪算法的性能，需要构建一套科学、系统的评价指标体系。根据跟踪目标数量的不同，评价指标主要分为 单目标跟踪（SOT） 和 多目标跟踪（MOT） 两大类别。SOT 侧重于衡量单个目标的跟踪精确度与鲁棒性，而 MOT 则更加关注多目标场景下的完整性、一致性及轨迹管理能力。下面将逐一介绍这些常用指标，并附上完整的 Python 代码实现，便于开发者直接使用或二次开发。

一、单目标跟踪（SOT）常用评价指标

SOT 的评估核心在于预测框与真实框之间的空间重叠程度和中心位置偏差。以下是四个核心评价指标：

• 平均重叠率（Average Overlap Rate, AOR）：计算所有帧中预测框与真实框的 3D IoU 平均值。该值越高，说明预测框与真实框的重叠效果越好，跟踪精度越高。
• 平均中心误差（Average Center Error, ACE）：统计所有帧中预测框中心与真实框中心的 欧氏距离平均值。该值越小，表示中心定位越精准，跟踪稳定性越好。
• 成功率（Success Rate, SR）：IoU 超过设定阈值（如 0.5）的帧数占全部帧数的比例。通常会在多个阈值下计算，并绘制成功率曲线，以全面反映算法的重叠性能。
• 精确率（Precision Rate, PR）：中心距离小于设定阈值（如 1 米）的帧数占总帧数的比例。同样可通过绘制精度曲线，直观展示算法的定位精度表现。

二、多目标跟踪（MOT）常用评价指标

MOT 评估需要综合考量漏检、误检、ID 切换以及轨迹连续性等多维度因素。常见指标包括：

• 多目标跟踪精度（MOTA）：融合 漏检率、误检率和 ID 切换率 的综合指标，计算公式为 1 - (漏检数 + 误检数 + ID切换数) / 总真实数。该值越接近 1，表示跟踪系统的整体性能越优。
• 多目标跟踪精确度（MOTP）：统计所有成功匹配的预测框与真实框的 平均 IoU（或平均中心距离），主要用于衡量跟踪结果的位置精度。
• 跟踪长度（Track Length, TL）：每个目标被连续成功跟踪的帧数，该指标能够反映轨迹的连续性与稳定性。
• 跟踪片段（Track Fragment, TF）：每个目标在跟踪过程中被中断的次数，中断次数越少，说明轨迹的完整性越好。
• ID 切换率（ID Switch Rate, ISR）：每个目标被错误分配 ID 的次数，切换次数越少，表示身份保持能力越强。

三、评价指标代码实现

以下代码使用 Python 语言实现上述各项评价指标的计算。首先需要导入必要的库，并定义辅助函数，为后续指标计算奠定基础。

3.1 导入库与辅助函数

import numpy as np
from scipy.spatial.transform import Rotation as R
from scipy.optimize import linear_sum_assignment
from sklearn.metrics import pairwise_distances

关键辅助函数包括：

• 计算 3D IoU（iou_3d）：输入两个 7 维向量表示的边界框，输出两者之间的重叠比例。
• 边界框转顶点（box_to_corners）：将 7 维向量形式的边界框转换为 8 个顶点坐标。
• 欧氏距离（euclidean_distance）：计算两个 3D 空间点之间的直线距离。
• 数据关联（data_association）：采用匈牙利算法求解预测框与真实框之间的最优匹配。

# 计算两个3D边界框之间的重叠比例（IoU）
def iou_3d(box1, box2):
    # box1和box2都是7维向量，表示(x, y, z, w, l, h, yaw)
    # 其中(x, y, z)是中心点坐标，(w, l, h)是宽度、长度和高度，yaw是偏航角
    # 返回两个边界框之间的IoU值，范围在[0, 1]
    # 将边界框转换为8个顶点的矩阵
    box1_corners = box_to_corners(box1)
    box2_corners = box_to_corners(box2)
    # 计算两个边界框在每个轴上的投影区间
    box1_xmin = np.min(box1_corners[:, 0])
    box1_xmax = np.max(box1_corners[:, 0])
    box1_ymin = np.min(box1_corners[:, 1])
    box1_ymax = np.max(box1_corners[:, 1])
    box1_zmin = np.min(box1_corners[:, 2])
    box1_zmax = np.max(box1_corners[:, 2])
    box2_xmin = np.min(box2_corners[:, 0])
    box2_xmax = np.max(box2_corners[:, 0])
    box2_ymin = np.min(box2_corners[:, 1])
    box2_ymax = np.max(box2_corners[:, 1])
    box2_zmin = np.min(box2_corners[:, 2])
    box2_zmax = np.max(box2_corners[:, 2])
    # 计算两个边界框在每个轴上的交集区间
    inter_xmin = max(box1_xmin, box2_xmin)
    inter_xmax = min(box1_xmax, box2_xmax)
    inter_ymin = max(box1_ymin, box2_ymin)
    inter_ymax = min(box1_ymax, box2_ymax)
    inter_zmin = max(box1_zmin, box2_zmin)
    inter_zmax = min(box1_zmax, box2_zmax)
    # 如果没有交集，返回0
    if inter_xmax < inter_xmin or inter_ymax < inter_ymin or inter_zmax < inter_zmin:
        return 0.0
    # 计算交集区域的体积
    inter_vol = (inter_xmax - inter_xmin) * (inter_ymax - inter_ymin) * (inter_zmax - inter_zmin)
    # 计算两个边界框的体积
    box1_vol = (box1_xmax - box1_xmin) * (box1_ymax - box1_ymin) * (box1_zmax - box1_zmin)
    box2_vol = (box2_xmax - box2_xmin) * (box2_ymax - box2_ymin) * (box2_zmax - box2_zmin)
    # 计算并返回IoU值
    iou = inter_vol / (box1_vol + box2_vol - inter_vol)
    return iou

# 将7维向量表示的边界框转换为8个顶点的矩阵表示
def box_to_corners(box):
    # 输入是一个7维向量，表示(x, y, z, w, l, h, yaw)
    # 输出是一个8x3的矩阵，表示8个顶点的坐标
    # 提取边界框的参数
    x, y, z, w, l, h, yaw = box
    # 计算旋转矩阵
    rot = R.from_euler('z', yaw).as_matrix()
    # 计算边界框的中心点
    center = np.array([x, y, z])
    # 计算边界框的8个顶点的相对坐标
    x_corners = np.array([w, w, -w, -w, w, w, -w, -w]) / 2
    y_corners = np.array([l, -l, -l, l, l, -l, -l, l]) / 2
    z_corners = np.array([h, h, h, h, -h, -h, -h, -h]) / 2
    corners = np.vstack((x_corners, y_corners, z_corners))
    # 通过旋转和平移，将相对坐标转换为绝对坐标
    corners = np.dot(rot, corners).T + center
    return corners

# 计算两个3D点之间的欧氏距离
def euclidean_distance(point1, point2):
    # point1和point2都是3维向量，表示(x, y, z)
    # 返回两个点之间的欧氏距离
    # 计算两个点之间的差异向量
    diff = point1 - point2
    # 计算并返回欧氏距离
    dist = np.sqrt(np.sum(diff ** 2))
    return dist

# 使用匈牙利算法进行数据关联
def data_association(cost_matrix):
    # cost_matrix是一个m x n的矩阵，表示m个预测和n个观测之间的代价（如距离或者负IoU）
    # 返回一个长度为m的向量，表示每个预测匹配的观测的索引，如果没有匹配，则为-1
    # 使用scipy库中的linear_sum_assignment函数，求解最小化总代价的匹配方案
    row_ind, col_ind = linear_sum_assignment(cost_matrix)
    # 初始化匹配结果为-1
    matches = np.full(cost_matrix.shape[0], -1)
    # 将匹配方案赋值给匹配结果
    matches[row_ind] = col_ind
    return matches

小提示： 匈牙利算法要求代价矩阵为方形，但实际应用中预测与观测数量可能不相等。linear_sum_assignment 函数能够自动处理非方阵，返回的匹配结果允许部分预测或观测未匹配。匹配后未匹配的预测被视为误检（FP），未匹配的真实框则视为漏检（FN）。

3.2 SOT 评价指标计算函数

# 计算平均重叠率（AOR）
def a verage_overlap_rate(pred_boxes, gt_boxes):
    # pred_boxes是一个p x 7的矩阵，表示p个预测的3D边界框
    # gt_boxes是一个g x 7的矩阵，表示g个真实的3D边界框
    # 返回平均重叠率（AOR）值
    # 如果没有预测或真实边界框，返回0
    if pred_boxes.shape[0] == 0 or gt_boxes.shape[0] == 0:
        return 0.0
    # 计算预测和真实边界框之间的重叠比例矩阵，大小为p x g
    iou_matrix = np.zeros((pred_boxes.shape[0], gt_boxes.shape[0]))
    for i in range(pred_boxes.shape[0]):
        for j in range(gt_boxes.shape[0]):
            iou_matrix[i][j] = iou_3d(pred_boxes[i], gt_boxes[j])
    # 使用匈牙利算法进行数据关联，得到匹配结果
    matches = data_association(-iou_matrix)
    # 计算并返回平均重叠率（AOR）值
    aor = np.mean(iou_matrix[matches != -1])
    return aor

# 计算成功率（SR）
def success_rate(pred_boxes, gt_boxes, iou_threshold=0.5):
    # pred_boxes是一个p x 7的矩阵，表示p个预测的3D边界框
    # gt_boxes是一个g x 7的矩阵，表示g个真实的3D边界框
    # iou_threshold是一个浮点数，表示重叠比例的阈值，默认为0.5
    # 返回成功率（SR）值
    # 如果没有预测或真实边界框，返回0
    if pred_boxes.shape[0] == 0 or gt_boxes.shape[0] == 0:
        return 0.0
    # 计算预测和真实边界框之间的重叠比例矩阵，大小为p x g
    iou_matrix = np.zeros((pred_boxes.shape[0], gt_boxes.shape[0]))
    for i in range(pred_boxes.shape[0]):
        for j in range(gt_boxes.shape[0]):
            iou_matrix[i][j] = iou_3d(pred_boxes[i], gt_boxes[j])
    # 使用匈牙利算法进行数据关联，得到匹配结果
    matches = data_association(-iou_matrix)
    # 计算并返回成功率（SR）值
    sr = np.sum(iou_matrix[matches != -1] >= iou_threshold) / pred_boxes.shape[0]
    return sr

# 计算精确率（PR）
def precision_rate(pred_boxes, gt_boxes, dist_threshold=1.0):
    # pred_boxes是一个p x 7的矩阵，表示p个预测的3D边界框
    # gt_boxes是一个g x 7的矩阵，表示g个真实的3D边界框
    # dist_threshold是一个浮点数，表示中心点距离的阈值，默认为1.0
    # 返回精确率（PR）值
    # 如果没有预测或真实边界框，返回0
    if pred_boxes.shape[0] == 0 or gt_boxes.shape[0] == 0:
        return 0.0
    # 提取预测和真实边界框的中心点坐标
    pred_centers = pred_boxes[:, :3]
    gt_centers = gt_boxes[:, :3]
    # 计算预测和真实边界框之间的中心点距离矩阵，大小为p x g
    dist_matrix = pairwise_distances(pred_centers, gt_centers)
    # 使用匈牙利算法进行数据关联，得到匹配结果
    matches = data_association(dist_matrix)
    # 计算并返回精确率（PR）值
    pr = np.sum(dist_matrix[matches != -1] <= dist_threshold) / pred_boxes.shape[0]
    return pr

注意： 原文中 a verage_overlap_rate 函数内部存在笔误：最后一行应为 aor = np.mean(iou_matrix[matches != -1])，并返回 aor。以下已修正。

3.3 MOT 评价指标计算函数

# 计算多目标跟踪精度（MOTA）
def multiple_object_tracking_accuracy(pred_boxes, gt_boxes, iou_threshold=0.5):
    # pred_boxes是一个列表，长度为t，表示t个时间步的预测的3D边界框
    # gt_boxes是一个列表，长度为t，表示t个时间步的真实的3D边界框
    # iou_threshold是一个浮点数，表示重叠比例的阈值，默认为0.5
    # 返回多目标跟踪精度（MOTA）值
    # 如果没有预测或真实边界框，返回0
    if len(pred_boxes) == 0 or len(gt_boxes) == 0:
        return 0.0
    # 初始化漏检数、误检数、ID切换数和总真实数为0
    miss_count = 0
    false_count = 0
    switch_count = 0
    total_count = 0
    # 初始化上一时间步的匹配结果为空字典
    prev_matches = {}
    # 遍历每个时间步
    for t in range(len(pred_boxes)):
        # 获取当前时间步的预测和真实边界框
        pred_box = pred_boxes[t]
        gt_box = gt_boxes[t]
        # 计算当前时间步的真实边界框的数量，并累加到总真实数中
        total_count += gt_box.shape[0]
        # 如果当前时间步没有预测或真实边界框，跳过该时间步
        if pred_box.shape[0] == 0 or gt_box.shape[0] == 0:
            continue
        # 计算当前时间步的预测和真实边界框之间的重叠比例矩阵，大小为p x g
        iou_matrix = np.zeros((pred_box.shape[0], gt_box.shape[0]))
        for i in range(pred_box.shape[0]):
            for j in range(gt_box.shape[0]):
                iou_matrix[i][j] = iou_3d(pred_box[i], gt_box[j])
        # 使用匈牙利算法进行数据关联，得到匹配结果
        matches = data_association(-iou_matrix)
        # 初始化当前时间步的匹配结果为空字典
        curr_matches = {}
        # 遍历每个预测边界框
        for i in range(pred_box.shape[0]):
            # 如果没有匹配的真实边界框，或者重叠比例低于阈值，累加误检数，并跳过该预测边界框
            if matches[i] == -1 or iou_matrix[i][matches[i]] < iou_threshold:
                false_count += 1
                continue
            # 获取匹配的真实边界框的索引
            j = matches[i]
            # 如果上一时间步有匹配的真实边界框，并且ID不同，累加ID切换数
            if j in prev_matches and prev_matches[j] != i:
                switch_count += 1
            # 将当前的匹配结果保存到字典中
            curr_matches[j] = i
        # 遍历每个真实边界框
        for j in range(gt_box.shape[0]):
            # 如果没有匹配的预测边界框，累加漏检数
            if j not in curr_matches:
                miss_count += 1
        # 更新上一时间步的匹配结果为当前的匹配结果
        prev_matches = curr_matches
    # 计算并返回多目标跟踪精度（MOTA）值
    mota = 1 - (miss_count + false_count + switch_count) / total_count
    return mota

# 计算多目标跟踪精确度（MOTP）
def multiple_object_tracking_precision(pred_boxes, gt_boxes, iou_threshold=0.5):
    # pred_boxes是一个列表，长度为t，表示t个时间步的预测的3D边界框
    # gt_boxes是一个列表，长度为t，表示t个时间步的真实的3D边界框
    # iou_threshold是一个浮点数，表示重叠比例的阈值，默认为0.5
    # 返回多目标跟踪精确度（MOTP）值
    # 如果没有预测或真实边界框，返回0
    if len(pred_boxes) == 0 or len(gt_boxes) == 0:
        return 0.0
    # 初始化总匹配数和总重叠率为0
    match_count = 0
    sum_iou = 0.0
    # 遍历每个时间步
    for t in range(len(pred_boxes)):
        # 获取当前时间步的预测和真实边界框
        pred_box = pred_boxes[t]
        gt_box = gt_boxes[t]
        # 如果当前时间步没有预测或真实边界框，跳过该时间步
        if pred_box.shape[0] == 0 or gt_box.shape[0] == 0:
            continue
        # 计算当前时间步的预测和真实边界框之间的重叠比例矩阵，大小为p x g
        iou_matrix = np.zeros((pred_box.shape[0], gt_box.shape[0]))
        for i in range(pred_box.shape[0]):
            for j in range(gt_box.shape[0]):
                iou_matrix[i][j] = iou_3d(pred_box[i], gt_box[j])
        # 使用匈牙利算法进行数据关联，得到匹配结果
        matches = data_association(-iou_matrix)
        # 遍历每个预测边界框
        for i in range(pred_box.shape[0]):
            # 如果没有匹配的真实边界框，或者重叠比例低于阈值，跳过该预测边界框
            if matches[i] == -1 or iou_matrix[i][matches[i]] < iou_threshold:
                continue
            # 获取匹配的真实边界框的索引
            j = matches[i]
            # 累加匹配数和重叠率
            match_count += 1
            sum_iou += iou_matrix[i][j]
    # 计算并返回多目标跟踪精确度（MOTP）值
    motp = sum_iou / match_count
    return motp

# 计算跟踪长度（TL）
def track_length(pred_boxes, gt_boxes, iou_threshold=0.5):
    # pred_boxes是一个列表，长度为t，表示t个时间步的预测的3D边界框
    # gt_boxes是一个列表，长度为t，表示t个时间步的真实的3D边界框
    # iou_threshold是一个浮点数，表示重叠比例的阈值，默认为0.5
    # 返回一个字典，键为真实目标的ID，值为对应的跟踪长度
    # 如果没有预测或真实边界框，返回空字典
    if len(pred_boxes) == 0 or len(gt_boxes) == 0:
        return {}
    # 初始化跟踪长度字典为空字典
    tl_dict = {}
    # 遍历每个时间步
    for t in range(len(pred_boxes)):
        # 获取当前时间步的预测和真实边界框
        pred_box = pred_boxes[t]
        gt_box = gt_boxes[t]
        # 如果当前时间步没有预测或真实边界框，跳过该时间步
        if pred_box.shape[0] == 0 or gt_box.shape[0] == 0:
            continue
        # 计算当前时间步的预测和真实边界框之间的重叠比例矩阵，大小为p x g
        iou_matrix = np.zeros((pred_box.shape[0], gt_box.shape[0]))
        for i in range(pred_box.shape[0]):
            for j in range(gt_box.shape[0]):
                iou_matrix[i][j] = iou_3d(pred_box[i], gt_box[j])
        # 使用匈牙利算法进行数据关联，得到匹配结果
        matches = data_association(-iou_matrix)
        # 遍历每个预测边界框
        for i in range(pred_box.shape[0]):
            # 如果没有匹配的真实边界框，或者重叠比例低于阈值，跳过该预测边界框
            if matches[i] == -1 or iou_matrix[i][matches[i]] < iou_threshold:
                continue
            # 获取匹配的真实边界框的索引
            j = matches[i]
            # 如果真实目标的ID已经在跟踪长度字典中，累加1
            if j in tl_dict:
                tl_dict[j] += 1
            # 否则，初始化为1
            else:
                tl_dict[j] = 1
    # 返回跟踪长度字典
    return tl_dict

# 计算跟踪片段（TF）
def track_fragment(pred_boxes, gt_boxes, iou_threshold=0.5):
    # pred_boxes是一个列表，长度为t，表示t个时间步的预测的3D边界框
    # gt_boxes是一个列表，长度为t，表示t个时间步的真实的3D边界框
    # iou_threshold是一个浮点数，表示重叠比例的阈值，默认为0.5
    # 返回一个字典，键为真实目标的ID，值为对应的跟踪片段数
    # 如果没有预测或真实边界框，返回空字典
    if len(pred_boxes) == 0 or len(gt_boxes) == 0:
        return {}
    # 初始化跟踪片段字典为空字典
    tf_dict = {}
    # 初始化上一时间步的匹配结果为空字典
    prev_matches = {}
    # 遍历每个时间步
    for t in range(len(pred_boxes)):
        # 获取当前时间步的预测和真实边界框
        pred_box = pred_boxes[t]
        gt_box = gt_boxes[t]
        # 如果当前时间步没有预测或真实边界框，跳过该时间步
        if pred_box.shape[0] == 0 or gt_box.shape[0] == 0:
            continue
        # 计算当前时间步的预测和真实边界框之间的重叠比例矩阵，大小为p x g
        iou_matrix = np.zeros((pred_box.shape[0], gt_box.shape[0]))
        for i in range(pred_box.shape[0]):
            for j in range(gt_box.shape[0]):
                iou_matrix[i][j] = iou_3d(pred_box[i], gt_box[j])
        # 使用匈牙利算法进行数据关联，得到匹配结果
        matches = data_association(-iou_matrix)
        # 初始化当前时间步的匹配结果为空字典
        curr_matches = {}
        # 遍历每个预测边界框
        for i in range(pred_box.shape[0]):
            # 如果没有匹配的真实边界框，或者重叠比例低于阈值，跳过该预测边界框
            if matches[i] == -1 or iou_matrix[i][matches[i]] < iou_threshold:
                continue
            # 获取匹配的真实边界框的索引
            j = matches[i]
            # 将当前的匹配结果保存到字典中
            curr_matches[j] = i
            # 如果真实目标的ID已经在跟踪片段字典中，且上一时间步没有匹配该目标，累加1
            if j in tf_dict and j not in prev_matches:
                tf_dict[j] += 1
            # 否则，初始化为1
            elif j not in tf_dict:
                tf_dict[j] = 1
        # 更新上一时间步的匹配结果为当前的匹配结果
        prev_matches = curr_matches
    # 返回跟踪片段字典
    return tf_dict

# 计算ID切换率（ISR）
def id_switch_rate(pred_boxes, gt_boxes, iou_threshold=0.5):
    # pred_boxes是一个列表，长度为t，表示t个时间步的预测的3D边界框
    # gt_boxes是一个列表，长度为t，表示t个时间步的真实的3D边界框
    # iou_threshold是一个浮点数，表示重叠比例的阈值，默认为0.5
    # 返回一个字典，键为真实目标的ID，值为对应的ID切换次数
    # 如果没有预测或真实边界框，返回空字典
    if len(pred_boxes) == 0 or len(gt_boxes) == 0:
        return {}
    # 初始化ID切换率字典为空字典
    isr_dict = {}
    # 初始化上一时间步的匹配结果为空字典
    prev_matches = {}
    # 遍历每个时间步
    for t in range(len(pred_boxes)):
        # 获取当前时间步的预测和真实边界框
        pred_box = pred_boxes[t]
        gt_box = gt_boxes[t]
        # 如果当前时间步没有预测或真实边界框，跳过该时间步
        if pred_box.shape[0] == 0 or gt_box.shape[0] == 0:
            continue
        # 计算当前时间步的预测和真实边界框之间的重叠比例矩阵，大小为p x g
        iou_matrix = np.zeros((pred_box.shape[0], gt_box.shape[0]))
        for i in range(pred_box.shape[0]):
            for j in range(gt_box.shape[0]):
                iou_matrix[i][j] = iou_3d(pred_box[i], gt_box[j])
        # 使用匈牙利算法进行数据关联，得到匹配结果
        matches = data_association(-iou_matrix)
        # 初始化当前时间步的匹配结果为空字典
        curr_matches = {}
        # 遍历每个预测边界框
        for i in range(pred_box.shape[0]):
            # 如果没有匹配的真实边界框，或者重叠比例低于阈值，跳过该预测边界框
            if matches[i] == -1 or iou_matrix[i][matches[i]] < iou_threshold:
                continue
            # 获取匹配的真实边界框的索引
            j = matches[i]
            # 将当前的匹配结果保存到字典中
            curr_matches[j] = i
            # 如果上一时间步有匹配的真实边界框，并且ID不同，累加1
            if j in prev_matches and prev_matches[j] != i:
                # 如果真实目标的ID已经在ID切换率字典中，累加1
                if j in isr_dict:
                    isr_dict[j] += 1
                # 否则，初始化为1
                else:
                    isr_dict[j] = 1
        # 更新上一时间步的匹配结果为当前的匹配结果
        prev_matches = curr_matches
    # 返回ID切换率字典
    return isr_dict

四、常见问题与提示

常见问题 1：如何选择合适的 IoU 阈值？

在 SOT 的 SR 指标以及 MOT 的 MOTA/MOTP 指标中，通常将 IoU 阈值设为 0.5（即 50% 重叠）。实际应用时，可以根据任务对精度的具体要求灵活调整：高精度场景（如自动驾驶环境感知）可选用 0.7，而宽松场景则可设为 0.3。建议绘制不同阈值下的性能曲线（如成功率曲线、精度曲线），对算法进行综合评估，以获得更全面的性能画像。

常见问题 2：匈牙利算法为什么用于数据关联？

在多目标跟踪任务中，每个时间步内通常存在多个预测框和多个真实框，需要找到最优的一对一匹配方案，使得总代价最小（例如负 IoU 最小，即 IoU 最大）。匈牙利算法能够高效求解此类分配问题，确保每个预测框最多匹配一个真实框，反之亦然。未匹配的预测框被视为误检（FP），未匹配的真实框则被视为漏检（FN），从而为后续指标计算提供可靠的匹配依据。

常见问题 3：MOTA 值可能为负数吗？

是的，完全可能。当漏检、误检和 ID 切换的总和超过总真实框数量时，MOTA 值会小于 0。这意味着跟踪算法几乎无法正确完成目标跟踪任务。理想情况下，MOTA 值应接近 1，但在实际应用中，该值通常分布在 0.5~0.9 之间，具体取决于场景复杂度和算法性能。

小提示：数据预处理建议

• 确保预测框和真实框的数据格式保持一致：均采用 [x, y, z, w, l, h, yaw] 形式，其中 yaw 角符合右手坐标系定义。
• 对于多时间步数据，请将每个时间步的边界框组织为 (N, 7) 的二维数组，并将所有时间步的数据统一放入一个列表中。
• 如果目标数量较多，建议对 IoU 计算进行向量化优化（例如利用 numpy 广播机制），以有效减少双重循环带来的计算开销。

以上就是 3D 点云目标跟踪中常见的评价指标及其完整的代码实现。希望这份教程能够帮助你更清晰地理解各项指标的含义，并正确运用代码评估自己的跟踪算法，从而推动算法性能的持续提升。

作者：大森林 编辑：黄飞