修改聚类参数

models/.DS_Store

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49618902cea3b65197edab1b87a9814144c76a88ed7f3e79b31c153418e861a4
+size 6148

src/gait_analyze.py

@@ -9,6 +9,7 @@ import matplotlib.pyplot as plt
 from matplotlib.patches import Rectangle
 import seaborn as sns
 import os
+import logging
 
 @dataclass
 class GaitPrint:
@@ -36,9 +37,14 @@ class GaitAnalyzer:
         self.mice_positions: List[Dict] = []  # 现在存储pose关键点信息
         self.params = {}
         self.time_window = 0.2
-        self.distance_threshold = 30
+        self.distance_threshold = 5
         self.gait_pattern = None
         self.result_dir = self._create_result_dir()
+        
+        # 添加 logger
+        self.logger = logging.getLogger(__name__)
+        
+        self.fps = 120  # 添加 fps 属性，默认值为 120
     
     def _detect_mouse_time_range(self, video_path: str, margin_ratio: float = 0.05) -> Tuple[float, float]:
         """使用pose模型的鼻子和尾巴点来检测老鼠"""
@@ -122,38 +128,103 @@ class GaitAnalyzer:
             from sklearn.preprocessing import StandardScaler
             from sklearn.cluster import DBSCAN
             
-            # 1. 准备数据
-            features = np.array([[p.x, p.y, p.timestamp * 30] for p in self.gait_prints])
+            # 1. 准备数据 - 调整时间权重
+            time_weight = 0.2  # 减小时间维度的权重
+            features = np.array([
+                [p.x, p.y, p.timestamp * self.fps * time_weight] 
+                for p in self.gait_prints
+            ])
             print(f"开始聚类，原始足印数量: {len(features)}")
             
             # 2. 标准化特征
             scaler = StandardScaler()
             features_scaled = scaler.fit_transform(features)
             
-            # 3. DBSCAN聚类
-            eps = 0.3  # 可以根据实际情况调整
-            min_samples = 1  # 设为1以保留所有检测
+            # 3. 计算合适的eps
+            from sklearn.neighbors import NearestNeighbors
+            k = min(len(features), 5)
+            nbrs = NearestNeighbors(n_neighbors=k).fit(features_scaled)
+            distances, _ = nbrs.kneighbors(features_scaled)
+            mean_dist = np.mean(distances[:, 1:])
+            
+            # 设置更大的eps以获得更合适的聚类
+            eps = mean_dist * 3.0  # 增大eps
+            
+            # 放宽最小样本数要求
+            min_samples = max(int(0.02 * self.fps), 2)  # 降低持续时间要求到0.02秒
+            
+            print(f"聚类参数: eps={eps:.3f}, min_samples={min_samples}")
+            
+            # 4. DBSCAN聚类
             dbscan = DBSCAN(eps=eps, min_samples=min_samples)
             cluster_labels = dbscan.fit_predict(features_scaled)
             
-            # 4. 将聚类结果添加到足印对象中
+            # 5. 评估聚类结果
+            n_clusters = len(set(cluster_labels)) - (1 if -1 in cluster_labels else 0)
+            n_noise = list(cluster_labels).count(-1)
+            
+            print(f"\n聚类结果:")
+            print(f"- 识别出的独立足印数: {n_clusters}")
+            print(f"- 噪声点数量: {n_noise} ({n_noise/len(features)*100:.1f}%)")
+            
+            # 6. 如果聚类数量不合理，调整参数重试
+            if n_clusters < 12 or n_clusters > 24:  # 期望12-24个足印
+                print("\n尝试调整参数...")
+                for eps_factor in [2.0, 2.5, 3.0]:  # 尝试更大的eps值
+                    new_eps = mean_dist * eps_factor
+                    dbscan = DBSCAN(eps=new_eps, min_samples=min_samples)
+                    new_labels = dbscan.fit_predict(features_scaled)
+                    new_n_clusters = len(set(new_labels)) - (1 if -1 in new_labels else 0)
+                    new_n_noise = list(new_labels).count(-1)
+                    
+                    print(f"eps={new_eps:.3f}: {new_n_clusters} 簇, {new_n_noise} 噪声点")
+                    
+                    if 12 <= new_n_clusters <= 24:
+                        print(f"使用新参数: eps={new_eps:.3f}")
+                        cluster_labels = new_labels
+                        break
+            
+            # 7. 更新足印对象
             for print_obj, label in zip(self.gait_prints, cluster_labels):
                 print_obj.cluster_id = label
             
-            # 打印聚类统计信息
-            n_clusters = len(set(cluster_labels)) - (1 if -1 in cluster_labels else 0)
-            print(f"聚类完成! 共识别出 {n_clusters} 个独立足印")
-            
-            # 按cluster_id分组并打印每组的大小
+            # 8. 打印统计信息
             from collections import Counter
             cluster_sizes = Counter(cluster_labels)
             print("\n各组足印检测数量:")
             for cluster_id, size in sorted(cluster_sizes.items()):
                 if cluster_id != -1:
-                    print(f"足印 #{cluster_id}: {size}个检测")
+                    cluster_prints = [p for p in self.gait_prints if p.cluster_id == cluster_id]
+                    time_span = max(p.timestamp for p in cluster_prints) - min(p.timestamp for p in cluster_prints)
+                    print(f"足印 #{cluster_id}: {size}个检测, 持续时间: {time_span:.3f}s")
             
         except Exception as e:
             print(f"聚类过程出错: {str(e)}")
+            raise
+
+    def _visualize_clusters(self, features, labels):
+        """可视化聚类结果"""
+        try:
+            import matplotlib.pyplot as plt
+            
+            plt.figure(figsize=(12, 8))
+            
+            # 绘制散点图
+            scatter = plt.scatter(features[:, 0], features[:, 1], 
+                                c=labels, cmap='rainbow',
+                                alpha=0.6)
+            
+            plt.colorbar(scatter)
+            plt.title('足印聚类结果')
+            plt.xlabel('X坐标')
+            plt.ylabel('Y坐标')
+            
+            # 保存图片
+            plt.savefig(os.path.join(self.result_dir, 'plots', 'cluster_visualization.png'))
+            plt.close()
+            
+        except Exception as e:
+            print(f"可视化过程出错: {str(e)}")
 
     def _post_process_footprints(self):
         """后处理足迹数据：聚类、过滤和分类"""
@@ -179,113 +250,141 @@ class GaitAnalyzer:
         # 4. 确定步态周期
         self._determine_gait_cycles()
 
-    def _classify_footprints(self, moving_right: bool):
-        """使用pose关键点来分类足迹"""
-        if len(self.gait_prints) < 4 or not self.mice_positions:
-            print("警告：足迹或姿态数据不足")
-            return
-
-        # 按时间排序足印
-        sorted_prints = sorted(self.gait_prints, key=lambda p: p.timestamp)
+    def _classify_footprints(self, moving_right=True):
+        """基于姿态关键点对足印簇进行分类
         
-        # 对每个cluster进行分类
-        cluster_groups = {}
-        for p in sorted_prints:
-            if p.cluster_id not in cluster_groups:
-                cluster_groups[p.cluster_id] = []
-            cluster_groups[p.cluster_id].append(p)
-
-        # 对每个cluster，找到最近时间的pose数据
-        for cluster_id, prints in cluster_groups.items():
-            mid_time = np.mean([p.timestamp for p in prints])
-            closest_pose = min(self.mice_positions, 
-                             key=lambda m: abs(m['timestamp'] - mid_time))
+        Args:
+            moving_right: bool, 老鼠是否向右移动，影响左右判定
+        """
+        self.logger.info("开始基于姿态关键点对足印簇进行分类...")
+        
+        # 1. 首先获取所有足印簇
+        clusters = {}
+        for print in self.gait_prints:
+            if print.cluster_id not in clusters:
+                clusters[print.cluster_id] = []
+            clusters[print.cluster_id].append(print)
+        
+        # 2. 对每个足印簇进行分类
+        for cluster_id, prints in clusters.items():
+            # 计算簇的中心点
+            cluster_x = np.mean([p.x for p in prints])
+            cluster_y = np.mean([p.y for p in prints])
+            
+            # 找到时间上最接近的姿态关键点帧
+            closest_pose = None
+            min_time_diff = float('inf')
             
-            if 'keypoints' not in closest_pose:
-                print(f"警告：时间戳 {mid_time:.2f}s 处的姿态数据缺少关键点信息")
+            # 使用簇中第一个足印的时间戳
+            cluster_time = prints[0].timestamp
+            
+            for pose in self.mice_positions:
+                if 'keypoints' not in pose:
+                    continue
+                time_diff = abs(pose['timestamp'] - cluster_time)
+                if time_diff < min_time_diff:
+                    min_time_diff = time_diff
+                    closest_pose = pose
+            
+            if not closest_pose or 'keypoints' not in closest_pose:
+                self.logger.warning(f"簇 {cluster_id} 未找到对应的姿态关键点")
                 continue
             
-            # 计算cluster中心位置
-            center_x = np.mean([p.x for p in prints])
-            center_y = np.mean([p.y for p in prints])
-            
-            # 获取关键点位置
-            nose = closest_pose['keypoints']['nose']
-            re = closest_pose['keypoints']['right_ear']
-            le = closest_pose['keypoints']['left_ear']
-            mid = closest_pose['keypoints']['mid']
-            rl = closest_pose['keypoints']['right_leg']
-            ll = closest_pose['keypoints']['left_leg']
-            tail = closest_pose['keypoints']['tail_base']
-            
-            # 计算到各关键点的距离
-            dist_to_front = min(
-                np.sqrt((center_x - nose[0])**2 + (center_y - nose[1])**2),
-                np.sqrt((center_x - re[0])**2 + (center_y - re[1])**2),
-                np.sqrt((center_x - le[0])**2 + (center_y - le[1])**2)
-            )
-            
-            dist_to_back = min(
-                np.sqrt((center_x - rl[0])**2 + (center_y - rl[1])**2),
-                np.sqrt((center_x - ll[0])**2 + (center_y - ll[1])**2),
-                np.sqrt((center_x - tail[0])**2 + (center_y - tail[1])**2)
-            )
-            
-            # 前后判断：比较到前后关键点的距离
-            is_front = dist_to_front < dist_to_back
-            
-            # 左右判断：根据y坐标相对位置
-            if is_front:
-                is_left = center_y > (re[1] + le[1])/2  # 比较与耳朵中点的位置
+            # 3. 提取关键点
+            kpts = closest_pose['keypoints']
+            nose = np.array([kpts['nose'][0], kpts['nose'][1]])
+            right_ear = np.array([kpts['right_ear'][0], kpts['right_ear'][1]])
+            left_ear = np.array([kpts['left_ear'][0], kpts['left_ear'][1]])
+            mid = np.array([kpts['mid'][0], kpts['mid'][1]])
+            right_leg = np.array([kpts['right_leg'][0], kpts['right_leg'][1]])
+            left_leg = np.array([kpts['left_leg'][0], kpts['left_leg'][1]])
+            tail_base = np.array([kpts['tail_base'][0], kpts['tail_base'][1]])
+            
+            cluster_pos = np.array([cluster_x, cluster_y])
+            
+            # 4. 计算距离特征
+            distances = {
+                'nose': np.linalg.norm(cluster_pos - nose),
+                'right_ear': np.linalg.norm(cluster_pos - right_ear),
+                'left_ear': np.linalg.norm(cluster_pos - left_ear),
+                'mid': np.linalg.norm(cluster_pos - mid),
+                'right_leg': np.linalg.norm(cluster_pos - right_leg),
+                'left_leg': np.linalg.norm(cluster_pos - left_leg),
+                'tail_base': np.linalg.norm(cluster_pos - tail_base)
+            }
+            
+            # 5. 计算前后特征
+            front_score = (distances['nose'] + distances['right_ear'] + distances['left_ear']) / 3
+            back_score = (distances['right_leg'] + distances['left_leg'] + distances['tail_base']) / 3
+            
+            # 6. 计算左右特征
+            # 考虑到底部视角：右侧(上方)特征点包括右耳和右腿，左侧(下方)特征点包括左耳和左腿
+            right_score = (distances['right_ear'] + distances['right_leg']) / 2
+            left_score = (distances['left_ear'] + distances['left_leg']) / 2
+            
+            # 7. 分类决策
+            is_front = front_score < back_score
+            # 根据移动方向调整左右判定
+            if moving_right:
+                is_right = right_score < left_score
             else:
-                is_left = center_y > (rl[1] + ll[1])/2  # 比较与后腿中点的位置
+                is_right = left_score < right_score
             
-            # 确定爪子类型
-            paw_type = None
+            # 8. 分配爪子类型
+            paw_type = ''
             if is_front:
-                paw_type = 'LF' if is_left else 'RF'
+                if is_right:
+                    paw_type = 'RF'  # 右前爪
+                else:
+                    paw_type = 'LF'  # 左前爪
             else:
-                paw_type = 'LH' if is_left else 'RH'
+                if is_right:
+                    paw_type = 'RH'  # 右后爪
+                else:
+                    paw_type = 'LH'  # 左后爪
             
-            # 应用分类结果
-            for p in prints:
-                p.paw_type = paw_type
-
-        # 按帧组织足印数据，用于时序一致性检查
-        frame_prints = {}
-        for p in sorted_prints:
-            if p.frame_id not in frame_prints:
-                frame_prints[p.frame_id] = []
-            frame_prints[p.frame_id].append(p)
-
-        # 进行时序一致性检查
-        self._enforce_temporal_consistency(frame_prints)
+            # 9. 更新簇中所有足印的类型
+            for print in prints:
+                print.paw_type = paw_type
+            
+            self.logger.info(f"簇 {cluster_id} 被分类为 {paw_type}")
+            
+            # 10. 添加调试信息
+            self.logger.debug(f"簇 {cluster_id} 分类详情:")
+            self.logger.debug(f"位置: ({cluster_x:.2f}, {cluster_y:.2f})")
+            self.logger.debug(f"前后分数: 前={front_score:.2f}, 后={back_score:.2f}")
+            self.logger.debug(f"左右分数: 右={right_score:.2f}, 左={left_score:.2f}")
+            self.logger.debug(f"各点距离: {distances}")
+        
+        # 11. 验证分类结果
+        self._validate_classification()
 
-    def _enforce_temporal_consistency(self, frame_prints):
-        """确保时序一致性：同一时间同一类型的足印只能有一个"""
-        for frame_id, prints in frame_prints.items():
-            # 按类型分组
-            type_groups = {'LF': [], 'RF': [], 'LH': [], 'RH': []}
-            for p in prints:
-                if p.paw_type:
-                    type_groups[p.paw_type].append(p)
-            
-            # 处理每个有多个足印的类型
-            for paw_type, group in type_groups.items():
-                if len(group) > 1:
-                    # 保留cluster_id较大的足印（通常是较新的足印）
-                    newest_print = max(group, key=lambda p: p.cluster_id)
-                    for p in group:
-                        if p != newest_print:
-                            # 将重复的足印重新分类为对角的另一只脚
-                            if paw_type == 'LF':
-                                p.paw_type = 'RH'
-                            elif paw_type == 'RF':
-                                p.paw_type = 'LH'
-                            elif paw_type == 'LH':
-                                p.paw_type = 'RF'
-                            else:  # RH
-                                p.paw_type = 'LF'
+    def _validate_classification(self):
+        """验证足印分类结果的合理性"""
+        # 统计各类型足印数量
+        type_counts = {'LF': 0, 'RF': 0, 'LH': 0, 'RH': 0}
+        for print in self.gait_prints:
+            if print.paw_type:
+                type_counts[print.paw_type] += 1
+        
+        # 检查数量是否平衡
+        total = sum(type_counts.values())
+        expected = total / 4
+        threshold = expected * 0.5  # 允许50%的偏差
+        
+        for paw_type, count in type_counts.items():
+            if abs(count - expected) > threshold:
+                self.logger.warning(f"{paw_type}的数量({count})与预期({expected:.1f})相差较大")
+        
+        # 检查时空分布
+        for paw_type in ['LF', 'RF', 'LH', 'RH']:
+            prints = [p for p in self.gait_prints if p.paw_type == paw_type]
+            if len(prints) >= 2:
+                # 检查时间间隔
+                timestamps = sorted([p.timestamp for p in prints])
+                intervals = np.diff(timestamps)
+                if np.std(intervals) > np.mean(intervals):
+                    self.logger.warning(f"{paw_type}的时间间隔变异性较大")
 
     def _smooth_classifications(self):
         """使用时序信息平滑分类结果"""
@@ -313,7 +412,7 @@ class GaitAnalyzer:
                 
                 # 如果当前足迹位置偏离太远，考虑重新分类
                 dist = np.sqrt((print.x - avg_x)**2 + (print.y - avg_y)**2)
-                if dist > 50:  # 像素距离阈值
+                if dist > 10:  # 像素距离阈值
                     # 尝试重新分类
                     self._reclassify_print(print, sorted_prints, i)
             
@@ -719,6 +818,7 @@ class GaitAnalyzer:
         print("\n[6/6] 生成轨迹视频...")
         self.generate_trajectory_video(video_path)
         print("视频生成完成!")
+        # print("api版本取消生成视频！")
 
     def _get_paw_color(self, paw_type: str) -> Tuple[int, int, int]:
         """获取不同爪子类型的颜色"""
@@ -1245,10 +1345,10 @@ class GaitAnalyzer:
         
         # 转换爪子类型
         type_map = {
-            'LF': 'leftFront',
-            'RF': 'rightFront',
-            'LH': 'leftHind',
-            'RH': 'rightHind'
+            'LF': 'LF',
+            'RF': 'RF',
+            'LH': 'LH',
+            'RH': 'RH'
         }
         
         # 生成frames数据
@@ -1367,7 +1467,7 @@ class GaitAnalyzer:
 
 def main():
     analyzer = GaitAnalyzer()
-    video_path = "/Users/hakureirm/codespace/Work/Algorithm/gait/exp_videos/Exp8.mp4"
+    video_path = "/Users/hakureirm/codespace/Work/Algorithm/gait/exp_videos/Exp7.mp4"
     
     # 自动检测时间范围
     start_time, end_time = analyzer._detect_mouse_time_range(video_path)
@@ -1377,7 +1477,7 @@ def main():
         video_path,
         start_time=start_time,
         end_time=end_time,
-        conf_thres=0.7,
+        conf_thres=0.8,
         iou_thres=0.5
     )