Delete app_cn.py

app_cn.py

@@ -1,1515 +0,0 @@
-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 time
-import json
-import uuid
-from pathlib import Path
-import tempfile
-import zipfile
-from skimage import measure
-from matplotlib import cm
-from glob import glob
-from natsort import natsorted
-
-# ===== 导入三个推理模块 =====
-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("===== 清理缓存 =====")
-# cache_path = os.path.expanduser("~/.cache/")
-cache_path = os.path.expanduser("~/.cache/huggingface/gradio")
-if os.path.exists(cache_path):
-    try:
-        shutil.rmtree(cache_path)
-        # print("✅ Deleted ~/.cache/")
-        print("✅ Deleted ~/.cache/huggingface/gradio")
-    except:
-        pass
-
-# ===== 全局模型变量 =====
-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)
-
-load_all_models()
-
-# ===== 保存用户反馈 =====
-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):
-    """保存用户反馈到JSON文件"""
-    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)
-
-# ===== 辅助函数 =====
-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
-
-def colorize_mask(mask: np.ndarray, num_colors: int = 512) -> np.ndarray:
-    """将实例掩码转换为彩色图像"""
-    def hsv_to_rgb(h, s, v):
-        i = int(h * 6.0)
-        f = h * 6.0 - i
-        i = i % 6
-        p = v * (1 - s)
-        q = v * (1 - f * s)
-        t = v * (1 - (1 - f) * s)
-        if i == 0: r, g, b = v, t, p
-        elif i == 1: r, g, b = q, v, p
-        elif i == 2: r, g, b = p, v, t
-        elif i == 3: r, g, b = p, q, v
-        elif i == 4: r, g, b = t, p, v
-        else: r, g, b = v, p, q
-        return int(r * 255), int(g * 255), int(b * 255)
-
-    palette = [(0, 0, 0)]
-    for i in range(1, num_colors):
-        h = (i % num_colors) / float(num_colors)
-        palette.append(hsv_to_rgb(h, 1.0, 0.95))
-
-    palette_arr = np.array(palette, dtype=np.uint8)
-    color_idx = mask % num_colors
-    return palette_arr[color_idx]
-
-# ===== 分割功能 =====
-def segment_with_choice(use_box_choice, annot_value):
-    print("边界框选择:", use_box_choice)
-    print("注释值:", annot_value)
-    """分割主函数 - 每个实例不同颜色+轮廓"""
-    if annot_value is None or len(annot_value) < 1:
-        print("❌ No annotation input")
-        return None, None
-
-    img_path = annot_value[0]
-    bboxes = annot_value[1] if len(annot_value) > 1 else []
-
-    print(f"🖼️ 图像路径: {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"📦 使用边界框: {box_array}")
-
-    # 运行分割模型
-    try:
-        mask = run_seg(SEG_MODEL, img_path, box=box_array, device=SEG_DEVICE)
-        print("📏 mask shape:", mask.shape, "dtype:", mask.dtype, "unique:", np.unique(mask))
-    except Exception as e:
-        print(f"❌ 推理失败: {str(e)}")
-        return None, None
-
-    # 保存原始mask为TIF文件
-    temp_mask_file = tempfile.NamedTemporaryFile(delete=False, suffix=".tif")
-    mask_img = Image.fromarray(mask.astype(np.uint16))
-    mask_img.save(temp_mask_file.name)
-    print(f"💾 原始mask保存到: {temp_mask_file.name}")
-
-    # 读取原图
-    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, 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, 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)), None
-
-    # ==== Color Overlay (每个实例一个颜色) ====
-    overlay = img_np.copy()
-    alpha = 0.5
-    # cmap = cm.get_cmap("hsv", 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
-        color = get_well_spaced_color(inst_id)
-        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)
-            # 确保坐标在范围内
-            valid_y = np.clip(contour[:, 0], 0, overlay.shape[0] - 1)
-            valid_x = np.clip(contour[:, 1], 0, overlay.shape[1] - 1)
-            overlay[valid_y, valid_x] = [1.0, 1.0, 0.0]  # 黄色轮廓
-
-    overlay = np.clip(overlay * 255.0, 0, 255).astype(np.uint8)
-
-    return Image.fromarray(overlay), temp_mask_file.name
-
-# ===== 计数功能 =====
-def count_cells_handler(use_box_choice, annot_value):
-    """计数处理函数 - 支持边界框,只返回密度图"""
-    if annot_value is None or len(annot_value) < 1:
-        return None, "⚠️ 请先上传图像"
-    
-    image_path = annot_value[0]
-    bboxes = annot_value[1] if len(annot_value) > 1 else []
-    
-    print(f"🖼️ 图像路径: {image_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"📦 使用边界框: {box_array}")
-    
-    try:
-        print(f"🔢 Counting - Image: {image_path}")
-        
-        result = run_count(
-            COUNT_MODEL,
-            image_path,
-            box=box_array,
-            device=COUNT_DEVICE,
-            visualize=True
-        )
-        
-        if 'error' in result:
-            return None, f"❌ 计数失败: {result['error']}"
-        
-        count = result['count']
-        density_map = result['density_map']
-        # save density map as temp file
-        temp_density_file = tempfile.NamedTemporaryFile(delete=False, suffix=".npy")
-        np.save(temp_density_file.name, density_map)
-        print(f"💾 Density map saved to {temp_density_file.name}")
-        
-        # 只提取密度图部分(假设visualized_path是拼接图,我们只要右半部分)
-        # viz_path = result.get('visualized_path')
-        
-        # 如果有density_map_path,直接使用
-        # if 'density_map_path' in result:
-        #     density_path = result['density_map_path']
-        # elif viz_path and os.path.exists(viz_path):
-        #     # 如果是拼接图,提取右半部分(密度图)
-        #     try:
-        #         viz_img = Image.open(viz_path)
-        #         w, h = viz_img.size
-        #         # 取右半部分
-        #         density_img = viz_img
-        #         # 保存为新文件
-        #         temp_density = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
-        #         density_img.save(temp_density.name)
-        #         density_path = temp_density.name
-        #     except:
-        #         density_path = viz_path
-        # else:
-        #     density_path = viz_path
-
-        # 读取原图
-        try:
-            img = Image.open(image_path)
-            print("📷 Image mode:", img.mode, "size:", img.size)
-        except Exception as e:
-            print(f"❌ Failed to open image: {e}")
-            return None, None
-
-        try:
-            img_rgb = img.convert("RGB").resize(density_map.shape[::-1], resample=Image.BILINEAR)
-            img_np = np.array(img_rgb, dtype=np.float32)
-            img_np = (img_np - img_np.min()) / (img_np.max() - img_np.min() + 1e-8)
-            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, None
-
-        
-        # Normalize density map to [0, 1]
-        density_normalized = density_map.copy()
-        if density_normalized.max() > 0:
-            density_normalized = (density_normalized - density_normalized.min()) / (density_normalized.max() - density_normalized.min())
-        
-        # Apply colormap
-        cmap = cm.get_cmap("jet")
-        alpha = 0.3
-        density_colored = cmap(density_normalized)[:, :, :3]  # RGB only, ignore alpha
-        
-        # Create overlay
-        overlay = img_np.copy()
-        
-        # Blend only where density is significant (optional: threshold)
-        threshold = 0.01  # Only overlay where density > 1% of max
-        significant_mask = density_normalized > threshold
-        
-        overlay[significant_mask] = (1 - alpha) * overlay[significant_mask] + alpha * density_colored[significant_mask]
-        
-        # Clip and convert to uint8
-        overlay = np.clip(overlay * 255.0, 0, 255).astype(np.uint8)
-        
-        
-
-
-        
-        result_text = f"✅ 检测到 {round(count)} 个细胞"
-        
-        print(f"✅ Counting done - Count: {count:.1f}")
-
-        return Image.fromarray(overlay), temp_density_file.name, result_text
-        
-        # return density_path, result_text
-        
-    except Exception as e:
-        print(f"❌ Counting error: {e}")
-        import traceback
-        traceback.print_exc()
-        return None, f"❌ 计数失败: {str(e)}"
-
-# ===== 跟踪功能 =====
-def find_tif_dir(root_dir):
-    """递归查找第一个包含 .tif 文件的目录"""
-    for dirpath, _, filenames in os.walk(root_dir):
-        if '__MACOSX' in dirpath:
-            continue
-        if any(f.lower().endswith('.tif') for f in filenames):
-            return dirpath
-    return None
-
-def is_valid_tiff(filepath):
-    """Check if a file is a valid TIFF image"""
-    try:
-        with Image.open(filepath) as img:
-            img.verify()
-            return True
-    except Exception as e:
-        return False
-
-def find_valid_tif_dir(root_dir):
-    """递归查找第一个包含有效 .tif 文件的目录"""
-    for dirpath, dirnames, filenames in os.walk(root_dir):
-        if '__MACOSX' in dirpath:
-            continue
-        
-        potential_tifs = [
-            os.path.join(dirpath, f) 
-            for f in filenames 
-            if f.lower().endswith(('.tif', '.tiff')) and not f.startswith('._')
-        ]
-        
-        if not potential_tifs:
-            continue
-        
-        valid_tifs = [f for f in potential_tifs if is_valid_tiff(f)]
-        
-        if valid_tifs:
-            print(f"✅ Found {len(valid_tifs)} valid TIFF files in: {dirpath}")
-            return dirpath
-    
-    return None
-
-def create_ctc_results_zip(output_dir):
-    """
-    Create a ZIP file with CTC format results
-    
-    Parameters:
-    -----------
-    output_dir : str
-        Directory containing tracking results (res_track.txt, etc.)
-    
-    Returns:
-    --------
-    zip_path : str
-        Path to created ZIP file
-    """
-    # Create temp directory for ZIP
-    temp_zip_dir = tempfile.mkdtemp()
-    zip_filename = f"tracking_results_{time.strftime('%Y%m%d_%H%M%S')}.zip"
-    zip_path = os.path.join(temp_zip_dir, zip_filename)
-    
-    print(f"📦 Creating results ZIP: {zip_path}")
-    
-    # Create ZIP with all tracking results
-    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
-        # Add all files from output directory
-        for root, dirs, files in os.walk(output_dir):
-            for file in files:
-                file_path = os.path.join(root, file)
-                arcname = os.path.relpath(file_path, output_dir)
-                zipf.write(file_path, arcname)
-                print(f"  📄 Added: {arcname}")
-        
-        # Add a README with summary
-        readme_content = f"""Tracking Results Summary
-            ========================
-
-            Generated: {time.strftime('%Y-%m-%d %H:%M:%S')}
-
-            Files:
-            ------
-            - res_track.txt: CTC format tracking data
-            Format: track_id start_frame end_frame parent_id
-            
-            - Segmentation masks
-
-            For more information on CTC format:
-            http://celltrackingchallenge.net/
-            """
-        zipf.writestr("README.txt", readme_content)
-    
-    print(f"✅ ZIP created: {zip_path} ({os.path.getsize(zip_path) / 1024:.1f} KB)")
-    return zip_path
-
-# 使用更智能的颜色分配 - 让相邻的ID颜色差异更大
-def get_well_spaced_color(track_id, num_colors=256):
-    """生成间隔良好的颜色，相邻ID使用对比色"""
-    # 使用质数跳跃来分散颜色
-    golden_ratio = 0.618033988749895
-    hue = (track_id * golden_ratio) % 1.0
-    
-    # 使用高饱和度和明度
-    import colorsys
-    rgb = colorsys.hsv_to_rgb(hue, 0.9, 0.95)
-    return np.array(rgb)
-
-
-def extract_first_frame(tif_dir):
-    """
-    Extract the first frame from a directory of TIF files
-    
-    Returns:
-    --------
-    first_frame_path : str
-        Path to the first TIF frame
-    """
-    tif_files = natsorted(glob(os.path.join(tif_dir, "*.tif")) + 
-                      glob(os.path.join(tif_dir, "*.tiff")))
-    valid_tif_files = [f for f in tif_files 
-                      if not os.path.basename(f).startswith('._') and is_valid_tiff(f)]
-    
-    if valid_tif_files:
-        return valid_tif_files[0]
-    return None
-
-def create_tracking_visualization(tif_dir, output_dir, valid_tif_files):
-    """
-    Create an animated GIF/video showing tracked objects with consistent colors
-    
-    Parameters:
-    -----------
-    tif_dir : str
-        Directory containing input TIF frames
-    output_dir : str
-        Directory containing tracking results (masks)
-    valid_tif_files : list
-        List of valid TIF file paths
-    
-    Returns:
-    --------
-    video_path : str
-        Path to generated visualization (GIF or first frame)
-    """
-    import numpy as np
-    from matplotlib import colormaps
-    from skimage import measure
-    import tifffile
-    
-    # Look for tracking mask files in output directory
-    # Common CTC formats: man_track*.tif, mask*.tif, or numbered masks
-    mask_files = natsorted(glob(os.path.join(output_dir, "mask*.tif")) + 
-                       glob(os.path.join(output_dir, "man_track*.tif")) +
-                       glob(os.path.join(output_dir, "*.tif")))
-    
-    if not mask_files:
-        print("⚠️  No mask files found in output directory")
-        # Return first frame as fallback
-        return valid_tif_files[0]
-    
-    print(f"📊 Found {len(mask_files)} mask files")
-    
-    # Create color map for consistent track IDs
-    # Use a colormap with many distinct colors
-    # try:
-    #     cmap = colormaps.get_cmap("hsv")
-    # except:
-    #     from matplotlib import cm
-    #     cmap = cm.get_cmap("hsv")
-    
-    frames = []
-    alpha = 0.3  # Transparency for overlay
-    
-    # Process each frame
-    num_frames = min(len(valid_tif_files), len(mask_files))
-    for i in range(num_frames):
-        try:
-            # Load original image using tifffile (handles ZSTD compression)
-            try:
-                img_np = tifffile.imread(valid_tif_files[i])
-
-                # Normalize to [0, 1] range based on actual data type and values
-                if img_np.dtype == np.uint8:
-                    img_np = img_np.astype(np.float32) / 255.0
-                elif img_np.dtype == np.uint16:
-                    # Normalize uint16 to [0, 1] using actual min/max
-                    img_min, img_max = img_np.min(), img_np.max()
-                    if img_max > img_min:
-                        img_np = (img_np.astype(np.float32) - img_min) / (img_max - img_min)
-                    else:
-                        img_np = img_np.astype(np.float32) / 65535.0
-                else:
-                    # For float or other types, normalize based on actual range
-                    img_np = img_np.astype(np.float32)
-                    img_min, img_max = img_np.min(), img_np.max()
-                    if img_max > img_min:
-                        img_np = (img_np - img_min) / (img_max - img_min)
-                    else:
-                        img_np = np.clip(img_np, 0, 1)
-
-                # Convert to RGB if grayscale
-                if img_np.ndim == 2:
-                    img_np = np.stack([img_np]*3, axis=-1)
-                img_np = img_np.astype(np.float32)
-                if img_np.max() > 1.5:
-                    img_np = img_np / 255.0
-            except Exception as e:
-                print(f"⚠️  Error loading image frame {i}: {e}")
-                # Fallback to PIL
-                img = Image.open(valid_tif_files[i]).convert("RGB")
-                img_np = np.array(img, dtype=np.float32) / 255.0
-            
-            # Load tracking mask using tifffile (handles ZSTD compression)
-            try:
-                mask = tifffile.imread(mask_files[i])
-            except Exception as e:
-                print(f"⚠️  Error loading mask frame {i}: {e}")
-                # Fallback to PIL
-                mask = np.array(Image.open(mask_files[i]))
-            
-            # Resize mask to match image if needed
-            if mask.shape[:2] != img_np.shape[:2]:
-                from scipy.ndimage import zoom
-                zoom_factors = [img_np.shape[0] / mask.shape[0], img_np.shape[1] / mask.shape[1]]
-                mask = zoom(mask, zoom_factors, order=0).astype(mask.dtype)
-            
-            # Create overlay
-            overlay = img_np.copy()
-            
-            # Get unique track IDs (excluding background 0)
-            track_ids = np.unique(mask)
-            track_ids = track_ids[track_ids != 0]
-            
-            # Color each tracked object
-            for track_id in track_ids:
-                # Create binary mask for this track
-                binary_mask = (mask == track_id)
-                
-                # Get consistent color for this track ID
-                # color = np.array(cmap(int(track_id) % 256)[:3])
-                color = get_well_spaced_color(int(track_id))
-                
-                # Blend color onto image
-                overlay[binary_mask] = (1 - alpha) * overlay[binary_mask] + alpha * color
-                
-                # Draw contours (optional, adds yellow boundaries)
-                try:
-                    contours = measure.find_contours(binary_mask.astype(np.uint8), 0.5)
-                    for contour in contours:
-                        contour = contour.astype(np.int32)
-                        valid_y = np.clip(contour[:, 0], 0, overlay.shape[0] - 1)
-                        valid_x = np.clip(contour[:, 1], 0, overlay.shape[1] - 1)
-                        overlay[valid_y, valid_x] = [1.0, 1.0, 0.0]  # Yellow contour
-                except:
-                    pass  # Skip contours if they fail
-            
-            # Convert to uint8
-            overlay_uint8 = np.clip(overlay * 255.0, 0, 255).astype(np.uint8)
-            frames.append(Image.fromarray(overlay_uint8))
-            
-            if i % 10 == 0 or i == num_frames - 1:
-                print(f"  📸 Processed frame {i+1}/{num_frames}")
-        
-        except Exception as e:
-            print(f"⚠️  Error processing frame {i}: {e}")
-            import traceback
-            traceback.print_exc()
-            continue
-    
-    if not frames:
-        print("⚠️  No frames were processed successfully")
-        return valid_tif_files[0]
-    
-    # Save as animated GIF
-    try:
-        temp_gif = tempfile.NamedTemporaryFile(delete=False, suffix=".gif")
-        frames[0].save(
-            temp_gif.name,
-            save_all=True,
-            append_images=frames[1:],
-            duration=200,  # 200ms per frame = 5fps
-            loop=0
-        )
-        temp_gif.close()  # Close the file handle
-        print(f"✅ Created tracking visualization GIF: {temp_gif.name}")
-        print(f"   Size: {os.path.getsize(temp_gif.name)} bytes, Frames: {len(frames)}")
-        return temp_gif.name
-    except Exception as e:
-        print(f"⚠️  Failed to create GIF: {e}")
-        import traceback
-        traceback.print_exc()
-        # Return first frame as static image fallback
-        try:
-            temp_img = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
-            frames[0].save(temp_img.name)
-            temp_img.close()
-            return temp_img.name
-        except:
-            return valid_tif_files[0]
-
-
-def track_video_handler(use_box_choice, first_frame_annot, zip_file_obj):
-    """
-    支持 ZIP 压缩包上传的 Tracking 处理函数 - 支持首帧边界框
-    
-    Parameters:
-    -----------
-    use_box_choice : str
-        "Yes" or "No" - 是否使用边界框
-    first_frame_annot : tuple or None
-        (image_path, bboxes) from BBoxAnnotator, only used if user annotated first frame
-    zip_file_obj : File
-        Uploaded ZIP file containing TIF sequence
-    """
-    if zip_file_obj is None:
-        return None, "⚠️ 请上传包含视频帧的压缩包 (.zip)", None, None
-    
-    temp_dir = None
-    output_temp_dir = None
-    
-    try:
-        # Parse bounding box if provided
-        box_array = None
-        if use_box_choice == "Yes" and first_frame_annot is not None:
-            if isinstance(first_frame_annot, (list, tuple)) and len(first_frame_annot) > 1:
-                bboxes = first_frame_annot[1]
-                if bboxes:
-                    box = parse_first_bbox(bboxes)
-                    if box:
-                        xmin, ymin, xmax, ymax = map(int, box)
-                        box_array = [[xmin, ymin, xmax, ymax]]
-                        print(f"📦 使用边界框: {box_array}")
-        
-        # Extract input ZIP
-        temp_dir = tempfile.mkdtemp()
-        print(f"\n📦 解压到临时目录: {temp_dir}")
-
-        with zipfile.ZipFile(zip_file_obj.name, 'r') as zip_ref:
-            extracted_count = 0
-            skipped_count = 0
-            
-            for member in zip_ref.namelist():
-                basename = os.path.basename(member)
-                
-                if ('__MACOSX' in member or 
-                    basename.startswith('._') or 
-                    basename.startswith('.DS_Store') or
-                    member.endswith('/')):
-                    skipped_count += 1
-                    continue
-                
-                try:
-                    zip_ref.extract(member, temp_dir)
-                    extracted_count += 1
-                    if basename.lower().endswith(('.tif', '.tiff')):
-                        print(f"📄 Extracted TIFF: {basename}")
-                except Exception as e:
-                    print(f"⚠️  Failed to extract {member}: {e}")
-            
-            print(f"\n📊 提取: {extracted_count} 文件, 跳过: {skipped_count} 文件")
-        
-        # Find valid TIFF directory
-        tif_dir = find_valid_tif_dir(temp_dir)
-        
-        if tif_dir is None:
-            return None, "❌ 未找到有效的TIFF文件", None, None
-        
-        # Validate TIFF files
-        tif_files = sorted(glob(os.path.join(tif_dir, "*.tif")) + 
-                          glob(os.path.join(tif_dir, "*.tiff")))
-        valid_tif_files = [f for f in tif_files 
-                          if not os.path.basename(f).startswith('._') and is_valid_tiff(f)]
-        
-        if len(valid_tif_files) == 0:
-            return None, "❌ 没有有效的TIFF文件", None, None
-        
-        print(f"📈 使用 {len(valid_tif_files)} 个TIFF文件")
-        
-        # Store paths for later visualization
-        first_frame_path = valid_tif_files[0]
-
-        # Create temporary output directory for CTC results
-        output_temp_dir = tempfile.mkdtemp()
-        print(f"💾 CTC结果将保存到: {output_temp_dir}")
-
-        # Run tracking with optional bounding box
-        result = run_track(
-            TRACK_MODEL,
-            video_dir=tif_dir,
-            box=box_array,  # Pass bounding box if specified
-            device=TRACK_DEVICE,
-            output_dir=output_temp_dir
-        )
-        
-        if 'error' in result:
-            return None, f"❌ 跟踪失败: {result['error']}", None, None
-        
-        # Create visualization video of tracked objects
-        print("\n🎬 Creating tracking visualization...")
-        try:
-            tracking_video = create_tracking_visualization(
-                tif_dir, 
-                output_temp_dir, 
-                valid_tif_files
-            )
-        except Exception as e:
-            print(f"⚠️  Failed to create visualization: {e}")
-            import traceback
-            traceback.print_exc()
-            # Fallback to first frame if visualization fails
-            try:
-                tracking_video = Image.open(first_frame_path)
-            except:
-                tracking_video = None
-        
-        # Create downloadable ZIP with results
-        try:
-            results_zip = create_ctc_results_zip(output_temp_dir)
-        except Exception as e:
-            print(f"⚠️  Failed to create ZIP: {e}")
-            results_zip = None
-        
-        bbox_info = ""
-        if box_array:
-            bbox_info = f"\n🔲 使用边界框: [{box_array[0][0]}, {box_array[0][1]}, {box_array[0][2]}, {box_array[0][3]}]"
-        
-        result_text = f"""✅ 跟踪完成!
-
-            🖼️  处理帧数: {len(valid_tif_files)}{bbox_info}
-
-            📥 点击下方按钮下载CTC格式结果
-            结果包含:
-            - res_track.txt (CTC格式轨迹数据)
-            - 其他跟踪相关文件
-            - README.txt (结果说明)
-            """
-        
-        print(f"\n✅ Tracking完成")
-        
-        # Clean up input temp directory (keep output temp for download)
-        if temp_dir:
-            try:
-                shutil.rmtree(temp_dir)
-                print(f"🗑️  清理输入临时目录")
-            except:
-                pass
-        
-        return results_zip, result_text, gr.update(visible=True), tracking_video
-
-    except zipfile.BadZipFile:
-        return None, "❌ 不是有效的ZIP文件", None, None
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-        
-        # Clean up on error
-        for d in [temp_dir, output_temp_dir]:
-            if d:
-                try:
-                    shutil.rmtree(d)
-                except:
-                    pass
-        
-        return None, f"❌ 跟踪失败: {str(e)}", None, None
-
-
-
-# ===== 示例图像 =====
-example_images_seg = [f for f in glob("example_imgs/seg/*")]
-# ["example_imgs/seg/003_img.png", "example_imgs/seg/1977_Well_F-5_Field_1.png"]
-example_images_cnt = [f for f in glob("example_imgs/cnt/*")]
-example_tracking_zips = [f for f in glob("example_imgs/tra/*.zip")]
-
-# ===== Gradio UI =====
-with gr.Blocks(
-    title="Microscopy Analysis Suite", 
-    theme=gr.themes.Soft(),
-    css="""
-    .tabs button {
-        font-size: 20px !important;
-        font-weight: 600 !important;
-        padding: 12px 20px !important;
-    }
-    """
-    ) as demo:
-    gr.Markdown(
-        """
-        # 🔬 显微图像分析工具套件
-        
-        支持三种分析模式:
-        - 🎨 **分割 (Segmentation)**: 实例分割显微镜物体
-        - 🔢 **计数 (Counting)**: 基于密度图的显微镜物体计数
-        - 🎬 **跟踪 (Tracking)**: 视频序列中的显微镜物体跟踪
-        """
-    )
-    
-    # 全局状态
-    current_query_id = gr.State(str(uuid.uuid4()))
-    user_uploaded_examples = gr.State(example_images_seg.copy())  # 初始化时包含原始示例
-    
-    with gr.Tabs():
-        # ===== Tab 1: Segmentation =====
-        with gr.Tab("🎨 分割 (Segmentation)"):
-            gr.Markdown("## 显微镜物体实例分割")
-            gr.Markdown(
-                        """
-                        **使用说明:**
-                        1. 上传图像或选择示例图片（支持多种格式: .png, .jpg, .tif）
-                        2. (可选) 标注一个目标物体的边界框并选择 "Yes"，或直接点击 "运行分割"
-                        3. 点击 "运行分割"
-                        4. 查看分割结果,下载原始预测mask (.tif格式)；如果需要，点击 "清空重选" 选择新图像运行
-                        5. 评分并提交反馈以帮助我们改进模型!
-                        """
-                    )
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    annotator = BBoxAnnotator(
-                        label="🖼️ 上传图像 (可选标注边界框)",
-                        categories=["cell"]
-                    )
-                    
-                    # 示例图片Gallery
-                    example_gallery = gr.Gallery(
-                        label="📁 示例图片",
-                        columns=len(example_images_seg),
-                        rows=1,
-                        height=120,
-                        object_fit="cover",
-                        show_download_button=False
-                    )
-                    
-                    
-                    with gr.Row():
-                        use_box_radio = gr.Radio(
-                            choices=["Yes", "No"],
-                            value="No",
-                            label="🔲 使用边界框?"
-                        )
-                    with gr.Row():
-                        run_seg_btn = gr.Button("▶️ 运行分割", variant="primary", size="lg")
-                        clear_btn = gr.Button("🔄 清空重选", variant="secondary")
-                        
-                    # 上传示例图片
-                    image_uploader = gr.Image(
-                        label="➕ 上传新示例到Gallery",
-                        type="filepath"
-                    )
-
-
-                with gr.Column(scale=2):
-                    seg_output = gr.Image(
-                        type="pil",
-                        label="📸 分割结果",
-                        height=400
-                    )
-                    
-                    # 下载原始预测结果
-                    download_mask_btn = gr.File(
-                        label="📥 下载原始预测 (.tif 格式)",
-                        visible=True,
-                        height=40,
-                    )
-                    
-                    # 满意度评分
-                    score_slider = gr.Slider(
-                        minimum=1,
-                        maximum=5,
-                        step=1,
-                        value=5,
-                        label="🌟 满意度评分 (1-5)"
-                    )
-                    
-                    # 反馈文本框
-                    feedback_box = gr.Textbox(
-                        placeholder="请输入您的反馈意见...",
-                        lines=2,
-                        label="💬 反馈意见"
-                    )
-                    
-                    # 提交按钮
-                    submit_feedback_btn = gr.Button("💾 提交反馈", variant="secondary")
-                    
-                    feedback_status = gr.Textbox(
-                        label="✅ 提交状态",
-                        lines=1,
-                        visible=False
-                    )
-            
-            # 绑定事件: 运行分割
-            run_seg_btn.click(
-                fn=segment_with_choice,
-                inputs=[use_box_radio, annotator],
-                outputs=[seg_output, download_mask_btn]
-            )
-
-            # 清空按钮事件
-            clear_btn.click(
-                fn=lambda: None,
-                inputs=None,
-                outputs=annotator
-            )
-            
-            # 初始化Gallery显示
-            demo.load(
-                fn=lambda: example_images_seg.copy(),
-                outputs=example_gallery
-            )
-            
-            # 绑定事件: 上传示例图片
-            def add_to_gallery(img_path, current_imgs):
-                if not img_path:
-                    return current_imgs
-                try:
-                    if img_path not in current_imgs:
-                        current_imgs.append(img_path)
-                    return current_imgs
-                except:
-                    return current_imgs
-            
-            image_uploader.change(
-                fn=add_to_gallery,
-                inputs=[image_uploader, user_uploaded_examples],
-                outputs=user_uploaded_examples
-            ).then(
-                fn=lambda imgs: imgs,
-                inputs=user_uploaded_examples,
-                outputs=example_gallery
-            )
-            
-            # 绑定事件: 点击Gallery加载
-            def load_from_gallery(evt: gr.SelectData, all_imgs):
-                if evt.index is not None and evt.index < len(all_imgs):
-                    return all_imgs[evt.index]
-                return None
-            
-            example_gallery.select(
-                fn=load_from_gallery,
-                inputs=user_uploaded_examples,
-                outputs=annotator
-            )
-            
-            # 绑定事件: 提交反馈
-            def submit_user_feedback(query_id, score, comment, annot_val):
-                try:
-                    img_path = annot_val[0] if annot_val and len(annot_val) > 0 else None
-                    bboxes = annot_val[1] if annot_val and len(annot_val) > 1 else []
-                    
-                    save_feedback(
-                        query_id=query_id,
-                        feedback_type=f"score_{int(score)}",
-                        feedback_text=comment,
-                        img_path=img_path,
-                        bboxes=bboxes
-                    )
-                    return "✅ 反馈已提交,感谢您的评价!", gr.update(visible=True)
-                except Exception as e:
-                    return f"❌ 提交失败: {str(e)}", gr.update(visible=True)
-            
-            submit_feedback_btn.click(
-                fn=submit_user_feedback,
-                inputs=[current_query_id, score_slider, feedback_box, annotator],
-                outputs=[feedback_status, feedback_status]
-            )
-        
-        # ===== Tab 2: Counting =====
-        with gr.Tab("🔢 计数 (Counting)"):
-            gr.Markdown("## 显微镜物体计数分析")
-            gr.Markdown(
-                """
-                **使用说明:**
-                1. 上传图像或选择示例图片（支持多种格式: .png, .jpg, .tif）
-                2. (可选) 标注边界框并选择 "Yes"，或直接点击 "运行计数"
-                3. 点击 "运行计数"
-                4. 查看密度图,下载原始预测 (.npy格式)；如果需要，点击 "清空重选" 选择新图像运行
-                5. 评分并提交反馈以帮助我们改进模型!
-                """
-            )
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    count_annotator = BBoxAnnotator(
-                        label="🖼️ 上传图像 (可选标注边界框)",
-                        categories=["cell"]
-                    )
-                    
-                    # Example gallery with "add" functionality
-                    with gr.Row():
-                        count_example_gallery = gr.Gallery(
-                            label="📁 示例图片",
-                            columns=len(example_images_cnt),
-                            rows=1,
-                            object_fit="cover",
-                            height=120,
-                            value=example_images_cnt.copy(),  # Initialize with examples
-                            show_download_button=False
-                        )
-                    
-                    
-                    with gr.Row():
-                        count_use_box_radio = gr.Radio(
-                            choices=["Yes", "No"],
-                            value="No",
-                            label="🔲 使用边界框?"
-                        )
-                    
-                    with gr.Row():
-                        count_btn = gr.Button("▶️ 运行计数", variant="primary", size="lg")
-                        clear_btn = gr.Button("🔄 清空重选", variant="secondary")
-                    
-                    # Add button to upload new examples
-                    with gr.Row():
-                        count_image_uploader = gr.File(
-                            label="➕ 添加示例图片",
-                            file_types=["image"],
-                            type="filepath"
-                        )
-
-                
-                with gr.Column(scale=2):
-                    count_output = gr.Image(
-                        label="📸 密度图",
-                        type="filepath",
-                        height=400
-                    )
-                    count_status = gr.Textbox(
-                        label="📊 统计信息",
-                        lines=2
-                    )
-                    download_density_btn = gr.File(
-                        label="📥 下载原始预测 (.npy 格式)",
-                        visible=True
-                    )
-
-                    # 满意度评分
-                    score_slider = gr.Slider(
-                        minimum=1,
-                        maximum=5,
-                        step=1,
-                        value=5,
-                        label="🌟 满意度评分 (1-5)"
-                    )
-                    
-                    # 反馈文本框
-                    feedback_box = gr.Textbox(
-                        placeholder="请输入您的反馈意见...",
-                        lines=2,
-                        label="💬 反馈意见"
-                    )
-                    
-                    # 提交按钮
-                    submit_feedback_btn = gr.Button("💾 提交反馈", variant="secondary")
-                    
-                    feedback_status = gr.Textbox(
-                        label="✅ 提交状态",
-                        lines=1,
-                        visible=False
-                    )
-            
-            # State for managing gallery images
-            count_user_examples = gr.State(example_images_cnt.copy())
-            
-            # Function to add image to gallery
-            def add_to_count_gallery(new_img_file, current_imgs):
-                """Add uploaded image to gallery"""
-                if new_img_file is None:
-                    return current_imgs, current_imgs
-                
-                try:
-                    # Add new image path to list
-                    if new_img_file not in current_imgs:
-                        current_imgs.append(new_img_file)
-                        print(f"✅ Added image to gallery: {new_img_file}")
-                except Exception as e:
-                    print(f"⚠️  Failed to add image: {e}")
-                
-                return current_imgs, current_imgs
-            
-            # When user uploads a new image file
-            count_image_uploader.upload(
-                fn=add_to_count_gallery,
-                inputs=[count_image_uploader, count_user_examples],
-                outputs=[count_user_examples, count_example_gallery]
-            )
-            
-            # When user selects from gallery, load into annotator
-            def load_from_count_gallery(evt: gr.SelectData, all_imgs):
-                """Load selected image from gallery into annotator"""
-                if evt.index is not None and evt.index < len(all_imgs):
-                    selected_img = all_imgs[evt.index]
-                    print(f"📸 Loading image from gallery: {selected_img}")
-                    return selected_img
-                return None
-            
-            count_example_gallery.select(
-                fn=load_from_count_gallery,
-                inputs=count_user_examples,
-                outputs=count_annotator
-            )
-            
-            # Run counting
-            count_btn.click(
-                fn=count_cells_handler,
-                inputs=[count_use_box_radio, count_annotator],
-                outputs=[count_output, download_density_btn, count_status]
-            )
-
-            # 清空按钮事件
-            clear_btn.click(
-                fn=lambda: None,
-                inputs=None,
-                outputs=count_annotator
-            )
-
-            # 绑定事件: 提交反馈
-            def submit_user_feedback(query_id, score, comment, annot_val):
-                try:
-                    img_path = annot_val[0] if annot_val and len(annot_val) > 0 else None
-                    bboxes = annot_val[1] if annot_val and len(annot_val) > 1 else []
-                    
-                    save_feedback(
-                        query_id=query_id,
-                        feedback_type=f"score_{int(score)}",
-                        feedback_text=comment,
-                        img_path=img_path,
-                        bboxes=bboxes
-                    )
-                    return "✅ 反馈已提交,感谢您的评价!", gr.update(visible=True)
-                except Exception as e:
-                    return f"❌ 提交失败: {str(e)}", gr.update(visible=True)
-            
-            submit_feedback_btn.click(
-                fn=submit_user_feedback,
-                inputs=[current_query_id, score_slider, feedback_box, annotator],
-                outputs=[feedback_status, feedback_status]
-            )
-        
-        # ===== Tab 3: Tracking =====
-        with gr.Tab("🎬 跟踪 (Tracking)"):
-            gr.Markdown("## 显微镜物体视频跟踪 - 支持 ZIP 压缩包上传")
-            gr.Markdown(
-                        """
-                        **使用说明:**
-                        1. 上传ZIP文件或从示例库选择，ZIP内应包含按时间顺序命名的TIF图像序列 (如: t000.tif, t001.tif...)
-                        2. (可选) 在首帧上���注边界框并选择 "Yes"
-                        3. 点击 "运行跟踪"
-                        4. 下载CTC格式结果；如果需要，点击 "清空重选" 选择新ZIP文件运行
-                        5. 评分并提交反馈以帮助我们改进模型!
-
-                        """
-                    )
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    track_zip_upload = gr.File(
-                        label="📦 上传视频帧 ZIP 文件",
-                        file_types=[".zip"]
-                    )
-
-                    # First frame annotation for bounding box
-                    track_first_frame_annotator = BBoxAnnotator(
-                        label="🖼️ 首帧边界框标注 (可选)",
-                        categories=["cell"],
-                        visible=False  # Hidden initially
-                    )
-
-                    # Example ZIP gallery
-                    track_example_gallery = gr.Gallery(
-                        label="📁 示例视频库 (点击选择)",
-                        columns=10,
-                        rows=1,
-                        height=120,
-                        object_fit="contain",
-                        show_download_button=False
-                    )
-                    
-                    with gr.Row():
-                        track_use_box_radio = gr.Radio(
-                            choices=["Yes", "No"],
-                            value="No",
-                            label="🔲 使用边界框?"
-                        )
-                    
-                    with gr.Row():
-                        track_btn = gr.Button("▶️ 运行跟踪", variant="primary", size="lg")
-                        clear_btn = gr.Button("🔄 清空重选", variant="secondary")
-                    
-                    # Add to gallery button
-                    track_gallery_upload = gr.File(
-                        label="➕ 添加ZIP到示例库",
-                        file_types=[".zip"],
-                        type="filepath"
-                    )
-                
-                with gr.Column(scale=2):
-                    track_first_frame_preview = gr.Image(
-                        label="📸 跟踪可视化 (动画预览)",
-                        type="filepath",
-                        height=400,
-                        interactive=False
-                    )
-                    
-                    track_output = gr.Textbox(
-                        label="📊 跟踪信息",
-                        lines=8,
-                        interactive=False
-                    )
-                    
-                    track_download = gr.File(
-                        label="📥 下载跟踪结果 (CTC格式)",
-                        visible=False
-                    )
-
-                    # 满意度评分
-                    score_slider = gr.Slider(
-                        minimum=1,
-                        maximum=5,
-                        step=1,
-                        value=5,
-                        label="🌟 满意度评分 (1-5)"
-                    )
-                    
-                    # 反馈文本框
-                    feedback_box = gr.Textbox(
-                        placeholder="请输入您的反馈意见...",
-                        lines=2,
-                        label="💬 反馈意见"
-                    )
-                    
-                    # 提交按钮
-                    submit_feedback_btn = gr.Button("💾 提交反馈", variant="secondary")
-                    
-                    feedback_status = gr.Textbox(
-                        label="✅ 提交状态",
-                        lines=1,
-                        visible=False
-                    )
-            
-            # State for tracking examples
-            track_user_examples = gr.State(example_tracking_zips.copy())
-            
-            # Function to get preview image from ZIP
-            def get_zip_preview(zip_path):
-                """Extract first frame from ZIP for gallery preview"""
-                try:
-                    temp_dir = tempfile.mkdtemp()
-                    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-                        for member in zip_ref.namelist():
-                            basename = os.path.basename(member)
-                            if ('__MACOSX' not in member and 
-                                not basename.startswith('._') and
-                                basename.lower().endswith(('.tif', '.tiff', '.png', '.jpg'))):
-                                zip_ref.extract(member, temp_dir)
-                                extracted_path = os.path.join(temp_dir, member)
-                                
-                                # Load and normalize for preview
-                                import tifffile
-                                import numpy as np
-                                
-                                img_np = tifffile.imread(extracted_path)
-                                if img_np.dtype == np.uint16:
-                                    img_min, img_max = img_np.min(), img_np.max()
-                                    if img_max > img_min:
-                                        img_np = ((img_np.astype(np.float32) - img_min) / (img_max - img_min) * 255).astype(np.uint8)
-                                
-                                if img_np.ndim == 2:
-                                    img_np = np.stack([img_np]*3, axis=-1)
-                                
-                                # Save preview
-                                preview_path = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
-                                Image.fromarray(img_np).save(preview_path.name)
-                                return preview_path.name
-                except:
-                    pass
-                return None
-            
-            # Initialize gallery with previews
-            def init_tracking_gallery():
-                """Create preview images for ZIP examples"""
-                previews = []
-                for zip_path in example_tracking_zips:
-                    if os.path.exists(zip_path):
-                        preview = get_zip_preview(zip_path)
-                        if preview:
-                            previews.append(preview)
-                return previews
-            
-            # Load gallery on startup
-            demo.load(
-                fn=init_tracking_gallery,
-                outputs=track_example_gallery
-            )
-            
-            # Add ZIP to gallery
-            def add_zip_to_gallery(zip_path, current_zips):
-                if not zip_path:
-                    return current_zips, track_example_gallery
-                try:
-                    if zip_path not in current_zips:
-                        current_zips.append(zip_path)
-                        print(f"✅ Added ZIP to gallery: {zip_path}")
-                    # Regenerate previews
-                    previews = []
-                    for zp in current_zips:
-                        preview = get_zip_preview(zp)
-                        if preview:
-                            previews.append(preview)
-                    return current_zips, previews
-                except Exception as e:
-                    print(f"⚠️ Error: {e}")
-                    return current_zips, []
-            
-            track_gallery_upload.upload(
-                fn=add_zip_to_gallery,
-                inputs=[track_gallery_upload, track_user_examples],
-                outputs=[track_user_examples, track_example_gallery]
-            )
-            
-            # Select ZIP from gallery
-            def load_zip_from_gallery(evt: gr.SelectData, all_zips):
-                if evt.index is not None and evt.index < len(all_zips):
-                    selected_zip = all_zips[evt.index]
-                    print(f"📁 Selected ZIP from gallery: {selected_zip}")
-                    return selected_zip
-                return None
-            
-            track_example_gallery.select(
-                fn=load_zip_from_gallery,
-                inputs=track_user_examples,
-                outputs=track_zip_upload
-            )
-
-            # Load first frame when ZIP is uploaded
-            def load_first_frame_for_annotation(zip_file_obj):
-                '''Load and normalize first frame from ZIP for annotation'''
-                if zip_file_obj is None:
-                    return None, gr.update(visible=False)
-                
-                import tifffile
-                import numpy as np
-                
-                try:
-                    temp_dir = tempfile.mkdtemp()
-                    with zipfile.ZipFile(zip_file_obj.name, 'r') as zip_ref:
-                        for member in zip_ref.namelist():
-                            basename = os.path.basename(member)
-                            if ('__MACOSX' not in member and 
-                                not basename.startswith('._') and
-                                basename.lower().endswith(('.tif', '.tiff'))):
-                                zip_ref.extract(member, temp_dir)
-                    
-                    tif_dir = find_valid_tif_dir(temp_dir)
-                    if tif_dir:
-                        first_frame = extract_first_frame(tif_dir)
-                        if first_frame:
-                            # Load and normalize the first frame
-                            try:
-                                img_np = tifffile.imread(first_frame)
-                                
-                                # Normalize to [0, 255] uint8 range for display
-                                if img_np.dtype == np.uint8:
-                                    pass  # Already uint8
-                                elif img_np.dtype == np.uint16:
-                                    # Normalize uint16 using actual min/max
-                                    img_min, img_max = img_np.min(), img_np.max()
-                                    if img_max > img_min:
-                                        img_np = ((img_np.astype(np.float32) - img_min) / (img_max - img_min) * 255).astype(np.uint8)
-                                    else:
-                                        img_np = (img_np.astype(np.float32) / 65535.0 * 255).astype(np.uint8)
-                                else:
-                                    # Float or other types
-                                    img_np = img_np.astype(np.float32)
-                                    img_min, img_max = img_np.min(), img_np.max()
-                                    if img_max > img_min:
-                                        img_np = ((img_np - img_min) / (img_max - img_min) * 255).astype(np.uint8)
-                                    else:
-                                        img_np = np.clip(img_np * 255, 0, 255).astype(np.uint8)
-                                
-                                # Convert to RGB if grayscale
-                                if img_np.ndim == 2:
-                                    img_np = np.stack([img_np]*3, axis=-1)
-                                elif img_np.ndim == 3 and img_np.shape[2] > 3:
-                                    img_np = img_np[:, :, :3]
-                                
-                                # Save normalized image to temp file
-                                temp_img = tempfile.NamedTemporaryFile(delete=False, suffix=".png")
-                                Image.fromarray(img_np).save(temp_img.name)
-                                
-                                print(f"✅ Loaded and normalized first frame: {first_frame}")
-                                print(f"   Original dtype: {tifffile.imread(first_frame).dtype}")
-                                print(f"   Normalized to uint8 RGB for annotation")
-                                
-                                return temp_img.name, gr.update(visible=True)
-                            except Exception as e:
-                                print(f"⚠️  Error normalizing first frame: {e}")
-                                import traceback
-                                traceback.print_exc()
-                                # Fallback to original file
-                                return first_frame, gr.update(visible=True)
-                except Exception as e:
-                    print(f"⚠️  Error loading first frame: {e}")
-                    import traceback
-                    traceback.print_exc()
-                return None, gr.update(visible=False)
-            
-            # Load first frame when ZIP is uploaded
-            track_zip_upload.change(
-                fn=load_first_frame_for_annotation,
-                inputs=track_zip_upload,
-                outputs=[track_first_frame_annotator, track_first_frame_annotator]
-            )
-            
-            # Run tracking
-            track_btn.click(
-                fn=track_video_handler,
-                inputs=[track_use_box_radio, track_first_frame_annotator, track_zip_upload],
-                outputs=[track_download, track_output, track_download, track_first_frame_preview]
-            )
-
-            # 清空按钮事件
-            clear_btn.click(
-                fn=lambda: None,
-                inputs=None,
-                outputs=track_first_frame_annotator
-            )
-
-            # 绑定事件: 提交反馈
-            def submit_user_feedback(query_id, score, comment, annot_val):
-                try:
-                    img_path = annot_val[0] if annot_val and len(annot_val) > 0 else None
-                    bboxes = annot_val[1] if annot_val and len(annot_val) > 1 else []
-                    
-                    save_feedback(
-                        query_id=query_id,
-                        feedback_type=f"score_{int(score)}",
-                        feedback_text=comment,
-                        img_path=img_path,
-                        bboxes=bboxes
-                    )
-                    return "✅ 反馈已提交,感谢您的评价!", gr.update(visible=True)
-                except Exception as e:
-                    return f"❌ 提交失败: {str(e)}", gr.update(visible=True)
-            
-            submit_feedback_btn.click(
-                fn=submit_user_feedback,
-                inputs=[current_query_id, score_slider, feedback_box, annotator],
-                outputs=[feedback_status, feedback_status]
-            )
-    
-    gr.Markdown(
-        """
-        ---
-        ### 💡 技术说明
-        
-        **MicroscopyMatching** - 基于 Stable Diffusion 的显微图像分析工具套件
-        """
-    )
-
-if __name__ == "__main__":
-    demo.queue().launch(
-        server_name="0.0.0.0",
-        server_port=7862,
-        share=False,
-        ssr_mode=False,
-        show_error=True,
-    )