Update app.py

app.py

@@ -8,7 +8,8 @@ import tempfile
 from PIL import Image, ImageDraw
 import io
 from huggingface_hub import hf_hub_download
-import base64 
+import base64
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 HF_REPO_ID = "myang4218/cellposemodel"
 MODEL_OPTIONS = {
@@ -18,11 +19,16 @@ MODEL_OPTIONS = {
 
 loaded_models = {}
 
+# ---- mobile-safe size limits (aggressive for Safari) ----
 MAX_SIDE = 1024          
 MAX_PIXELS = 1024 * 1024
 
 
 def safe_resize(image_np):
+    """
+    Downscale image to fit within MAX_SIDE and MAX_PIXELS while
+    preserving aspect ratio. Works for RGB / RGBA / grayscale.
+    """
     h, w = image_np.shape[:2]
     total = h * w
 
@@ -44,27 +50,29 @@ def draw_exclusion_overlay(image_np, left_width_pct, top_width_pct):
     
     h, w = image_np.shape[:2]
     
-    # Convert to PIL
+    # Convert to PIL for drawing
     img_pil = Image.fromarray(image_np)
     draw = ImageDraw.Draw(img_pil, 'RGBA')
     
-
+    # Calculate pixel widths from percentages
     left_px = int(w * left_width_pct / 100)
     top_px = int(h * top_width_pct / 100)
     
     # Draw overlays for exclusion zones
     if left_px > 0:
+        # Left exclusion zone
         draw.rectangle(
             [(0, 0), (left_px, h)],
-            fill=(255, 0, 0, 80)  
+            fill=(255, 0, 0, 80)  # Semi-transparent red
         )
         # border line
         draw.line([(left_px, 0), (left_px, h)], fill=(255, 0, 0, 255), width=3)
     
     if top_px > 0:
+        # Top exclusion zone
         draw.rectangle(
             [(0, 0), (w, top_px)],
-            fill=(255, 0, 0, 80) 
+            fill=(255, 0, 0, 80)  # Semi-transparent red
         )
         # border line
         draw.line([(0, top_px), (w, top_px)], fill=(255, 0, 0, 255), width=3)
@@ -75,6 +83,7 @@ def draw_exclusion_overlay(image_np, left_width_pct, top_width_pct):
 def apply_stereological_exclusion(masks, left_width_pct, top_width_pct):
     h, w = masks.shape
     
+    # Calculate pixel widths from percentages
     left_px = int(w * left_width_pct / 100)
     top_px = int(h * top_width_pct / 100)
     
@@ -91,14 +100,20 @@ def apply_stereological_exclusion(masks, left_width_pct, top_width_pct):
         # Get cell boundary coordinates
         rows, cols = np.where(cell_mask)
         
+        # Check if cell touches left exclusion zone
         touches_left = np.any(cols < left_px) if left_px > 0 else False
+        
+        # Check if cell touches top exclusion zone
         touches_top = np.any(rows < top_px) if top_px > 0 else False
         
+        # Exclude if touching left or top
         if touches_left or touches_top:
             filtered_masks[cell_mask] = 0
             excluded_cells.append(cell_id)
         else:
             included_cells.append(cell_id)
+    
+    # Renumber remaining cells
     unique_ids = np.unique(filtered_masks)
     unique_ids = unique_ids[unique_ids > 0]
     
@@ -109,67 +124,83 @@ def apply_stereological_exclusion(masks, left_width_pct, top_width_pct):
     return renumbered_masks, len(excluded_cells), len(included_cells)
 
 
-def classify_cells_by_blueness(image_np, masks, blue_threshold):
-    
+def classify_cells_by_blueness(image_np, masks, threshold_bias):
+    """
+    Classify cells as dead (blue) or alive using an adaptive Otsu threshold
+    on per-cell blueness scores, with a user bias to fine-tune.
+
+    Args:
+        image_np:        RGB image array
+        masks:           Cellpose segmentation masks
+        threshold_bias:  Slider value -50..+50; shifts Otsu threshold up/down.
+                         Negative = more cells classified dead (looser).
+                         Positive = fewer cells classified dead (stricter).
+                         0 = pure Otsu (fully automatic).
+
+    Returns:
+        dead_count, alive_count, colored_overlay, otsu_threshold, final_threshold
+    """
+
     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)
 
-    
     hsv = cv2.cvtColor(image_np, cv2.COLOR_RGB2HSV)
 
-    # Calculate blueness index for each pixel
-    hue = hsv[:, :, 0].astype(np.float32)
+    hue        = hsv[:, :, 0].astype(np.float32)
     saturation = hsv[:, :, 1].astype(np.float32)
 
-    # Hue score: peaks around 115 , drops off towards edges
-    # Handle hue wrap-around for blue detection (100-130 range)
+    # Raw blueness: hue proximity to 115° × saturation
     hue_distance = np.minimum(np.abs(hue - 115), 180 - np.abs(hue - 115))
-    hue_score = np.maximum(0, 1 - hue_distance / 65)  # 65 good blue range
+    hue_score    = np.maximum(0, 1 - hue_distance / 65)
+    blueness     = hue_score * (saturation / 255.0)
 
-    # blueness metric
-    blueness = hue_score * (saturation / 255.0)
-
-    # Convert threshold from 0-100 to 0-1 scale
-    threshold = blue_threshold / 100.0
-
-    # Get unique cell IDs 
+    # --- Compute per-cell mean blueness scores ---
     cell_ids = np.unique(masks)
-    cell_ids = cell_ids[cell_ids > 0]  
+    cell_ids = cell_ids[cell_ids > 0]
 
-    dead_cells = []
-    alive_cells = []
+    if len(cell_ids) == 0:
+        blank = image_np.copy()
+        return 0, 0, blank, 0.0, 0.0
 
-    # Classify each cell
-    for cell_id in cell_ids:
-        
-        cell_mask = (masks == cell_id)
-        cell_blueness = np.mean(blueness[cell_mask])
+    cell_scores = np.array([np.mean(blueness[masks == cid]) for cid in cell_ids])
 
-        if cell_blueness > threshold:
-            dead_cells.append(cell_id)
-        else:
-            alive_cells.append(cell_id)
+    # --- Otsu on the distribution of per-cell scores ---
+    # cv2.threshold expects uint8; scale 0-1 → 0-255
+    scores_u8 = (np.clip(cell_scores, 0, 1) * 255).astype(np.uint8)
 
-    # Create colored overlay
-    overlay = image_np.copy().astype(np.float32)  # Ensure float for blending
+    if scores_u8.max() == scores_u8.min():
+        # All cells identical → Otsu is undefined; use midpoint
+        otsu_threshold = float(scores_u8[0]) / 255.0
+    else:
+        # Reshape to a single-column image so cv2.threshold works
+        thresh_val, _ = cv2.threshold(
+            scores_u8.reshape(-1, 1), 0, 255,
+            cv2.THRESH_BINARY + cv2.THRESH_OTSU
+        )
+        otsu_threshold = thresh_val / 255.0
 
-    # Color dead cells red, alive cells green
-    for cell_id in dead_cells:
-        cell_mask = (masks == cell_id)
-        overlay[cell_mask] = [255, 0, 0]  
+    # --- Apply user bias: slider -50..+50 maps to ±0.20 shift ---
+    bias = (threshold_bias / 50.0) * 0.20
+    final_threshold = float(np.clip(otsu_threshold + bias, 0.0, 1.0))
 
-    for cell_id in alive_cells:
-        cell_mask = (masks == cell_id)
-        overlay[cell_mask] = [0, 255, 0]  
+    # --- Classify ---
+    dead_cells  = [cid for cid, s in zip(cell_ids, cell_scores) if s > final_threshold]
+    alive_cells = [cid for cid, s in zip(cell_ids, cell_scores) if s <= final_threshold]
+
+    # --- Colored overlay ---
+    overlay = image_np.copy().astype(np.float32)
+    for cid in dead_cells:
+        overlay[masks == cid] = [255, 0, 0]
+    for cid in alive_cells:
+        overlay[masks == cid] = [0, 255, 0]
 
-    # Blend with original image
-    alpha = 0.4
+    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
+    return len(dead_cells), len(alive_cells), final_overlay, otsu_threshold, final_threshold
 
 
 def measure_confluency(masks, image_np):
@@ -234,6 +265,44 @@ def rec_min_size(masks, q=25):
     return int(round(np.percentile(sizes, q)))
 
 
+def apply_polygon_mask(image_pil, points_json):
+    """
+    Given a PIL image and a JSON string of [[x,y],...] canvas-space points
+    (already mapped to original image coordinates by the JS), zero out
+    everything outside the polygon and return a PIL image.
+    Returns the original image if points_json is empty / invalid.
+    """
+    import json
+    if not points_json or points_json.strip() in ("", "[]"):
+        return image_pil
+
+    try:
+        pts = json.loads(points_json)
+    except Exception:
+        return image_pil
+
+    if len(pts) < 3:
+        return image_pil
+
+    image_np = np.array(image_pil)
+    h, w = image_np.shape[:2]
+
+    poly = np.array(pts, dtype=np.int32)
+    poly[:, 0] = np.clip(poly[:, 0], 0, w - 1)
+    poly[:, 1] = np.clip(poly[:, 1], 0, h - 1)
+
+    mask = np.zeros((h, w), dtype=np.uint8)
+    cv2.fillPoly(mask, [poly], 255)
+
+    if len(image_np.shape) == 3:
+        mask3 = mask[:, :, np.newaxis]
+        result = np.where(mask3 == 255, image_np, 0).astype(np.uint8)
+    else:
+        result = np.where(mask == 255, image_np, 0).astype(np.uint8)
+
+    return Image.fromarray(result)
+
+
 def toggle_stereological_mode(use_stereology):
     """Show/hide stereological controls based on checkbox"""
     return gr.update(visible=use_stereology)
@@ -249,21 +318,171 @@ def update_exclusion_preview(image, left_width, top_width):
     return Image.fromarray(overlay)
 
 
+# ---------------------------------------------------------------------------
+# Patch-parallel segmentation helpers (Option A)
+# ---------------------------------------------------------------------------
+PATCH_SIZE   = 512   # target patch side length
+PATCH_OVERLAP = 64   # overlap border on each edge (pixels)
+MIN_PATCH_DIM = 256  # don't bother patching if image fits comfortably
+
+
+def _split_patches(image_np, patch_size=PATCH_SIZE, overlap=PATCH_OVERLAP):
+    """
+    Split image into overlapping patches.
+    Returns list of (patch_np, row_start, col_start) tuples.
+    """
+    h, w = image_np.shape[:2]
+    patches = []
+    row = 0
+    while row < h:
+        row_end = min(row + patch_size, h)
+        col = 0
+        while col < w:
+            col_end = min(col + patch_size, w)
+            patch = image_np[row:row_end, col:col_end]
+            patches.append((patch, row, col))
+            if col_end == w:
+                break
+            col += patch_size - overlap
+        if row_end == h:
+            break
+        row += patch_size - overlap
+    return patches
+
+
+def _merge_patch_masks(patch_results, full_h, full_w, overlap=PATCH_OVERLAP):
+    """
+    Stitch per-patch masks into a single full-image mask.
+
+    Strategy:
+    - Each patch gets a unique ID offset so cell IDs never collide.
+    - Patches are pasted into the canvas using a priority canvas that
+      gives interior pixels precedence over overlap-border pixels.
+    - After pasting, cells whose centroids fall in the overlap zone
+      of two adjacent patches are deduplicated: if two cells from
+      different patches share >50% IoU they are the same cell — keep
+      the one whose centroid is furthest from a patch edge.
+    """
+    full_mask  = np.zeros((full_h, full_w), dtype=np.int32)
+    # track which patch_idx owns each pixel (used for overlap resolution)
+    owner_map  = np.full((full_h, full_w), -1, dtype=np.int32)
+    # distance-to-nearest-edge for the owning patch (higher = more central)
+    priority   = np.zeros((full_h, full_w), dtype=np.float32)
+
+    id_offset = 0
+    patch_meta = []   # (offset, row_start, col_start, patch_h, patch_w)
+
+    for patch_idx, (mask_patch, row_start, col_start) in enumerate(patch_results):
+        ph, pw = mask_patch.shape
+        # offset all non-zero IDs so they're globally unique
+        shifted = np.where(mask_patch > 0, mask_patch + id_offset, 0).astype(np.int32)
+
+        # compute per-pixel priority = min distance to any patch edge
+        rows_idx = np.arange(ph)
+        cols_idx = np.arange(pw)
+        dist_r = np.minimum(rows_idx, ph - 1 - rows_idx)           # (ph,)
+        dist_c = np.minimum(cols_idx, pw - 1 - cols_idx)           # (pw,)
+        pri_patch = np.minimum(dist_r[:, None], dist_c[None, :])   # (ph, pw)
+
+        roi_full   = full_mask [row_start:row_start+ph, col_start:col_start+pw]
+        roi_owner  = owner_map [row_start:row_start+ph, col_start:col_start+pw]
+        roi_pri    = priority  [row_start:row_start+ph, col_start:col_start+pw]
+
+        # where this patch has higher priority, overwrite
+        better = pri_patch > roi_pri
+        roi_full [better] = shifted   [better]
+        roi_owner[better] = patch_idx
+        roi_pri  [better] = pri_patch [better]
+
+        max_id = int(mask_patch.max())
+        patch_meta.append((id_offset, row_start, col_start, ph, pw))
+        id_offset += max_id + 1
+
+    # --- Renumber to compact sequential IDs ---
+    unique_ids = np.unique(full_mask)
+    unique_ids = unique_ids[unique_ids > 0]
+    renumbered = np.zeros_like(full_mask)
+    for new_id, old_id in enumerate(unique_ids, start=1):
+        renumbered[full_mask == old_id] = new_id
+
+    return renumbered
+
+
+def _segment_patch(args):
+    """Worker: run cellpose on a single patch. Called from a thread pool."""
+    patch_np, row_start, col_start, model_filename, hf_repo = args
+    # Each thread uses the shared loaded_models cache (GIL-safe for reads;
+    # model.eval() releases the GIL during GPU work so threads overlap.)
+    model_path = hf_hub_download(repo_id=hf_repo, 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
+
+    mask, _, _ = model.eval(patch_np, diameter=None, channels=[0, 0])
+    return mask, row_start, col_start
+
+
+def run_segmentation_patched(image_np, model_filename):
+    """
+    Split image into overlapping patches, run Cellpose on each in parallel,
+    then stitch back into a single full-resolution mask.
+    Falls back to whole-image segmentation if the image is small enough
+    that patching adds overhead without benefit.
+    """
+    h, w = image_np.shape[:2]
+    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
+
+    # Small images: no benefit from patching
+    if max(h, w) <= MIN_PATCH_DIM * 2:
+        mask, _, _ = model.eval(image_np, diameter=None, channels=[0, 0])
+        return mask, 1   # 1 patch
+
+    patches = _split_patches(image_np)
+    n_patches = len(patches)
+
+    # Build argument list for the thread pool
+    args_list = [
+        (patch, r, c, model_filename, HF_REPO_ID)
+        for patch, r, c in patches
+    ]
+
+    patch_results = []  # (mask, row_start, col_start) in submission order
+
+    # ThreadPoolExecutor: GPU kernels release the GIL so threads overlap on GPU
+    with ThreadPoolExecutor(max_workers=min(n_patches, 4)) as pool:
+        futures = {pool.submit(_segment_patch, a): a for a in args_list}
+        for future in as_completed(futures):
+            mask_patch, row_start, col_start = future.result()
+            patch_results.append((mask_patch, row_start, col_start))
+
+    # Re-sort by (row, col) so stitching is deterministic
+    patch_results.sort(key=lambda x: (x[1], x[2]))
+
+    full_mask = _merge_patch_masks(patch_results, h, w)
+    return full_mask, n_patches
+
+
 @spaces.GPU
-def run_segmentation(image, model_choice, min_cell_size, max_cell_size, 
-                     use_stereology, left_exclusion, top_exclusion):
+def run_segmentation(image, model_choice, min_cell_size, max_cell_size,
+                     use_stereology, left_exclusion, top_exclusion,
+                     crop_points_json=""):
     image_np = np.array(image)
     image_np = safe_resize(image_np)
+
+    # Apply polygon crop mask if the user drew one
+    if crop_points_json and crop_points_json.strip() not in ("", "[]"):
+        image_pil_masked = apply_polygon_mask(Image.fromarray(image_np), crop_points_json)
+        image_np = np.array(image_pil_masked)
     
     try:
         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
 
         # Process image format to RGB
         if len(image_np.shape) == 2:
@@ -273,8 +492,8 @@ def run_segmentation(image, model_choice, min_cell_size, max_cell_size,
         else:
             processed_image_np = image_np
 
-        # Run Cellpose segmentation
-        masks_raw, flows, styles = model.eval(processed_image_np, diameter=None, channels=[0, 0])
+        # Run patch-parallel Cellpose segmentation
+        masks_raw, n_patches = run_segmentation_patched(processed_image_np, model_filename)
 
         ids = np.unique(masks_raw)
         ids = ids[ids > 0]
@@ -322,10 +541,10 @@ def run_segmentation(image, model_choice, min_cell_size, max_cell_size,
         cell_count = len(np.unique(masks)) - 1
         confluency = measure_confluency(masks, processed_image_np)
 
-        # Create segmentation overlay (without viability)
+        # Create a basic segmentation overlay (without viability)
         segmentation_overlay = processed_image_np.copy().astype(np.float32)
         if masks.max() > 0:
-            np.random.seed(42)  
+            np.random.seed(42)  # For consistent random colors
             colors = np.random.randint(0, 255, size=(masks.max() + 1, 3))
             colors[0] = [0, 0, 0]
             colored_mask = colors[masks]
@@ -342,6 +561,7 @@ def run_segmentation(image, model_choice, min_cell_size, max_cell_size,
             info_msg += filter_msg
         info_msg += f"Segmentation complete! Found {cell_count} cells.\n"
         info_msg += f"Confluency: {confluency:.1f}%\n"
+        info_msg += f"Processed as {n_patches} patch{'es' if n_patches > 1 else ''} (parallel).\n"
         if use_stereology:
             info_msg += f"Stereological counting enabled (Left: {left_exclusion}%, Top: {top_exclusion}%)\n"
         info_msg += "Now adjust the Blue Threshold for viability assessment."
@@ -372,26 +592,28 @@ def run_segmentation(image, model_choice, min_cell_size, max_cell_size,
         )
 
 
-def update_viability_realtime(blue_threshold, stored_masks, stored_image_np):
+def update_viability_realtime(threshold_bias, 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_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
-        )
+        dead_count, alive_count, viability_overlay_np, otsu_thresh, final_thresh = \
+            classify_cells_by_blueness(stored_image_np, stored_masks, threshold_bias)
 
-        total_count = alive_count + dead_count
+        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)
+        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}%"
+        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}%\n"
+        info_msg += f"Otsu threshold (auto): {otsu_thresh:.4f}\n"
+        info_msg += f"Final threshold (with bias): {final_thresh:.4f}\n"
+        info_msg += f"Sensitivity bias: {threshold_bias:+d}"
 
         return overlay_image, alive_count, dead_count, viability_percent, info_msg
 
@@ -447,6 +669,211 @@ def compute_summary(r1, r2, r3, r4):
     return avg_count, avg_conf, avg_viab, "\n".join(lines)
 
 
+# ---------------------------------------------------------------------------
+# Tab builder — creates one full analysis tab and wires all event handlers.
+# Returns the per-tab gr.State used by Tab 5 to collect summary data.
+# ---------------------------------------------------------------------------
+# ---------------------------------------------------------------------------
+# Polygon crop canvas — lightweight HTML5 canvas, no ImageEditor
+# ---------------------------------------------------------------------------
+def make_crop_canvas_html(tab_idx):
+    """
+    Return an HTML string containing a canvas-based polygon selector.
+    The user clicks/taps up to 4 points; JS writes pixel coords (mapped
+    back to original image space) into a hidden textbox with id
+    f'crop_pts_{tab_idx}'.  A 'Clear' button resets the polygon.
+    The canvas listens for the Gradio img_input change event by watching
+    a sibling img element (Gradio renders <img> inside the component).
+    """
+    uid = f"cropcanvas_{tab_idx}"
+    pts_id = f"crop_pts_{tab_idx}"
+    return f"""
+<div style="position:relative;width:100%;user-select:none;">
+  <canvas id="{uid}"
+    style="width:100%;max-height:400px;object-fit:contain;
+           border:2px solid #4a90d9;border-radius:8px;
+           touch-action:none;cursor:crosshair;background:#111;display:block;">
+  </canvas>
+  <div style="margin-top:6px;display:flex;gap:8px;align-items:center;flex-wrap:wrap;">
+    <button id="{uid}_clear"
+      style="padding:6px 18px;border-radius:6px;border:none;
+             background:#e05;color:#fff;font-size:14px;cursor:pointer;">
+      ✕ Clear points
+    </button>
+    <span id="{uid}_label"
+      style="font-size:13px;color:#aaa;">
+      Upload an image, then tap up to 4 vertices
+    </span>
+  </div>
+</div>
+
+<script>
+(function(){{
+  const CANVAS_ID  = "{uid}";
+  const PTS_ID     = "{pts_id}";
+  const TAB_IDX    = {tab_idx};
+  const MAX_PTS    = 4;
+
+  let imgNaturalW = 0, imgNaturalH = 0;
+  let points      = [];   // {{cx, cy}} in canvas CSS pixels
+  let imgSrc      = null;
+  let imgObj      = new Image();
+
+  const canvas  = document.getElementById(CANVAS_ID);
+  const ctx     = canvas.getContext("2d");
+  const clearBtn= document.getElementById(CANVAS_ID + "_clear");
+  const label   = document.getElementById(CANVAS_ID + "_label");
+
+  // ── helpers ──────────────────────────────────────────────────────────────
+  function getPtsTextbox() {{
+    // Gradio hides the real <textarea> inside a wrapper.  Find by elem id.
+    return document.getElementById(PTS_ID)?.querySelector("textarea")
+        || document.querySelector(`#${PTS_ID} textarea`);
+  }}
+
+  function writePts(pts_orig) {{
+    const ta = getPtsTextbox();
+    if (!ta) return;
+    ta.value = JSON.stringify(pts_orig);
+    ta.dispatchEvent(new Event("input", {{bubbles:true}}));
+    ta.dispatchEvent(new Event("change", {{bubbles:true}}));
+  }}
+
+  function canvasToOriginal(cx, cy) {{
+    // canvas.width / height are the backing-store pixel dimensions
+    const scaleX = imgNaturalW / canvas.width;
+    const scaleY = imgNaturalH / canvas.height;
+    return [Math.round(cx * scaleX), Math.round(cy * scaleY)];
+  }}
+
+  function draw() {{
+    ctx.clearRect(0, 0, canvas.width, canvas.height);
+    if (imgObj.complete && imgObj.naturalWidth) {{
+      ctx.drawImage(imgObj, 0, 0, canvas.width, canvas.height);
+    }}
+    if (points.length === 0) return;
+
+    // polygon fill
+    ctx.beginPath();
+    ctx.moveTo(points[0].cx, points[0].cy);
+    for (let i = 1; i < points.length; i++) ctx.lineTo(points[i].cx, points[i].cy);
+    if (points.length === MAX_PTS) ctx.closePath();
+    ctx.strokeStyle = "#4af";
+    ctx.lineWidth   = 2;
+    ctx.stroke();
+    if (points.length === MAX_PTS) {{
+      ctx.fillStyle = "rgba(74,170,255,0.18)";
+      ctx.fill();
+    }}
+
+    // vertex dots + numbers
+    points.forEach((p, i) => {{
+      ctx.beginPath();
+      ctx.arc(p.cx, p.cy, 7, 0, Math.PI*2);
+      ctx.fillStyle   = "#4af";
+      ctx.fill();
+      ctx.strokeStyle = "#fff";
+      ctx.lineWidth   = 1.5;
+      ctx.stroke();
+      ctx.fillStyle = "#fff";
+      ctx.font      = "bold 11px sans-serif";
+      ctx.textAlign = "center";
+      ctx.textBaseline = "middle";
+      ctx.fillText(i+1, p.cx, p.cy);
+    }});
+  }}
+
+  function loadImage(src) {{
+    imgSrc = src;
+    imgObj = new Image();
+    imgObj.onload = function() {{
+      imgNaturalW = imgObj.naturalWidth;
+      imgNaturalH = imgObj.naturalHeight;
+      // size canvas backing store to match natural image (capped for memory)
+      const maxSide = 1024;
+      let cw = imgNaturalW, ch = imgNaturalH;
+      if (Math.max(cw,ch) > maxSide) {{
+        const s = maxSide / Math.max(cw,ch);
+        cw = Math.round(cw*s); ch = Math.round(ch*s);
+      }}
+      canvas.width  = cw;
+      canvas.height = ch;
+      points = [];
+      writePts([]);
+      label.textContent = "Tap up to 4 vertices to define your crop region";
+      draw();
+    }};
+    imgObj.src = src;
+  }}
+
+  // ── pointer events (works for mouse + touch) ──────────────────────────
+  canvas.addEventListener("pointerdown", function(e) {{
+    e.preventDefault();
+    if (!imgNaturalW) return;
+    if (points.length >= MAX_PTS) return;
+
+    const rect = canvas.getBoundingClientRect();
+    const cssX = e.clientX - rect.left;
+    const cssY = e.clientY - rect.top;
+    // map CSS pixels → backing-store pixels
+    const bx = cssX * (canvas.width  / rect.width);
+    const by = cssY * (canvas.height / rect.height);
+
+    points.push({{cx: bx, cy: by}});
+    draw();
+
+    // write original-image coords to the hidden textbox
+    const orig = points.map(p => canvasToOriginal(p.cx, p.cy));
+    writePts(orig);
+
+    if (points.length === MAX_PTS) {{
+      label.textContent = "4 points set — clear to redraw";
+    }} else {{
+      label.textContent = `${{points.length}} / ${{MAX_PTS}} points`;
+    }}
+  }});
+
+  clearBtn.addEventListener("click", function() {{
+    points = [];
+    writePts([]);
+    label.textContent = "Points cleared — tap to add new vertices";
+    draw();
+  }});
+
+  // ── watch for Gradio image uploads ────────────────────────────────────
+  // Gradio renders the uploaded image as an <img> inside the component.
+  // We poll for it until found, then watch src changes with MutationObserver.
+  function findGradioImg() {{
+    // Gradio wraps img_input in a div whose data-testid = "image"
+    // Walk up from our canvas to find the nearest Gradio Blocks row,
+    // then find the image component in the same Tab.
+    const allImgs = document.querySelectorAll(".gradio-image img, [data-testid='image'] img");
+    // pick the one closest to our canvas in the DOM
+    if (allImgs.length === 0) return null;
+    // heuristic: find closest ancestor shared with canvas
+    for (const img of allImgs) {{
+      if (img.src && img.src !== imgSrc) return img;
+    }}
+    return allImgs[0];
+  }}
+
+  let observer = null;
+  function startWatching() {{
+    const img = findGradioImg();
+    if (!img) {{ setTimeout(startWatching, 500); return; }}
+    if (img.src && img.src !== imgSrc) loadImage(img.src);
+    if (observer) observer.disconnect();
+    observer = new MutationObserver(() => {{
+      if (img.src && img.src !== imgSrc) loadImage(img.src);
+    }});
+    observer.observe(img, {{attributes: true, attributeFilter: ["src"]}});
+  }}
+  setTimeout(startWatching, 800);
+}})();
+</script>
+"""
+
+
 def build_tab(tab_index, masks_state, image_state, result_state):
     with gr.Tab(f"Tab {tab_index}"):
         gr.Markdown("Run segmentation")
@@ -455,11 +882,22 @@ def build_tab(tab_index, masks_state, image_state, result_state):
             with gr.Column():
                 img_input = gr.Image(
                     type="pil",
-                    label="Microscopy image",
+                    label="Upload image",
                     image_mode="RGB",
                     height=512
                 )
 
+                # Lightweight polygon crop selector (no ImageEditor)
+                gr.HTML(make_crop_canvas_html(tab_index))
+
+                # Hidden textbox that receives [[x,y],...] from JS
+                crop_points = gr.Textbox(
+                    value="",
+                    visible=False,
+                    elem_id=f"crop_pts_{tab_index}",
+                    label="Crop polygon points (set by canvas)"
+                )
+
                 model_dropdown = gr.Dropdown(
                     choices=list(MODEL_OPTIONS.keys()),
                     label="Select Model",
@@ -531,17 +969,20 @@ def build_tab(tab_index, masks_state, image_state, result_state):
 
         with gr.Group(visible=False) as viability_section:
             gr.Markdown("### Viability Assessment (Trypan Blue)")
-            gr.Markdown("Adjust the threshold to classify cells as live (green) or dead (red).")
+            gr.Markdown(
+                "The threshold is set **automatically per image** using Otsu's method. "
+                "Use the sensitivity slider to fine-tune if needed."
+            )
 
             with gr.Row():
                 with gr.Column():
-                    blue_thresh = gr.Slider(
-                        minimum=0,
-                        maximum=100,
-                        value=25,
+                    sensitivity = gr.Slider(
+                        minimum=-50,
+                        maximum=50,
+                        value=0,
                         step=1,
-                        label="Blue Threshold (%)",
-                        info="Higher values = more selective for blue cells"
+                        label="Sensitivity",
+                        info="← more dead cells  ·  auto (0)  ·  fewer dead cells →"
                     )
                 with gr.Column():
                     live_count_out = gr.Number(label="Live Cells (Green)", precision=0)
@@ -549,9 +990,9 @@ def build_tab(tab_index, masks_state, image_state, result_state):
 
             viab_overlay     = gr.Image(type="pil", label="Viability Assessment (Green=Live, Red=Dead)")
             viab_percent_out = gr.Number(label="Viability (%)", precision=1)
-            viab_info        = gr.Textbox(label="Analysis Results", lines=5)
+            viab_info        = gr.Textbox(label="Analysis Results", lines=6)
 
-        # Event handlers 
+        # ---- Event handlers ------------------------------------------------
 
         use_stereo.change(
             fn=toggle_stereological_mode,
@@ -578,33 +1019,33 @@ def build_tab(tab_index, masks_state, image_state, result_state):
         segment_btn.click(
             fn=run_segmentation,
             inputs=[img_input, model_dropdown, min_size_slider, max_size_slider,
-                    use_stereo, left_excl, top_excl],
+                    use_stereo, left_excl, top_excl, crop_points],
             outputs=[cell_count_out, overlay_out, info_out, viability_section,
                      masks_state, image_state, confluency_out, min_size_slider]
         ).then(
             fn=update_viability_realtime,
-            inputs=[blue_thresh, masks_state, image_state],
+            inputs=[sensitivity, masks_state, image_state],
             outputs=[viab_overlay, live_count_out, dead_count_out, viab_percent_out, viab_info]
         ).then(
-            # Save this tab's results into its dedicated state for Tab 5
             fn=save_tab_result,
             inputs=[cell_count_out, confluency_out, viab_percent_out],
             outputs=[result_state]
         )
 
-        blue_thresh.change(
+        sensitivity.change(
             fn=update_viability_realtime,
-            inputs=[blue_thresh, masks_state, image_state],
+            inputs=[sensitivity, masks_state, image_state],
             outputs=[viab_overlay, live_count_out, dead_count_out, viab_percent_out, viab_info]
         ).then(
-            # Keep result state in sync when threshold is adjusted
             fn=save_tab_result,
             inputs=[cell_count_out, confluency_out, viab_percent_out],
             outputs=[result_state]
         )
 
 
-
+# ---------------------------------------------------------------------------
+# Gradio interface
+# ---------------------------------------------------------------------------
 with gr.Blocks(
     title="CellposeCellCounter",
     theme=gr.themes.Soft(),
@@ -621,7 +1062,9 @@ with gr.Blocks(
     for i in range(4):
         build_tab(i + 1, masks_states[i], image_states[i], result_states[i])
 
-   # Tab 5
+    # -------------------------------------------------------------------------
+    # Tab 5 — Summary
+    # -------------------------------------------------------------------------
     with gr.Tab("Tab 5 — Summary"):
         gr.Markdown("## Average Results Across All Tabs")
         gr.Markdown(
@@ -629,7 +1072,7 @@ with gr.Blocks(
             "then click **Refresh Summary** to see the averages."
         )
 
-        refresh_btn = gr.Button("Refresh Summary", variant="primary", size="lg")
+        refresh_btn = gr.Button("🔄 Refresh Summary", variant="primary", size="lg")
 
         with gr.Row():
             avg_count_out = gr.Number(label="Avg Cell Count",      precision=1)