Delete app.py

app.py

@@ -1,525 +0,0 @@
-import gradio as gr
-import spaces
-from cellpose import models
-import numpy as np
-import cv2
-import matplotlib.pyplot as plt
-import tempfile
-from PIL import Image
-import io
-from huggingface_hub import hf_hub_download
-import base64  # needed for mobile ImageEditor base64 handling
-
-HF_REPO_ID = "myang4218/cellposemodel"
-MODEL_OPTIONS = {
-    "Hemocytometer Model": "hemocytometermodel.npy",
-    "General Model": "generalmodel.npy"
-}
-
-loaded_models = {}
-
-# ---- mobile-safe size limits (aggressive for Safari) ----
-MAX_SIDE = 384           
-MAX_PIXELS = 384 * 384   
-
-
-def safe_resize(image_np):
-    h, w = image_np.shape[:2]
-    total = h * w
-
-    # already small enough
-    if max(h, w) <= MAX_SIDE and total <= MAX_PIXELS:
-        return image_np
-
-    # compute scale so BOTH constraints are satisfied
-    scale_side = MAX_SIDE / max(h, w)
-    scale_pixels = (MAX_PIXELS / total) ** 0.5
-    scale = min(scale_side, scale_pixels)
-
-    new_w = max(1, int(w * scale))
-    new_h = max(1, int(h * scale))
-
-    return cv2.resize(image_np, (new_w, new_h), interpolation=cv2.INTER_AREA)
-
-
-def extract_region_from_editor(editor_data):
-    """Extract selected region from ImageEditor data (mobile-safe)."""
-    if editor_data is None:
-        return None, None
-
-    # CASE 1 — Editor returns a PIL Image directly
-    if isinstance(editor_data, Image.Image):
-        return np.array(editor_data), None
-
-    # CASE 2 — Editor returns a NumPy array
-    if isinstance(editor_data, np.ndarray):
-        return editor_data, None
-
-    # CASE 3 — Mobile browser returns dict structure
-    if isinstance(editor_data, dict):
-
-        # --- Get background from multiple possible formats ---
-        bg = editor_data.get("background")
-
-        if bg is None:
-            return None, None
-
-        # Mobile ImageEditor sometimes wraps image like: {'image': base64, 'mask': None}
-        if isinstance(bg, dict) and "image" in bg:
-            try:
-                # Decode base64 → PIL → NumPy
-                img_bytes = io.BytesIO(base64.b64decode(bg["image"].split(",")[-1]))
-                bg_img = Image.open(img_bytes).convert("RGB")
-                background_np = np.array(bg_img)
-            except Exception:
-                return None, None
-
-        # Desktop / some mobile: bg is a PIL image
-        elif isinstance(bg, Image.Image):
-            background_np = np.array(bg)
-
-        # Final fallback
-        else:
-            try:
-                background_np = np.array(bg)
-            except Exception:
-                return None, None
-
-        # --- Layers (selection mask) ---
-        layers = editor_data.get("layers", [])
-        if layers:
-            sel = layers[0]
-
-            # Convert to NumPy if needed
-            if isinstance(sel, Image.Image):
-                sel_np = np.array(sel)
-            elif isinstance(sel, dict) and "image" in sel:
-                try:
-                    sel_bytes = io.BytesIO(base64.b64decode(sel["image"].split(",")[-1]))
-                    sel_np = np.array(Image.open(sel_bytes).convert("RGBA"))
-                except Exception:
-                    sel_np = None
-            else:
-                try:
-                    sel_np = np.array(sel)
-                except Exception:
-                    sel_np = None
-
-            # If selection exists: compute bounding box
-            if sel_np is not None:
-                if sel_np.ndim == 3:
-                    if sel_np.shape[2] == 4:
-                        mask = sel_np[:, :, 3] > 0
-                    else:
-                        mask = np.any(sel_np > 0, axis=2)
-                else:
-                    mask = sel_np > 0
-
-                coords = np.where(mask)
-                if coords[0].size > 0:
-                    y0, y1 = coords[0].min(), coords[0].max()
-                    x0, x1 = coords[1].min(), coords[1].max()
-                    return background_np[y0:y1 + 1, x0:x1 + 1], (x0, y0, x1, y1)
-
-        # No selection → return full image
-        return background_np, None
-
-    # CASE 4 — Unknown structure
-    return None, None
-
-
-def classify_cells_by_blueness(image_np, masks, blue_threshold):
-    """
-    Classify cells as dead (blue) or alive based on single blueness metric
-
-    Args:
-        image_np: RGB image array
-        masks: Cellpose segmentation masks
-        blue_threshold: Single threshold value (0-100) for blueness detection
-
-    Returns:
-        dead_count, alive_count, colored_overlay
-    """
-    # Ensure image_np is RGB for consistency with HSV conversion
-    if len(image_np.shape) == 2:
-        image_np = cv2.cvtColor(image_np, cv2.COLOR_GRAY2RGB)
-    elif len(image_np.shape) == 3 and image_np.shape[2] == 4:
-        image_np = cv2.cvtColor(image_np, cv2.COLOR_RGBA2RGB)
-
-    # Convert RGB to HSV
-    hsv = cv2.cvtColor(image_np, cv2.COLOR_RGB2HSV)
-
-    # Calculate blueness index for each pixel
-    hue = hsv[:, :, 0].astype(np.float32)
-    saturation = hsv[:, :, 1].astype(np.float32)
-
-    # Hue score: peaks around 115 (blue in HSV), drops off towards edges
-    # Handle hue wrap-around for blue detection (100-130 range)
-    hue_distance = np.minimum(np.abs(hue - 115), 180 - np.abs(hue - 115))
-    hue_score = np.maximum(0, 1 - hue_distance / 65)  # 65 gives good blue range
-
-    # Combine hue proximity with saturation intensity
-    blueness = hue_score * (saturation / 255.0)
-
-    # Convert threshold from 0-100 to 0-1 scale
-    threshold = blue_threshold / 100.0
-
-    # Get unique cell IDs (excluding background)
-    cell_ids = np.unique(masks)
-    cell_ids = cell_ids[cell_ids > 0]  # Remove background (0)
-
-    dead_cells = []
-    alive_cells = []
-
-    # Classify each cell
-    for cell_id in cell_ids:
-        # Get mask for this specific cell
-        cell_mask = (masks == cell_id)
-
-        # Calculate average blueness for this cell
-        cell_blueness = np.mean(blueness[cell_mask])
-
-        # Classify based on threshold
-        if cell_blueness > threshold:
-            dead_cells.append(cell_id)
-        else:
-            alive_cells.append(cell_id)
-
-    # Create colored overlay
-    overlay = image_np.copy().astype(np.float32)  # Ensure float for blending
-
-    # Color dead cells red, alive cells green
-    for cell_id in dead_cells:
-        cell_mask = (masks == cell_id)
-        overlay[cell_mask] = [255, 0, 0]  # Red for dead
-
-    for cell_id in alive_cells:
-        cell_mask = (masks == cell_id)
-        overlay[cell_mask] = [0, 255, 0]  # Green for alive
-
-    # Blend with original image
-    alpha = 0.4
-    final_overlay = (1 - alpha) * image_np.astype(np.float32) + alpha * overlay
-    final_overlay = np.clip(final_overlay, 0, 255).astype(np.uint8)
-
-    return len(dead_cells), len(alive_cells), final_overlay
-
-
-def measure_confluency(masks, image_np):
-    """Calculate the percentage of image area covered by cells"""
-    tot_pixels = image_np.shape[0] * image_np.shape[1]
-    cell_pixels = np.count_nonzero(masks)
-    confluency = cell_pixels / tot_pixels * 100
-    return confluency
-
-
-@spaces.GPU
-def run_segmentation_editor(editor_data, model_choice):
-    
-    try:
-        image_np = np.array(image)
-        image_np = safe_resize(image_np)
-        
-        model_filename = MODEL_OPTIONS[model_choice]
-        model_path = hf_hub_download(repo_id=HF_REPO_ID, filename=model_filename)
-
-        if model_filename in loaded_models:
-            model = loaded_models[model_filename]
-        else:
-            model = models.CellposeModel(gpu=True, pretrained_model=model_path)
-            loaded_models[model_filename] = model
-
-        region_np, region_coords = extract_region_from_editor(editor_data)
-
-        if region_np is None:
-            return 0, None, f"No image provided.", gr.update(visible=False), None, None, 0.0
-
-        # Enforce mobile-safe size limit immediately
-        region_np = safe_resize(region_np)
-
-        # Process image format to RGB
-        if len(region_np.shape) == 2:
-            processed_image_np = cv2.cvtColor(region_np, cv2.COLOR_GRAY2RGB)
-        elif len(region_np.shape) == 3 and region_np.shape[2] == 4:
-            processed_image_np = cv2.cvtColor(region_np, cv2.COLOR_RGBA2RGB)
-        else:
-            processed_image_np = region_np
-
-        # Run Cellpose segmentation
-        masks, flows, styles = model.eval(processed_image_np, diameter=None, channels=[0, 0])
-
-        cell_count = len(np.unique(masks)) - 1
-        confluency = measure_confluency(masks, processed_image_np)
-
-        # Create a basic segmentation overlay (without viability)
-        segmentation_overlay = processed_image_np.copy().astype(np.float32)
-        if masks.max() > 0:
-            np.random.seed(42)  # For consistent random colors
-            colors = np.random.randint(0, 255, size=(masks.max() + 1, 3))
-            colors[0] = [0, 0, 0]  # Background color
-            colored_mask = colors[masks]
-            alpha = 0.4
-            segmentation_overlay = (1 - alpha) * segmentation_overlay + alpha * colored_mask
-        segmentation_overlay = np.clip(segmentation_overlay, 0, 255).astype(np.uint8)
-
-        info_msg = f"Segmentation complete! Found {cell_count} cells.\n"
-        info_msg += f"Confluency: {confluency:.1f}%\n"
-        if region_coords:
-            info_msg += f"Processed region: {region_coords[0]},{region_coords[1]} to {region_coords[2]},{region_coords[3]}\n"
-        info_msg += f"Now adjust the Blue Threshold for viability assessment."
-
-        # Return initial segmentation display and state variables (packed for Gradio State)
-        return (
-            cell_count,
-            Image.fromarray(segmentation_overlay),
-            info_msg,
-            gr.update(visible=True),
-            pack_array(masks),
-            pack_array(processed_image_np),
-            confluency,
-        )
-
-    except Exception as e:
-        return 0, None, f"Error during segmentation: {str(e)}", gr.update(visible=False), None, None, 0.0
-        
-def run_segmentation_with_cleanup(func):
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except Exception as e:
-            # Force garbage collection on error
-            import gc
-            gc.collect()
-            return 0, None, f"Error: {str(e)}", gr.update(visible=False), None, None, 0.0
-    return wrapper
-
-run_segmentation_editor = run_segmentation_with_cleanup(run_segmentation_editor)
-
-def validate_and_prepare_image(image_np, max_side=384, max_pixels=384*384):
-    """
-    Validate image and prepare for processing with strict size limits
-    Returns: (processed_image, error_message)
-    """
-    if image_np is None:
-        return None, "No image provided"
-    
-    # Check if image is too small
-    h, w = image_np.shape[:2]
-    if h < 50 or w < 50:
-        return None, "Image too small (minimum 50x50 pixels)"
-    
-    # Check file size before processing
-    if h * w > 4000 * 4000:  # Reject images over 16 megapixels before resize
-        return None, "Image too large. Please resize to under 4000x4000 before uploading."
-    
-    # Apply safe resize
-    resized = safe_resize(image_np)
-    
-    # Ensure RGB format
-    if len(resized.shape) == 2:
-        resized = cv2.cvtColor(resized, cv2.COLOR_GRAY2RGB)
-    elif len(resized.shape) == 3 and resized.shape[2] == 4:
-        resized = cv2.cvtColor(resized, cv2.COLOR_RGBA2RGB)
-    
-    return resized, None
-    
-
-def update_viability_realtime(blue_threshold, stored_masks, stored_image_np):
-    # avoid unpacking None (e.g. slider moved before segmentation)
-    if stored_masks is None or stored_image_np is None:
-        return None, 0, 0, 0.0, "Please run segmentation first."
-
-    stored_masks = unpack_array(stored_masks)
-    stored_image_np = unpack_array(stored_image_np)
-
-    try:
-        dead_count, alive_count, viability_overlay_np = classify_cells_by_blueness(
-            stored_image_np, stored_masks, blue_threshold
-        )
-
-        total_count = alive_count + dead_count
-        viability_percent = (alive_count / total_count * 100) if total_count > 0 else 0.0
-        confluency = measure_confluency(stored_masks, stored_image_np)
-
-        overlay_image = Image.fromarray(viability_overlay_np)
-        info_msg = f"Total cells: {total_count}\nLive (green): {alive_count}\nDead (red): {dead_count}\n"
-        info_msg += f"Viability: {viability_percent:.1f}%\nConfluency: {confluency:.1f}%\nBlue threshold: {blue_threshold}%"
-
-        return overlay_image, alive_count, dead_count, viability_percent, info_msg
-
-    except Exception as e:
-        return None, 0, 0, 0.0, f"Error updating viability: {str(e)}"
-
-
-def diagnose_image_upload(image):
-    """Helper function to diagnose upload issues"""
-    try:
-        if image is None:
-            return "No image received"
-        
-        img_np = np.array(image)
-        h, w = img_np.shape[:2]
-        channels = img_np.shape[2] if len(img_np.shape) == 3 else 1
-        dtype = img_np.dtype
-        size_mb = img_np.nbytes / (1024 * 1024)
-        
-        info = f"Image received successfully!\n"
-        info += f"Dimensions: {w}x{h}\n"
-        info += f"Channels: {channels}\n"
-        info += f"Data type: {dtype}\n"
-        info += f"Memory size: {size_mb:.2f} MB\n"
-        
-        if size_mb > 10:
-            info += "\n⚠️ WARNING: Image is large and may cause issues on mobile"
-        
-        return info
-    except Exception as e:
-        return f"Error analyzing image: {str(e)}"
-
-
-def pack_array(arr):
-    pil = Image.fromarray(arr.astype(np.uint8))
-    buf = io.BytesIO()
-    pil.save(buf, format="PNG")
-    return buf.getvalue()
-
-
-def unpack_array(data):
-    return np.array(Image.open(io.BytesIO(data)))
-
-
-# Gradio interface
-with gr.Blocks(
-    title="CellposeCellCounter",
-    theme=gr.themes.Soft(),
-) as demo:
-    gr.Markdown("# CellposeCellCounter")
-    gr.Markdown("For accurate cell confluency, crop the image to display only desired area.")
-
-    # Define State components to store masks and image data across function calls
-    masks_state = gr.State(value=None)
-    image_state = gr.State(value=None)
-
-    with gr.Tab("Image Editor (Draw Selection)"):
-        gr.Markdown("### Draw selection and run segmentation")
-
-        with gr.Row():
-            with gr.Column():
-                image_editor = gr.ImageEditor(
-                label="Draw selection on image",
-                type="pil",
-                image_mode="RGB",
-                height=384,  # Reduced from 512
-                width=384,   # ADD explicit width
-                brush=gr.Brush(colors=["#ff0000"], color_mode="fixed", default_size=20),
-                eraser=gr.Eraser(default_size=20)
-                )
-            
-            image_input = gr.Image(
-                type="pil",
-                label="Microscopy Image",
-                image_mode="RGB",
-                height=384,  # Reduced from 512
-                width=384    # ADD explicit width
-                )
-            
-            model_dropdown1 = gr.Dropdown(
-                choices=list(MODEL_OPTIONS.keys()),
-                label="Select Model",
-                value="Hemocytometer Model"
-                )
-                
-            segment_btn1 = gr.Button("🔬 Run Segmentation", variant="primary", size="lg")
-
-            with gr.Column():
-                cell_count_output1 = gr.Number(label="Total Cells Detected", precision=0)
-                confluency_output1 = gr.Number(label="Confluency (%)", precision=1)
-                overlay_output1 = gr.Image(type="pil", label="Segmentation Result")
-                info_output1 = gr.Textbox(label="Processing Info", lines=4)
-
-        # Viability Assessment Section
-        with gr.Group(visible=False) as viability_section1:
-            gr.Markdown("### Viability Assessment (Trypan Blue)")
-            gr.Markdown("Adjust the threshold to classify cells as live (green) or dead (red).")
-
-            with gr.Row():
-                with gr.Column():
-                    blue_threshold1 = gr.Slider(
-                        minimum=0,
-                        maximum=100,
-                        value=25,
-                        step=1,
-                        label="Blue Threshold (%)",
-                        info="Higher values = more selective for blue cells"
-                    )
-
-                with gr.Column():
-                    live_count_output1 = gr.Number(label="Live Cells (Green)", precision=0)
-                    dead_count_output1 = gr.Number(label="Dead Cells (Red)", precision=0)
-
-            viability_overlay1 = gr.Image(type="pil", label="Viability Assessment (Green=Live, Red=Dead)")
-            viability_percent_output1 = gr.Number(label="Viability (%)", precision=1)
-            viability_info1 = gr.Textbox(label="Analysis Results", lines=5)
-
-        # Event handlers
-        diagnose_btn1 = gr.Button("🔍 Diagnose Image", variant="secondary", size="sm")
-        diagnose_output1 = gr.Textbox(label="Diagnostic Info", lines=3, visible=True)
-        
-        # Diagnostic handler
-        diagnose_btn1.click(
-            fn=diagnose_image_upload,
-            inputs=[image_editor],
-            outputs=[diagnose_output1]
-        )
-        segment_btn1.click(
-            fn=run_segmentation_editor,
-            inputs=[image_editor, model_dropdown1],
-            outputs=[cell_count_output1, overlay_output1, info_output1, viability_section1, masks_state, image_state, confluency_output1]
-        ).then(  # Chain the initial viability assessment after segmentation
-            fn=update_viability_realtime,
-            inputs=[blue_threshold1, masks_state, image_state],  # Pass stored state as inputs
-            outputs=[viability_overlay1, live_count_output1, dead_count_output1, viability_percent_output1, viability_info1]
-        )
-
-        # Slider changes update viability in real-time
-        blue_threshold1.change(
-            fn=update_viability_realtime,
-            inputs=[blue_threshold1, masks_state, image_state],
-            outputs=[viability_overlay1, live_count_output1, dead_count_output1, viability_percent_output1, viability_info1]
-        )
-
-    # Instructions
-    with gr.Accordion("Instructions", open=False):
-        gr.Markdown("""
-        ### How to use:
-
-        1. **Upload and Segment**:
-            - Upload your microscopy image.
-            - Select a Cellpose model (e.g., "Hemocytometer Model" for suspenion culture).
-            - Draw a selection region using the Image Editor.
-            - Click "Run Segmentation".
-
-        2. **Analysis Results**:
-            - **Cell Count**: Total number of detected cells
-            - **Confluency**: Percentage of image area covered by cells (useful for assessing cell density). Note that cell confluency is calculated per the entire area of the image input.
-
-        3. **Real-time Viability Assessment (Trypan Blue)**:
-            - After segmentation, the viability section will become visible.
-            - This tool is specifically designed for **Trypan Blue stained images**, where dead cells appear blue.
-            - Adjust the **"Blue Threshold (%)"** slider in real-time. As you change it, the green (live) and red (dead) classification on the overlay will update.
-            - **Lower values (e.g., 10-20%)** are more sensitive and will classify more cells as blue/dead.
-            - **Higher values (e.g., 30-50%)** are more selective and will only classify strongly blue cells as dead.
-            - Green cells = Live, Red cells = Dead.
-
-        4. **Interpreting Results**:
-            - The app calculates and displays the total, live, and dead cell counts, along with the viability percentage and confluency.
-            - **Confluency** helps assess how densely packed your cells are, which is important for cell culture monitoring.
-        """)
-
-if __name__ == "__main__":
-    demo.launch(
-        share=False,
-        show_error=True,  # Show detailed errors
-        max_file_size="10mb",  # Limit upload size
-        favicon_path="favicon.png"
-    )