Update app.py

app.py

@@ -35,16 +35,13 @@ try:
 except Exception as e:
     print(f"Viability classifier not found or failed to load: {e}")
 
-# ---- mobile-safe size limits (aggressive for Safari) ----
+# mobile safe resize limits
 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
 
@@ -152,11 +149,7 @@ FEATURE_COLS_INFERENCE = [
 
 
 def classify_cells_by_model(image_np, masks):
-    """
-    Run the trained LogisticRegression classifier to predict live/dead per cell.
-    Returns (dead_count, alive_count, overlay_np, {cell_id: label}).
-    Requires VIABILITY_CLF and VIABILITY_SCALER to be loaded.
-    """
+    
     import numpy as np
     cell_ids = np.unique(masks)
     cell_ids = cell_ids[cell_ids > 0]
@@ -188,11 +181,7 @@ def classify_cells_by_model(image_np, masks):
 
 
 def draw_viability_overlay(image_np, masks, label_map):
-    """
-    Draw coloured contours + cell-number labels onto image_np.
-    label_map: {cell_id: 0=live, 1=dead}
-    Returns a uint8 numpy array.
-    """
+   
     overlay  = image_np.copy()
     cell_ids = np.unique(masks)
     cell_ids = cell_ids[cell_ids > 0]
@@ -224,112 +213,6 @@ def draw_viability_overlay(image_np, masks, label_map):
     return overlay
 
 
-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]
-
-    # --- Outline-only overlay on raw image with enumerated labels ---
-    final_overlay = image_np.copy()
-
-    # Compute a consistent enumeration order (cell_ids is already sorted ascending)
-    cell_enum = {cid: idx + 1 for idx, cid in enumerate(cell_ids)}
-
-    dead_set  = set(dead_cells)
-    alive_set = set(alive_cells)
-
-    for cid in cell_ids:
-        cell_mask = (masks == cid).astype(np.uint8)
-        contours, _ = cv2.findContours(cell_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
-        color = (220, 50, 50) if cid in dead_set else (50, 220, 80)
-        cv2.drawContours(final_overlay, contours, -1, color, thickness=2)
-
-        # Draw enumeration label at centroid
-        ys, xs = np.where(cell_mask)
-        if len(ys) > 0:
-            cx, cy = int(xs.mean()), int(ys.mean())
-            label_str = str(cell_enum[cid])
-            font       = cv2.FONT_HERSHEY_SIMPLEX
-            font_scale = 0.35
-            thickness  = 1
-            (tw, th), _ = cv2.getTextSize(label_str, font, font_scale, thickness)
-            # Dark background rectangle for readability
-            cv2.rectangle(
-                final_overlay,
-                (cx - tw // 2 - 1, cy - th // 2 - 1),
-                (cx + tw // 2 + 1, cy + th // 2 + 1),
-                (0, 0, 0),
-                -1
-            )
-            cv2.putText(
-                final_overlay, label_str,
-                (cx - tw // 2, cy + th // 2),
-                font, font_scale, color, thickness, cv2.LINE_AA
-            )
-
-    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)
@@ -451,12 +334,10 @@ def warp_polygon_to_square(image_np, points):
 
 
 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
     
@@ -465,9 +346,8 @@ def update_exclusion_preview(image, left_width, top_width):
     return Image.fromarray(overlay)
 
 
-# ---------------------------------------------------------------------------
 # Patch segmentation
-# ---------------------------------------------------------------------------
+
 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
@@ -750,7 +630,6 @@ def run_segmentation(image, model_choice, min_cell_size, max_cell_size,
 
 
 def run_viability(stored_masks, stored_image_np):
-    """Run model-based viability classification. Returns overlay + counts + label_map."""
     if stored_masks is None or stored_image_np is None:
         return None, 0, 0, 0.0, "Please run segmentation first.", {}
     if VIABILITY_CLF is None:
@@ -820,29 +699,12 @@ def compute_summary(r1, r2, r3, r4):
     return avg_count, avg_conf, avg_viab, "\n".join(lines)
 
 
-# ---------------------------------------------------------------------------
+
 # Training data export — feature extraction per cell
-# ---------------------------------------------------------------------------
+
 
 def extract_cell_features(image_np, masks):
-    """
-    For every segmented cell, extract a fixed feature vector from the pixels
-    inside its mask.  Returns a list of dicts, one per cell.
-
-    Features:
-      RGB channels        — mean_r, mean_g, mean_b, std_r, std_g, std_b
-      HSV channels        — mean_h, mean_s, mean_v, std_s, std_v
-      Ratios              — blue_red_ratio, blue_green_ratio, rg_ratio
-      Morphology          — area_px, circularity
-      Centre/edge profile — inner_brightness, peak_brightness,
-                            bright_spot_fraction, ring_darkness,
-                            centre_periphery_ratio, brightness_std_normalised
-
-    Profile zones are tuned to hemocytometer live-cell morphology:
-    a small intense specular highlight at the centre surrounded by a dark
-    navy membrane ring. Dead cells are pale blue-grey blobs with no ring
-    and no bright spot.
-    """
+    
     if len(image_np.shape) == 2:
         image_np = cv2.cvtColor(image_np, cv2.COLOR_GRAY2RGB)
     elif image_np.shape[2] == 4:
@@ -1003,9 +865,8 @@ def prepare_export(stored_masks, stored_image, threshold_bias):
     return path, msg
 
 
-# ---------------------------------------------------------------------------
+
 # Tab builder
-# ---------------------------------------------------------------------------
 
 def draw_polygon_overlay(image_pil, points):
     """
@@ -1063,14 +924,12 @@ def clear_crop_points(image_pil):
 
 
 
-# ---------------------------------------------------------------------------
 # Label correction grid
-# ---------------------------------------------------------------------------
 
-THUMB_SIZE   = 80   # each cell thumbnail is THUMB_SIZE × THUMB_SIZE px
-GRID_COLS    = 6    # thumbnails per row
-BORDER       = 4    # coloured border thickness in px
-LABEL_H      = 16   # height of the text label strip at the bottom of each thumb
+THUMB_SIZE   = 80   
+GRID_COLS    = 6   
+BORDER       = 4    
+LABEL_H      = 16   
 
 def _crop_cell_thumb(image_np, masks, cid):
     """
@@ -1102,14 +961,7 @@ def _crop_cell_thumb(image_np, masks, cid):
 
 
 def build_correction_grid(image_np, masks, labelled_features, raw_image_np=None):
-    """
-    Render all cell thumbnails into a single PIL image grid.
-    Each thumbnail has a coloured border: green=live(0), red=dead(1).
-    A small number in the corner identifies the cell_id.
-
-    Returns the PIL grid image.
-    Cell order in the grid matches the order of labelled_features.
-    """
+    
     if not labelled_features:
         placeholder = Image.fromarray(
             np.zeros((THUMB_SIZE, THUMB_SIZE, 3), dtype=np.uint8)
@@ -1496,9 +1348,8 @@ def build_tab(tab_index, masks_state, image_state, result_state):
 
 
 
-# ---------------------------------------------------------------------------
 # Gradio interface
-# ---------------------------------------------------------------------------
+
 with gr.Blocks(
     title="CellposeCellCounter",
     theme=gr.themes.Soft(),