Delete app.py

app.py

@@ -1,583 +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
-
-HF_REPO_ID = "myang4218/cellposemodel"
-MODEL_OPTIONS = {
-    "Hemocytometer Model": "hemocytometermodel.npy",
-    "General Model": "generalmodel.npy"
-}
-loaded_models = {}
-
-# Global variable for region coordinates (can remain global if only for info display)
-current_region_coords = None
-
-"""
-# Commented out debugging function
-def debug_editor_data(editor_data):
-    \"\"\"Debug function to understand the structure of ImageEditor data\"\"\"
-    if editor_data is None:
-        return "No data provided"
-    info = f"Type: {type(editor_data)}\n"
-    if isinstance(editor_data, dict):
-        info += f"Keys: {list(editor_data.keys())}\n"
-        for key, value in editor_data.items():
-            info += f"  {key}: {type(value)}\n"
-            if key == 'layers' and value:
-                info += f"    Layers count: {len(value)}\n"
-                for i, layer in enumerate(value):
-                    info += f"    Layer {i}: {type(layer)}\n"
-                    if hasattr(layer, 'size'):
-                        info += f"      Size: {layer.size}\n"
-                        info += f"      Mode: {layer.mode}\n"
-    else: # Direct PIL Image
-        if hasattr(editor_data, 'size'):
-            info += f"Size: {editor_data.size}\n"
-            info += f"Mode: {editor_data.mode}\n"
-    return info
-"""
-
-def extract_region_from_editor(editor_data):
-    """Extract the selected region from ImageEditor data"""
-    if editor_data is None:
-        # print("DEBUG: extract_region_from_editor - editor_data is None")
-        return None, None
-    
-    # print(f"DEBUG: extract_region_from_editor - editor_data type: {type(editor_data)}")
-    
-    if isinstance(editor_data, dict):
-        background = editor_data.get('background')
-        layers = editor_data.get('layers', [])
-        
-        if background is None:
-            # print("DEBUG: extract_region_from_editor - background is None")
-            return None, None
-        
-        background_np = np.array(background)
-        # print(f"DEBUG: extract_region_from_editor - background_np shape: {background_np.shape}")
-        
-        if layers and len(layers) > 0:
-            selection_layer = layers[0]
-            selection_np = np.array(selection_layer)
-            # print(f"DEBUG: extract_region_from_editor - selection_np shape: {selection_np.shape}")
-            
-            if len(selection_np.shape) == 3:
-                if selection_np.shape[2] == 4:  # RGBA
-                    mask = selection_np[:, :, 3] > 0
-                else:  # RGB
-                    mask = np.any(selection_np > 0, axis=2)
-            else:
-                mask = selection_np > 0
-            
-            coords = np.where(mask)
-            if len(coords[0]) > 0:
-                y_min, y_max = coords[0].min(), coords[0].max()
-                x_min, x_max = coords[1].min(), coords[1].max()
-                
-                pad = 5
-                h, w = background_np.shape[:2]
-                y_min = max(0, y_min - pad)
-                y_max = min(h, y_max + pad)
-                x_min = max(0, x_min - pad)
-                x_max = min(w, x_max + pad)
-                
-                region = background_np[y_min:y_max+1, x_min:x_max+1]
-                # print(f"DEBUG: extract_region_from_editor - Extracted region shape: {region.shape}")
-                return region, (x_min, y_min, x_max, y_max)
-        # print("DEBUG: extract_region_from_editor - No selection or empty selection, returning full background.")
-        return background_np, None
-    else: # Assuming it's a direct PIL Image if not dict
-        if hasattr(editor_data, 'size'):
-            image_np = np.array(editor_data)
-            # print(f"DEBUG: extract_region_from_editor - Direct PIL image, shape: {image_np.shape}")
-            return image_np, None
-        else:
-            # print("DEBUG: extract_region_from_editor - editor_data is not dict and no size attribute, returning None.")
-            return None, None
-
-def calculate_blue_intensity(image_np, masks):
-    """Calculate blue intensity for each cell"""
-    # Ensure image is in correct format
-    if len(image_np.shape) == 2:
-        # Convert grayscale to RGB
-        image_np = cv2.cvtColor(image_np, cv2.COLOR_GRAY2RGB)
-    elif len(image_np.shape) == 3 and image_np.shape[2] == 4:
-        # Handle RGBA
-        image_np = cv2.cvtColor(image_np, cv2.COLOR_RGBA2RGB)
-        
-    # Calculate blue intensity for each cell
-    cell_blue_intensities = {}
-    unique_cells = np.unique(masks)
-    
-    # print(f"DEBUG: Found {len(unique_cells)} unique mask values: {unique_cells}")
-    # print(f"DEBUG: Image shape: {image_np.shape}, dtype: {image_np.dtype}")
-    # print(f"DEBUG: Masks shape: {masks.shape}, dtype: {masks.dtype}")
-    
-    for cell_id in unique_cells:
-        if cell_id == 0:  # Skip background
-            continue
-        
-        cell_mask = masks == cell_id
-        cell_pixels = image_np[cell_mask]
-        
-        if len(cell_pixels) > 0:
-            # Calculate mean blue intensity (blue channel is index 2)
-            blue_intensity = np.mean(cell_pixels[:, 2])  # Blue channel
-            cell_blue_intensities[cell_id] = blue_intensity
-            # print(f"DEBUG: Cell {cell_id}: {len(cell_pixels)} pixels, blue intensity: {blue_intensity:.2f}")
-    # print(f"DEBUG: Total cells with blue intensity: {len(cell_blue_intensities)}")
-    return cell_blue_intensities
-
-def create_viability_overlay(image_np, masks, blue_threshold):
-    """Create overlay showing live/dead cells based on blue threshold"""
-    
-    if masks is None or image_np is None:
-        # print("DEBUG: create_viability_overlay - masks or image_np is None, returning None.")
-        return None, 0, 0
-    
-    # print(f"DEBUG: create_viability_overlay called with threshold: {blue_threshold}")
-    # print(f"DEBUG: Image shape: {image_np.shape}, Masks shape: {masks.shape}, Masks max: {masks.max()}")
-    
-    # Ensure image is RGB
-    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)
-        
-    # Calculate blue intensities
-    cell_blue_intensities = calculate_blue_intensity(image_np, masks)
-    
-    # print(f"DEBUG: Got {len(cell_blue_intensities)} cells with blue intensities")
-    
-    # Create overlay - start with original image
-    overlay = image_np.copy().astype(np.float32)
-    
-    live_count = 0
-    dead_count = 0
-    
-    # Color cells based on viability
-    for cell_id, blue_intensity in cell_blue_intensities.items():
-        cell_mask = masks == cell_id
-        
-        # print(f"DEBUG: Processing cell {cell_id}, blue intensity: {blue_intensity:.2f}, threshold: {blue_threshold}")
-        
-        if blue_intensity > blue_threshold:
-            # Dead cell - color in red
-            overlay[cell_mask] = [255, 0, 0]  # Red
-            dead_count += 1
-            # print(f"DEBUG: Cell {cell_id} classified as DEAD")
-        else:
-            # Live cell - color in green
-            overlay[cell_mask] = [0, 255, 0]  # Green
-            live_count += 1
-            # print(f"DEBUG: Cell {cell_id} classified as LIVE")
-    # print(f"DEBUG: Final counts - Live: {live_count}, Dead: {dead_count}")
-    
-    # Blend with original image
-    alpha = 0.6  # Increased alpha for better visibility
-    final_overlay = (1 - alpha) * image_np.astype(np.float32) + alpha * overlay
-    final_overlay = np.clip(final_overlay, 0, 255).astype(np.uint8)
-    
-    return Image.fromarray(final_overlay), live_count, dead_count
-
-@spaces.GPU
-def segment_cells(editor_data, model_choice): # crop_coords removed from here, handled within extract_region_from_editor implicitly by ImageEditor
-    """
-    First stage: Segment cells and return results for viability assessment
-    """
-    global current_region_coords # Keep global for info display if needed later
-    
-    try:
-        # print("DEBUG: --- Starting segment_cells ---")
-        # debug_info = debug_editor_data(editor_data) # Commented out debug function call
-        # print(f"DEBUG: Editor data info:\n{debug_info}")
-        
-        # Load the model
-        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
-        
-        # Extract region from editor
-        region_np, region_coords = extract_region_from_editor(editor_data)
-        
-        if region_np is None:
-            # print("DEBUG: region_np is None, returning error and hiding viability section.")
-            current_region_coords = None
-            # Also return None for masks and image for the gr.State components
-            return 0, None, f"No image provided.", gr.update(visible=False), None, None # Removed debug_info
-        
-        # print(f"DEBUG: Image to segment shape (after extraction/cropping): {region_np.shape}, dtype: {region_np.dtype}")
-        
-        # Process image format
-        if len(region_np.shape) == 2:
-            region_np_processed = cv2.cvtColor(region_np, cv2.COLOR_GRAY2RGB)
-        elif len(region_np.shape) == 3 and region_np.shape[2] == 4:
-            region_np_processed = cv2.cvtColor(region_np, cv2.COLOR_RGBA2RGB)
-        else:
-            region_np_processed = region_np # Already RGB or suitable
-
-        # print(f"DEBUG: Image before model.eval shape: {region_np_processed.shape}, dtype: {region_np_processed.dtype}")
-        
-        # Run Cellpose segmentation
-        masks, flows, styles = model.eval(region_np_processed, diameter=None, channels=[0, 0])
-        # print(f"DEBUG: After model.eval: masks type: {type(masks)}, shape: {masks.shape if hasattr(masks, 'shape') else 'N/A'}")
-        
-        # Update global region coords for info display
-        current_region_coords = region_coords
-        
-        # Count unique cells
-        cell_count = len(np.unique(masks)) - 1
-        # print(f"DEBUG: Cell count: {cell_count}")
-        
-        # Create basic segmentation overlay
-        overlay = region_np_processed.copy().astype(np.float32)
-        
-        if masks.max() > 0:
-            np.random.seed(42)
-            colors = np.random.randint(0, 255, size=(masks.max() + 1, 3))
-            colors[0] = [0, 0, 0]  # Background stays black
-                        
-            colored_mask = colors[masks]
-            alpha = 0.4
-            overlay = (1 - alpha) * overlay + alpha * colored_mask
-                
-        overlay = np.clip(overlay, 0, 255).astype(np.uint8)
-        overlay_image = Image.fromarray(overlay)
-        
-        info_msg = f"Segmentation complete! Found {cell_count} cells.\n"
-        if region_coords:
-            info_msg += f"Region: {region_coords}\n"
-        info_msg += f"Now use the blue threshold slider below for viability assessment."
-                
-        # Make viability section visible
-        viability_section_update = gr.update(visible=True)
-        # print("DEBUG: segment_cells returning successfully, viability section visible.")
-        
-        # Return masks and original processed image for state components
-        return cell_count, overlay_image, info_msg, viability_section_update, masks, region_np_processed
-            
-    except Exception as e:
-        # print(f"ERROR: An exception occurred in segment_cells: {e}")
-        current_region_coords = None
-        # Return None for masks and image in case of error
-        return 0, None, f"Error: {str(e)}", gr.update(visible=False), None, None
-
-def update_viability_assessment(blue_threshold, stored_masks, stored_image):
-    """
-    Real-time viability assessment based on blue threshold
-    """
-    
-    # print("DEBUG: --- Starting update_viability_assessment ---")
-    # print(f"DEBUG: At start of update_viability_assessment: stored_masks is None? {stored_masks is None}, stored_image is None? {stored_image is None}")
-    
-    if stored_masks is None or stored_image is None:
-        # print("DEBUG: Passed-in stored_masks or stored_image is None, returning 'Please run segmentation first'.")
-        return None, 0, 0, "Please run segmentation first"
-    
-    try:
-        # Debug information (kept for now, but can be removed if not needed for user info)
-        unique_cells = np.unique(stored_masks)
-        total_cells = len(unique_cells) - 1  # Subtract background
-                
-        debug_info = f"Debug - Total cells found: {total_cells}\n"
-        debug_info += f"Image shape: {stored_image.shape}\n"
-        debug_info += f"Masks shape: {stored_masks.shape}\n"
-        debug_info += f"Unique mask values (first 10): {unique_cells[:10]}...\n"
-                
-        # Create viability overlay
-        viability_overlay, live_count, dead_count = create_viability_overlay(
-            stored_image, stored_masks, blue_threshold
-        )
-                
-        total_count = live_count + dead_count
-        viability_info = f"Blue threshold: {blue_threshold}\n"
-        viability_info += f"Total cells: {total_count}\nLive (green): {live_count}\nDead (red): {dead_count}\n"
-                
-        if total_count > 0:
-            viability_percentage = (live_count / total_count) * 100
-            viability_info += f"Viability: {viability_percentage:.1f}%\n"
-                
-        # viability_info += f"\n{debug_info}" # Removed this line to hide debug info from UI
-        # print("DEBUG: update_viability_assessment returning successfully.")
-                
-        return viability_overlay, live_count, dead_count, viability_info
-            
-    except Exception as e:
-        # print(f"ERROR: An exception occurred in update_viability_assessment: {e}")
-        return None, 0, 0, f"Error in viability assessment: {str(e)}\nMasks available: {stored_masks is not None}\nImage available: {stored_image is not None}"
-
-@spaces.GPU
-def segment_with_coords(image, model_choice, crop_coords):
-    """Alternative function for manual coordinates input"""
-    global current_region_coords
-        
-    # print("DEBUG: --- Starting segment_with_coords ---")
-    if image is None:
-        # print("DEBUG: No image provided for segment_with_coords, returning error.")
-        current_region_coords = None
-        return 0, None, "No image provided", gr.update(visible=False), None, None
-        
-    try:
-        # Load the model
-        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
-                
-        # Convert PIL Image to numpy array
-        image_np = np.array(image)
-        # print(f"DEBUG: image_np from PIL: shape={image_np.shape}, dtype={image_np.dtype}")
-                
-        # Apply crop if coordinates are provided
-        if crop_coords and crop_coords.strip():
-            try:
-                coords = [int(x.strip()) for x in crop_coords.split(',')]
-                if len(coords) == 4:
-                    x_min, y_min, x_max, y_max = coords
-                    h, w = image_np.shape[:2]
-                    x_min = max(0, min(x_min, w-1))
-                    y_min = max(0, min(y_min, h-1))
-                    x_max = max(x_min+1, min(x_max, w))
-                    y_max = max(y_min+1, min(y_max, h))
-                                        
-                    image_np_processed = image_np[y_min:y_max, x_min:x_max]
-                    current_region_coords = (x_min, y_min, x_max, y_max)
-                    # print(f"DEBUG: Applied manual crop in segment_with_coords: {current_region_coords}, new image_np_processed shape: {image_np_processed.shape}")
-                else:
-                    image_np_processed = image_np # No valid crop, use original
-            except ValueError:
-                # print(f"DEBUG: Invalid crop coordinates format in segment_with_coords: {crop_coords}")
-                image_np_processed = image_np # Invalid crop, use original
-        else:
-            image_np_processed = image_np # No crop coords, use original
-        
-        # Process image format
-        if len(image_np_processed.shape) == 2:
-            image_np_final = cv2.cvtColor(image_np_processed, cv2.COLOR_GRAY2RGB)
-        elif len(image_np_processed.shape) == 3 and image_np_processed.shape[2] == 4:
-            image_np_final = cv2.cvtColor(image_np_processed, cv2.COLOR_RGBA2RGB)
-        else:
-            image_np_final = image_np_processed
-        
-        # print(f"DEBUG: Image before model.eval (segment_with_coords) shape: {image_np_final.shape}, dtype: {image_np_final.dtype}")
-        # Run Cellpose
-        masks, flows, styles = model.eval(image_np_final, diameter=None, channels=[0, 0])
-        # print(f"DEBUG: After model.eval (segment_with_coords): masks type: {type(masks)}, shape: {masks.shape if hasattr(masks, 'shape') else 'N/A'}")
-        
-        # Count unique cells
-        cell_count = len(np.unique(masks)) - 1
-                
-        # Create overlay
-        overlay = image_np_final.copy().astype(np.float32)
-                
-        if masks.max() > 0:
-            np.random.seed(42)
-            colors = np.random.randint(0, 255, size=(masks.max() + 1, 3))
-            colors[0] = [0, 0, 0]                        
-            colored_mask = colors[masks]
-            alpha = 0.4
-            overlay = (1 - alpha) * overlay + alpha * colored_mask
-                
-        overlay = np.clip(overlay, 0, 255).astype(np.uint8)
-        overlay_image = Image.fromarray(overlay)
-                
-        info_msg = f"Segmentation complete! Found {cell_count} cells.\n"
-        if current_region_coords: # Use global if set by crop
-            info_msg += f"Region: {current_region_coords}\n"
-        info_msg += f"Now use the blue threshold slider below for viability assessment."
-        # print("DEBUG: segment_with_coords returning successfully, viability section visible.")
-                
-        return cell_count, overlay_image, info_msg, gr.update(visible=True), masks, image_np_final
-            
-    except Exception as e:
-        # print(f"ERROR: An exception occurred in segment_with_coords: {e}")
-        current_region_coords = None
-        return 0, None, f"Error: {str(e)}", gr.update(visible=False), None, None
-
-# Create the Gradio interface
-with gr.Blocks(title="Cell Counter with Real-time Viability Assessment", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# Cell Counter with Real-time Viability Assessment")
-    gr.Markdown("Upload a microscopy image, run segmentation, then use the blue threshold slider for real-time viability assessment.")
-        
-    # Define State components to store masks and image data across function calls
-    # These are hidden from the UI but persist data per session.
-    masks_state = gr.State(value=None)
-    image_state = gr.State(value=None)
-
-    with gr.Tab("Image Editor (Draw Selection)"):
-        gr.Markdown("### Step 1: Draw selection and run segmentation")
-                
-        with gr.Row():
-            with gr.Column():
-                image_editor = gr.ImageEditor(
-                    label="Draw selection on image",
-                    type="pil",
-                    brush=gr.Brush(colors=["#ff0000"], color_mode="fixed", default_size=20),
-                    eraser=gr.Eraser(default_size=20)
-                )
-                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)
-                overlay_output1 = gr.Image(type="pil", label="Segmentation Result")
-                info_output1 = gr.Textbox(label="Processing Info", lines=3)
-                
-        # Viability Assessment Section
-        with gr.Group(visible=False) as viability_section1:
-            gr.Markdown("### Step 2: Real-time Viability Assessment")
-            gr.Markdown("Adjust the blue threshold to classify cells as live (green) or dead (red). Higher values = more blue = more dead.")
-                        
-            with gr.Row():
-                with gr.Column():
-                    blue_threshold_slider1 = gr.Slider(
-                        minimum=0,
-                        maximum=255,
-                        value=100,
-                        step=1,
-                        label="Blue Threshold",
-                        info="Higher values = more cells classified as dead"
-                    )
-                                    
-                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_info1 = gr.Textbox(label="Viability Statistics", lines=4)
-                
-        # Event handlers
-        # segment_cells now returns masks and image_np which are stored in masks_state and image_state
-        segment_btn1.click(
-            fn=segment_cells,
-            inputs=[image_editor, model_dropdown1],
-            outputs=[cell_count_output1, overlay_output1, info_output1, viability_section1, masks_state, image_state]
-        ).then(  # Chain the viability assessment after segmentation
-            fn=update_viability_assessment,
-            inputs=[blue_threshold_slider1, masks_state, image_state], # Pass stored state as inputs
-            outputs=[viability_overlay1, live_count_output1, dead_count_output1, viability_info1]
-        )
-                
-        # blue_threshold_slider changes also need the stored state
-        blue_threshold_slider1.change(
-            fn=update_viability_assessment,
-            inputs=[blue_threshold_slider1, masks_state, image_state], # Pass stored state as inputs
-            outputs=[viability_overlay1, live_count_output1, dead_count_output1, viability_info1]
-        )
-
-    with gr.Tab("Manual Coordinates"):
-        gr.Markdown("### Step 1: Upload image and run segmentation")
-                
-        with gr.Row():
-            with gr.Column():
-                image_input = gr.Image(type="pil", label="Microscopy Image")
-                model_dropdown2 = gr.Dropdown(
-                    choices=list(MODEL_OPTIONS.keys()),
-                    label="Select Model",
-                    value="Hemocytometer Model"
-                )
-                coord_input = gr.Textbox(
-                    label="Crop Coordinates (optional)",
-                    placeholder="e.g., 100,100,400,400",
-                    info="Format: x_min,y_min,x_max,y_max"
-                )
-                segment_btn2 = gr.Button("🔬 Run Segmentation", variant="primary", size="lg")
-                            
-            with gr.Column():
-                cell_count_output2 = gr.Number(label="Total Cells Detected", precision=0)
-                overlay_output2 = gr.Image(type="pil", label="Segmentation Result")
-                info_output2 = gr.Textbox(label="Processing Info", lines=3)
-                
-        # Viability Assessment Section
-        with gr.Group(visible=False) as viability_section2:
-            gr.Markdown("### Step 2: Real-time Viability Assessment")
-            gr.Markdown("Adjust the blue threshold to classify cells as live (green) or dead (red). Higher values = more blue = more dead.")
-                        
-            with gr.Row():
-                with gr.Column():
-                    blue_threshold_slider2 = gr.Slider(
-                        minimum=0,
-                        maximum=255,
-                        value=100,
-                        step=1,
-                        label="Blue Threshold",
-                        info="Higher values = more cells classified as dead"
-                    )
-                                    
-                with gr.Column():
-                    live_count_output2 = gr.Number(label="Live Cells (Green)", precision=0)
-                    dead_count_output2 = gr.Number(label="Dead Cells (Red)", precision=0)
-                        
-            viability_overlay2 = gr.Image(type="pil", label="Viability Assessment (Green=Live, Red=Dead)")
-            viability_info2 = gr.Textbox(label="Viability Statistics", lines=4)
-                
-        # Event handlers
-        # segment_with_coords now returns masks and image_np which are stored in masks_state and image_state
-        segment_btn2.click(
-            fn=segment_with_coords,
-            inputs=[image_input, model_dropdown2, coord_input],
-            outputs=[cell_count_output2, overlay_output2, info_output2, viability_section2, masks_state, image_state]
-        ).then(  # Chain the viability assessment after segmentation
-            fn=update_viability_assessment,
-            inputs=[blue_threshold_slider2, masks_state, image_state], # Pass stored state as inputs
-            outputs=[viability_overlay2, live_count_output2, dead_count_output2, viability_info2]
-        )
-                
-        # blue_threshold_slider changes also need the stored state
-        blue_threshold_slider2.change(
-            fn=update_viability_assessment,
-            inputs=[blue_threshold_slider2, masks_state, image_state], # Pass stored state as inputs
-            outputs=[viability_overlay2, live_count_output2, dead_count_output2, viability_info2]
-        )
-
-    # Instructions
-    with gr.Accordion("Instructions", open=False):
-        gr.Markdown("""
-        ### How to use:
-                
-        1. **Upload and Segment**:
-            - Upload your microscopy image
-            - Select a model (Hemocytometer Model for blood cells)
-            - Draw a selection region or specify coordinates
-            - Click "Run Segmentation"
-                
-        2. **Viability Assessment**:
-            - After segmentation, the viability section will appear
-            - Use the blue threshold slider to classify cells in real-time
-            - Green cells = Live (low blue intensity)
-            - Red cells = Dead (high blue intensity)
-            - Adjust the threshold until the classification looks correct
-                
-        3. **Interpreting Results**:
-            - The app calculates viability percentage automatically
-            - Live cells appear green, dead cells appear red
-            - Statistics show total counts and viability percentage
-                
-        ### Tips:
-        - Start with a threshold around 100 and adjust based on your staining
-        - Dead cells typically have higher blue intensity due to trypan blue uptake
-        - The threshold is applied in real-time without re-running segmentation
-        """)
-
-if __name__ == "__main__":
-    demo.launch()