Delete app.py

app.py

@@ -1,1102 +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, ImageDraw
-import io
-from huggingface_hub import hf_hub_download
-import base64
-from concurrent.futures import ThreadPoolExecutor, as_completed
-
-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 = 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
-
-    if max(h, w) <= MAX_SIDE and total <= MAX_PIXELS:
-        return image_np
-
-    # compute scale 
-    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 draw_exclusion_overlay(image_np, left_width_pct, top_width_pct):
-    
-    h, w = image_np.shape[:2]
-    
-    # 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)  # 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)  # Semi-transparent red
-        )
-        # border line
-        draw.line([(0, top_px), (w, top_px)], fill=(255, 0, 0, 255), width=3)
-    
-    return np.array(img_pil)
-
-
-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)
-    
-    filtered_masks = masks.copy()
-    cell_ids = np.unique(masks)
-    cell_ids = cell_ids[cell_ids > 0]
-    
-    excluded_cells = []
-    included_cells = []
-    
-    for cell_id in cell_ids:
-        cell_mask = (masks == cell_id)
-        
-        # 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]
-    
-    renumbered_masks = np.zeros_like(filtered_masks)
-    for new_id, old_id in enumerate(unique_ids, start=1):
-        renumbered_masks[filtered_masks == old_id] = new_id
-    
-    return renumbered_masks, len(excluded_cells), len(included_cells)
-
-
-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)
-
-    hue        = hsv[:, :, 0].astype(np.float32)
-    saturation = hsv[:, :, 1].astype(np.float32)
-
-    # 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)
-    blueness     = hue_score * (saturation / 255.0)
-
-    # --- Compute per-cell mean blueness scores ---
-    cell_ids = np.unique(masks)
-    cell_ids = cell_ids[cell_ids > 0]
-
-    if len(cell_ids) == 0:
-        blank = image_np.copy()
-        return 0, 0, blank, 0.0, 0.0
-
-    cell_scores = np.array([np.mean(blueness[masks == cid]) for cid in cell_ids])
-
-    # --- 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)
-
-    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
-
-    # --- 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))
-
-    # --- 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]
-
-    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, otsu_threshold, final_threshold
-
-
-def measure_confluency(masks, image_np):
-    tot_pixels = image_np.shape[0] * image_np.shape[1]
-    cell_pixels = np.count_nonzero(masks)
-    confluency = cell_pixels / tot_pixels * 100
-    return confluency
-    
-def filter_mask_by_size(masks, minimum_pixels):
-    filtered_masks = masks.copy()
-    cell_ids = np.unique(masks)
-    cell_ids = cell_ids[cell_ids > 0]
-
-    removed_count = 0
-    
-    for cell_id in cell_ids:
-        cell_mask = (masks == cell_id)
-        cell_pixels = np.count_nonzero(cell_mask)
-        if cell_pixels < minimum_pixels:
-            filtered_masks[cell_mask] = 0
-            removed_count += 1
-
-    unique_ids = np.unique(filtered_masks)
-    unique_ids = unique_ids[unique_ids > 0]
-
-    renumbered_masks = np.zeros_like(filtered_masks)
-    for new_id, old_id in enumerate(unique_ids, start=1):
-        renumbered_masks[filtered_masks == old_id] = new_id
-
-    return renumbered_masks, removed_count
-
-
-def filter_mask_by_maxsize(masks, maximum_pixels):
-    filtered_masks = masks.copy()
-    cell_ids = np.unique(masks)
-    cell_ids = cell_ids[cell_ids > 0]
-
-    removed_count = 0
-    for cell_id in cell_ids:
-        cell_mask = (masks == cell_id)
-        cell_pixels = np.count_nonzero(cell_mask)
-        if cell_pixels > maximum_pixels:
-            filtered_masks[cell_mask] = 0
-            removed_count += 1
-
-    unique_ids = np.unique(filtered_masks)
-    unique_ids = unique_ids[unique_ids > 0]
-
-    renumbered_masks = np.zeros_like(filtered_masks)
-    for new_id, old_id in enumerate(unique_ids, start=1):
-        renumbered_masks[filtered_masks == old_id] = new_id
-
-    return renumbered_masks, removed_count
-
-
-def rec_min_size(masks, q=25):
-    ids = np.unique(masks)
-    ids = ids[ids > 0]
-    if len(ids) == 0:
-        return 0
-    sizes = np.array([np.count_nonzero(masks == cid) for cid in ids])
-    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)
-
-
-def update_exclusion_preview(image, left_width, top_width):
-    """Update the preview image with exclusion zone overlay"""
-    if image is None:
-        return None
-    
-    image_np = np.array(image)
-    overlay = draw_exclusion_overlay(image_np, 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,
-                     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]
-
-        # Process image format to RGB
-        if len(image_np.shape) == 2:
-            processed_image_np = cv2.cvtColor(image_np, cv2.COLOR_GRAY2RGB)
-        elif len(image_np.shape) == 3 and image_np.shape[2] == 4:
-            processed_image_np = cv2.cvtColor(image_np, cv2.COLOR_RGBA2RGB)
-        else:
-            processed_image_np = image_np
-
-        # 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]
-
-        sizes = np.array([np.count_nonzero(masks_raw == cid) for cid in ids])
-
-        print("num_cells:", len(ids))
-        print("mean:", sizes.mean() if len(sizes) > 0 else 0)
-        print("median:", np.median(sizes) if len(sizes) > 0 else 0)
-        print("p90:", np.percentile(sizes, 90) if len(sizes) > 0 else 0)
-        print("max:", sizes.max() if len(sizes) > 0 else 0)
-        
-        # Compute recommendation from RAW masks 
-        recommend_min = rec_min_size(masks_raw)
-
-        # If user sets slider to 0, use the recommendation
-        min_used = recommend_min if (min_cell_size == 0) else int(min_cell_size)
-
-        # Apply filters
-        masks = masks_raw.copy()
-        removed_small = 0
-        removed_large = 0
-
-        if min_used > 0:
-            masks, removed_small = filter_mask_by_size(masks, min_used)
-
-        if max_cell_size > 0:
-            masks, removed_large = filter_mask_by_maxsize(masks, int(max_cell_size))
-
-        # Apply stereological exclusion if enabled
-        excluded_count = 0
-        if use_stereology:
-            masks, excluded_count, included_count = apply_stereological_exclusion(
-                masks, left_exclusion, top_exclusion
-            )
-        
-        filter_msg = ""
-        if removed_small:
-            filter_msg += f"Removed {removed_small} small objects (< {min_used} pixels).\n"
-        if removed_large:
-            filter_msg += f"Removed {removed_large} large objects (> {int(max_cell_size)} pixels).\n"
-        if use_stereology and excluded_count > 0:
-            filter_msg += f"Stereological exclusion: {excluded_count} cells excluded (touching left/top zones).\n"
-
-        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]
-            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)
-        
-        # Add exclusion zone overlay if stereology is enabled
-        if use_stereology:
-            segmentation_overlay = draw_exclusion_overlay(segmentation_overlay, left_exclusion, top_exclusion)
-
-        info_msg = ""
-        if filter_msg:
-            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."
-
-        return (
-            cell_count,
-            Image.fromarray(segmentation_overlay),
-            info_msg,
-            gr.update(visible=True),
-            pack_array(masks),
-            pack_array(processed_image_np),
-            confluency,
-            gr.update(value=recommend_min),  # update slider display to recommended
-        )
-
-    except Exception as e:
-        import traceback
-        traceback.print_exc()
-        return (
-            0,
-            None,
-            f"Error during segmentation: {str(e)}",
-            gr.update(visible=False),
-            None,
-            None,
-            0.0,
-            gr.update(),
-        )
-
-
-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_image_np = unpack_array(stored_image_np)
-
-    try:
-        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
-        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}%\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
-
-    except Exception as e:
-        return None, 0, 0, 0.0, f"Error updating viability: {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)))
-
-
-def save_tab_result(cell_count, confluency, viab_percent):
-    """Package per-tab results into a dict for Tab 5 summary."""
-    return {
-        "cell_count": float(cell_count) if cell_count is not None else None,
-        "confluency": float(confluency) if confluency is not None else None,
-        "viab_percent": float(viab_percent) if viab_percent is not None else None,
-    }
-
-
-def compute_summary(r1, r2, r3, r4):
-    """Average cell count, confluency, and viability across tabs that have data."""
-    all_results = [r1, r2, r3, r4]
-    valid = [(i + 1, r) for i, r in enumerate(all_results)
-             if r is not None and r.get("cell_count") is not None]
-
-    if not valid:
-        return (
-            0.0, 0.0, 0.0,
-            "No data yet — run segmentation in at least one tab, then click Refresh Summary."
-        )
-
-    avg_count  = sum(r["cell_count"]   for _, r in valid) / len(valid)
-    avg_conf   = sum(r["confluency"]   for _, r in valid) / len(valid)
-    avg_viab   = sum(r["viab_percent"] for _, r in valid) / len(valid)
-
-    lines = [f"Tab {tab_num}: {r['cell_count']:.0f} cells | "
-             f"{r['confluency']:.1f}% confluency | "
-             f"{r['viab_percent']:.1f}% viability"
-             for tab_num, r in valid]
-    lines.append(f"\nAverages ({len(valid)} tab{'s' if len(valid) > 1 else ''}):")
-    lines.append(f"  Cell count:  {avg_count:.1f}")
-    lines.append(f"  Confluency:  {avg_conf:.1f}%")
-    lines.append(f"  Viability:   {avg_viab:.1f}%")
-
-    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):
-    """
-    Static HTML+JS for the polygon crop canvas.
-    Image data is pushed from Python via push_image_to_canvas().
-    A global function window.loadCropCanvas_{uid}(dataURL) is registered
-    so the gr.HTML update triggered by img_input.change can load the image.
-    """
-    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 MAX_PTS   = 4;
-
-  let imgNaturalW = 0, imgNaturalH = 0;
-  let points      = [];
-  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");
-
-  function getPtsTextbox() {{
-    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) {{
-    return [Math.round(cx * imgNaturalW / canvas.width),
-            Math.round(cy * imgNaturalH / canvas.height)];
-  }}
-
-  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) return;
-
-    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();
-    }}
-    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);
-    }});
-  }}
-
-  // ── called by Python push via gr.HTML update ──────────────────────────
-  function loadFromDataURL(dataURL) {{
-    imgObj = new Image();
-    imgObj.onload = function() {{
-      imgNaturalW = imgObj.naturalWidth;
-      imgNaturalH = imgObj.naturalHeight;
-      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 = dataURL;
-  }}
-
-  // Register globally so the injected <script> snippet can call it
-  window["loadCropCanvas_{uid}"] = loadFromDataURL;
-
-  // ── pointer / touch events ────────────────────────────────────────────
-  canvas.addEventListener("pointerdown", function(e) {{
-    e.preventDefault();
-    if (!imgNaturalW || points.length >= MAX_PTS) return;
-    const rect = canvas.getBoundingClientRect();
-    const bx = (e.clientX - rect.left)  * (canvas.width  / rect.width);
-    const by = (e.clientY - rect.top)   * (canvas.height / rect.height);
-    points.push({{cx: bx, cy: by}});
-    draw();
-    writePts(points.map(p => canvasToOriginal(p.cx, p.cy)));
-    label.textContent = points.length === MAX_PTS
-      ? "4 points set — clear to redraw"
-      : `${{points.length}} / ${{MAX_PTS}} points`;
-  }});
-
-  clearBtn.addEventListener("click", function() {{
-    points = []; writePts([]);
-    label.textContent = "Points cleared — tap to add new vertices";
-    draw();
-  }});
-}})();
-</script>
-"""
-
-
-def push_image_to_canvas(image_pil, tab_idx):
-    """
-    Convert the uploaded PIL image to a base64 data URL and return a
-    gr.HTML snippet that calls the canvas loader function registered by
-    make_crop_canvas_html.  Returned value is set on a hidden gr.HTML
-    component whose change fires the JS.
-    """
-    if image_pil is None:
-        return ""
-    uid = f"cropcanvas_{tab_idx}"
-    buf = io.BytesIO()
-    # Downscale for the preview only — keep it lightweight
-    thumb = image_pil.copy()
-    thumb.thumbnail((1024, 1024), Image.LANCZOS)
-    thumb.save(buf, format="JPEG", quality=85)
-    b64 = base64.b64encode(buf.getvalue()).decode()
-    data_url = f"data:image/jpeg;base64,{b64}"
-    return f"""<script>
-(function(){{
-  const fn = window["loadCropCanvas_{uid}"];
-  if (fn) {{ fn("{data_url}"); }}
-  else {{ setTimeout(()=>{{ const f=window["loadCropCanvas_{uid}"]; if(f) f("{data_url}"); }}, 400); }}
-}})();
-</script>"""
-
-
-def build_tab(tab_index, masks_state, image_state, result_state):
-    with gr.Tab(f"Tab {tab_index}"):
-        gr.Markdown("Run segmentation")
-
-        with gr.Row():
-            with gr.Column():
-                img_input = gr.Image(
-                    type="pil",
-                    label="Upload image",
-                    image_mode="RGB",
-                    height=512
-                )
-
-                # Lightweight polygon crop selector (no ImageEditor)
-                gr.HTML(make_crop_canvas_html(tab_index))
-
-                # Hidden HTML component — Python pushes a <script> snippet here
-                # on every img_input change to load the image into the canvas
-                canvas_pusher = gr.HTML(value="", visible=False)
-
-                # 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",
-                    value="Hemocytometer Model"
-                )
-
-                min_size_slider = gr.Slider(
-                    minimum=0,
-                    maximum=500,
-                    value=0,
-                    step=10,
-                    label="Minimum Cell Size (pixels). Leave at zero for automated recommendation",
-                )
-
-                max_size_slider = gr.Slider(
-                    minimum=0,
-                    maximum=10000,
-                    value=10000,
-                    step=10,
-                    label="Maximum Cell Size (pixels)",
-                )
-
-                gr.Markdown("### Stereological Counting")
-                use_stereo = gr.Checkbox(
-                    label="Enable Stereological Counting",
-                    value=False,
-                    info="Use unbiased stereological rules for cell counting"
-                )
-
-                with gr.Group(visible=False) as stereo_controls:
-                    gr.Markdown("""
-                    **Stereological Counting Rules:**
-                    - Cells touching LEFT or TOP exclusion zones are EXCLUDED
-                    - Cells touching RIGHT or BOTTOM edges are INCLUDED
-                    - This provides unbiased counting for quantification
-                    """)
-
-                    excl_preview = gr.Image(
-                        type="pil",
-                        label="Exclusion Zone Preview (Red = Excluded)",
-                        height=500
-                    )
-
-                    left_excl = gr.Slider(
-                        minimum=0,
-                        maximum=50,
-                        value=10,
-                        step=1,
-                        label="Left Exclusion Width (%)",
-                        info="Width of left exclusion zone"
-                    )
-
-                    top_excl = gr.Slider(
-                        minimum=0,
-                        maximum=50,
-                        value=10,
-                        step=1,
-                        label="Top Exclusion Width (%)",
-                        info="Width of top exclusion zone"
-                    )
-
-                segment_btn = gr.Button("🔬 Run Segmentation", variant="primary", size="lg")
-
-            with gr.Column():
-                cell_count_out = gr.Number(label="Total Cells Detected", precision=0)
-                confluency_out = gr.Number(label="Confluency (%)", precision=1)
-                overlay_out    = gr.Image(type="pil", label="Segmentation Result")
-                info_out       = gr.Textbox(label="Processing Info", lines=4)
-
-        with gr.Group(visible=False) as viability_section:
-            gr.Markdown("### Viability Assessment (Trypan Blue)")
-            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():
-                    sensitivity = gr.Slider(
-                        minimum=-50,
-                        maximum=50,
-                        value=0,
-                        step=1,
-                        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)
-                    dead_count_out = gr.Number(label="Dead Cells (Red)", precision=0)
-
-            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=6)
-
-        # ---- Event handlers ------------------------------------------------
-
-        use_stereo.change(
-            fn=toggle_stereological_mode,
-            inputs=[use_stereo],
-            outputs=[stereo_controls]
-        )
-
-        img_input.change(
-            fn=update_exclusion_preview,
-            inputs=[img_input, left_excl, top_excl],
-            outputs=[excl_preview]
-        )
-        img_input.change(
-            fn=lambda img: push_image_to_canvas(img, tab_index),
-            inputs=[img_input],
-            outputs=[canvas_pusher]
-        )
-        left_excl.change(
-            fn=update_exclusion_preview,
-            inputs=[img_input, left_excl, top_excl],
-            outputs=[excl_preview]
-        )
-        top_excl.change(
-            fn=update_exclusion_preview,
-            inputs=[img_input, left_excl, top_excl],
-            outputs=[excl_preview]
-        )
-
-        segment_btn.click(
-            fn=run_segmentation,
-            inputs=[img_input, model_dropdown, min_size_slider, max_size_slider,
-                    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=[sensitivity, masks_state, image_state],
-            outputs=[viab_overlay, live_count_out, dead_count_out, viab_percent_out, viab_info]
-        ).then(
-            fn=save_tab_result,
-            inputs=[cell_count_out, confluency_out, viab_percent_out],
-            outputs=[result_state]
-        )
-
-        sensitivity.change(
-            fn=update_viability_realtime,
-            inputs=[sensitivity, masks_state, image_state],
-            outputs=[viab_overlay, live_count_out, dead_count_out, viab_percent_out, viab_info]
-        ).then(
-            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(),
-) as demo:
-    gr.Markdown("# CellposeCellCounter")
-    gr.Markdown("For accurate cell confluency, crop the image to display only desired area. Note that some image file types are not yet supported. PNG and JPEG are preferred.")
-
-    # Shared mask/image state (one pair per tab so tabs don't clobber each other)
-    masks_states  = [gr.State(value=None) for _ in range(4)]
-    image_states  = [gr.State(value=None) for _ in range(4)]
-    result_states = [gr.State(value=None) for _ in range(4)]
-
-    # Build Tabs 1–4 with a loop
-    for i in range(4):
-        build_tab(i + 1, masks_states[i], image_states[i], result_states[i])
-
-    # -------------------------------------------------------------------------
-    # Tab 5 — Summary
-    # -------------------------------------------------------------------------
-    with gr.Tab("Tab 5 — Summary"):
-        gr.Markdown("## Average Results Across All Tabs")
-        gr.Markdown(
-            "Run segmentation (and optionally adjust the blue threshold) in one or more tabs, "
-            "then click **Refresh Summary** to see the averages."
-        )
-
-        refresh_btn = gr.Button("🔄 Refresh Summary", variant="primary", size="lg")
-
-        with gr.Row():
-            avg_count_out = gr.Number(label="Avg Cell Count",      precision=1)
-            avg_conf_out  = gr.Number(label="Avg Confluency (%)",  precision=1)
-            avg_viab_out  = gr.Number(label="Avg Viability (%)",   precision=1)
-
-        summary_box = gr.Textbox(label="Per-Tab Breakdown", lines=10)
-
-        refresh_btn.click(
-            fn=compute_summary,
-            inputs=result_states,   # list of 4 gr.State components
-            outputs=[avg_count_out, avg_conf_out, avg_viab_out, summary_box]
-        )
-
-    # 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 suspension culture).
-            - **(Optional)** Enable Stereological Counting for unbiased quantification.
-            - Click "Run Segmentation".
-
-        2. **Stereological Counting** (Optional):
-            - Check "Enable Stereological Counting" to use unbiased counting rules.
-            - Adjust the Left and Top exclusion zone widths using the sliders.
-            - Preview shows excluded areas in red.
-            - **Counting Rules**:
-                - Cells touching LEFT or TOP exclusion zones are EXCLUDED
-                - Cells touching RIGHT or BOTTOM edges are INCLUDED
-                - This ensures unbiased, systematic counting
-
-        3. **Analysis Results**:
-            - **Cell Count**: Total number of detected cells (after exclusions if using stereology)
-            - **Confluency**: Percentage of image area covered by cells
-
-        4. **Real-time Viability Assessment (Trypan Blue)**:
-            - After segmentation, the viability section will become visible.
-            - Adjust the **"Blue Threshold (%)"** slider in real-time.
-            - **Lower values (10-20%)** are more sensitive.
-            - **Higher values (30-50%)** are more selective.
-            - Green cells = Live, Red cells = Dead.
-
-        5. **Summary (Tab 5)**:
-            - After running segmentation in one or more tabs, switch to **Tab 5**.
-            - Click **Refresh Summary** to compute averages across all completed tabs.
-            - Displays average cell count, confluency, and viability, plus a per-tab breakdown.
-
-        6. **Interpreting Results**:
-            - The app displays total, live, and dead cell counts, viability percentage, and confluency.
-            - If stereological counting is enabled, excluded cells are noted in the processing info.
-        """)
-
-if __name__ == "__main__":
-    demo.launch()