Update app.py

app.py

@@ -281,72 +281,73 @@ import torch
 import os
 import shutil
 import subprocess
-import time, json, uuid
+import time
+import json
+import uuid
 from pathlib import Path
 import tempfile
-from inference import load_model, run
 from skimage import measure
-# === 图像处理依赖 ===
-from scipy.ndimage import label
 from matplotlib import cm
 
+# ===== 导入三个推理模块 =====
+from inference_seg import load_model as load_seg_model, run as run_seg
+from inference_count import load_model as load_count_model, run as run_count
+from inference_track import load_model as load_track_model, run as run_track
+
 # ===== 清理缓存目录 =====
-print("===== Space Usage =====")
-subprocess.run("du -sh *", shell=True)
-print("===== ~/.cache =====")
-subprocess.run("ls -lh ~/.cache", shell=True)
+print("===== Cleaning Cache =====")
 cache_path = os.path.expanduser("~/.cache")
 if os.path.exists(cache_path):
-    shutil.rmtree(cache_path)
-    print("✅ Deleted ~/.cache to free space.")
-
-# ===== 模型初始化 =====
-MODEL = None
-DEVICE = torch.device("cpu")
-CUDA_READY = False
+    try:
+        shutil.rmtree(cache_path)
+        print("✅ Deleted ~/.cache to free space.")
+    except:
+        print("⚠️ Could not delete cache")
+
+# ===== 全局模型变量 =====
+SEG_MODEL = None
+SEG_DEVICE = torch.device("cpu")
+
+COUNT_MODEL = None
+COUNT_DEVICE = torch.device("cpu")
+
+TRACK_MODEL = None
+TRACK_DEVICE = torch.device("cpu")
+
+def load_all_models():
+    """启动时加载所有模型"""
+    global SEG_MODEL, SEG_DEVICE
+    global COUNT_MODEL, COUNT_DEVICE
+    global TRACK_MODEL, TRACK_DEVICE
+    
+    # 加载分割模型
+    print("\n" + "="*60)
+    print("📦 Loading Segmentation Model")
+    print("="*60)
+    SEG_MODEL, SEG_DEVICE = load_seg_model(use_box=False)
+    
+    # 加载计数模型
+    print("\n" + "="*60)
+    print("📦 Loading Counting Model")
+    print("="*60)
+    COUNT_MODEL, COUNT_DEVICE = load_count_model(use_box=False)
+    
+    # 加载跟踪模型
+    print("\n" + "="*60)
+    print("📦 Loading Tracking Model")
+    print("="*60)
+    TRACK_MODEL, TRACK_DEVICE = load_track_model(use_box=False)
+    
+    print("\n" + "="*60)
+    print("✅ All Models Loaded Successfully")
+    print("="*60)
 
-# 用于counting和tracking的模型
-COUNTING_MODEL = None
-TRACKING_MODEL = None
+# 启动时加载所有模型
+load_all_models()
 
-def load_model_cpu():
-    global MODEL, DEVICE
-    MODEL, DEVICE = load_model(use_box=False)
-    
-load_model_cpu()
-
-def load_counting_model():
-    """
-    加载计数模型
-    替换为你的计数模型加载代码
-    """
-    global COUNTING_MODEL
-    # TODO: 替换为实际的计数模型
-    # 例如: COUNTING_MODEL = torch.load("counting_model.pth")
-    print("✅ Counting model loaded (placeholder)")
-    pass
-
-def load_tracking_model():
-    """
-    加载跟踪模型
-    替换为你的跟踪模型加载代码
-    """
-    global TRACKING_MODEL
-    # TODO: 替换为实际的跟踪模型
-    # 例如: TRACKING_MODEL = torch.load("tracking_model.pth")
-    print("✅ Tracking model loaded (placeholder)")
-    pass
-
-def prepare_cuda():
-    global MODEL, DEVICE, CUDA_READY
-    if torch.cuda.is_available() and not CUDA_READY:
-        MODEL.to("cuda")
-        DEVICE = torch.device("cuda")
-        CUDA_READY = True
-        _ = torch.zeros(1, device=DEVICE)
-
-# ===== BBox 解析 =====
+# ===== 辅助函数 =====
 def parse_first_bbox(bboxes):
+    """解析第一个边界框"""
     if not bboxes:
         return None
     b = bboxes[0]
@@ -358,35 +359,8 @@ def parse_first_bbox(bboxes):
         return float(b[0]), float(b[1]), float(b[2]), float(b[3])
     return None
 
-# ===== 保存用户反馈 =====
-DATASET_DIR = Path("solver_cache")
-DATASET_DIR.mkdir(parents=True, exist_ok=True)
-
-def save_feedback(query_id, feedback_type, feedback_text=None, img_path=None, bboxes=None):
-    feedback_data = {
-        "query_id": query_id,
-        "feedback_type": feedback_type,
-        "feedback_text": feedback_text,
-        "image": img_path,
-        "bboxes": bboxes,
-        "datetime": time.strftime("%Y%m%d_%H%M%S")
-    }
-    feedback_file = DATASET_DIR / query_id / "feedback.json"
-    feedback_file.parent.mkdir(parents=True, exist_ok=True)
-    if feedback_file.exists():
-        with feedback_file.open("r") as f:
-            existing = json.load(f)
-            if not isinstance(existing, list):
-                existing = [existing]
-            existing.append(feedback_data)
-            feedback_data = existing
-    else:
-        feedback_data = [feedback_data]
-    with feedback_file.open("w") as f:
-        json.dump(feedback_data, f, indent=4, ensure_ascii=False)
-
-# ===== 彩色 mask 可视化 =====
 def colorize_mask(mask: np.ndarray, num_colors: int = 512) -> np.ndarray:
+    """将实例掩码转换为彩色图像"""
     mask = mask.astype(np.int32)
 
     def hsv_to_rgb(hh, ss, vv):
@@ -413,17 +387,17 @@ def colorize_mask(mask: np.ndarray, num_colors: int = 512) -> np.ndarray:
     palette_arr = np.array(palette, dtype=np.uint8)
     return palette_arr[color_idx]
 
-# ===== 推理 + 实例彩色可视化 (Segmentation) =====
+# ===== 分割功能 =====
 def segment_with_choice(use_box_choice, annot_value, mode="Overlay"):
-    prepare_cuda()
+    """分割处理函数"""
     if annot_value is None or len(annot_value) < 1:
-        print("❌ No annotation input")
-        return None
+        return None, "⚠️ 请先上传图像"
 
     img_path = annot_value[0]
     bboxes = annot_value[1] if len(annot_value) > 1 else []
 
-    print(f"🖼️ Image path: {img_path}")
+    print(f"🖼️ Segmentation - Image: {img_path}")
+    
     box_array = None
     if use_box_choice == "Yes" and bboxes:
         box = parse_first_bbox(bboxes)
@@ -433,284 +407,221 @@ def segment_with_choice(use_box_choice, annot_value, mode="Overlay"):
             print(f"📦 Using box: {box_array}")
 
     try:
-        mask = run(MODEL, img_path, box=box_array, device=DEVICE)
-        print("📏 Mask shape:", mask.shape, "dtype:", mask.dtype, "unique:", np.unique(mask))
-    except Exception as e:
-        print(f"❌ Error during inference: {e}")
-        return None
-
-    try:
-        img = Image.open(img_path)
-        print("📷 Image mode:", img.mode, "size:", img.size)
+        # 运行分割
+        mask = run_seg(SEG_MODEL, img_path, box=box_array, device=SEG_DEVICE)
+        
+        if mask is None:
+            return None, "❌ 分割失败"
+        
+        print(f"✅ Segmentation done - Mask shape: {mask.shape}")
     except Exception as e:
-        print(f"❌ Failed to open image: {e}")
-        return None
+        print(f"❌ Segmentation error: {e}")
+        return None, f"分割失败: {str(e)}"
 
     try:
-        img_rgb = img.convert("RGB").resize(mask.shape[::-1], resample=Image.BILINEAR)
+        # 读取原图
+        img = Image.open(img_path).convert("RGB")
+        img_rgb = img.resize(mask.shape[::-1], resample=Image.BILINEAR)
         img_np = np.array(img_rgb, dtype=np.float32)
         if img_np.max() > 1.5:
             img_np = img_np / 255.0
     except Exception as e:
-        print(f"❌ Error in image conversion/resizing: {e}")
-        return None
+        print(f"❌ Image processing error: {e}")
+        return None, f"图像处理失败: {str(e)}"
 
+    # 生成可视化
     mask_np = np.array(mask)
     inst_mask = mask_np.astype(np.int32)
     unique_ids = np.unique(inst_mask)
     num_instances = len(unique_ids[unique_ids != 0])
-    print(f"✅ Instance IDs found: {unique_ids}, Total instances: {num_instances}")
-
+    
     if num_instances == 0:
-        print("⚠️ No instance found, returning dummy red image")
-        return Image.new("RGB", mask.shape[::-1], (255, 0, 0))
+        result_text = "⚠️ 未检测到细胞"
+        return Image.new("RGB", mask.shape[::-1], (255, 200, 200)), result_text
 
-    # ==== Color Overlay (每个实例一个颜色) ====
+    # 创建叠加图
     overlay = img_np.copy()
     alpha = 0.5
-    cmap = cm.get_cmap("nipy_spectral", num_instances + 1)
+    cmap_vis = cm.get_cmap("nipy_spectral", num_instances + 1)
 
-    for inst_id in np.unique(inst_mask):
+    for inst_id in unique_ids:
         if inst_id == 0:
             continue
         binary_mask = (inst_mask == inst_id).astype(np.uint8)
-        color = np.array(cmap(inst_id / (num_instances + 1))[:3])  # RGB only, ignore alpha
+        color = np.array(cmap_vis(inst_id / (num_instances + 1))[:3])
         overlay[binary_mask == 1] = (1 - alpha) * overlay[binary_mask == 1] + alpha * color
 
-        # 可选：绘制轮廓
+        # 绘制轮廓
         contours = measure.find_contours(binary_mask, 0.5)
         for contour in contours:
             contour = contour.astype(np.int32)
-            overlay[contour[:, 0], contour[:, 1]] = [1.0, 1.0, 0.0]  # 黄色轮廓
+            overlay[contour[:, 0], contour[:, 1]] = [1.0, 1.0, 0.0]
 
     overlay = np.clip(overlay * 255.0, 0, 255).astype(np.uint8)
+    result_text = f"✅ 检测到 {num_instances} 个细胞"
 
     if mode == "Instance Mask Only":
-        return Image.fromarray(colorize_mask(inst_mask, num_colors=512))
+        return Image.fromarray(colorize_mask(inst_mask, num_colors=512)), result_text
 
-    return Image.fromarray(overlay)
+    return Image.fromarray(overlay), result_text
 
-# ===== Counting 功能 =====
-def count_cells(image_path):
-    """
-    计数功能
-    TODO: 替换为你的计数模型推理代码
-    """
+# ===== 计数功能 =====
+def count_cells_handler(image_path):
+    """计数处理函数"""
     if image_path is None:
-        return None, "请先上传图像"
+        return None, "⚠️ 请先上传图像"
+    
+    if COUNT_MODEL is None:
+        return None, "❌ 计数模型未加载"
     
     try:
-        img = Image.open(image_path)
-        img_np = np.array(img)
-        
-        # TODO: 替换为实际的计数模型推理
-        # 示例代码:
-        # results = COUNTING_MODEL(img_np)
-        # count = len(results)
-        
-        # 临时使用��单的计数方法作为演示
-        from skimage import filters, morphology
-        gray = np.array(img.convert('L'))
-        thresh = filters.threshold_otsu(gray)
-        binary = gray > thresh
-        labeled = morphology.label(binary)
-        count = labeled.max()
+        print(f"🔢 Counting - Image: {image_path}")
         
-        # 可视化
-        import matplotlib.pyplot as plt
-        from matplotlib import cm
+        result = run_count(
+            COUNT_MODEL,
+            image_path,
+            box=None,
+            device=COUNT_DEVICE,
+            visualize=True
+        )
         
-        fig, ax = plt.subplots(1, 1, figsize=(10, 10))
-        ax.imshow(img)
+        if 'error' in result:
+            return None, f"❌ 计数失败: {result['error']}"
         
-        # 标注每个对象
-        for region_id in range(1, count + 1):
-            region_mask = labeled == region_id
-            coords = np.argwhere(region_mask)
-            if len(coords) > 0:
-                y, x = coords.mean(axis=0)
-                ax.text(x, y, str(region_id), color='red', 
-                       fontsize=12, fontweight='bold',
-                       bbox=dict(boxstyle='round', facecolor='yellow', alpha=0.7))
+        count = result['count']
+        viz_path = result['visualized_path']
+        result_text = f"✅ 检测到 {count:.1f} 个细胞"
         
-        ax.axis('off')
+        print(f"✅ Counting done - Count: {count:.1f}")
         
-        # 保存到临时文件
-        temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
-        plt.savefig(temp_file.name, bbox_inches='tight', dpi=150)
-        plt.close()
-        
-        result_text = f"🔢 检测到 {count} 个细胞"
-        print(f"✅ Counting result: {count} cells")
-        
-        return temp_file.name, result_text
+        return viz_path, result_text
         
     except Exception as e:
         print(f"❌ Counting error: {e}")
-        return None, f"计数失败: {str(e)}"
-
-# ===== Tracking 功能 =====
-def track_video(video_path, progress=gr.Progress()):
-    """
-    视频跟踪功能
-    TODO: 替换为你的跟踪模型推理代码
-    """
-    if video_path is None:
-        return None, "请先上传视频"
+        import traceback
+        traceback.print_exc()
+        return None, f"❌ 计数失败: {str(e)}"
+
+# ===== 跟踪功能 =====
+def track_video_handler(video_dir_input):
+    """跟踪处理函数"""
+    if video_dir_input is None or video_dir_input.strip() == "":
+        return None, "⚠️ 请输入视频帧目录路径"
+    
+    if TRACK_MODEL is None:
+        return None, "❌ 跟踪模型未加载"
+    
+    # 检查目录是否存在
+    if not os.path.exists(video_dir_input):
+        return None, f"❌ 目录不存在: {video_dir_input}"
     
     try:
-        import cv2
+        print(f"🎬 Tracking - Video dir: {video_dir_input}")
         
-        # 读取视频
-        cap = cv2.VideoCapture(video_path)
-        fps = int(cap.get(cv2.CAP_PROP_FPS))
-        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        result = run_track(
+            TRACK_MODEL,
+            video_dir=video_dir_input,
+            box=None,
+            device=TRACK_DEVICE,
+            output_dir="tracked_results"
+        )
         
-        # 创建输出视频
-        output_path = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4').name
-        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        if 'error' in result:
+            return None, f"❌ 跟踪失败: {result['error']}"
         
-        print(f"📹 Processing video: {total_frames} frames, {fps} fps")
+        num_tracks = result['num_tracks']
+        output_dir = result['output_dir']
         
-        # TODO: 初始化跟踪器
-        # tracker = initialize_your_tracker()
-        
-        frame_count = 0
-        while cap.isOpened():
-            ret, frame = cap.read()
-            if not ret:
-                break
-            
-            # TODO: 替换为实际的跟踪模型推理
-            # tracked_frame, tracks = TRACKING_MODEL.update(frame)
-            
-            # 临时演示: 在帧上添加文字
-            tracked_frame = frame.copy()
-            cv2.putText(tracked_frame, f"Frame {frame_count}/{total_frames}", 
-                       (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
-            
-            out.write(tracked_frame)
-            frame_count += 1
-            
-            # 更新进度条
-            if frame_count % 10 == 0:
-                progress((frame_count / total_frames, f"处理中: {frame_count}/{total_frames}"))
-        
-        cap.release()
-        out.release()
+        result_text = f"""✅ 跟踪完成!
+
+🎯 跟踪轨迹数量: {num_tracks}
+📁 结果保存在: {output_dir}
+
+包含的文件:
+- res_track.txt (CTC格式轨迹)
+- 其他跟踪数据文件
+"""
         
-        result_text = f"✅ 跟踪完成! 处理了 {frame_count} 帧"
-        print(result_text)
+        print(f"✅ Tracking done - {num_tracks} tracks")
         
-        return output_path, result_text
+        return None, result_text
         
     except Exception as e:
         print(f"❌ Tracking error: {e}")
-        return None, f"跟踪失败: {str(e)}"
-
-# ===== 示例图像 =====
-example_data = [
-    ("003_img.png", [(50, 60, 120, 150, "cell")]),
-    ("1977_Well_F-5_Field_1.png", [(30, 40, 100, 130, "cell")]),
-]
-gallery_images = [p for p, _ in example_data]
+        import traceback
+        traceback.print_exc()
+        return None, f"❌ 跟踪失败: {str(e)}"
 
 # ===== Gradio UI =====
 with gr.Blocks(title="Microscopy Analysis Suite", theme=gr.themes.Soft()) as demo:
     gr.Markdown(
         """
         # 🔬 显微图像分析工具套件
-        支持三种分析模式: 分割 (Segmentation) | 计数 (Counting) | 跟踪 (Tracking)
+        
+        支持三种分析模式:
+        - 🎨 **分割 (Segmentation)**: 实例分割，每个细胞不同颜色
+        - 🔢 **计数 (Counting)**: 基于密度图的细胞计数
+        - 🎬 **跟踪 (Tracking)**: 视频序列中的细胞运动跟踪
         """
     )
     
     with gr.Tabs():
         # ===== Tab 1: Segmentation =====
         with gr.Tab("🎨 分割 (Segmentation)"):
-            gr.Markdown("## 🧬 细胞分割 — 每个细胞一个颜色")
+            gr.Markdown("## 细胞实例分割 - 每个细胞一个颜色")
             
             with gr.Row():
                 with gr.Column(scale=1):
-                    annotator = BBoxAnnotator(label="🖼️ 上传 & 标注", categories=["cell"])
-
-                    example_gallery = gr.Gallery(
-                        value=gallery_images,
-                        label="📁 示例图像",
-                        columns=[3], object_fit="cover", height=128
+                    annotator = BBoxAnnotator(
+                        label="🖼️ 上传图像 (可选标注边界框)",
+                        categories=["cell"]
+                    )
+                    
+                    with gr.Row():
+                        use_box_radio = gr.Radio(
+                            choices=["Yes", "No"],
+                            value="No",
+                            label="🔲 使用边界框?"
+                        )
+                        mode_radio = gr.Radio(
+                            choices=["Overlay", "Instance Mask Only"],
+                            value="Overlay",
+                            label="🎨 显示模式"
+                        )
+                    
+                    run_seg_btn = gr.Button("▶️ 运行分割", variant="primary", size="lg")
+                    
+                    gr.Markdown(
+                        """
+                        **使用说明:**
+                        1. 上传图像
+                        2. (可选) 标注边界框并选择 "Yes"
+                        3. 选择显示模式
+                        4. 点击 "运行分割"
+                        """
                     )
-
-                    image_uploader = gr.Image(label="➕ 上传图像", type="filepath")
-
-                    run_btn = gr.Button("▶️ 运行分割", variant="primary")
-                    use_box_radio = gr.Radio(choices=["Yes", "No"], label="🔲 使用边界框?", visible=False)
-                    confirm_btn = gr.Button("✅ 确认", visible=False)
-                    mode_radio = gr.Radio(choices=["Overlay", "Instance Mask Only"], value="Overlay",
-                                          label="🎨 显示模式")
 
                 with gr.Column(scale=2):
-                    image_output = gr.Image(type="pil", label="📸 分割结果", height=400)
-                    score = gr.Slider(1, 5, step=1, value=3, label="🌟 满意度 (1–5)")
-                    comment_box = gr.Textbox(placeholder="输入您的反馈...", lines=2, label="💬 反馈")
-                    submit_score = gr.Button("💾 提交评分")
-
-            user_uploaded_images = gr.State([])
-
-            def add_uploaded_image(img_path, current_gallery):
-                if not img_path:
-                    return current_gallery
-                try:
-                    img = Image.open(img_path)
-                    img.thumbnail((128, 128))
-                    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
-                    img.save(temp_file.name, format="PNG")
-                    thumb_path = temp_file.name
-                    if thumb_path not in current_gallery:
-                        current_gallery.append(thumb_path)
-                except Exception as e:
-                    print(f"❌ Failed image: {e}")
-                return current_gallery
-
-            image_uploader.upload(add_uploaded_image, [image_uploader, user_uploaded_images], 
-                                 [example_gallery, user_uploaded_images])
-
-            def on_gallery_select(evt: gr.SelectData, gallery_images):
-                index = evt.index
-                if index < len(example_data):
-                    selected_path, selected_boxes = example_data[index]
-                    return selected_path, selected_boxes
-                else:
-                    selected_path = gallery_images[index]
-                    return selected_path, []
-
-            example_gallery.select(on_gallery_select, inputs=[user_uploaded_images], outputs=[annotator])
-
-            def show_radio():
-                return gr.update(visible=True), gr.update(visible=True)
-
-            run_btn.click(fn=show_radio, outputs=[use_box_radio, confirm_btn])
-            confirm_btn.click(fn=segment_with_choice,
-                              inputs=[use_box_radio, annotator, mode_radio],
-                              outputs=image_output)
-
-            def handle_comment(comment, annot_value):
-                save_feedback(time.strftime("%Y%m%d_%H%M%S") + "_" + str(uuid.uuid4())[:8], 
-                            "comment", comment, annot_value[0], annot_value[1])
-                return ""
-
-            def handle_rating(score, annot_value):
-                save_feedback(time.strftime("%Y%m%d_%H%M%S") + "_" + str(uuid.uuid4())[:8], 
-                            "rating", f"Satisfaction Score: {score}", annot_value[0], annot_value[1])
-                return 3
-
-            comment_box.submit(fn=handle_comment, inputs=[comment_box, annotator], outputs=[comment_box])
-            submit_score.click(fn=handle_rating, inputs=[score, annotator], outputs=[score])
+                    seg_output = gr.Image(
+                        type="pil",
+                        label="📸 分割结果",
+                        height=500
+                    )
+                    seg_status = gr.Textbox(
+                        label="📊 状态信息",
+                        lines=2
+                    )
+            
+            # 绑定事件
+            run_seg_btn.click(
+                fn=segment_with_choice,
+                inputs=[use_box_radio, annotator, mode_radio],
+                outputs=[seg_output, seg_status]
+            )
         
         # ===== Tab 2: Counting =====
         with gr.Tab("🔢 计数 (Counting)"):
-            gr.Markdown("## 细胞计数分析")
+            gr.Markdown("## 细胞计数分析 - 基于密度图")
             
             with gr.Row():
                 with gr.Column(scale=1):
@@ -718,127 +629,117 @@ with gr.Blocks(title="Microscopy Analysis Suite", theme=gr.themes.Soft()) as dem
                         label="🖼️ 上传图像",
                         type="filepath"
                     )
-                    count_btn = gr.Button("▶️ 运行计数", variant="primary")
+                    count_btn = gr.Button("▶️ 运行计数", variant="primary", size="lg")
                     
                     gr.Markdown(
                         """
-                        **说明:**
-                        - 自动检测并计数图像中的细胞
-                        - 结果会在图像上标注编号
+                        **使用说明:**
+                        1. 上传细胞图像
+                        2. 点击 "运行计数"
+                        3. 查看密度图和计数结果
+                        
+                        **特点:**
+                        - 基于 Stable Diffusion 特征
+                        - 自动生成密度图
+                        - 无需手动标注
                         """
                     )
                 
                 with gr.Column(scale=2):
-                    count_output_img = gr.Image(
-                        label="📸 计数结果",
-                        type="filepath"
+                    count_output = gr.Image(
+                        label="📸 计数结果 (左: 原图 | 右: 密度图)",
+                        type="filepath",
+                        height=500
                     )
-                    count_output_text = gr.Textbox(
-                        label="🔢 统计信息",
+                    count_status = gr.Textbox(
+                        label="📊 统计信息",
                         lines=2
                     )
-                    
-                    count_score = gr.Slider(1, 5, step=1, value=3, label="🌟 满意度 (1–5)")
-                    count_comment = gr.Textbox(placeholder="输入反馈...", lines=2, label="💬 反馈")
-                    count_submit = gr.Button("💾 提交评分")
             
             # 绑定事件
             count_btn.click(
-                fn=count_cells,
+                fn=count_cells_handler,
                 inputs=count_input,
-                outputs=[count_output_img, count_output_text]
-            )
-            
-            def handle_count_feedback(score, comment, img_path):
-                if img_path:
-                    save_feedback(
-                        time.strftime("%Y%m%d_%H%M%S") + "_count_" + str(uuid.uuid4())[:8],
-                        "counting",
-                        f"Score: {score}, Comment: {comment}",
-                        img_path,
-                        None
-                    )
-                return 3, ""
-            
-            count_submit.click(
-                fn=handle_count_feedback,
-                inputs=[count_score, count_comment, count_input],
-                outputs=[count_score, count_comment]
+                outputs=[count_output, count_status]
             )
         
         # ===== Tab 3: Tracking =====
         with gr.Tab("🎬 跟踪 (Tracking)"):
-            gr.Markdown("## 视频细胞跟踪")
+            gr.Markdown("## 视频细胞跟踪 - 时间序列分析")
             
             with gr.Row():
                 with gr.Column(scale=1):
-                    track_input = gr.Video(
-                        label="📹 上传视频"
+                    track_input = gr.Textbox(
+                        label="📁 视频帧目录路径",
+                        placeholder="例如: example_imgs/2D+Time/Fluo-N2DL-HeLa/train/02/",
+                        lines=2
                     )
-                    track_btn = gr.Button("▶️ 运行跟踪", variant="primary")
+                    track_btn = gr.Button("▶️ 运行跟踪", variant="primary", size="lg")
                     
                     gr.Markdown(
                         """
-                        **说明:**
-                        - 支持格式: MP4, AVI, MOV
-                        - 自动跟踪视频中的细胞运动
-                        - 处理时间取决于视频长度
+                        **使用说明:**
+                        1. 输入包含视频帧序列的目录路径
+                        2. 目录应包含: t000.tif, t001.tif, ...
+                        3. 点击 "运行跟踪"
+                        4. 结果将保存到 `tracked_results/` 目录
+                        
+                        **输入格式:**
+                        ```
+                        video_dir/
+                        ├── t000.tif
+                        ├── t001.tif
+                        ├── t002.tif
+                        └── ...
+                        ```
+                        
+                        **跟踪模式:** Greedy (快速)
                         """
                     )
                 
                 with gr.Column(scale=2):
-                    track_output_video = gr.Video(
-                        label="📸 跟踪结果"
+                    track_output = gr.Video(
+                        label="📹 跟踪结果视频 (暂不支持)",
+                        visible=False
                     )
-                    track_output_text = gr.Textbox(
-                        label="📊 处理状态",
-                        lines=2
+                    track_status = gr.Textbox(
+                        label="📊 跟踪信息",
+                        lines=10
                     )
-                    
-                    track_score = gr.Slider(1, 5, step=1, value=3, label="🌟 满意度 (1–5)")
-                    track_comment = gr.Textbox(placeholder="输入反馈...", lines=2, label="💬 反馈")
-                    track_submit = gr.Button("💾 提交评分")
             
             # 绑定事件
             track_btn.click(
-                fn=track_video,
+                fn=track_video_handler,
                 inputs=track_input,
-                outputs=[track_output_video, track_output_text]
-            )
-            
-            def handle_track_feedback(score, comment, video_path):
-                if video_path:
-                    save_feedback(
-                        time.strftime("%Y%m%d_%H%M%S") + "_track_" + str(uuid.uuid4())[:8],
-                        "tracking",
-                        f"Score: {score}, Comment: {comment}",
-                        video_path,
-                        None
-                    )
-                return 3, ""
-            
-            track_submit.click(
-                fn=handle_track_feedback,
-                inputs=[track_score, track_comment, track_input],
-                outputs=[track_score, track_comment]
+                outputs=[track_output, track_status]
             )
 
-    # ===== 页脚 =====
     gr.Markdown(
         """
         ---
-        ### 💡 功能说明
-        - **Segmentation**: 分割并可视化图像中的每个细胞
-        - **Counting**: 自动计数图像中的细胞数量
-        - **Tracking**: 跟踪视频中细胞的运动轨迹
+        ### 💡 技术说明
+        
+        **分割 (Segmentation)**
+        - 模型: 基于 Stable Diffusion 特征的实例分割
+        - 输出: 每个细胞一个唯一颜色的掩码
+        
+        **计数 (Counting)**
+        - 模型: 密度图估计
+        - 输出: 密度热力图 + 总计数
+        
+        **跟踪 (Tracking)**
+        - 模型: Trackastra 跟踪算法
+        - 输出: CTC 格式的轨迹文件
+        
+        ---
+        📧 问题反馈 | 🌟 GitHub
         """
     )
 
 if __name__ == "__main__":
     demo.queue().launch(
-        server_name="0.0.0.0", 
-        server_port=7860, 
-        share=True, 
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
         show_error=True
     )
-