3D点云目标跟踪的评价指标，可以根据跟踪的目标是单个还是多个，分为单目标跟踪（SOT）和多目标跟踪（MOT）两种。一般来说，SOT的评价指标主要关注跟踪的准确性和鲁棒性，而MOT的评价指标则需要考虑跟踪的完整性和一致性。
SOT的常用评价指标有：
- 平均重叠率（Average Overlap Rate, AOR）：表示预测的3D边界框与真实的3D边界框之间的重叠比例的平均值。
- 平均中心误差（Average Center Error, ACE）：表示预测的3D边界框与真实的3D边界框之间的中心点距离的平均值。
- 成功率（Success Rate, SR）：表示预测的3D边界框与真实的3D边界框之间的重叠比例超过某个阈值（如0.5）的帧数占总帧数的比例。
- 精确率（Precision Rate, PR）：表示预测的3D边界框与真实的3D边界框之间的中心点距离小于某个阈值（如1米）的帧数占总帧数的比例。
MOT的常用评价指标有：
- 多目标跟踪精度（Multiple Object Tracking Accuracy, MOTA）：综合考虑了漏检率、误检率和ID切换率对跟踪精度的影响。
- 多目标跟踪精确度（Multiple Object Tracking Precision, MOTP）：表示预测的3D边界框与真实的3D边界框之间的重叠比例或中心点距离的平均值。
- 跟踪长度（Track Length, TL）：表示每个目标被成功跟踪的帧数。
- 跟踪片段（Track Fragment, TF）：表示每个目标被中断跟踪的次数。
- ID切换率（ID Switch Rate, ISR）：表示每个目标被错误地分配给另一个ID或从另一个ID切换过来的次数。
评价指标详细代码：
首先，我们需要导入一些必要的库，如numpy, scipy和sklearn。然后，我们需要定义一些辅助函数，如计算两个3D边界框之间的重叠比例（IoU），计算两个3D点之间的欧氏距离，以及使用匈牙利算法进行数据关联。
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）
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- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
- 36.
- 37.
- 38.
- 39.
- 40.
- 41.
- 42.
- 43.
- 44.
- 45.
- 46.
- 47.
- 48.
- 49.
- 50.
- 51.
- 52.
- 53.
- 54.
- 55.
- 56.
- 57.
- 58.
- 59.
- 60.
- 61.
- 62.
- 63.
- 64.
- 65.
- 66.
- 67.
- 68.
- 69.
- 70.
- 71.
- 72.
- 73.
- 74.
- 75.
- 76.
- 77.
- 78.
- 79.
- 80.
- 81.
- 82.
- 83.
- 84.
- 85.
- 86.
- 87.
- 88.
- 89.
- 90.
- 91.
- 92.
- 93.
- 94.
- 95.
- 96.
- 97.
- 98.
- 99.
- 100.
- 101.
- 102.
- 103.
- 104.
- 105.
接下来，我们需要定义一些评价指标的计算函数，如AOR，ACE，SR，PR，MOTA，MOTP，TL，TF，ISR等。我们已经有了预测的3D边界框和真实的3D边界框的列表，以及每个边界框的置信度得分。我们还需要定义一些阈值，如重叠比例阈值（iou_threshold），中心点距离阈值（dist_threshold），置信度得分阈值（score_threshold）等，这些阈值将在代码中具体给出。
# 计算平均重叠率（AOR）
def average_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）值
ace = np.mean(dist_matrix[matches != -1])
return ace
# 计算成功率（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
# 计算多目标跟踪精度（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.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
- 20.
- 21.
- 22.
- 23.
- 24.
- 25.
- 26.
- 27.
- 28.
- 29.
- 30.
- 31.
- 32.
- 33.
- 34.
- 35.
- 36.
- 37.
- 38.
- 39.
- 40.
- 41.
- 42.
- 43.
- 44.
- 45.
- 46.
- 47.
- 48.
- 49.
- 50.
- 51.
- 52.
- 53.
- 54.
- 55.
- 56.
- 57.
- 58.
- 59.
- 60.
- 61.
- 62.
- 63.
- 64.
- 65.
- 66.
- 67.
- 68.
- 69.
- 70.
- 71.
- 72.
- 73.
- 74.
- 75.
- 76.
- 77.
- 78.
- 79.
- 80.
- 81.
- 82.
- 83.
- 84.
- 85.
- 86.
- 87.
- 88.
- 89.
- 90.
- 91.
- 92.
- 93.
- 94.
- 95.
- 96.
- 97.
- 98.
- 99.
- 100.
- 101.
- 102.
- 103.
- 104.
- 105.
- 106.
- 107.
- 108.
- 109.
- 110.
- 111.
- 112.
- 113.
- 114.
- 115.
- 116.
- 117.
- 118.
- 119.
- 120.
- 121.
- 122.
- 123.
- 124.
- 125.
- 126.
- 127.
- 128.
- 129.
- 130.
- 131.
- 132.
- 133.
- 134.
- 135.
- 136.
- 137.
- 138.
- 139.
- 140.
- 141.
- 142.
- 143.
- 144.
- 145.
- 146.
- 147.
- 148.
- 149.
- 150.
- 151.
- 152.
- 153.
- 154.
- 155.
- 156.
- 157.
- 158.
- 159.
- 160.
- 161.
- 162.
- 163.
- 164.
- 165.
- 166.
- 167.
- 168.
- 169.
- 170.
- 171.
- 172.
- 173.
- 174.
- 175.
- 176.
- 177.
- 178.
- 179.
- 180.
- 181.
- 182.
- 183.
- 184.
- 185.
- 186.
- 187.
- 188.
- 189.
- 190.
- 191.
- 192.
- 193.
- 194.
- 195.
- 196.
- 197.
- 198.
- 199.
- 200.
- 201.
- 202.
- 203.
- 204.
- 205.
- 206.
- 207.
- 208.
- 209.
- 210.
- 211.
- 212.
- 213.
- 214.
- 215.
- 216.
- 217.
- 218.
- 219.
- 220.
- 221.
- 222.
- 223.
- 224.
- 225.
- 226.
- 227.
- 228.
- 229.
- 230.
- 231.
- 232.
- 233.
- 234.
- 235.
- 236.
- 237.
- 238.
- 239.
- 240.
- 241.
- 242.
- 243.
- 244.
- 245.
- 246.
- 247.
- 248.
- 249.
- 250.
- 251.
- 252.
- 253.
- 254.
- 255.
- 256.
- 257.
- 258.
- 259.
- 260.
- 261.
- 262.
- 263.
- 264.
- 265.
- 266.
- 267.
- 268.
- 269.
- 270.
- 271.
- 272.
- 273.
- 274.
- 275.
- 276.
- 277.
- 278.
- 279.
- 280.
- 281.
- 282.
- 283.
- 284.
- 285.
- 286.
- 287.
- 288.
- 289.
- 290.
- 291.
- 292.
- 293.
- 294.
- 295.
- 296.
- 297.
- 298.
- 299.
- 300.
- 301.
- 302.
- 303.
- 304.
- 305.
- 306.
- 307.
- 308.
- 309.
- 310.
- 311.
- 312.
- 313.
- 314.
- 315.
- 316.
- 317.
- 318.
- 319.
- 320.
- 321.
- 322.
- 323.
- 324.
- 325.
- 326.
- 327.
- 328.
- 329.
- 330.
- 331.
- 332.
- 333.
- 334.
- 335.
- 336.
- 337.
- 338.
- 339.
- 340.
- 341.
- 342.
- 343.
- 344.
- 345.
- 346.
- 347.
- 348.
- 349.
- 350.
- 351.
- 352.
- 353.
- 354.
- 355.
- 356.
- 357.
- 358.
- 359.
- 360.
- 361.
- 362.
- 363.
- 364.
- 365.
- 366.
- 367.
- 368.
- 369.
- 370.
- 371.
- 372.
- 373.
- 374.
- 375.
- 376.
- 377.
- 378.
- 379.
- 380.
396
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
