Add initial code

.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+*$py.class
+.env
+.venv
+env/
+venv/
+ENV/
+results/
+*.mp4
+*.avi
+*.mov

requirements.txt

@@ -0,0 +1,10 @@
+ultralytics
+opencv-python
+numpy
+pandas
+matplotlib
+seaborn
+scikit-learn
+fastapi
+python-multipart
+uvicorn

src/api_server.py

@@ -0,0 +1,104 @@
+from fastapi import FastAPI, UploadFile, Form, File
+from fastapi.middleware.cors import CORSMiddleware
+import json
+import tempfile
+import os
+from pathlib import Path
+import uvicorn
+from typing import Optional
+from pydantic import BaseModel
+import shutil
+
+from gait_analyze import GaitAnalyzer
+
+app = FastAPI()
+
+# 配置CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # 在生产环境中应该设置具体的域名
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class AnalysisResponse(BaseModel):
+    """分析响应模型"""
+    status: str
+    message: str
+    data: Optional[dict] = None
+
+@app.post("/api/v1/analysisFootVideo")
+async def analysis_foot_video(
+    video: UploadFile = File(...),
+    params: str = Form(...)
+):
+    """处理足印视频分析请求"""
+    try:
+        # 解析参数
+        analysis_params = json.loads(params)
+        
+        # 创建临时目录保存视频
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # 保存上传的视频
+            video_path = os.path.join(temp_dir, "input_video.mp4")
+            with open(video_path, "wb") as buffer:
+                shutil.copyfileobj(video.file, buffer)
+            
+            # 创建分析器实例
+            analyzer = GaitAnalyzer()
+            
+            # 自动检测时间范围
+            start_time, end_time = analyzer._detect_mouse_time_range(video_path)
+            
+            # 处理视频
+            analyzer.process_video(
+                video_path,
+                start_time=start_time,
+                end_time=end_time,
+                conf_thres=0.7,
+                iou_thres=0.5
+            )
+            
+            # 获取结果目录中的数据
+            result_dir = Path(analyzer.result_dir)
+            
+            # 读取JSON结果
+            json_path = result_dir / "data" / "footprint_data.json"
+            with open(json_path, 'r') as f:
+                footprint_data = json.load(f)
+            
+            # 添加视频参数到结果中
+            footprint_data.update({
+                "video_info": {
+                    "fps": analysis_params.get("video_fps"),
+                    "width": analysis_params.get("video_width"),
+                    "height": analysis_params.get("video_height"),
+                    "scale_length": analysis_params.get("scale_length"),
+                    "actual_length": analysis_params.get("actual_length"),
+                }
+            })
+            
+            return AnalysisResponse(
+                status="success",
+                message="分析完成",
+                data=footprint_data
+            )
+            
+    except Exception as e:
+        return AnalysisResponse(
+            status="error",
+            message=f"分析失败: {str(e)}"
+        )
+
+def main():
+    """启动服务器"""
+    uvicorn.run(
+        "api_server:app",
+        host="0.0.0.0",
+        port=12345,
+        reload=True
+    )
+
+if __name__ == "__main__":
+    main() 

src/gait_analyze.py

@@ -0,0 +1,1385 @@
+from ultralytics import YOLO
+import cv2
+import numpy as np
+from dataclasses import dataclass
+from typing import List, Dict, Tuple
+import pandas as pd
+from datetime import datetime
+import matplotlib.pyplot as plt
+from matplotlib.patches import Rectangle
+import seaborn as sns
+import os
+
+@dataclass
+class GaitPrint:
+    """足印数据类"""
+    frame_id: int          # 帧号
+    x: float              # 中心x坐标
+    y: float              # 中心y坐标
+    w: float              # 宽度
+    h: float              # 高度
+    conf: float           # 置信度
+    paw_type: str = None  # 爪子类型 (LF, RF, LH, RH)
+    timestamp: float = None  # 时间戳
+    stance_phase: bool = True  # 支撑相标志
+    gait_cycle: int = 0   # 步态周期编号
+    image_patch: np.ndarray = None  # 足印图像块
+    image_features: np.ndarray = None  # 图像特征向量
+    cluster_id: int = -1  # 聚类ID
+
+class GaitAnalyzer:
+    def __init__(self):
+        """初始化步态分析器"""
+        self.gait_model = YOLO('models/mice-gait-v1.0.mlpackage', task='detect')
+        self.pose_model = YOLO('models/mice-pose-bottomview-v1.0.mlpackage', task='pose')  # 新增pose模型
+        self.gait_prints: List[GaitPrint] = []
+        self.mice_positions: List[Dict] = []  # 现在存储pose关键点信息
+        self.params = {}
+        self.time_window = 0.2
+        self.distance_threshold = 30
+        self.gait_pattern = None
+        self.result_dir = self._create_result_dir()
+    
+    def _detect_mouse_time_range(self, video_path: str, margin_ratio: float = 0.05) -> Tuple[float, float]:
+        """使用pose模型的鼻子和尾巴点来检测老鼠"""
+        print("\n[0/6] 预处理视频以确定分析时间范围...")
+        
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            raise ValueError("无法打开视频文件")
+        
+        # 获取视频基本信息
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        fps = int(cap.get(cv2.CAP_PROP_FPS))
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        
+        margin = int(width * margin_ratio)
+        left_boundary = margin
+        right_boundary = width - margin
+        
+        start_frame = None
+        end_frame = None
+        frame_id = 0
+        
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            if frame_id % 30 == 0:  # 每30帧打印一次进度
+                print(f"预处理进度: {frame_id}/{total_frames} ({frame_id/total_frames*100:.1f}%)")
+            
+            # 使用pose模型检测
+            results = self.pose_model(frame, conf=0.5, verbose=False)
+            
+            for r in results:
+                keypoints = r.keypoints.data[0]  # 获取关键点
+                if len(keypoints) >= 7:  # 确保检测到所有关键点
+                    nose_x = keypoints[0][0].item()  # 鼻子x坐标
+                    tail_x = keypoints[6][0].item()  # 尾巴x坐标
+                    
+                    # 使用鼻子位置判断开始
+                    if start_frame is None and nose_x > left_boundary + margin:
+                        start_frame = frame_id
+                    
+                    # 使用尾巴位置判断结束
+                    if start_frame is not None and tail_x > right_boundary - margin:
+                        end_frame = frame_id
+                        break
+            
+            if end_frame is not None:
+                break
+            
+            frame_id += 1
+        
+        cap.release()
+        
+        # 转换为时间
+        start_time = start_frame / fps if start_frame is not None else 0
+        end_time = end_frame / fps if end_frame is not None else total_frames / fps
+        
+        print(f"检测到有效时间范围: {start_time:.2f}s - {end_time:.2f}s")
+        return start_time, end_time
+
+    def _create_result_dir(self) -> str:
+        """创建结果目录结构"""
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        result_dir = f"results/{timestamp}"
+        
+        # 创建目录结构
+        for subdir in ['data', 'plots', 'videos']:
+            os.makedirs(f"{result_dir}/{subdir}", exist_ok=True)
+        
+        return result_dir
+
+    def _filter_footprints(self):
+        """对足印进行时空聚类，将同一个足印的多次检测归为一组"""
+        if not self.gait_prints:
+            print("警告：没有足印数据可供聚类")
+            return
+        
+        try:
+            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])
+            print(f"开始聚类，原始足印数量: {len(features)}")
+            
+            # 2. 标准化特征
+            scaler = StandardScaler()
+            features_scaled = scaler.fit_transform(features)
+            
+            # 3. DBSCAN聚类
+            eps = 0.3  # 可以根据实际情况调整
+            min_samples = 1  # 设为1以保留所有检测
+            dbscan = DBSCAN(eps=eps, min_samples=min_samples)
+            cluster_labels = dbscan.fit_predict(features_scaled)
+            
+            # 4. 将聚类结果添加到足印对象中
+            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分组并打印每组的大小
+            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}个检测")
+            
+        except Exception as e:
+            print(f"聚类过程出错: {str(e)}")
+
+    def _post_process_footprints(self):
+        """后处理足迹数据：聚类、过滤和分类"""
+        if not self.gait_prints:
+            print("警告：没有足印数据可供处理")
+            return
+        
+        # 1. 时空聚类
+        self._filter_footprints()
+        
+        if not self.gait_prints:
+            print("错误：后处理后没有足印数据")
+            return
+        
+        # 2. 全局分析
+        mouse_path = pd.DataFrame(self.mice_positions)
+        total_dx = mouse_path['x'].iloc[-1] - mouse_path['x'].iloc[0]
+        moving_right = total_dx > 0
+        
+        # 3. 使用机器学习进行足迹分类
+        self._classify_footprints(moving_right)
+        
+        # 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)
+        
+        # 对每个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))
+            
+            if 'keypoints' not in closest_pose:
+                print(f"警告：时间戳 {mid_time:.2f}s 处的姿态数据缺少关键点信息")
+                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  # 比较与耳朵中点的位置
+            else:
+                is_left = center_y > (rl[1] + ll[1])/2  # 比较与后腿中点的位置
+            
+            # 确定爪子类型
+            paw_type = None
+            if is_front:
+                paw_type = 'LF' if is_left else 'RF'
+            else:
+                paw_type = 'LH' if is_left else 'RH'
+            
+            # 应用分类结果
+            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)
+
+    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 _smooth_classifications(self):
+        """使用时序信息平滑分类结果"""
+        # 1. 按时间排序足迹
+        sorted_prints = sorted(self.gait_prints, key=lambda x: x.timestamp)
+        
+        # 2. 为每种爪子类型建立时间序列
+        paw_sequences = {'LF': [], 'RF': [], 'LH': [], 'RH': []}
+        
+        # 3. 检测和修正异常分类
+        window_size = 0.2  # 200ms时间窗口
+        for i, print in enumerate(sorted_prints):
+            # 获取时间窗口内的同类足迹
+            nearby_prints = [
+                p for p in sorted_prints
+                if abs(p.timestamp - print.timestamp) < window_size
+                and p.paw_type == print.paw_type
+                and p != print
+            ]
+            
+            if nearby_prints:
+                # 检查空间一致性
+                avg_x = np.mean([p.x for p in nearby_prints])
+                avg_y = np.mean([p.y for p in nearby_prints])
+                
+                # 如果当前足迹位置偏离太远，考虑重新分类
+                dist = np.sqrt((print.x - avg_x)**2 + (print.y - avg_y)**2)
+                if dist > 50:  # 像素距离阈值
+                    # 尝试重新分类
+                    self._reclassify_print(print, sorted_prints, i)
+            
+            # 更新序列
+            paw_sequences[print.paw_type].append(print)
+        
+        # 4. 验证步态模式的合理性
+        self._validate_gait_pattern(paw_sequences)
+
+    def _reclassify_print(self, print, all_prints, current_idx):
+        """重新分类可能错误的足迹"""
+        # 获取临近的其他足迹
+        window_size = 0.2
+        nearby_prints = [
+            p for p in all_prints
+            if abs(p.timestamp - print.timestamp) < window_size
+            and p != print
+        ]
+        
+        if not nearby_prints:
+            return
+        
+        # 计算到每种类型足迹的平均距离
+        type_distances = {}
+        for paw_type in ['LF', 'RF', 'LH', 'RH']:
+            same_type = [p for p in nearby_prints if p.paw_type == paw_type]
+            if same_type:
+                avg_dist = np.mean([
+                    np.sqrt((print.x - p.x)**2 + (print.y - p.y)**2)
+                    for p in same_type
+                ])
+                type_distances[paw_type] = avg_dist
+        
+        # 选择距离最小的类型
+        if type_distances:
+            new_type = min(type_distances.items(), key=lambda x: x[1])[0]
+            print.paw_type = new_type
+
+    def _validate_gait_pattern(self, paw_sequences):
+        """验证步态模式的合理性"""
+        # 1. 检查每个爪子的步频是否合理
+        for paw_type, sequence in paw_sequences.items():
+            if len(sequence) >= 2:
+                time_diffs = [
+                    sequence[i+1].timestamp - sequence[i].timestamp
+                    for i in range(len(sequence)-1)
+                ]
+                avg_freq = 1 / np.mean(time_diffs) if time_diffs else 0
+                
+                # 步频应该在合理范围内 (通常2-5Hz)
+                if not (2 <= avg_freq <= 5):
+                    print(f"警告：{paw_type}的步频 ({avg_freq:.2f}Hz) 可能不合理")
+        
+        # 2. ���查对角步态模式
+        diagonal_pairs = [('LF', 'RH'), ('RF', 'LH')]
+        for pair in diagonal_pairs:
+            seq1 = paw_sequences[pair[0]]
+            seq2 = paw_sequences[pair[1]]
+            if seq1 and seq2:
+                # 检查对角步态的同步性
+                for p1 in seq1:
+                    nearest = min(seq2, key=lambda p: abs(p.timestamp - p1.timestamp))
+                    if abs(nearest.timestamp - p1.timestamp) > 0.1:  # 100ms阈值
+                        print(f"警告：对角步态 {pair} 可能不同步")
+
+    def _is_position_reasonable(self, print_obj, new_type):
+        """检查新的分类是否在合理的空间位置范围内"""
+        # 获取同类型足迹的平均位置
+        same_type_prints = [p for p in self.gait_prints if p.paw_type == new_type]
+        if not same_type_prints:
+            return True
+        
+        # 计算平均位置
+        avg_x = np.mean([p.x for p in same_type_prints])
+        avg_y = np.mean([p.y for p in same_type_prints])
+        
+        # 计算标准差
+        std_x = np.std([p.x for p in same_type_prints])
+        std_y = np.std([p.y for p in same_type_prints])
+        
+        # 检查是否在3个标准差范围内
+        x_reasonable = abs(print_obj.x - avg_x) < 3 * std_x
+        y_reasonable = abs(print_obj.y - avg_y) < 3 * std_y
+        
+        return x_reasonable and y_reasonable
+    
+    def _determine_gait_cycles(self):
+        """确定每个足印所属的步态周期"""
+        # 按爪子类型分组
+        paw_groups = {'LF': [], 'RF': [], 'LH': [], 'RH': []}
+        for print in self.gait_prints:
+            if print.paw_type:
+                paw_groups[print.paw_type].append(print)
+        
+        # 为每种爪子类型确定步态周期
+        for paw_type, prints in paw_groups.items():
+            if len(prints) < 2:
+                continue
+                
+            # 按时间排序
+            prints.sort(key=lambda x: x.timestamp)
+            
+            # 初始化第一个周期
+            cycle_id = 1
+            prints[0].gait_cycle = cycle_id
+            
+            # 基于时空距离确定周期
+            for i in range(1, len(prints)):
+                prev_print = prints[i-1]
+                curr_print = prints[i]
+                
+                # 计算与前一个足印的时空距离
+                time_diff = curr_print.timestamp - prev_print.timestamp
+                space_diff = np.sqrt((curr_print.x - prev_print.x)**2 + 
+                                   (curr_print.y - prev_print.y)**2)
+                
+                # 如果时空距离超过阈值，开始新的周期
+                if time_diff > self.time_window * 2 or space_diff > self.distance_threshold * 3:
+                    cycle_id += 1
+                
+                curr_print.gait_cycle = cycle_id
+
+    def _calculate_gait_parameters(self):
+        """计算步态参数"""
+        # 按类型分组足印
+        paw_groups = {'LF': [], 'RF': [], 'LH': [], 'RH': []}
+        for print in self.gait_prints:
+            if print.paw_type:
+                paw_groups[print.paw_type].append(print)
+        
+        # 初始化参数字典
+        self.params = {
+            'stride_length': {},    # 步幅
+            'step_width': {},       # 步宽
+            'step_frequency': {},   # 步频
+            'stance_time': {},      # 支撑时间
+            'swing_time': {},       # 摆动时间
+            'duty_factor': {},      # 支撑占空比
+            'symmetry_index': {},   # 对称性指数
+            'base_of_support': {},  # 支撑基底
+            'stride_time': {}       # 步态周期时间
+        }
+        
+        # 计算每种爪子的参数
+        for paw_type, prints in paw_groups.items():
+            if len(prints) < 2:
+                continue
+                
+            # 按时间排序
+            prints.sort(key=lambda x: x.timestamp)
+            
+            # 1. 计算步幅 (相邻足印间距)
+            stride_lengths = []
+            for i in range(1, len(prints)):
+                if prints[i].gait_cycle == prints[i-1].gait_cycle:
+                    dist = np.sqrt((prints[i].x - prints[i-1].x)**2 + 
+                                 (prints[i].y - prints[i-1].y)**2)
+                    stride_lengths.append(dist)
+            self.params['stride_length'][paw_type] = np.mean(stride_lengths) if stride_lengths else 0
+            
+            # 2. 计算步频
+            if len(prints) > 1:
+                time_diff = prints[-1].timestamp - prints[0].timestamp
+                self.params['step_frequency'][paw_type] = (len(prints) - 1) / time_diff if time_diff > 0 else 0
+            
+            # 3. 计算步态周期时间
+            cycle_times = []
+            for i in range(1, len(prints)):
+                if prints[i].gait_cycle == prints[i-1].gait_cycle:
+                    cycle_times.append(prints[i].timestamp - prints[i-1].timestamp)
+            self.params['stride_time'][paw_type] = np.mean(cycle_times) if cycle_times else 0
+            
+            # 4. 计算支撑时间和摆动时间
+            stance_times = []
+            swing_times = []
+            for i in range(len(prints)-1):
+                if prints[i].gait_cycle == prints[i+1].gait_cycle:
+                    stance_time = 0.1  # 假设支撑相持续100ms
+                    swing_time = prints[i+1].timestamp - prints[i].timestamp - stance_time
+                    stance_times.append(stance_time)
+                    swing_times.append(swing_time)
+            
+            self.params['stance_time'][paw_type] = np.mean(stance_times) if stance_times else 0
+            self.params['swing_time'][paw_type] = np.mean(swing_times) if swing_times else 0
+            
+            # 5. 计算支撑占空比
+            total_time = self.params['stance_time'][paw_type] + self.params['swing_time'][paw_type]
+            self.params['duty_factor'][paw_type] = (self.params['stance_time'][paw_type] / total_time 
+                                                   if total_time > 0 else 0)
+        
+        # 6. 计算左右对称性指数
+        for side in ['F', 'H']:  # 前爪和后爪
+            left_paw = f'L{side}'
+            right_paw = f'R{side}'
+            if (left_paw in self.params['stride_length'] and 
+                right_paw in self.params['stride_length']):
+                left_stride = self.params['stride_length'][left_paw]
+                right_stride = self.params['stride_length'][right_paw]
+                symmetry = abs(left_stride - right_stride) / ((left_stride + right_stride) / 2)
+                self.params['symmetry_index'][side] = symmetry
+                
+        # 7. 计算支撑基底
+        for side in ['F', 'H']:  # 前爪和后爪
+            left_prints = paw_groups[f'L{side}']
+            right_prints = paw_groups[f'R{side}']
+            if left_prints and right_prints:
+                # 计算同一时间窗口内左右爪的横向距离
+                base_distances = []
+                for left_print in left_prints:
+                    # 找到最近时间的右爪足印
+                    nearest_right = min(right_prints, 
+                                      key=lambda p: abs(p.timestamp - left_print.timestamp))
+                    if abs(nearest_right.timestamp - left_print.timestamp) < self.time_window:
+                        dist = abs(left_print.y - nearest_right.y)
+                        base_distances.append(dist)
+                
+                self.params['base_of_support'][side] = np.mean(base_distances) if base_distances else 0
+        
+        # 8. 确定步态模式
+        self._determine_gait_pattern()
+
+    def _determine_gait_pattern(self):
+        """确定步态模式（walk, trot, gallop, bound）"""
+        if len(self.gait_prints) < 4:
+            return
+        
+        # 分析相邻足印的时间关系
+        prints_by_time = sorted(self.gait_prints, key=lambda p: p.timestamp)
+        time_diffs = []
+        for i in range(1, len(prints_by_time)):
+            if prints_by_time[i].paw_type and prints_by_time[i-1].paw_type:
+                time_diff = prints_by_time[i].timestamp - prints_by_time[i-1].timestamp
+                time_diffs.append(time_diff)
+        
+        if not time_diffs:
+            return
+        
+        # 计算时间差的变异系数
+        mean_diff = np.mean(time_diffs)
+        std_diff = np.std(time_diffs)
+        cv = std_diff / mean_diff if mean_diff > 0 else 0
+        
+        # 分析对角步态模式
+        diagonal_pairs = [('LF', 'RH'), ('RF', 'LH')]
+        diagonal_sync = []
+        for pair in diagonal_pairs:
+            prints1 = [p for p in self.gait_prints if p.paw_type == pair[0]]
+            prints2 = [p for p in self.gait_prints if p.paw_type == pair[1]]
+            
+            if prints1 and prints2:
+                # 计算对角足印的同步性
+                min_time_diff = float('inf')
+                for p1 in prints1:
+                    for p2 in prints2:
+                        time_diff = abs(p1.timestamp - p2.timestamp)
+                        min_time_diff = min(min_time_diff, time_diff)
+                diagonal_sync.append(min_time_diff)
+
+        # 基于时间特征确定步态模式
+        if cv < 0.2 and all(sync < 0.1 for sync in diagonal_sync):
+            self.gait_pattern = 'trot'  # 对角步态同步性高
+        elif cv > 0.4:
+            self.gait_pattern = 'gallop'  # 时间间隔变异大
+        elif len(set(p.gait_cycle for p in self.gait_prints)) > len(self.gait_prints) / 2:
+            self.gait_pattern = 'bound'  # 步态周期数量多
+        else:
+            self.gait_pattern = 'walk'  # 默认为行走
+
+    def process_video(self, video_path: str, start_time=0.0, end_time=None, conf_thres=0.7, iou_thres=0.5):
+        """处理视频并分析步态
+        
+        Args:
+            video_path (str): 视频文件路径
+            start_time (float): 开始时间(秒)，精确到0.01秒
+            end_time (float): 结束时间(秒)，精确到0.01秒，None表示处理到视频结束
+            conf_thres (float): 置信度阈值
+            iou_thres (float): IOU阈值
+        """
+        print(f"\n[1/6] 开始处理视频: {video_path}")
+        
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            raise ValueError(f"无法打开视频文件: {video_path}")
+        
+        fps = int(cap.get(cv2.CAP_PROP_FPS))
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        video_duration = total_frames / fps
+        
+        # 处理时间范围
+        if end_time is None:
+            end_time = video_duration
+        
+        # 确保时间范围有效
+        if start_time < 0 or start_time >= video_duration:
+            raise ValueError(f"起始时间 {start_time:.2f}s 超出视频范围 [0, {video_duration:.2f}s]")
+        if end_time <= start_time or end_time > video_duration:
+            raise ValueError(f"结束时间 {end_time:.2f}s 无效，应在区间 ({start_time:.2f}, {video_duration:.2f}s]")
+        
+        # 计算帧范围
+        start_frame = int(start_time * fps)
+        end_frame = int(end_time * fps)
+        process_frames = end_frame - start_frame
+        print(f"视频信息: 总时长 {video_duration:.2f}s ({total_frames}帧, {fps}FPS)")
+        print(f"处理时间段: {start_time:.2f}s - {end_time:.2f}s ({process_frames}帧)")
+        
+        # 跳转到起始帧
+        cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
+        
+        frame_id = start_frame
+        print("\n[2/6] 开始检测足迹...")
+        while cap.isOpened() and frame_id < end_frame:
+            success, frame = cap.read()
+            if not success:
+                break
+            
+            if (frame_id - start_frame) % 30 == 0:  # 每30帧打印一次进度
+                progress = (frame_id - start_frame) / process_frames
+                print(f"处理进度: {frame_id-start_frame}/{process_frames} ({progress*100:.1f}%)")
+            
+            timestamp = frame_id / fps
+            
+            # 处理pose检测结果
+            pose_results = self.pose_model(frame, conf=conf_thres, verbose=False)
+            for r in pose_results:
+                if r.keypoints is not None and len(r.keypoints.data) > 0:
+                    kpts = r.keypoints.data[0]  # 获取第一个检测到的老鼠的关键点
+                    if len(kpts) >= 7:  # 确保检测到所有关键点
+                        self.mice_positions.append({
+                            'frame_id': frame_id,
+                            'timestamp': timestamp,
+                            'keypoints': {
+                                'nose': (kpts[0][0].item(), kpts[0][1].item()),
+                                'right_ear': (kpts[1][0].item(), kpts[1][1].item()),
+                                'left_ear': (kpts[2][0].item(), kpts[2][1].item()),
+                                'mid': (kpts[3][0].item(), kpts[3][1].item()),
+                                'right_leg': (kpts[4][0].item(), kpts[4][1].item()),
+                                'left_leg': (kpts[5][0].item(), kpts[5][1].item()),
+                                'tail_base': (kpts[6][0].item(), kpts[6][1].item())
+                            },
+                            'x': kpts[3][0].item(),  # 使用中点作为老鼠位置
+                            'y': kpts[3][1].item()
+                        })
+            
+            # 处理gait检测结果
+            gait_results = self.gait_model(frame, conf=conf_thres, iou=iou_thres, verbose=False)
+            
+            # 处理检测结果
+            for r in gait_results:
+                boxes = r.boxes
+                for box in boxes:
+                    x1, y1, x2, y2 = map(int, box.xyxy[0])
+                    conf = float(box.conf[0])
+                    cls = int(box.cls[0])
+                    
+                    if cls == 0:  # gait
+                        # 提取足印图像块
+                        patch = frame[y1:y2, x1:x2].copy()
+                        # 只保留绿色通道
+                        green_mask = self._extract_green_channel(patch)
+                        # 提取图像特征
+                        image_features = self._extract_image_features(green_mask)
+                        
+                        self.gait_prints.append(GaitPrint(
+                            frame_id=frame_id,
+                            x=(x1 + x2) / 2,
+                            y=(y1 + y2) / 2,
+                            w=x2 - x1,
+                            h=y2 - y1,
+                            conf=conf,
+                            timestamp=timestamp,
+                            image_patch=green_mask,
+                            image_features=image_features
+                            
+                        ))
+                    else:  # mice类
+                        self.mice_positions.append({
+                            'frame_id': frame_id,
+                            'x': (x1 + x2) / 2,
+                            'y': (y1 + y2) / 2,
+                            'w': x2 - x1,
+                            'h': y2 - y1,
+                            'conf': conf,
+                            'timestamp': timestamp
+                        })
+            
+            frame_id += 1
+        
+        cap.release()
+        print(f"检测完成! 共检测到 {len(self.gait_prints)} 个足迹")
+        print("\n[3/6] 开始后处理...")
+        self._post_process_footprints()
+        print(f"后处理完成! 剩余 {len(self.gait_prints)} 个有效足迹")
+        
+        print("\n[4/6] 计算步态参数...")
+        self._calculate_gait_parameters()
+        print("参数计算完成!")
+        
+        print("\n[5/6] 保存分析结果...")
+        self._save_results()
+        self.visualize_results()
+        print("分析结果已保存!")
+        
+        print("\n[6/6] 生成轨迹视频...")
+        self.generate_trajectory_video(video_path)
+        print("视频生成完成!")
+
+    def _get_paw_color(self, paw_type: str) -> Tuple[int, int, int]:
+        """获取不同爪子类型的颜色"""
+        colors = {
+            'LF': (0, 255, 0),    # 绿色
+            'RF': (0, 255, 255),  # 黄色
+            'LH': (255, 0, 255),  # 紫色
+            'RH': (0, 165, 255),  # 橙色
+            None: (0, 255, 0)     # 未分类时为绿色
+        }
+        return colors.get(paw_type, (0, 255, 0))
+    
+    def _save_results(self):
+        """保存分析结果"""
+        # 保存原有的CSV数据
+        df = pd.DataFrame([{
+            'frame_id': p.frame_id,
+            'x': p.x,
+            'y': p.y,
+            'width': p.w,
+            'height': p.h,
+            'confidence': p.conf,
+            'paw_type': p.paw_type,
+            'timestamp': p.timestamp,
+            'gait_cycle': p.gait_cycle,
+            'stance_phase': p.stance_phase
+        } for p in self.gait_prints])
+        
+        df.to_csv(f'{self.result_dir}/data/gait_analysis.csv', index=False)
+        
+        # 保存参数数据
+        params_df = pd.DataFrame(self.params)
+        params_df.to_csv(f'{self.result_dir}/data/gait_parameters.csv')
+        
+        # 保存JSON格式的足印数据
+        self._save_footprint_json()
+
+    def visualize_results(self):
+        """可视化分析结果"""
+        # 创建保存路径
+        plots_dir = f'{self.result_dir}/plots'
+        
+        # 1. 足印轨迹图
+        fig, ax = plt.subplots(figsize=(10, 8))
+        self._plot_footprint_trajectory(ax)
+        plt.savefig(f'{plots_dir}/trajectory.png', dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        # 2. 步态时序图
+        fig, ax = plt.subplots(figsize=(12, 6))
+        self._plot_gait_timeline(ax)
+        plt.savefig(f'{plots_dir}/timeline.png', dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        # 3. 步态参数图
+        # 3.1 步幅
+        fig, ax = plt.subplots(figsize=(8, 6))
+        self._plot_stride_length(ax)
+        plt.savefig(f'{plots_dir}/stride_length.png', dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        # 3.2 步频
+        fig, ax = plt.subplots(figsize=(8, 6))
+        self._plot_step_frequency(ax)
+        plt.savefig(f'{plots_dir}/step_frequency.png', dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        # 3.3 支撑和摆动时间
+        fig, ax = plt.subplots(figsize=(10, 6))
+        self._plot_stance_swing_time(ax)
+        plt.savefig(f'{plots_dir}/stance_swing_time.png', dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        # 3.4 支撑占空比
+        fig, ax = plt.subplots(figsize=(8, 6))
+        self._plot_duty_factor(ax)
+        plt.savefig(f'{plots_dir}/duty_factor.png', dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        # 3.5 对称性指数
+        fig, ax = plt.subplots(figsize=(8, 6))
+        self._plot_symmetry_index(ax)
+        plt.savefig(f'{plots_dir}/symmetry_index.png', dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        # 3.6 支撑基底
+        fig, ax = plt.subplots(figsize=(8, 6))
+        self._plot_base_of_support(ax)
+        plt.savefig(f'{plots_dir}/base_of_support.png', dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        # 4. 步态模式热图
+        fig, ax = plt.subplots(figsize=(12, 6))
+        self._plot_gait_pattern(ax)
+        plt.savefig(f'{plots_dir}/gait_pattern.png', dpi=300, bbox_inches='tight')
+        plt.close()
+
+    def generate_trajectory_video(self, video_path: str):
+        """生成包含足迹轨迹的视频"""
+        try:
+            # 准备输出路径
+            video_name = os.path.splitext(os.path.basename(video_path))[0]
+            yolo_path = f"{self.result_dir}/videos/{video_name}_yolo.mp4"
+            trajectory_path = f"{self.result_dir}/videos/{video_name}_trajectory.mp4"
+            combined_path = f"{self.result_dir}/videos/{video_name}_combined.mp4"
+            
+            # 打开视频
+            cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened():
+                raise ValueError("无法打开视频文件")
+            
+            # 获取视频信息
+            width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            fps = int(cap.get(cv2.CAP_PROP_FPS))
+            frame_duration = 1.0 / fps
+            
+            # 确定有效时间范围
+            valid_times = [p.timestamp for p in self.gait_prints]
+            start_time = min(valid_times) if valid_times else 0
+            end_time = max(valid_times) if valid_times else 0
+            
+            # 跳转到起始帧
+            start_frame = int(start_time * fps)
+            cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
+            
+            # 创建视频写入器
+            fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+            yolo_writer = cv2.VideoWriter(yolo_path, fourcc, fps, (width, height))
+            traj_writer = cv2.VideoWriter(trajectory_path, fourcc, fps, (width, height))
+            combined_writer = cv2.VideoWriter(combined_path, fourcc, fps, (width, height*2))
+            
+            # 准备轨迹图像
+            trajectory_img = np.ones((height, width, 3), dtype=np.uint8) * 255
+            
+            # 按时间排序足迹和老鼠位置
+            sorted_prints = sorted(self.gait_prints, key=lambda x: x.timestamp)
+            sorted_mice = sorted(self.mice_positions, key=lambda x: x['timestamp'])
+            current_time = start_time
+            
+            while cap.isOpened() and current_time <= end_time:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                
+                # 1. 创建YOLO检测帧
+                yolo_frame = frame.copy()
+                
+                # 2. 创建轨迹帧
+                traj_frame = trajectory_img.copy()
+                
+                # 绘制当前时间的老鼠位置
+                current_mouse = next((m for m in sorted_mice if abs(m['timestamp'] - current_time) < frame_duration), None)
+                if current_mouse and 'keypoints' in current_mouse:  # 确保有关键点数据
+                    keypoints = current_mouse['keypoints']
+                    nose = keypoints['nose']
+                    tail = keypoints['tail_base']
+                    
+                    # 计算中点
+                    center_x = int((nose[0] + tail[0]) / 2)
+                    center_y = int((nose[1] + tail[1]) / 2)
+                    
+                    # 绘制鼻子到尾巴的虚线箭头
+                    # 计算箭头方向
+                    dx = nose[0] - tail[0]
+                    dy = nose[1] - tail[1]
+                    angle = np.arctan2(dy, dx)
+                    
+                    # 绘制虚线
+                    pt1 = (int(tail[0]), int(tail[1]))
+                    pt2 = (int(nose[0]), int(nose[1]))
+                    
+                    # 使用虚线绘制主线
+                    dash_length = 5
+                    total_length = np.sqrt(dx**2 + dy**2)
+                    num_segments = int(total_length / (dash_length * 2))
+                    
+                    for i in range(num_segments):
+                        start_ratio = i / num_segments
+                        end_ratio = (i + 0.5) / num_segments
+                        start_x = int(tail[0] + dx * start_ratio)
+                        start_y = int(tail[1] + dy * start_ratio)
+                        end_x = int(tail[0] + dx * end_ratio)
+                        end_y = int(tail[1] + dy * end_ratio)
+                        cv2.line(yolo_frame, (start_x, start_y), (end_x, end_y), (255, 0, 0), 1)
+                        cv2.line(traj_frame, (start_x, start_y), (end_x, end_y), (255, 0, 0), 1)
+                    
+                    # 绘制箭头
+                    arrow_length = 15
+                    arrow_angle = np.pi/6  # 30度
+                    
+                    # 计算箭头两边的点
+                    arrow1_x = int(nose[0] - arrow_length * np.cos(angle + arrow_angle))
+                    arrow1_y = int(nose[1] - arrow_length * np.sin(angle + arrow_angle))
+                    arrow2_x = int(nose[0] - arrow_length * np.cos(angle - arrow_angle))
+                    arrow2_y = int(nose[1] - arrow_length * np.sin(angle - arrow_angle))
+                    
+                    # 绘制箭头
+                    cv2.line(yolo_frame, (int(nose[0]), int(nose[1])), (arrow1_x, arrow1_y), (255, 0, 0), 1)
+                    cv2.line(yolo_frame, (int(nose[0]), int(nose[1])), (arrow2_x, arrow2_y), (255, 0, 0), 1)
+                    cv2.line(traj_frame, (int(nose[0]), int(nose[1])), (arrow1_x, arrow1_y), (255, 0, 0), 1)
+                    cv2.line(traj_frame, (int(nose[0]), int(nose[1])), (arrow2_x, arrow2_y), (255, 0, 0), 1)
+                    
+                    # 绘制中点
+                    cv2.circle(yolo_frame, (center_x, center_y), 3, (255, 0, 0), -1)
+                    cv2.circle(traj_frame, (center_x, center_y), 3, (255, 0, 0), -1)
+                
+                # 绘制当前时间之前的所有足迹
+                for foot_print in sorted_prints:
+                    if foot_print.timestamp <= current_time:
+                        color = self._get_paw_color(foot_print.paw_type)
+                        x1 = int(foot_print.x - foot_print.w/2)
+                        y1 = int(foot_print.y - foot_print.h/2)
+                        x2 = int(foot_print.x + foot_print.w/2)
+                        y2 = int(foot_print.y + foot_print.h/2)
+                        
+                        # 在YOLO帧上绘制检测框和标签
+                        cv2.rectangle(yolo_frame, (x1, y1), (x2, y2), color, 2)
+                        if foot_print.paw_type:
+                            cv2.putText(yolo_frame, foot_print.paw_type, (x1, y1-5), 
+                                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
+                        
+                        # 在轨迹帧上绘制足迹点
+                        cv2.circle(traj_frame, (int(foot_print.x), int(foot_print.y)), 3, color, -1)
+                
+                # 添加时间戳
+                cv2.putText(yolo_frame, f"Time: {current_time:.2f}s", (10, 30), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
+                cv2.putText(traj_frame, f"Time: {current_time:.2f}s", (10, 30), 
+                        cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
+                
+                # 合并视频
+                combined_frame = np.vstack((yolo_frame, traj_frame))
+                
+                # 写入帧
+                yolo_writer.write(yolo_frame)
+                traj_writer.write(traj_frame)
+                combined_writer.write(combined_frame)
+                
+                current_time += frame_duration
+            
+            # 释放资源
+            cap.release()
+            yolo_writer.release()
+            traj_writer.release()
+            combined_writer.release()
+            
+            print(f"\nYOLO视频生成完成: {yolo_path}")
+            print(f"轨迹视频生成完成: {trajectory_path}")
+            print(f"并列视频生成完成: {combined_path}")
+            
+        except Exception as e:
+            print(f"生成视频时出错: {str(e)}")
+            raise
+
+    def _plot_footprint_trajectory(self, ax):
+        """绘制足印轨迹"""
+        ax.set_title('Footprint Trajectory')
+        
+        # 为每种足印类型绘制散点图
+        colors = self._get_paw_color_dict()
+        for paw_type in ['LF', 'RF', 'LH', 'RH']:
+            prints = [p for p in self.gait_prints if p.paw_type == paw_type]
+            if prints:
+                x = [p.x for p in prints]
+                y = [p.y for p in prints]
+                ax.scatter(x, y, c=[colors[paw_type]], label=paw_type, alpha=0.6)
+        
+        # 绘制老鼠运动轨迹，使用鼻子到尾巴的中点
+        mouse_positions = []
+        for pos in self.mice_positions:
+            if 'keypoints' in pos:
+                nose = pos['keypoints']['nose']
+                tail = pos['keypoints']['tail_base']
+                mid_x = (nose[0] + tail[0]) / 2
+                mid_y = (nose[1] + tail[1]) / 2
+                mouse_positions.append((mid_x, mid_y))
+        
+        if mouse_positions:
+            mouse_x, mouse_y = zip(*mouse_positions)
+            ax.plot(mouse_x, mouse_y, 'b--', alpha=0.1, label='Mouse path')
+            # 在最后一个位置绘制一个点
+            ax.scatter(mouse_x[-1], mouse_y[-1], c='blue', s=50, alpha=0.6)
+        
+        ax.legend()
+        ax.set_xlabel('X position (pixels)')
+        ax.set_ylabel('Y position (pixels)')
+        ax.invert_yaxis()  # 图像坐标系y轴向下
+        
+    def _plot_gait_timeline(self, ax):
+        """绘制步态时序图"""
+        ax.set_title('Gait Timeline')
+        
+        colors = self._get_paw_color_dict()
+        y_positions = {'LF': 4, 'RF': 3, 'LH': 2, 'RH': 1}
+        
+        for paw_type in ['LF', 'RF', 'LH', 'RH']:
+            prints = [p for p in self.gait_prints if p.paw_type == paw_type]
+            times = [p.timestamp for p in prints]
+            y = [y_positions[paw_type]] * len(times)
+            ax.scatter(times, y, c=[colors[paw_type]], label=paw_type, marker='s')
+        
+        ax.set_yticks(list(y_positions.values()))
+        ax.set_yticklabels(list(y_positions.keys()))
+        ax.set_xlabel('Time (seconds)')
+        ax.grid(True, axis='x', alpha=0.3)
+    
+    def _plot_gait_parameters(self, ax):
+        """绘制步态参数柱状图"""
+        ax.set_title('Gait Parameters')
+        
+        # 提取步幅和步频数据
+        paw_types = list(self.params['stride_length'].keys())
+        stride_lengths = [self.params['stride_length'][p] for p in paw_types]
+        frequencies = [self.params['step_frequency'][p] for p in paw_types]
+        
+        x = np.arange(len(paw_types))
+        width = 0.35
+        
+        ax.bar(x - width/2, stride_lengths, width, label='Stride Length')
+        ax.bar(x + width/2, frequencies, width, label='Step Frequency')
+        
+        ax.set_xticks(x)
+        ax.set_xticklabels(paw_types)
+        ax.legend()
+        ax.set_ylabel('Value')
+        
+        if self.gait_pattern:
+            ax.text(0.02, 0.98, f'Gait Pattern: {self.gait_pattern}',
+                   transform=ax.transAxes, verticalalignment='top')
+            
+    def _plot_gait_pattern(self, ax):
+        """绘制步态模式热图"""
+        ax.set_title('Gait Pattern')
+        
+        # 创建时间窗口内的步态模式矩阵
+        time_bins = np.linspace(0, max(p.timestamp for p in self.gait_prints), 20)
+        paw_types = ['LF', 'RF', 'LH', 'RH']
+        pattern_matrix = np.zeros((len(paw_types), len(time_bins)-1))
+        
+        for i, paw_type in enumerate(paw_types):
+            prints = [p for p in self.gait_prints if p.paw_type == paw_type]
+            for p in prints:
+                bin_idx = np.digitize(p.timestamp, time_bins) - 1
+                if 0 <= bin_idx < len(time_bins)-1:
+                    pattern_matrix[i, bin_idx] += 1
+        
+        sns.heatmap(pattern_matrix, ax=ax, cmap='YlOrRd', 
+                   xticklabels=np.round(time_bins[:-1], 1),
+                   yticklabels=paw_types)
+        ax.set_xlabel('Time (seconds)')
+
+    def _plot_stride_length(self, ax):
+        """绘制步幅图"""
+        ax.set_title('Stride Length')
+        paw_types = list(self.params['stride_length'].keys())
+        values = [self.params['stride_length'][p] for p in paw_types]
+        colors = [self._get_paw_color_dict()[p] for p in paw_types]
+        
+        bars = ax.bar(paw_types, values)
+        for bar, color in zip(bars, colors):
+            bar.set_color(color)
+        
+        ax.set_ylabel('Length (pixels)')
+        ax.grid(True, alpha=0.3)
+        
+    def _plot_step_frequency(self, ax):
+        """绘制步频图"""
+        ax.set_title('Step Frequency')
+        paw_types = list(self.params['step_frequency'].keys())
+        values = [self.params['step_frequency'][p] for p in paw_types]
+        colors = [self._get_paw_color_dict()[p] for p in paw_types]
+        
+        bars = ax.bar(paw_types, values)
+        for bar, color in zip(bars, colors):
+            bar.set_color(color)
+        
+        ax.set_ylabel('Frequency (steps/second)')
+        ax.grid(True, alpha=0.3)
+        
+    def _plot_stance_swing_time(self, ax):
+        """绘制支撑和摆动时间图"""
+        ax.set_title('Stance and Swing Time')
+        paw_types = list(self.params['stance_time'].keys())
+        stance_times = [self.params['stance_time'][p] for p in paw_types]
+        swing_times = [self.params['swing_time'][p] for p in paw_types]
+        
+        x = np.arange(len(paw_types))
+        width = 0.35
+        
+        ax.bar(x - width/2, stance_times, width, label='Stance Time')
+        ax.bar(x + width/2, swing_times, width, label='Swing Time')
+        
+        ax.set_xticks(x)
+        ax.set_xticklabels(paw_types)
+        ax.set_ylabel('Time (seconds)')
+        ax.legend()
+        ax.grid(True, alpha=0.3)
+        
+    def _plot_duty_factor(self, ax):
+        """绘制支撑占空比图"""
+        ax.set_title('Duty Factor')
+        paw_types = list(self.params['duty_factor'].keys())
+        values = [self.params['duty_factor'][p] * 100 for p in paw_types]  # 转换为百分比
+        colors = [self._get_paw_color_dict()[p] for p in paw_types]
+        
+        bars = ax.bar(paw_types, values)
+        for bar, color in zip(bars, colors):
+            bar.set_color(color)
+        
+        ax.set_ylabel('Duty Factor (%)')
+        ax.grid(True, alpha=0.3)
+        
+    def _plot_symmetry_index(self, ax):
+        """绘制对称性指数图"""
+        ax.set_title('Symmetry Index')
+        sides = list(self.params['symmetry_index'].keys())
+        values = [self.params['symmetry_index'][s] * 100 for s in sides]  # 转换为百分比
+        
+        bars = ax.bar(sides, values)
+        ax.set_ylabel('Symmetry Index (%)')
+        ax.grid(True, alpha=0.3)
+        
+    def _plot_base_of_support(self, ax):
+        """绘制支撑基底图"""
+        ax.set_title('Base of Support')
+        sides = list(self.params['base_of_support'].keys())
+        values = [self.params['base_of_support'][s] for s in sides]
+        
+        bars = ax.bar(sides, values)
+        ax.set_ylabel('Width (pixels)')
+        ax.grid(True, alpha=0.3)
+    
+    def _get_paw_color_dict(self):
+        """获取足印颜色字典(matplotlib格式)"""
+        return {
+            'LF': 'green',
+            'RF': 'yellow',
+            'LH': 'purple',
+            'RH': 'orange'
+        }
+
+    def _extract_green_channel(self, patch: np.ndarray) -> np.ndarray:
+        """提取并增强绿色通道"""
+        # 转换为HSV颜色空间
+        hsv = cv2.cvtColor(patch, cv2.COLOR_BGR2HSV)
+        
+        # 定义绿色的HSV范围
+        lower_green = np.array([40, 40, 40])
+        upper_green = np.array([80, 255, 255])
+        
+        # 创建掩码
+        mask = cv2.inRange(hsv, lower_green, upper_green)
+        
+        # 应用掩码
+        green_only = cv2.bitwise_and(patch, patch, mask=mask)
+        
+        # 转换为灰度图
+        gray = cv2.cvtColor(green_only, cv2.COLOR_BGR2GRAY)
+        
+        # 标准化尺寸
+        resized = cv2.resize(gray, (32, 32))
+        
+        return resized
+
+    def _extract_image_features(self, green_mask: np.ndarray) -> np.ndarray:
+        """从足印图像提取特征"""
+        # 1. 计算形状特征
+        contours, _ = cv2.findContours(green_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        if not contours:
+            return np.zeros(10)  # 返回默认特征向量
+            
+        largest_contour = max(contours, key=cv2.contourArea)
+        
+        # 面积
+        area = cv2.contourArea(largest_contour)
+        # 周长
+        perimeter = cv2.arcLength(largest_contour, True)
+        # 圆度
+        circularity = 4 * np.pi * area / (perimeter * perimeter) if perimeter > 0 else 0
+        
+        # 2. 计算方向
+        if len(largest_contour) >= 5:
+            (x, y), (MA, ma), angle = cv2.fitEllipse(largest_contour)
+        else:
+            MA, ma, angle = 0, 0, 0
+        
+        # 3. 计算Hu矩
+        moments = cv2.moments(largest_contour)
+        hu_moments = cv2.HuMoments(moments).flatten()
+        
+        # 4. 组合特征
+        features = np.array([
+            area,
+            perimeter,
+            circularity,
+            MA/ma if ma > 0 else 0,  # 长宽比
+            angle,
+            *hu_moments[:5]  # 取前5个Hu矩
+        ])
+        
+        return features
+
+    def _generate_footprint_data(self) -> dict:
+        """生成足印数据的JSON格式"""
+        # 初始化数据结构
+        data = {
+            "frames": [],
+            "footprintArea": []
+        }
+        
+        # 按帧ID组织足印数据
+        frame_prints = {}
+        for print in self.gait_prints:
+            if print.frame_id not in frame_prints:
+                frame_prints[print.frame_id] = []
+            frame_prints[print.frame_id].append(print)
+        
+        # 生成footprintArea的ID映射
+        area_id_map = {}  # cluster_id -> footprintAreaId
+        for print in self.gait_prints:
+            if print.cluster_id not in area_id_map:
+                area_id_map[print.cluster_id] = f"footprintArea_{print.cluster_id}"
+        
+        # 转换爪子类型
+        type_map = {
+            'LF': 'leftFront',
+            'RF': 'rightFront',
+            'LH': 'leftHind',
+            'RH': 'rightHind'
+        }
+        
+        # 生成frames数据
+        for frame_id, prints in frame_prints.items():
+            frame_data = {
+                "frameId": frame_id,
+                "footprints": []
+            }
+            
+            for i, print in enumerate(prints):
+                # 转换中心点坐标为左上角坐标
+                x = int(print.x - print.w/2)
+                y = int(print.y - print.h/2)
+                w = int(print.w)
+                h = int(print.h)
+                
+                footprint_data = {
+                    "id": f"footprint_{frame_id}_{i}",
+                    "type": type_map.get(print.paw_type, 'unknown'),
+                    "isKeyFootprint": False,
+                    "position": {
+                        "x": x,
+                        "y": y,
+                        "width": w,
+                        "height": h
+                    },
+                    "footprintAreaId": area_id_map[print.cluster_id]
+                }
+                frame_data["footprints"].append(footprint_data)
+            
+            data["frames"].append(frame_data)
+        
+        # 生成footprintArea数据
+        cluster_groups = {}
+        for print in self.gait_prints:
+            if print.cluster_id not in cluster_groups:
+                cluster_groups[print.cluster_id] = []
+            cluster_groups[print.cluster_id].append(print)
+        
+        for cluster_id, prints in cluster_groups.items():
+            # 计算整个簇的边界框（考虑每个足印的完整区域）
+            x_coords = []
+            y_coords = []
+            for p in prints:
+                # 添加每个足印框的四个角点
+                x_coords.extend([
+                    p.x - p.w/2,  # 左边界
+                    p.x + p.w/2   # 右边界
+                ])
+                y_coords.extend([
+                    p.y - p.h/2,  # 上边界
+                    p.y + p.h/2   # 下边界
+                ])
+            
+            # 计算能包含所有足印的最小矩形
+            x_min = min(x_coords)
+            y_min = min(y_coords)
+            x_max = max(x_coords)
+            y_max = max(y_coords)
+            
+            # 选择关键帧（这里选择置信度最高的）
+            key_print = max(prints, key=lambda p: p.conf)
+            
+            # 获取图像数据
+            if key_print.image_patch is not None:
+                import base64
+                import cv2
+                success, buffer = cv2.imencode('.png', key_print.image_patch)
+                if success:
+                    img_base64 = base64.b64encode(buffer).decode('utf-8')
+                else:
+                    img_base64 = ""
+            else:
+                img_base64 = ""
+            
+            area_data = {
+                "footprintAreaId": area_id_map[cluster_id],
+                "type": type_map.get(key_print.paw_type, 'unknown'),
+                "areaPosition": {
+                    "x": int(x_min),
+                    "y": int(y_min),
+                    "width": int(x_max - x_min),
+                    "height": int(y_max - y_min)
+                },
+                "keyFootprintFrame": {
+                    "frameId": key_print.frame_id,
+                    "footprintId": f"footprint_{key_print.frame_id}_{cluster_id}",
+                    "footPosition": {
+                        "x": int(key_print.x - key_print.w/2),
+                        "y": int(key_print.y - key_print.h/2),
+                        "width": int(key_print.w),
+                        "height": int(key_print.h)
+                    },
+                    "base64Image": img_base64
+                },
+                "startFrame": min(p.frame_id for p in prints),
+                "endFrame": max(p.frame_id for p in prints)
+            }
+            
+            data["footprintArea"].append(area_data)
+        
+        return data
+
+    def _save_footprint_json(self):
+        """保存足印数据为JSON文件"""
+        import json
+        
+        data = self._generate_footprint_data()
+        json_path = f'{self.result_dir}/data/footprint_data.json'
+        
+        with open(json_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+        
+        print(f"足印数据已保存至: {json_path}")
+
+
+def main():
+    analyzer = GaitAnalyzer()
+    video_path = "/Users/hakureirm/codespace/Work/Algorithm/gait/exp_videos/Exp8.mp4"
+    
+    # 自动检测时间范围
+    start_time, end_time = analyzer._detect_mouse_time_range(video_path)
+    
+    # 处理检测到的时间段
+    analyzer.process_video(
+        video_path,
+        start_time=start_time,
+        end_time=end_time,
+        conf_thres=0.7,
+        iou_thres=0.5
+    )
+
+if __name__ == "__main__":
+    main()

src/visualize_footprint_json.py

@@ -0,0 +1,123 @@
+import json
+import cv2
+import numpy as np
+from pathlib import Path
+
+def visualize_footprint_json(json_path, output_dir):
+    """可视化足印JSON数据"""
+    # 读取JSON数据
+    with open(json_path, 'r') as f:
+        data = json.load(f)
+    
+    # 创建输出目录
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+    
+    # 确定画布大小（从数据中获取最大坐标）
+    max_x = max_y = 0
+    for frame in data['frames']:
+        for footprint in frame['footprints']:
+            pos = footprint['position']
+            max_x = max(max_x, pos['x'] + pos['width'])
+            max_y = max(max_y, pos['y'] + pos['height'])
+    
+    for area in data['footprintArea']:
+        pos = area['areaPosition']
+        max_x = max(max_x, pos['x'] + pos['width'])
+        max_y = max(max_y, pos['y'] + pos['height'])
+    
+    # 添加一些边距
+    canvas_width = max_x + 50
+    canvas_height = max_y + 50
+    
+    # 颜色映射
+    color_map = {
+        'leftFront': (0, 255, 0),    # 绿色
+        'rightFront': (0, 255, 255),  # 黄色
+        'leftHind': (255, 0, 255),    # 紫色
+        'rightHind': (0, 165, 255),   # 橙色
+        'unknown': (128, 128, 128)    # 灰色
+    }
+    
+    # 1. 绘制所有足印区域的覆盖范围
+    area_canvas = np.ones((canvas_height, canvas_width, 3), dtype=np.uint8) * 255
+    for area in data['footprintArea']:
+        pos = area['areaPosition']
+        color = color_map[area['type']]
+        
+        # 绘制区域边界框
+        cv2.rectangle(area_canvas, 
+                     (pos['x'], pos['y']), 
+                     (pos['x'] + pos['width'], pos['y'] + pos['height']), 
+                     color, 2)
+        
+        # 添加标签
+        label = f"{area['type']}#{area['footprintAreaId'].split('_')[-1]}"
+        cv2.putText(area_canvas, label, 
+                    (pos['x'], pos['y'] - 5),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
+    
+    # 保存足印区域图
+    cv2.imwrite(str(output_dir / 'footprint_areas.png'), area_canvas)
+    
+    # 2. 为每一帧创建可视化
+    frame_ids = sorted(list(set(frame['frameId'] for frame in data['frames'])))
+    for frame_id in frame_ids:
+        frame_canvas = np.ones((canvas_height, canvas_width, 3), dtype=np.uint8) * 255
+        
+        # 首先绘制所有区域的轮廓（半透明）
+        overlay = frame_canvas.copy()
+        for area in data['footprintArea']:
+            if area['startFrame'] <= frame_id <= area['endFrame']:
+                pos = area['areaPosition']
+                color = color_map[area['type']]
+                cv2.rectangle(overlay, 
+                            (pos['x'], pos['y']), 
+                            (pos['x'] + pos['width'], pos['y'] + pos['height']), 
+                            color, -1)  # 填充矩形
+        
+        # 应用半透明效果
+        alpha = 0.3
+        cv2.addWeighted(overlay, alpha, frame_canvas, 1 - alpha, 0, frame_canvas)
+        
+        # 然后绘制当前帧的足印
+        for frame_data in data['frames']:
+            if frame_data['frameId'] == frame_id:
+                for footprint in frame_data['footprints']:
+                    pos = footprint['position']
+                    color = color_map[footprint['type']]
+                    
+                    # 绘制足印边界框
+                    cv2.rectangle(frame_canvas, 
+                                (pos['x'], pos['y']), 
+                                (pos['x'] + pos['width'], pos['y'] + pos['height']), 
+                                color, 2)
+                    
+                    # 添加标签
+                    label = f"{footprint['type']}#{footprint['id'].split('_')[-1]}"
+                    cv2.putText(frame_canvas, label, 
+                              (pos['x'], pos['y'] - 5),
+                              cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 1)
+        
+        # 添加帧号
+        cv2.putText(frame_canvas, f"Frame: {frame_id}", 
+                    (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
+        
+        # 保存帧图像
+        cv2.imwrite(str(output_dir / f'frame_{frame_id:04d}.png'), frame_canvas)
+    
+    print(f"可视化结果已保存至: {output_dir}")
+
+def main():
+    # 假设JSON文件在results目录下的最新时间戳文件夹中
+    results_dir = Path("results")
+    latest_dir = max(results_dir.glob("*"), key=lambda p: p.stat().st_mtime)
+    json_path = latest_dir / "data" / "footprint_data.json"
+    
+    # 创建可视化输出目录
+    output_dir = latest_dir / "visualization"
+    
+    visualize_footprint_json(json_path, output_dir)
+
+if __name__ == "__main__":
+    main()