Update app.py

app.py

@@ -18,54 +18,90 @@ MODEL_OPTIONS = {
 loaded_models = {}
 
 def extract_region_from_editor(editor_data):
-    """Extract the selected region from ImageEditor 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):
-        background = editor_data.get('background')
-        layers = editor_data.get('layers', [])
-        
-        if background is None:
+
+        # --- Get background from multiple possible formats ---
+        bg = editor_data.get("background")
+
+        if bg is None:
             return None, None
-            
-        background_np = np.array(background)
-        
-        if layers and len(layers) > 0:
-            selection_layer = layers[0]
-            selection_np = np.array(selection_layer)
-            
-            if len(selection_np.shape) == 3:
-                if selection_np.shape[2] == 4:  # RGBA
-                    mask = selection_np[:, :, 3] > 0
-                else:  # RGB
-                    mask = np.any(selection_np > 0, axis=2)
+
+        # 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:
-                mask = selection_np > 0
-            
-            coords = np.where(mask)
-            if len(coords[0]) > 0:
-                y_min, y_max = coords[0].min(), coords[0].max()
-                x_min, x_max = coords[1].min(), coords[1].max()
-                
-                pad = 5
-                h, w = background_np.shape[:2]
-                y_min = max(0, y_min - pad)
-                y_max = min(h, y_max + pad)
-                x_min = max(0, x_min - pad)
-                x_max = min(w, x_max + pad)
-                
-                region = background_np[y_min:y_max+1, x_min:x_max+1]
-                return region, (x_min, y_min, x_max, y_max)
-        
+                try:
+                    sel_np = np.array(sel)
+                except:
+                    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
-    
-    else:
-        if hasattr(editor_data, 'size'):
-            image_np = np.array(editor_data)
-            return image_np, None
-        else:
-            return None, None
+
+    # CASE 4 — Unknown structure
+    return None, None
+
 
 def classify_cells_by_blueness(image_np, masks, blue_threshold):
     """