Update app.py

app.py

@@ -17,55 +17,37 @@ MODEL_OPTIONS = {
 
 loaded_models = {}
 
-# Removed the debug_editor_data function completely as per request
-
 def extract_region_from_editor(editor_data):
     """Extract the selected region from ImageEditor data"""
     if editor_data is None:
         return None, None
     
-    # ImageEditor can return different formats depending on version
-    # Let's handle the most common cases
-    
     if isinstance(editor_data, dict):
-        # Case 1: Dictionary with 'background' and 'layers'
         background = editor_data.get('background')
         layers = editor_data.get('layers', [])
         
         if background is None:
             return None, None
             
-        # Convert background to numpy array
         background_np = np.array(background)
         
-        # If there are drawn layers, try to extract selection
         if layers and len(layers) > 0:
-            # Get the first layer
             selection_layer = layers[0]
-            
-            # Convert to numpy array
             selection_np = np.array(selection_layer)
             
-            # Find non-transparent/non-black pixels as selection
             if len(selection_np.shape) == 3:
-                # For RGB, look for non-black pixels
                 if selection_np.shape[2] == 4:  # RGBA
-                    # Use alpha channel
                     mask = selection_np[:, :, 3] > 0
                 else:  # RGB
-                    # Use non-black pixels
                     mask = np.any(selection_np > 0, axis=2)
             else:
-                # Grayscale
                 mask = selection_np > 0
             
-            # Find bounding box of the selection
             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()
                 
-                # Add some padding to ensure we don't get tiny regions
                 pad = 5
                 h, w = background_np.shape[:2]
                 y_min = max(0, y_min - pad)
@@ -73,29 +55,18 @@ def extract_region_from_editor(editor_data):
                 x_min = max(0, x_min - pad)
                 x_max = min(w, x_max + pad)
                 
-                # Extract the region
                 region = background_np[y_min:y_max+1, x_min:x_max+1]
                 return region, (x_min, y_min, x_max, y_max)
         
-        # If no selection, return the full image
         return background_np, None
     
     else:
-        # Case 2: Direct PIL Image
-        if hasattr(editor_data, 'size'):  # Check if it's a PIL Image
+        if hasattr(editor_data, 'size'):
             image_np = np.array(editor_data)
             return image_np, None
         else:
             return None, None
 
-def crop_image_with_coords(image_np, coords):
-    """Crop image using provided coordinates"""
-    if coords is None:
-        return image_np
-    
-    x_min, y_min, x_max, y_max = coords
-    return image_np[y_min:y_max+1, x_min:x_max+1]
-
 def classify_cells_by_blueness(image_np, masks, blue_threshold):
     """
     Classify cells as dead (blue) or alive based on single blueness metric
@@ -108,6 +79,12 @@ def classify_cells_by_blueness(image_np, masks, blue_threshold):
     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)
     
@@ -148,7 +125,7 @@ def classify_cells_by_blueness(image_np, masks, blue_threshold):
             alive_cells.append(cell_id)
     
     # Create colored overlay
-    overlay = image_np.copy()
+    overlay = image_np.copy().astype(np.float32) # Ensure float for blending
     
     # Color dead cells red, alive cells green
     for cell_id in dead_cells:
@@ -161,18 +138,18 @@ def classify_cells_by_blueness(image_np, masks, blue_threshold):
     
     # Blend with original image
     alpha = 0.4
-    overlay = (1 - alpha) * image_np + alpha * overlay
-    overlay = np.clip(overlay, 0, 255).astype(np.uint8)
+    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), overlay
+    return len(dead_cells), len(alive_cells), final_overlay
 
 @spaces.GPU
-def segment_and_count_viability(editor_data, model_choice, blue_threshold, crop_coords=None):
+def run_segmentation_editor(editor_data, model_choice):
     """
-    Segment cells and analyze viability using single blueness threshold
+    Runs cell segmentation using ImageEditor data.
+    Returns initial segmentation overlay, counts, and also masks/image for state.
     """
     try:
-        # Load the model
         model_filename = MODEL_OPTIONS[model_choice]
         model_path = hf_hub_download(repo_id=HF_REPO_ID, filename=model_filename)
         
@@ -182,134 +159,157 @@ def segment_and_count_viability(editor_data, model_choice, blue_threshold, crop_
             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:
-            return 0, 0, 0, 0.0, None, f"No image provided."
+            return 0, None, f"No image provided.", gr.update(visible=False), None, None
         
-        # If manual crop coordinates are provided, use them instead
-        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
-                    # Ensure coordinates are within image bounds
-                    h, w = region_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))
-                    
-                    region_np = region_np[y_min:y_max, x_min:x_max]
-                    region_coords = (x_min, y_min, x_max, y_max)
-            except ValueError:
-                pass  # Invalid coordinates, continue with current region
-        
-        # If grayscale, convert to RGB
+        # Process image format to RGB
         if len(region_np.shape) == 2:
-            region_np = cv2.cvtColor(region_np, cv2.COLOR_GRAY2RGB)
+            processed_image_np = cv2.cvtColor(region_np, cv2.COLOR_GRAY2RGB)
         elif len(region_np.shape) == 3 and region_np.shape[2] == 4:
-            # Handle RGBA images
-            region_np = cv2.cvtColor(region_np, cv2.COLOR_RGBA2RGB)
-        
-        # Run Cellpose on the selected region
-        masks, flows, styles = model.eval(region_np, diameter=None, channels=[0, 0])
+            processed_image_np = cv2.cvtColor(region_np, cv2.COLOR_RGBA2RGB)
+        else:
+            processed_image_np = region_np
         
-        # Classify cells by blueness
-        dead_count, alive_count, viability_overlay = classify_cells_by_blueness(
-            region_np, masks, blue_threshold
-        )
+        # Run Cellpose segmentation
+        masks, flows, styles = model.eval(processed_image_np, diameter=None, channels=[0, 0])
         
-        total_count = dead_count + alive_count
-        viability_percent = (alive_count / total_count * 100) if total_count > 0 else 0.0
+        cell_count = len(np.unique(masks)) - 1
         
-        # Convert result to PIL Image for output
-        overlay_image = Image.fromarray(viability_overlay)
+        # 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)
         
-        # Create info message
-        info_msg = f"Total cells: {total_count}\nAlive cells: {alive_count}\nDead cells: {dead_count}\nViability: {viability_percent:.1f}%\nBlue threshold: {blue_threshold}%"
+        info_msg = f"Segmentation complete! Found {cell_count} cells.\n"
         if region_coords:
-            info_msg += f"\nProcessed region: {region_coords[0]},{region_coords[1]} to {region_coords[2]},{region_coords[3]}"
-        
-        return total_count, alive_count, dead_count, viability_percent, overlay_image, info_msg
-        
+            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
+        return cell_count, Image.fromarray(segmentation_overlay), info_msg, gr.update(visible=True), masks, processed_image_np
+            
     except Exception as e:
-        return 0, 0, 0, 0.0, None, f"Error occurred: {str(e)}"
+        return 0, None, f"Error during segmentation: {str(e)}", gr.update(visible=False), None, None
 
 @spaces.GPU
-def segment_with_coords_viability(image, model_choice, blue_threshold, crop_coords):
-    """Segment using regular image input with manual coordinate specification and viability analysis"""
+def run_segmentation_manual(image, model_choice, crop_coords):
+    """
+    Runs cell segmentation using manual image input and coordinates.
+    Returns initial segmentation overlay, counts, and also masks/image for state.
+    """
     if image is None:
-        return 0, 0, 0, 0.0, None, "No image provided"
-    
+        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)
-        
+                
         # 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
-                    # Ensure coordinates are within image bounds
                     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 = image_np[y_min:y_max, x_min:x_max]
+                                        
+                    processed_image_np = image_np[y_min:y_max, x_min:x_max]
+                else:
+                    processed_image_np = image_np # No valid crop, use original
             except ValueError:
-                pass  # Invalid coordinates, use full image
+                processed_image_np = image_np # Invalid crop, use original
+        else:
+            processed_image_np = image_np # No crop coords, use original
         
-        # Process image format
-        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)
+        # Process image format to RGB
+        if len(processed_image_np.shape) == 2:
+            processed_image_np = cv2.cvtColor(processed_image_np, cv2.COLOR_GRAY2RGB)
+        elif len(processed_image_np.shape) == 3 and processed_image_np.shape[2] == 4:
+            processed_image_np = cv2.cvtColor(processed_image_np, cv2.COLOR_RGBA2RGB)
         
         # Run Cellpose
-        masks, flows, styles = model.eval(image_np, diameter=None, channels=[0, 0])
+        masks, flows, styles = model.eval(processed_image_np, diameter=None, channels=[0, 0])
         
-        # Classify cells by blueness
-        dead_count, alive_count, viability_overlay = classify_cells_by_blueness(
-            image_np, masks, blue_threshold
+        cell_count = len(np.unique(masks)) - 1
+                
+        # Create a basic segmentation overlay
+        segmentation_overlay = processed_image_np.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
+            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"
+        if crop_coords:
+            info_msg += f"Processed with coordinates: {crop_coords}\n"
+        info_msg += f"Now adjust the Blue Threshold for viability assessment."
+                
+        return cell_count, Image.fromarray(segmentation_overlay), info_msg, gr.update(visible=True), masks, processed_image_np
+            
+    except Exception as e:
+        return 0, None, f"Error during segmentation: {str(e)}", gr.update(visible=False), None, None
+
+def update_viability_realtime(blue_threshold, stored_masks, stored_image_np):
+    """
+    Updates viability assessment in real-time based on blue threshold.
+    Takes stored masks and image_np from state.
+    """
+    if stored_masks is None or stored_image_np is None:
+        return None, 0, 0, 0.0, "Please run segmentation first."
+    
+    try:
+        dead_count, alive_count, viability_overlay_np = classify_cells_by_blueness(
+            stored_image_np, stored_masks, blue_threshold
         )
         
-        total_count = dead_count + alive_count
+        total_count = alive_count + dead_count
         viability_percent = (alive_count / total_count * 100) if total_count > 0 else 0.0
         
-        overlay_image = Image.fromarray(viability_overlay)
-        
-        info_msg = f"Total cells: {total_count}\nAlive cells: {alive_count}\nDead cells: {dead_count}\nViability: {viability_percent:.1f}%\nBlue threshold: {blue_threshold}%"
-        if crop_coords:
-            info_msg += f"\nProcessed with coordinates: {crop_coords}"
-        
-        return total_count, alive_count, dead_count, viability_percent, overlay_image, info_msg
+        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}%\nBlue threshold: {blue_threshold}%"
         
+        return overlay_image, alive_count, dead_count, viability_percent, info_msg
+            
     except Exception as e:
-        return 0, 0, 0, 0.0, None, f"Error occurred: {str(e)}"
+        return None, 0, 0, 0.0, f"Error updating viability: {str(e)}"
 
-# Create the Gradio interface with tabs for different input methods
-with gr.Blocks(title="Cell Viability Counter with Trypan Blue Analysis") as demo:
+
+# Create the Gradio interface
+with gr.Blocks(title="Cell Viability Counter with Trypan Blue Analysis", theme=gr.themes.Soft()) as demo:
     gr.Markdown("# Cell Viability Counter with Trypan Blue Analysis")
     gr.Markdown("Upload a trypan blue stained microscopy image and analyze cell viability. Dead cells appear blue, alive cells are unstained.")
-    
-    with gr.Tab("Image Editor (Draw Selection)"):
-        gr.Markdown("Use the drawing tools to select a region of the image for segmentation and viability analysis.")
         
+    # 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("### Step 1: Draw selection and run segmentation")
+                
         with gr.Row():
             with gr.Column():
                 image_editor = gr.ImageEditor(
@@ -318,114 +318,147 @@ with gr.Blocks(title="Cell Viability Counter with Trypan Blue Analysis") as demo
                     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"
                 )
-                
-                # Single blue threshold control
-                gr.Markdown("### Trypan Blue Threshold")
-                blue_threshold1 = gr.Slider(
-                    0, 100, value=25, step=1, 
-                    label="Blue Threshold (%)",
-                    info="Higher values = more selective for blue cells"
-                )
-                
-                segment_btn1 = gr.Button("Analyze Viability", variant="primary")
-                
+                segment_btn1 = gr.Button("🔬 Run Segmentation", variant="primary", size="lg")
+                            
             with gr.Column():
-                with gr.Row():
-                    total_count_output1 = gr.Number(label="Total Cells")
-                    alive_count_output1 = gr.Number(label="Alive Cells")
-                    dead_count_output1 = gr.Number(label="Dead Cells")
+                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_output1 = gr.Number(label="Viability (%)", precision=1)
-                overlay_output1 = gr.Image(type="pil", label="Viability Analysis (Green=Alive, Red=Dead)")
-                info_output1 = gr.Textbox(label="Analysis Results")
-        
+        # Viability Assessment Section
+        with gr.Group(visible=False) as viability_section1:
+            gr.Markdown("### Step 2: Real-time 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="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_and_count_viability,
-            inputs=[image_editor, model_dropdown1, blue_threshold1],
-            outputs=[total_count_output1, alive_count_output1, dead_count_output1, viability_output1, overlay_output1, info_output1]
+            fn=run_segmentation_editor,
+            inputs=[image_editor, model_dropdown1],
+            outputs=[cell_count_output1, overlay_output1, info_output1, viability_section1, masks_state, image_state]
+        ).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]
+        )
+
     with gr.Tab("Manual Coordinates"):
-        gr.Markdown("Upload an image and specify coordinates manually (format: x_min,y_min,x_max,y_max)")
-        
+        gr.Markdown("### Step 1: Upload image and run segmentation")
+                
         with gr.Row():
             with gr.Column():
-                image_input = gr.Image(type="pil", label="Trypan Blue Stained Image")
-                
+                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"
                 )
-                
-                # Single blue threshold control
-                gr.Markdown("### Trypan Blue Threshold")
-                blue_threshold2 = gr.Slider(
-                    0, 100, value=25, step=1, 
-                    label="Blue Threshold (%)",
-                    info="Higher values = more selective for blue cells"
-                )
-                
-                segment_btn2 = gr.Button("Analyze Viability", variant="primary")
-                
+                segment_btn2 = gr.Button("🔬 Run Segmentation", variant="primary", size="lg")
+                            
             with gr.Column():
-                with gr.Row():
-                    total_count_output2 = gr.Number(label="Total Cells")
-                    alive_count_output2 = gr.Number(label="Alive Cells")
-                    dead_count_output2 = gr.Number(label="Dead Cells")
+                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_output2 = gr.Number(label="Viability (%)", precision=1)
-                overlay_output2 = gr.Image(type="pil", label="Viability Analysis (Green=Alive, Red=Dead)")
-                info_output2 = gr.Textbox(label="Analysis Results")
-        
+        # Viability Assessment Section
+        with gr.Group(visible=False) as viability_section2:
+            gr.Markdown("### Step 2: Real-time 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_threshold2 = 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_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_percent_output2 = gr.Number(label="Viability (%)", precision=1)
+            viability_info2 = gr.Textbox(label="Viability Statistics", lines=4)
+                
+        # Event handlers
         segment_btn2.click(
-            fn=segment_with_coords_viability,
-            inputs=[image_input, model_dropdown2, blue_threshold2, coord_input],
-            outputs=[total_count_output2, alive_count_output2, dead_count_output2, viability_output2, overlay_output2, info_output2]
+            fn=run_segmentation_manual,
+            inputs=[image_input, model_dropdown2, coord_input],
+            outputs=[cell_count_output2, overlay_output2, info_output2, viability_section2, masks_state, image_state]
+        ).then(  # Chain the initial viability assessment after segmentation
+            fn=update_viability_realtime,
+            inputs=[blue_threshold2, masks_state, image_state],
+            outputs=[viability_overlay2, live_count_output2, dead_count_output2, viability_percent_output2, viability_info2]
         )
-    
-    # Add usage instructions
-    with gr.Tab("Usage Instructions"):
+                
+        # Slider changes update viability in real-time
+        blue_threshold2.change(
+            fn=update_viability_realtime,
+            inputs=[blue_threshold2, masks_state, image_state],
+            outputs=[viability_overlay2, live_count_output2, dead_count_output2, viability_percent_output2, viability_info2]
+        )
+
+    # Instructions
+    with gr.Accordion("Instructions", open=False):
         gr.Markdown("""
-        ## How to Use This Tool
-        
-        ### 1. Image Preparation
-        - Upload a trypan blue stained microscopy image
-        - Dead cells should appear blue, alive cells should be unstained (clear)
-        
-        ### 2. Blue Threshold Adjustment
-        - **Single Slider (0-100%)**: Adjusts sensitivity to blue coloration
-        - **Lower values (10-20%)**: More sensitive, detects lightly stained cells
-        - **Higher values (30-50%)**: More selective, only detects strongly blue cells
-        - **Default (25%)**: Works well for most standard trypan blue staining
-        
-        ### 3. How the Blue Detection Works
-        - Analyzes hue (color) and saturation (intensity) in each cell
-        - Focuses on blue range around 115° in HSV color space
-        - Combines color proximity with saturation strength
-        - Calculates average \"blueness\" for each detected cell
-        
-        ### 4. Output
-        - **Green overlay**: Live cells
-        - **Red overlay**: Dead cells
-        - **Viability %**: (Alive cells / Total cells) × 100
-        
-        ### 5. Tips
-        - Use consistent lighting and staining protocols for best results
-        - Adjust thresholds if cells are misclassified
-        - The tool works best with clear contrast between stained and unstained cells
+        ### How to use:
+                
+        1. **Upload and Segment**:
+            - Upload your microscopy image.
+            - Select a Cellpose model (e.g., "Hemocytometer Model" for blood cells).
+            - Draw a selection region using the Image Editor, or specify coordinates manually.
+            - Click "Run Segmentation".
+                
+        2. **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.
+                
+        3. **Interpreting Results**:
+            - The app calculates and displays the total, live, and dead cell counts, along with the viability percentage.
         """)
 
 if __name__ == "__main__":