Upload app.py

app.py

@@ -1052,12 +1052,10 @@ def prepare_export(stored_masks, stored_image, threshold_bias):
 # Tab builder
 # ---------------------------------------------------------------------------
 
-def draw_polygon_overlay(image_pil, points, stem_px=0):
+def draw_polygon_overlay(image_pil, points):
     """
     Draw numbered vertex dots and polygon edges onto a copy of image_pil.
     points: list of (x, y) tuples in preview pixel space.
-    stem_px: if non-zero, draw a tail from the last vertex down to the touch
-             point it was offset from (see add_crop_point).
     Returns a new PIL image.
     """
     img = image_pil.copy().convert("RGBA")
@@ -1080,15 +1078,6 @@ def draw_polygon_overlay(image_pil, points, stem_px=0):
                      fill=(74, 170, 255, 255), outline=(255, 255, 255, 255))
         draw.text((x, y), str(i + 1), fill=(255, 255, 255, 255), anchor="mm")
 
-    # In offset mode the marker sits above the fingertip. Without something
-    # connecting the two it reads as "the app put my point in the wrong place",
-    # so draw the stem down to where the touch actually landed.
-    if stem_px and points:
-        x, y = points[-1]
-        draw.line([(x, y + r), (x, y + stem_px)], fill=(74, 170, 255, 140), width=2)
-        draw.ellipse([x - 5, y + stem_px - 5, x + 5, y + stem_px + 5],
-                     outline=(255, 255, 255, 170), width=2)
-
     combined = Image.alpha_composite(img, overlay)
     return combined.convert("RGB")
 
@@ -1111,7 +1100,6 @@ def make_preview(image_pil):
     return preview, (preview.width / float(image_pil.width)) if image_pil.width else 1.0
 
 
-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
 
 
@@ -1146,47 +1134,6 @@ def make_zoom_view(full_img, cx_full, cy_full):
     return view, {"x0": x0, "y0": y0, "zscale": zscale}
 
 
-def add_crop_point(preview_pil, points, scale, offset_pct, evt: gr.SelectData):
-    """
-    Called by gr.Image .select(). Appends the clicked coordinate,
-    redraws the overlay on the PREVIEW, returns (updated_preview, updated_points).
-
-    `points` are kept in ORIGINAL image pixels so run_segmentation's warp is
-    unaffected; only the drawing happens in preview space.
-    Ignores clicks once 4 points are set.
-    """
-    if points is None:
-        points = []
-    scale = scale or 1.0
-
-    def to_preview(pts):
-        return [(int(px * scale), int(py * scale)) for px, py in pts]
-
-    if preview_pil is None:
-        return preview_pil, points
-
-    # Vertical offset so the marker is not hidden under the fingertip.
-    # Expressed as a share of picker height, which keeps it consistent across
-    # phone sizes instead of being tied to the image's pixel dimensions.
-    stem = int(preview_pil.height * (float(offset_pct or 0.0) / 100.0))
-
-    if len(points) >= 4:
-        return draw_polygon_overlay(preview_pil, to_preview(points), stem), points
-
-    # Gradio can deliver an empty selection (see gradio-app/gradio#5945);
-    # dropping it beats raising a red error box the user cannot interpret.
-    if evt is None or evt.index is None or evt.index[0] is None:
-        return draw_polygon_overlay(preview_pil, to_preview(points)), points
-
-    tx, ty = int(evt.index[0]), int(evt.index[1])
-    # Lift the marker above the touch, clamped so a tap near the top edge
-    # cannot place a vertex off the image.
-    my = max(0, min(preview_pil.height - 1, ty - stem))
-    x, y = int(tx / scale), int(my / scale)
-    new_points = points + [(x, y)]
-    return draw_polygon_overlay(preview_pil, to_preview(new_points), stem), new_points
-
-
 def clear_crop_points(image_pil):
     """Reset polygon — return original image with no overlay and empty points."""
     return image_pil, []
@@ -1397,13 +1344,6 @@ def build_tab(tab_index, masks_state, image_state, result_state):
                 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 (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(
                     choices=list(MODEL_OPTIONS.keys()),
                     label="Select Model",
@@ -1594,7 +1534,7 @@ def build_tab(tab_index, masks_state, image_state, result_state):
             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,
+        def on_crop_click(full_img, preview, points, scale, zoom,
                           evt: gr.SelectData):
             """Two stages per corner: rough tap -> zoomed view -> precise tap."""
             points = list(points or [])
@@ -1615,18 +1555,15 @@ def build_tab(tab_index, masks_state, image_state, result_state):
                     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)
+                view, z = make_zoom_view(full_img, tx / scale, ty / 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"]
+            y_full = zoom["y0"] + ty / 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)))]
@@ -1639,7 +1576,7 @@ def build_tab(tab_index, masks_state, image_state, result_state):
 
         crop_display.select(fn=on_crop_click,
             inputs=[img_input, base_image_state, crop_points_state,
-                    preview_scale_state, zoom_state, touch_offset],
+                    preview_scale_state, zoom_state],
             outputs=[crop_display, crop_points_state, zoom_state, crop_status,
                      cancel_zoom_btn])