Update app.py

app.py

@@ -19,15 +19,11 @@ MODEL_OPTIONS = {
 loaded_models = {}
 
 # ---- mobile-safe size limits (aggressive for Safari) ----
-MAX_SIDE = 512           # shrink any side larger than this
-MAX_PIXELS = 512 * 512   # ~0.26 megapixels
+MAX_SIDE = 384           
+MAX_PIXELS = 384 * 384   
 
 
 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
 
@@ -219,11 +215,11 @@ 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.
-    """
+    
     try:
+        image_np = np.array(image)
+        image_np = safe_resize(image_np)
+        
         model_filename = MODEL_OPTIONS[model_choice]
         model_path = hf_hub_download(repo_id=HF_REPO_ID, filename=model_filename)
 
@@ -287,93 +283,6 @@ def run_segmentation_editor(editor_data, model_choice):
         return 0, None, f"Error during segmentation: {str(e)}", gr.update(visible=False), None, None, 0.0
 
 
-@spaces.GPU
-def run_segmentation_manual(image, model_choice, crop_coords):
-    """
-    Runs cell segmentation using manual image input and coordinates.
-    Returns initial segmentation overlay, counts, confluency, and also masks/image for state.
-    """
-    if image is None:
-        return 0, None, "No image provided", gr.update(visible=False), None, None, 0.0
-
-    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
-
-        image_np = np.array(image)
-
-        # Enforce mobile-safe size limit immediately
-        image_np = safe_resize(image_np)
-
-        # Apply crop if coordinates are provided
-        if crop_coords and crop_coords.strip():
-            try:
-                coords = [int(x.strip()) for x in crop_coords.split(',')]
-                if len(coords) == 4:
-                    x_min, y_min, x_max, y_max = coords
-                    h, w = image_np.shape[:2]
-                    x_min = max(0, min(x_min, w - 1))
-                    y_min = max(0, min(y_min, h - 1))
-                    x_max = max(x_min + 1, min(x_max, w))
-                    y_max = max(y_min + 1, min(y_max, h))
-
-                    processed_image_np = image_np[y_min:y_max, x_min:x_max]
-                else:
-                    processed_image_np = image_np  # No valid crop, use original
-            except ValueError:
-                processed_image_np = image_np  # Invalid crop, use original
-        else:
-            processed_image_np = image_np  # No crop coords, use original
-
-        # Process image format to RGB
-        if len(processed_image_np.shape) == 2:
-            processed_image_np = cv2.cvtColor(processed_image_np, cv2.COLOR_GRAY2RGB)
-        elif len(processed_image_np.shape) == 3 and processed_image_np.shape[2] == 4:
-            processed_image_np = cv2.cvtColor(processed_image_np, cv2.COLOR_RGBA2RGB)
-
-        # Run Cellpose
-        masks, flows, styles = model.eval(processed_image_np, diameter=None, channels=[0, 0])
-
-        cell_count = len(np.unique(masks)) - 1
-        confluency = measure_confluency(masks, processed_image_np)
-
-        # Create a basic segmentation overlay
-        segmentation_overlay = processed_image_np.copy().astype(np.float32)
-        if masks.max() > 0:
-            np.random.seed(42)
-            colors = np.random.randint(0, 255, size=(masks.max() + 1, 3))
-            colors[0] = [0, 0, 0]
-            colored_mask = colors[masks]
-            alpha = 0.4
-            segmentation_overlay = (1 - alpha) * segmentation_overlay + alpha * colored_mask
-        segmentation_overlay = np.clip(segmentation_overlay, 0, 255).astype(np.uint8)
-
-        info_msg = f"Segmentation complete! Found {cell_count} cells.\n"
-        info_msg += f"Confluency: {confluency:.1f}%\n"
-        if crop_coords:
-            info_msg += f"Processed with coordinates: {crop_coords}\n"
-        info_msg += f"Now adjust the Blue Threshold for viability assessment."
-
-        return (
-            cell_count,
-            Image.fromarray(segmentation_overlay),
-            info_msg,
-            gr.update(visible=True),
-            pack_array(masks),
-            pack_array(processed_image_np),
-            confluency,
-        )
-
-    except Exception as e:
-        return 0, None, f"Error during segmentation: {str(e)}", gr.update(visible=False), None, None, 0.0
-
-
 def update_viability_realtime(blue_threshold, 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:
@@ -517,77 +426,6 @@ with gr.Blocks(
             outputs=[viability_overlay1, live_count_output1, dead_count_output1, viability_percent_output1, viability_info1]
         )
 
-    with gr.Tab("Manual Coordinates"):
-        gr.Markdown("### Upload image and run segmentation")
-
-        with gr.Row():
-            with gr.Column():
-                image_input = gr.Image(
-                    type="pil",
-                    label="Microscopy Image",
-                    image_mode="RGB",
-                    height=512  # limit canvas size here too
-                )
-                model_dropdown2 = gr.Dropdown(
-                    choices=list(MODEL_OPTIONS.keys()),
-                    label="Select Model",
-                    value="Hemocytometer Model"
-                )
-                coord_input = gr.Textbox(
-                    label="Crop Coordinates (optional)",
-                    placeholder="e.g., 100,100,400,400",
-                    info="Format: x_min,y_min,x_max,y_max"
-                )
-                segment_btn2 = gr.Button("🔬 Run Segmentation", variant="primary", size="lg")
-
-            with gr.Column():
-                cell_count_output2 = gr.Number(label="Total Cells Detected", precision=0)
-                confluency_output2 = gr.Number(label="Confluency (%)", precision=1)
-                overlay_output2 = gr.Image(type="pil", label="Segmentation Result")
-                info_output2 = gr.Textbox(label="Processing Info", lines=4)
-
-        # Viability Assessment Section
-        with gr.Group(visible=False) as viability_section2:
-            gr.Markdown("### Viability Assessment (Trypan Blue)")
-            gr.Markdown("Adjust the threshold to classify cells as live (green) or dead (red).")
-
-            with gr.Row():
-                with gr.Column():
-                    blue_threshold2 = gr.Slider(
-                        minimum=0,
-                        maximum=100,
-                        value=25,
-                        step=1,
-                        label="Blue Threshold (%)",
-                        info="Higher values = more selective for blue cells"
-                    )
-
-                with gr.Column():
-                    live_count_output2 = gr.Number(label="Live Cells (Green)", precision=0)
-                    dead_count_output2 = gr.Number(label="Dead Cells (Red)", precision=0)
-
-            viability_overlay2 = gr.Image(type="pil", label="Viability Assessment (Green=Live, Red=Dead)")
-            viability_percent_output2 = gr.Number(label="Viability (%)", precision=1)
-            viability_info2 = gr.Textbox(label="Analysis Results", lines=5)
-
-        # Event handlers
-        segment_btn2.click(
-            fn=run_segmentation_manual,
-            inputs=[image_input, model_dropdown2, coord_input],
-            outputs=[cell_count_output2, overlay_output2, info_output2, viability_section2, masks_state, image_state, confluency_output2]
-        ).then(  # Chain the initial viability assessment after segmentation
-            fn=update_viability_realtime,
-            inputs=[blue_threshold2, masks_state, image_state],
-            outputs=[viability_overlay2, live_count_output2, dead_count_output2, viability_percent_output2, viability_info2]
-        )
-
-        # Slider changes update viability in real-time
-        blue_threshold2.change(
-            fn=update_viability_realtime,
-            inputs=[blue_threshold2, masks_state, image_state],
-            outputs=[viability_overlay2, live_count_output2, dead_count_output2, viability_percent_output2, viability_info2]
-        )
-
     # Instructions
     with gr.Accordion("Instructions", open=False):
         gr.Markdown("""