add annotations

single_people_detect_track.py

@@ -976,44 +976,54 @@ tracking_initialized = False
 lost_frame_count = 0
 lost_frame_threshold = 12  # 0.5秒，假设20fps
 
+
+# ===================== 主循环：逐帧处理检测与跟踪 =====================
 while True:
     # 重新梳理跟踪逻辑，保证唯一目标、唯一初始化、鲁棒丢失判定
     try:
+        # 获取下一个时间步的所有相机检测结果
         detections = next(sync_gen)
+        # 过滤低置信度的检测，提升后续三角化和跟踪的准确性
         detections = filter_keypoints_by_scores(detections, threshold=0.5)
     except StopIteration:
+        # 检测数据读取完毕，退出主循环
         break
 
     # 1. 检查当前是否有已初始化的跟踪目标
+    # 跟踪目标按id排序，便于后续一致性处理
     trackings: list[Tracking] = sorted(
         global_tracking_state.trackings.values(), key=lambda x: x.id
     )
 
+    # ========== 跟踪目标初始化流程 ==========
     if not tracking_initialized:
-        # 只初始化一次
+        # 只初始化一次跟踪目标，防止多次重复初始化
-        camera_port_this = filter_camera_port(detections)
+        camera_port_this = filter_camera_port(detections)  # 获取当前帧检测到的相机端口
+        # 如果检测到的相机数量小于总机位数-1，则认为初始化条件不满足，跳过本帧
         if len(camera_port_this) < len(camera_port) - 1:
             print(
                 "init tracking error, filter_detections len:",
                 len(camera_port_this),
             )
             continue
+        # 满足条件后，初始化全局跟踪状态，添加跟踪目标
         global_tracking_state.add_tracking(detections)
-        tracking_initialized = True
+        tracking_initialized = True  # 标记已初始化
-        lost_frame_count = 0
+        lost_frame_count = 0  # 丢失帧计数器归零
-        # 保留第一帧的3d姿态数据
+        # 保留第一帧的3d姿态数据，按id存储到all_3d_kps字典
         for element_tracking in global_tracking_state.trackings.values():
             if str(element_tracking.id) not in all_3d_kps.keys():
                 all_3d_kps[str(element_tracking.id)] = [
                     element_tracking.state.keypoints.tolist()
                 ]
         print("init tracking:", global_tracking_state.trackings.values())
-        continue
+        continue  # 跳过本帧后续处理，进入下一帧
 
-    # tracking_initialized = True
+    # ========== 丢失目标处理 ==========
     if len(detections) == 0:
+        # 当前帧没有检测到目标，进入丢失计数逻辑
         print("no detections in this frame, continue")
-        lost_frame_count += 1
+        lost_frame_count += 1  # 丢失帧数+1
         # 进一步完善退出条件：
         # 1. 连续丢失阈值帧后才退出
         # 2. 若丢失时，最后一次检测到的时间与当前帧时间间隔超过1秒，才彻底退出
@@ -1022,18 +1032,19 @@ while True:
             last_tracking = list(global_tracking_state.trackings.values())[0]
         if lost_frame_count >= lost_frame_threshold:
             should_remove = True
-            # 可选：可加时间间隔判定
+            # 可选：可加时间间隔判定（可扩展）
             if should_remove:
-                global_tracking_state._trackings.clear()
+                global_tracking_state._trackings.clear()  # 清空所有跟踪目标
-                tracking_initialized = False
+                tracking_initialized = False  # 允许后续重新初始化
                 print(
                     f"tracking lost after {lost_frame_count} frames, reset tracking state"
                 )
-                lost_frame_count = 0
+                lost_frame_count = 0  # 丢失计数归零
-        continue
+        continue  # 跳过本帧后续处理
 
-    # 有检测，正常跟踪
+    # ========== 正常跟踪流程 ==========
-    lost_frame_count = 0
+    lost_frame_count = 0  # 检测到目标，丢失计数归零
+    # 计算当前帧所有跟踪目标与检测目标的相似度矩阵（多机位）
     affinities: dict[str, AffinityResult] = calculate_affinity_matrix(
         trackings,
         detections,
@@ -1044,13 +1055,13 @@ while True:
         lambda_a=LAMBDA_A,
     )
     for element_tracking in trackings:
-        tracking_detection = []
+        tracking_detection = []  # 存储每个跟踪目标在各相机下最优匹配的检测
-        temp_matrix = []
+        temp_matrix = []  # 打印用：每个相机的最大相似度
         for camera_name in affinities.keys():
             camera_matrix = jnp.array(affinities[camera_name].matrix).flatten()
-            detection_index = jnp.argmax(camera_matrix).item()
+            detection_index = jnp.argmax(camera_matrix).item()  # 取最大相似度的检测索引
             if isnan(camera_matrix[detection_index].item()):
-                breakpoint()
+                breakpoint()  # 出现异常时调试
             temp_matrix.append(
                 f"{camera_name} : {camera_matrix[detection_index].item()}"
             )
@@ -1060,8 +1071,10 @@ while True:
                 affinities[camera_name].detections[detection_index]
             )
         print("affinities matrix:", temp_matrix)
+        # 只有匹配到足够多的检测目标时才更新跟踪（如多于2个相机）
         if len(tracking_detection) > 2:
             update_tracking(element_tracking, tracking_detection)
+            # 记录每一帧的3d关键点结果
             all_3d_kps[str(element_tracking.id)].append(
                 element_tracking.state.keypoints.tolist()
             )