Upload app.py

app.py

@@ -1111,7 +1111,39 @@ def make_preview(image_pil):
     return preview, (preview.width / float(image_pil.width)) if image_pil.width else 1.0
 
 
-OFFSET_PCT_DEFAULT = 10.0   # % of picker height; ~a fingertip on a phone
+OFFSET_PCT_DEFAULT = 0.0    # % of picker height; 0 = marker under the finger
+ZOOM_FACTOR = 6             # zoom window is 1/6 of the image width
+
+
+def make_zoom_view(full_img, cx_full, cy_full):
+    """Zoomed window of the ORIGINAL pixels, centred on a rough tap.
+
+    Corner placement fails on a phone because the fingertip covers the target.
+    Zooming makes the target ~6x larger than the finger, so the second tap
+    needs no precision at all -- and cropping from the original rather than the
+    preview means the second tap also gains real detail, not interpolation.
+    """
+    W, H = full_img.size
+    win_w = max(32, W // ZOOM_FACTOR)
+    win_h = max(24, int(win_w * 0.75))
+    x0 = int(min(max(0, cx_full - win_w // 2), max(0, W - win_w)))
+    y0 = int(min(max(0, cy_full - win_h // 2), max(0, H - win_h)))
+    win_w, win_h = min(win_w, W - x0), min(win_h, H - y0)
+
+    view = full_img.crop((x0, y0, x0 + win_w, y0 + win_h))
+    out_w = PREVIEW_MAX
+    view = view.resize((out_w, max(1, int(out_w * win_h / win_w))), Image.LANCZOS)
+    zscale = view.width / float(win_w)          # view px per original px
+
+    d = ImageDraw.Draw(view)
+    cx_v = (cx_full - x0) * zscale
+    cy_v = (cy_full - y0) * zscale
+    arm = max(20, view.width // 25)
+    for dx, dy in ((1, 0), (0, 1)):
+        d.line([(cx_v - arm * dx, cy_v - arm * dy), (cx_v + arm * dx, cy_v + arm * dy)],
+               fill=(255, 90, 90, 255), width=2)
+    d.ellipse([cx_v - 4, cy_v - 4, cx_v + 4, cy_v + 4], outline=(255, 90, 90), width=2)
+    return view, {"x0": x0, "y0": y0, "zscale": zscale}
 
 
 def add_crop_point(preview_pil, points, scale, offset_pct, evt: gr.SelectData):
@@ -1323,6 +1355,8 @@ def build_tab(tab_index, masks_state, image_state, result_state):
         # preview->original scale, so taps on the small picker map back to
         # full-resolution coordinates for the segmentation warp
         preview_scale_state = gr.State(value=1.0)
+        # None = showing the overview; dict = showing a zoomed window
+        zoom_state = gr.State(value=None)
         #raw image state
         raw_image_state  = gr.State(value=None)
         # Masks as segmented, before stereological exclusion — lets the zones
@@ -1340,11 +1374,11 @@ def build_tab(tab_index, masks_state, image_state, result_state):
 
                 gr.Markdown(
                     "### Crop region (optional)\n"
-                    "Tap up to **4 points** on the image below to define the region "
-                    "to segment. On a touch screen the marker is placed **above "
-                    "your fingertip** so it is not hidden — a faint tail shows "
-                    "where you actually touched. "
-                    "Leave empty to segment the full image."
+                    "For each corner, tap **twice**: once roughly near it, then "
+                    "again precisely in the zoomed view that appears. The rough "
+                    "tap needs no accuracy — your finger can cover it entirely. "
+                    "Four corners define the region to segment; leave empty to "
+                    "use the whole image."
                 )
 
                 crop_display = gr.Image(
@@ -1360,11 +1394,14 @@ def build_tab(tab_index, masks_state, image_state, result_state):
 
                 clear_crop_btn = gr.Button("✕ Clear crop points", size="sm")
 
+                cancel_zoom_btn = gr.Button("↩ Back to full view", size="sm",
+                                            visible=False)
+
                 touch_offset = gr.Slider(
                     minimum=0, maximum=25, value=OFFSET_PCT_DEFAULT, step=1,
-                    label="Fingertip offset (% of picker height)",
-                    info="How far above your finger the marker is placed. "
-                         "Set to 0 when using a mouse.",
+                    label="Fingertip offset (optional, % of picker height)",
+                    info="Lifts the marker above your finger. Leave at 0 — "
+                         "the zoom step already solves the occlusion problem.",
                 )
 
                 model_dropdown = gr.Dropdown(
@@ -1511,7 +1548,7 @@ def build_tab(tab_index, masks_state, image_state, result_state):
             fn=on_image_upload,
             inputs=[img_input],
             outputs=[crop_display, base_image_state, preview_scale_state, crop_status]
-        ).then(fn=lambda: [], outputs=[crop_points_state])
+        ).then(fn=lambda: ([], None), outputs=[crop_points_state, zoom_state])
 
         # Grey the size sliders out while their filter is disabled, so the
         # checkbox state is visible rather than silently inferred.
@@ -1553,31 +1590,78 @@ def build_tab(tab_index, masks_state, image_state, result_state):
             _component.change(fn=on_exclusion_change,
                 inputs=exclusion_inputs, outputs=exclusion_outputs)
 
-        def on_crop_click(base_img, points, scale, offset_pct, evt: gr.SelectData):
-            before = len(points or [])
-            updated_img, updated_pts = add_crop_point(base_img, points, scale,
-                                                      offset_pct, evt)
-            n = len(updated_pts)
-            if n == before and n < 4:
-                status = "*Tap not registered — try again slightly inside the image*"
-            elif n < 4:
-                status = f"*{n} / 4 points set — keep tapping*"
-            else:
-                status = "*4 points set ✓ — **✕ Clear** to redo, or run segmentation*"
-            return updated_img, updated_pts, status
+        def _overview(preview, points, scale):
+            pv = [(int(x * scale), int(y * scale)) for x, y in points]
+            return draw_polygon_overlay(preview, pv)
+
+        def on_crop_click(full_img, preview, points, scale, zoom, offset_pct,
+                          evt: gr.SelectData):
+            """Two stages per corner: rough tap -> zoomed view -> precise tap."""
+            points = list(points or [])
+            if preview is None or full_img is None:
+                return (gr.update(), points, zoom, gr.update(), gr.update())
+
+            # Gradio can deliver an empty selection (gradio-app/gradio#5945)
+            if evt is None or evt.index is None or evt.index[0] is None:
+                return (gr.update(), points, zoom,
+                        "*Tap not registered — try again inside the image*",
+                        gr.update())
+
+            tx, ty = int(evt.index[0]), int(evt.index[1])
+
+            if zoom is None:
+                # ---- stage 1: rough tap on the overview ----------------------
+                if len(points) >= 4:
+                    return (_overview(preview, points, scale), points, None,
+                            "*4 points set ✓ — **✕ Clear** to redo, or run segmentation*",
+                            gr.update(visible=False))
+                stem = int(preview.height * (float(offset_pct or 0) / 100.0))
+                my = max(0, min(preview.height - 1, ty - stem))
+                view, z = make_zoom_view(full_img, tx / scale, my / scale)
+                return (view, points, z,
+                        f"*Zoomed in — now tap corner {len(points) + 1} precisely "
+                        f"(the red cross is your rough tap)*",
+                        gr.update(visible=True))
+
+            # ---- stage 2: precise tap inside the zoomed view -----------------
+            stem = int((PREVIEW_MAX * 0.75) * (float(offset_pct or 0) / 100.0))
+            x_full = zoom["x0"] + tx / zoom["zscale"]
+            y_full = zoom["y0"] + max(0, ty - stem) / zoom["zscale"]
+            W, H = full_img.size
+            new_points = points + [(int(min(max(0, x_full), W - 1)),
+                                    int(min(max(0, y_full), H - 1)))]
+            n = len(new_points)
+            status = (f"*{n} / 4 corners set — tap roughly near corner {n + 1}*"
+                      if n < 4 else
+                      "*4 points set ✓ — **✕ Clear** to redo, or run segmentation*")
+            return (_overview(preview, new_points, scale), new_points, None,
+                    status, gr.update(visible=False))
 
         crop_display.select(fn=on_crop_click,
-            inputs=[base_image_state, crop_points_state, preview_scale_state,
-                    touch_offset],
-            outputs=[crop_display, crop_points_state, crop_status])
+            inputs=[img_input, base_image_state, crop_points_state,
+                    preview_scale_state, zoom_state, touch_offset],
+            outputs=[crop_display, crop_points_state, zoom_state, crop_status,
+                     cancel_zoom_btn])
+
+        def on_cancel_zoom(preview, points, scale):
+            n = len(points or [])
+            return (_overview(preview, points or [], scale), None,
+                    f"*Back to full view — {n} / 4 corners set*",
+                    gr.update(visible=False))
+
+        cancel_zoom_btn.click(fn=on_cancel_zoom,
+            inputs=[base_image_state, crop_points_state, preview_scale_state],
+            outputs=[crop_display, zoom_state, crop_status, cancel_zoom_btn])
 
         def on_clear_crop(base_img):
             img, pts = clear_crop_points(base_img)
-            return img, pts, "*Points cleared — click to set new vertices*"
+            return (img, pts, None, "*Points cleared — tap roughly near corner 1*",
+                    gr.update(visible=False))
 
         clear_crop_btn.click(fn=on_clear_crop,
             inputs=[base_image_state],
-            outputs=[crop_display, crop_points_state, crop_status])
+            outputs=[crop_display, crop_points_state, zoom_state, crop_status,
+                     cancel_zoom_btn])
 
         segment_btn.click(
             fn=run_segmentation,