Update app.py

app.py

@@ -45,93 +45,6 @@ def safe_resize(image_np):
 
     return cv2.resize(image_np, (new_w, new_h), interpolation=cv2.INTER_AREA)
 
-
-def extract_region_from_editor(editor_data):
-    """Extract selected region from ImageEditor data (mobile-safe)."""
-    if editor_data is None:
-        return None, None
-
-    # CASE 1 — Editor returns a PIL Image directly
-    if isinstance(editor_data, Image.Image):
-        return np.array(editor_data), None
-
-    # CASE 2 — Editor returns a NumPy array
-    if isinstance(editor_data, np.ndarray):
-        return editor_data, None
-
-    # CASE 3 — Mobile browser returns dict structure
-    if isinstance(editor_data, dict):
-
-        # --- Get background from multiple possible formats ---
-        bg = editor_data.get("background")
-
-        if bg is None:
-            return None, None
-
-        # Mobile ImageEditor sometimes wraps image like: {'image': base64, 'mask': None}
-        if isinstance(bg, dict) and "image" in bg:
-            try:
-                # Decode base64 → PIL → NumPy
-                img_bytes = io.BytesIO(base64.b64decode(bg["image"].split(",")[-1]))
-                bg_img = Image.open(img_bytes).convert("RGB")
-                background_np = np.array(bg_img)
-            except Exception:
-                return None, None
-
-        # Desktop / some mobile: bg is a PIL image
-        elif isinstance(bg, Image.Image):
-            background_np = np.array(bg)
-
-        # Final fallback
-        else:
-            try:
-                background_np = np.array(bg)
-            except Exception:
-                return None, None
-
-        # --- Layers (selection mask) ---
-        layers = editor_data.get("layers", [])
-        if layers:
-            sel = layers[0]
-
-            # Convert to NumPy if needed
-            if isinstance(sel, Image.Image):
-                sel_np = np.array(sel)
-            elif isinstance(sel, dict) and "image" in sel:
-                try:
-                    sel_bytes = io.BytesIO(base64.b64decode(sel["image"].split(",")[-1]))
-                    sel_np = np.array(Image.open(sel_bytes).convert("RGBA"))
-                except Exception:
-                    sel_np = None
-            else:
-                try:
-                    sel_np = np.array(sel)
-                except Exception:
-                    sel_np = None
-
-            # If selection exists: compute bounding box
-            if sel_np is not None:
-                if sel_np.ndim == 3:
-                    if sel_np.shape[2] == 4:
-                        mask = sel_np[:, :, 3] > 0
-                    else:
-                        mask = np.any(sel_np > 0, axis=2)
-                else:
-                    mask = sel_np > 0
-
-                coords = np.where(mask)
-                if coords[0].size > 0:
-                    y0, y1 = coords[0].min(), coords[0].max()
-                    x0, x1 = coords[1].min(), coords[1].max()
-                    return background_np[y0:y1 + 1, x0:x1 + 1], (x0, y0, x1, y1)
-
-        # No selection → return full image
-        return background_np, None
-
-    # CASE 4 — Unknown structure
-    return None, None
-
-
 def classify_cells_by_blueness(image_np, masks, blue_threshold):
     """
     Classify cells as dead (blue) or alive based on single blueness metric
@@ -218,11 +131,10 @@ def measure_confluency(masks, image_np):
 
 
 @spaces.GPU
-def run_segmentation_editor(editor_data, model_choice):
-    """
-    Runs cell segmentation using ImageEditor data.
-    Returns initial segmentation overlay, counts, confluency, and also masks/image for state.
-    """
+def run_segmentation(image, model_choice):
+    image_np = np.array(image)
+    image_np = safe_resize(image_np)
+    
     try:
         model_filename = MODEL_OPTIONS[model_choice]
         model_path = hf_hub_download(repo_id=HF_REPO_ID, filename=model_filename)
@@ -233,19 +145,14 @@ def run_segmentation_editor(editor_data, model_choice):
             model = models.CellposeModel(gpu=True, pretrained_model=model_path)
             loaded_models[model_filename] = model
 
-        region_np, region_coords = extract_region_from_editor(editor_data)
 
-        if region_np is None:
-            return 0, None, f"No image provided.", gr.update(visible=False), None, None, 0.0
-
-        # Enforce mobile-safe size limit immediately
-        region_np = safe_resize(region_np)
+        
 
         # Process image format to RGB
-        if len(region_np.shape) == 2:
+        if len(image_np.shape) == 2:
             processed_image_np = cv2.cvtColor(region_np, cv2.COLOR_GRAY2RGB)
-        elif len(region_np.shape) == 3 and region_np.shape[2] == 4:
-            processed_image_np = cv2.cvtColor(region_np, cv2.COLOR_RGBA2RGB)
+        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 = region_np
 
@@ -268,8 +175,6 @@ def run_segmentation_editor(editor_data, model_choice):
 
         info_msg = f"Segmentation complete! Found {cell_count} cells.\n"
         info_msg += f"Confluency: {confluency:.1f}%\n"
-        if region_coords:
-            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 (packed for Gradio State)
@@ -339,18 +244,18 @@ with gr.Blocks(
     masks_state = gr.State(value=None)
     image_state = gr.State(value=None)
 
-    with gr.Tab("Image Editor (Draw Selection)"):
-        gr.Markdown("### Draw selection and run segmentation")
+    with gr.Tab("Cell Quantification"):
+        gr.Markdown("Run segmentation")
 
         with gr.Row():
             with gr.Column():
-                image_editor = gr.ImageEditor(
-                    label="Draw selection on image",
+                img_input=gr.Image(
                     type="pil",
+                    label="Microscopy image",
                     image_mode="RGB",
-                    height=512,  # limit canvas size on client (important for mobile)
-                    brush=gr.Brush(colors=["#ff0000"], color_mode="fixed", default_size=20),
-                    eraser=gr.Eraser(default_size=20)
+                    height=512
+                )
+                    
                 )
                 model_dropdown1 = gr.Dropdown(
                     choices=list(MODEL_OPTIONS.keys()),
@@ -391,8 +296,8 @@ with gr.Blocks(
 
         # Event handlers
         segment_btn1.click(
-            fn=run_segmentation_editor,
-            inputs=[image_editor, model_dropdown1],
+            fn=run_segmentation,
+            inputs=[img_input, model_dropdown1],
             outputs=[cell_count_output1, overlay_output1, info_output1, viability_section1, masks_state, image_state, confluency_output1]
         ).then(  # Chain the initial viability assessment after segmentation
             fn=update_viability_realtime,