Upload 5 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+003_img.png filter=lfs diff=lfs merge=lfs -text
+1977_Well_F-5_Field_1.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,12 @@
+---
+title: Celltool
+emoji: 🌖
+colorFrom: purple
+colorTo: gray
+sdk: gradio
+sdk_version: 5.49.1
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,844 @@
+# import gradio as gr
+# from gradio_bbox_annotator import BBoxAnnotator
+# from PIL import Image
+# import numpy as np
+# import torch
+# import os
+# import shutil
+# import subprocess
+# import time, json, 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
+# # ===== 清理缓存目录 =====
+# print("===== Space Usage =====")
+# subprocess.run("du -sh *", shell=True)
+# print("===== ~/.cache =====")
+# subprocess.run("ls -lh ~/.cache", shell=True)
+# 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
+
+# def load_model_cpu():
+#     global MODEL, DEVICE
+#     MODEL, DEVICE = load_model(use_box=False)
+# load_model_cpu()
+
+# 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]
+#     if isinstance(b, dict):
+#         x, y = float(b.get("x", 0)), float(b.get("y", 0))
+#         w, h = float(b.get("width", 0)), float(b.get("height", 0))
+#         return x, y, x + w, y + h
+#     if isinstance(b, (list, tuple)) and len(b) >= 4:
+#         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):
+#         i = int(hh * 6.0)
+#         f = hh * 6.0 - i
+#         p = vv * (1.0 - ss)
+#         q = vv * (1.0 - f * ss)
+#         t = vv * (1.0 - (1.0 - f) * ss)
+#         i = i % 6
+#         if i == 0: r, g, b = vv, t, p
+#         elif i == 1: r, g, b = q, vv, p
+#         elif i == 2: r, g, b = p, vv, t
+#         elif i == 3: r, g, b = p, q, vv
+#         elif i == 4: r, g, b = t, p, vv
+#         else: r, g, b = vv, p, q
+#         return int(r*255), int(g*255), int(b*255)
+
+#     palette = [(0, 0, 0)]
+#     for k in range(1, num_colors):
+#         hue = (k % num_colors) / float(num_colors)
+#         palette.append(hsv_to_rgb(hue, 1.0, 0.95))
+
+#     color_idx = mask % num_colors
+#     palette_arr = np.array(palette, dtype=np.uint8)
+#     return palette_arr[color_idx]
+
+# # ===== 推理 + 实例彩色可视化 =====
+# 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
+
+#     img_path = annot_value[0]
+#     bboxes = annot_value[1] if len(annot_value) > 1 else []
+
+#     print(f"🖼️ Image path: {img_path}")
+#     box_array = None
+#     if use_box_choice == "Yes" and bboxes:
+#         box = parse_first_bbox(bboxes)
+#         if box:
+#             xmin, ymin, xmax, ymax = map(int, box)
+#             box_array = [[xmin, ymin, xmax, ymax]]
+#             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)
+#     except Exception as e:
+#         print(f"❌ Failed to open image: {e}")
+#         return None
+
+#     try:
+#         img_rgb = img.convert("RGB").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
+
+#     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))
+
+#     # ==== Color Overlay (每个实例一个颜色) ====
+#     overlay = img_np.copy()
+#     alpha = 0.5
+#     cmap = cm.get_cmap("nipy_spectral", num_instances + 1)
+
+#     for inst_id in np.unique(inst_mask):
+#         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
+#         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 = np.clip(overlay * 255.0, 0, 255).astype(np.uint8)
+
+#     if mode == "Instance Mask Only":
+#         return Image.fromarray(colorize_mask(inst_mask, num_colors=512))
+
+#     return Image.fromarray(overlay)
+
+# # ===== 示例图像 =====
+# 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]
+
+# # ===== Gradio UI =====
+# with gr.Blocks(title="Microscopy Cell Segmentation") as demo:
+#     gr.Markdown("## 🧬 Microscopy Image Segmentation — One Cell, One Color")
+
+#     with gr.Row():
+#         with gr.Column(scale=1):
+#             annotator = BBoxAnnotator(label="🖼️ Upload & Annotate", categories=["cell"])
+
+#             example_gallery = gr.Gallery(
+#                 value=gallery_images,
+#                 label="📁 Example Inputs",
+#                 columns=[3], object_fit="cover", height=128
+#             )
+
+#             image_uploader = gr.Image(label="➕ Upload Image", type="filepath")
+
+#             run_btn = gr.Button("▶️ Run Segmentation")
+#             use_box_radio = gr.Radio(choices=["Yes", "No"], label="🔲 Use Bounding Box?", visible=False)
+#             confirm_btn = gr.Button("✅ Confirm", visible=False)
+#             mode_radio = gr.Radio(choices=["Overlay", "Instance Mask Only"], value="Overlay",
+#                                   label="🎨 Display Mode")
+
+#         with gr.Column(scale=2):
+#             image_output = gr.Image(type="pil", label="📸 Segmentation Result", height=400)
+#             score = gr.Slider(1, 5, step=1, value=3, label="🌟 Satisfaction (1–5)")
+#             comment_box = gr.Textbox(placeholder="Type your feedback...", lines=2, label="💬 Feedback")
+#             submit_score = gr.Button("💾 Submit Rating")
+
+#     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])
+
+# if __name__ == "__main__":
+#     demo.queue().launch(server_name="0.0.0.0", server_port=7860, share=True, show_error=True)
+import gradio as gr
+from gradio_bbox_annotator import BBoxAnnotator
+from PIL import Image
+import numpy as np
+import torch
+import os
+import shutil
+import subprocess
+import time, json, 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
+
+# ===== 清理缓存目录 =====
+print("===== Space Usage =====")
+subprocess.run("du -sh *", shell=True)
+print("===== ~/.cache =====")
+subprocess.run("ls -lh ~/.cache", shell=True)
+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
+
+# 用于counting和tracking的模型
+COUNTING_MODEL = None
+TRACKING_MODEL = None
+
+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]
+    if isinstance(b, dict):
+        x, y = float(b.get("x", 0)), float(b.get("y", 0))
+        w, h = float(b.get("width", 0)), float(b.get("height", 0))
+        return x, y, x + w, y + h
+    if isinstance(b, (list, tuple)) and len(b) >= 4:
+        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):
+        i = int(hh * 6.0)
+        f = hh * 6.0 - i
+        p = vv * (1.0 - ss)
+        q = vv * (1.0 - f * ss)
+        t = vv * (1.0 - (1.0 - f) * ss)
+        i = i % 6
+        if i == 0: r, g, b = vv, t, p
+        elif i == 1: r, g, b = q, vv, p
+        elif i == 2: r, g, b = p, vv, t
+        elif i == 3: r, g, b = p, q, vv
+        elif i == 4: r, g, b = t, p, vv
+        else: r, g, b = vv, p, q
+        return int(r*255), int(g*255), int(b*255)
+
+    palette = [(0, 0, 0)]
+    for k in range(1, num_colors):
+        hue = (k % num_colors) / float(num_colors)
+        palette.append(hsv_to_rgb(hue, 1.0, 0.95))
+
+    color_idx = mask % num_colors
+    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
+
+    img_path = annot_value[0]
+    bboxes = annot_value[1] if len(annot_value) > 1 else []
+
+    print(f"🖼️ Image path: {img_path}")
+    box_array = None
+    if use_box_choice == "Yes" and bboxes:
+        box = parse_first_bbox(bboxes)
+        if box:
+            xmin, ymin, xmax, ymax = map(int, box)
+            box_array = [[xmin, ymin, xmax, ymax]]
+            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)
+    except Exception as e:
+        print(f"❌ Failed to open image: {e}")
+        return None
+
+    try:
+        img_rgb = img.convert("RGB").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
+
+    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))
+
+    # ==== Color Overlay (每个实例一个颜色) ====
+    overlay = img_np.copy()
+    alpha = 0.5
+    cmap = cm.get_cmap("nipy_spectral", num_instances + 1)
+
+    for inst_id in np.unique(inst_mask):
+        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
+        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 = np.clip(overlay * 255.0, 0, 255).astype(np.uint8)
+
+    if mode == "Instance Mask Only":
+        return Image.fromarray(colorize_mask(inst_mask, num_colors=512))
+
+    return Image.fromarray(overlay)
+
+# ===== Counting 功能 =====
+def count_cells(image_path):
+    """
+    计数功能
+    TODO: 替换为你的计数模型推理代码
+    """
+    if image_path 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()
+        
+        # 可视化
+        import matplotlib.pyplot as plt
+        from matplotlib import cm
+        
+        fig, ax = plt.subplots(1, 1, figsize=(10, 10))
+        ax.imshow(img)
+        
+        # 标注每个对象
+        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))
+        
+        ax.axis('off')
+        
+        # 保存到临时文件
+        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
+        
+    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, "请先上传视频"
+    
+    try:
+        import cv2
+        
+        # 读取视频
+        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))
+        
+        # 创建输出视频
+        output_path = tempfile.NamedTemporaryFile(delete=False, suffix='.mp4').name
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        
+        print(f"📹 Processing video: {total_frames} frames, {fps} fps")
+        
+        # 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"✅ 跟踪完成! 处理了 {frame_count} 帧"
+        print(result_text)
+        
+        return output_path, 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]
+
+# ===== Gradio UI =====
+with gr.Blocks(title="Microscopy Analysis Suite", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 🔬 显微图像分析工具套件
+        支持三种分析模式: 分割 (Segmentation) | 计数 (Counting) | 跟踪 (Tracking)
+        """
+    )
+    
+    with gr.Tabs():
+        # ===== Tab 1: Segmentation =====
+        with gr.Tab("🎨 分割 (Segmentation)"):
+            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
+                    )
+
+                    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])
+        
+        # ===== Tab 2: Counting =====
+        with gr.Tab("🔢 计数 (Counting)"):
+            gr.Markdown("## 细胞计数分析")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    count_input = gr.Image(
+                        label="🖼️ 上传图像",
+                        type="filepath"
+                    )
+                    count_btn = gr.Button("▶️ 运行计数", variant="primary")
+                    
+                    gr.Markdown(
+                        """
+                        **说明:**
+                        - 自动检测并计数图像中的细胞
+                        - 结果会在图像上标注编号
+                        """
+                    )
+                
+                with gr.Column(scale=2):
+                    count_output_img = gr.Image(
+                        label="📸 计数结果",
+                        type="filepath"
+                    )
+                    count_output_text = 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,
+                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]
+            )
+        
+        # ===== Tab 3: Tracking =====
+        with gr.Tab("🎬 跟踪 (Tracking)"):
+            gr.Markdown("## 视频细胞跟踪")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    track_input = gr.Video(
+                        label="📹 上传视频"
+                    )
+                    track_btn = gr.Button("▶️ 运行跟踪", variant="primary")
+                    
+                    gr.Markdown(
+                        """
+                        **说明:**
+                        - 支持格式: MP4, AVI, MOV
+                        - 自动跟踪视频中的细胞运动
+                        - 处理时间取决于视频长度
+                        """
+                    )
+                
+                with gr.Column(scale=2):
+                    track_output_video = gr.Video(
+                        label="📸 跟踪结果"
+                    )
+                    track_output_text = gr.Textbox(
+                        label="📊 处理状态",
+                        lines=2
+                    )
+                    
+                    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,
+                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]
+            )
+
+    # ===== 页脚 =====
+    gr.Markdown(
+        """
+        ---
+        ### 💡 功能说明
+        - **Segmentation**: 分割并可视化图像中的每个细胞
+        - **Counting**: 自动计数图像中的细胞数量
+        - **Tracking**: 跟踪视频中细胞的运动轨迹
+        """
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        share=True, 
+        show_error=True
+    )
+

requirements.txt

@@ -0,0 +1,47 @@
+# PyTorch 2.4.1 + torchvision
+torch==2.4.1
+torchvision==0.19.1
+torchaudio==2.4.1
+# Core dependencies
+diffusers==0.29.0
+transformers==4.37.2
+huggingface_hub==0.24.1
+accelerate==0.23.0
+pyrallis
+easydict
+omegaconf==2.1.1
+einops==0.3.0
+torch-fidelity==0.3.0
+torchmetrics>=0.11.0
+pytorch-lightning==2.0.9
+taming-transformers @ git+https://github.com/CompVis/taming-transformers.git@master
+clip @ git+https://github.com/openai/CLIP.git@main
+
+# Computer vision
+opencv-python==4.5.5.64              # ✅ 避免 dnn.DictValue 错误
+opencv-python-headless==4.5.5.64     # ✅ 防止系统默认装新版导致冲突（和 GUI 冲突不大）
+kornia==0.6
+albumentations==0.4.3
+imageio>=2.27                        # ✅ 保证兼容 scikit-image 0.21.0
+imageio-ffmpeg==0.4.2
+matplotlib
+scikit-image==0.21.0
+Pillow
+segment-anything
+numpy==1.24.4                        # ✅ 避免 numpy 2.x 引发 ABI 问题              
+
+# Gradio
+gradio
+gradio-bbox-annotator
+
+# Utilities
+natsort
+roifile
+fill-voids
+configargparse
+ipywidgets
+ftfy
+sniffio
+websocket-client
+dask
+tensorboard