Update app.py

app.py

@@ -706,9 +706,6 @@ def terminal_nets_via_kdtree(tree, labels, terminal_xy, max_dist):
     return set()
 
 def component_terminal_points(d):
-    """Heuristic fallback terminal points (box-edge midpoints). Used only
-    when no real skeleton-endpoint pin is found near the component (see
-    find_pin_terminal_points / PIN-LEVEL CONNECTIVITY below)."""
     x1, y1 = d['x'], d['y']
     x2, y2 = x1 + d['w'], y1 + d['h']
     cx, cy = (x1 + x2) // 2, (y1 + y2) // 2
@@ -717,90 +714,6 @@ def component_terminal_points(d):
         return [(x1, cy), (x2, cy), (cx, y1), (cx, y2)]
     return [(cx, y1), (cx, y2), (x1, cy), (x2, cy)]
 
-
-# ── PIN-LEVEL CONNECTIVITY ──────────────────────────────────────────────────
-#
-# FIX (priority #1 -- pin-level connectivity instead of component-center
-# connectivity): component_terminal_points() above only ever guesses 2-4
-# fixed points on the bounding-box edge (left/right/top/bottom midpoints).
-# That's not where a real pin is -- it's just "somewhere on the box
-# perimeter" -- so every KDTree snap downstream inherits that imprecision,
-# regardless of how tight the search radius is tuned. A 2-terminal device
-# only ever has 1-2 real wire leads touching it; guessing 4 candidate
-# points per component (and firing a kdtree query at each) is part of why
-# GND/V1/V2/etc keep getting roped onto shared rails.
-#
-# Real fix: a wire lead is, by construction, a skeleton *endpoint* (a
-# skeleton pixel with exactly one 8-connected neighbor) sitting just
-# outside a component's bounding box, since break_skeleton_at_component_
-# boxes() cuts the skeleton at the box edge. So instead of guessing where
-# the pin is, find the actual skeleton endpoints near the box and use
-# those as the terminal points. This gives true pin-level precision
-# without needing new YOLO keypoint training.
-
-def find_skeleton_endpoints(skel):
-    """Return (N,2) array of (x,y) skeleton pixels with exactly one
-    8-connected skeleton neighbor (= a wire lead tip / dangling end)."""
-    if not np.any(skel):
-        return np.empty((0, 2), dtype=int)
-    sk = (skel > 0).astype(np.uint8)
-    kernel = np.array([[1, 1, 1], [1, 0, 1], [1, 1, 1]], dtype=np.uint8)
-    neighbor_count = cv2.filter2D(sk, -1, kernel, borderType=cv2.BORDER_CONSTANT)
-    endpoint_mask = (sk == 1) & (neighbor_count == 1)
-    ys, xs = np.where(endpoint_mask)
-    return np.column_stack((xs, ys))
-
-def find_pin_terminal_points(d, skel_endpoints, search_margin):
-    """For component d, find real skeleton-endpoint pins within
-    `search_margin` px of its bounding box (the box was eroded out of the
-    skeleton, so a genuine lead's endpoint sits just outside the edge).
-    Returns up to 2 points (one per expected lead side for 2-terminal
-    parts), picked as the nearest endpoint on each side of the box.
-    Falls back to an empty list if nothing found -- caller should then
-    use the box-edge heuristic instead."""
-    if len(skel_endpoints) == 0:
-        return []
-    x1, y1 = d['x'] - search_margin, d['y'] - search_margin
-    x2, y2 = d['x'] + d['w'] + search_margin, d['y'] + d['h'] + search_margin
-    xs, ys = skel_endpoints[:, 0], skel_endpoints[:, 1]
-    in_box = (xs >= x1) & (xs <= x2) & (ys >= y1) & (ys <= y2)
-    cand = skel_endpoints[in_box]
-    if len(cand) == 0:
-        return []
-
-    cx = d['x'] + d['w'] / 2.0
-    cy = d['y'] + d['h'] / 2.0
-    horizontal = d['w'] >= d['h']
-
-    if horizontal:
-        left = cand[cand[:, 0] <= cx]
-        right = cand[cand[:, 0] > cx]
-        sides = [left, right]
-    else:
-        top = cand[cand[:, 1] <= cy]
-        bot = cand[cand[:, 1] > cy]
-        sides = [top, bot]
-
-    pts = []
-    for side in sides:
-        if len(side) == 0:
-            continue
-        # nearest-to-box-edge candidate on this side (closest to the
-        # component center along the perpendicular axis -- i.e. the lead
-        # tip nearest the body, not a far-away unrelated endpoint)
-        d2 = (side[:, 0] - cx) ** 2 + (side[:, 1] - cy) ** 2
-        best = side[np.argmin(d2)]
-        pts.append((int(best[0]), int(best[1])))
-
-    # if both sides collapsed to the same side (e.g. an L-shaped lead),
-    # still return whatever we found rather than nothing
-    if not pts:
-        d2 = (cand[:, 0] - cx) ** 2 + (cand[:, 1] - cy) ** 2
-        best = cand[np.argmin(d2)]
-        pts.append((int(best[0]), int(best[1])))
-    return pts
-
-
 def build_graph_wire_cc(details, img_np):
     """Full Stage 3 pipeline.
     FIX: merge gap and KDTree query radius are scale-relative and
@@ -808,19 +721,11 @@ def build_graph_wire_cc(details, img_np):
     receives net_pixels so it can cap merge span (see merge_split_nets
     docstring); GND kdtree radius tightened from 18*scale to 10*scale
     since the looser radius was eagerly grabbing onto unrelated rail
-    segments, compounding the mega-net problem.
-
-    FIX (pin-level connectivity): terminal points are now real skeleton
-    endpoints found near each component's box (find_pin_terminal_points),
-    not the old 4 guessed box-edge midpoints. The box-edge heuristic is
-    kept ONLY as a per-component fallback for when no real endpoint is
-    found nearby (e.g. component drawn flush against the wire with no
-    visible stub), so unusual schematics don't go fully disconnected."""
+    segments, compounding the mega-net problem."""
     scale = _img_scale(img_np)
     merge_gap = max(3, int(4 * scale))
     kdtree_radius = max(4, int(5 * scale))
     gnd_kdtree_radius = max(8, int(10 * scale))  # was 18*scale -- too eager to grab onto unrelated rail segments
-    pin_search_margin = max(3, int(6 * scale))   # how far outside the box to look for a real lead endpoint
 
     wire_layer = extract_wire_layer(img_np)
     wire_clean = erase_component_bodies(wire_layer, details)
@@ -828,9 +733,6 @@ def build_graph_wire_cc(details, img_np):
     skel = skeletonize_wire(wire_clean)
     skel = break_skeleton_at_component_boxes(skel, details)
 
-    skel_endpoints = find_skeleton_endpoints(skel)
-    debug_log("PINS", f"{len(skel_endpoints)} skeleton endpoint candidates (margin={pin_search_margin}px)")
-
     num_cc, cc_map = compute_nets(skel)
 
     # DEBUG: raw (pre-merge) net sizes/bboxes -- helps confirm whether a
@@ -860,25 +762,15 @@ def build_graph_wire_cc(details, img_np):
         ctype = d.get('component', '').lower()
         is_gnd = 'ground' in ctype or 'gnd' in ctype
         radius = gnd_kdtree_radius if is_gnd else kdtree_radius
-
-        pin_pts = find_pin_terminal_points(d, skel_endpoints, pin_search_margin)
-        used_fallback = False
-        if not pin_pts:
-            pin_pts = component_terminal_points(d)
-            used_fallback = True
-
         nets_found = set()
-        for tx, ty in pin_pts:
+        for tx, ty in component_terminal_points(d):
             nets_found |= terminal_nets_via_kdtree(tree, labels, (tx, ty), max_dist=radius)
-
         # GND: also try its own centroid in case the lead is short/centered
         if is_gnd and not nets_found:
             cx, cy = d['x'] + d['w'] // 2, d['y'] + d['h'] // 2
             nets_found |= terminal_nets_via_kdtree(tree, labels, (cx, cy), max_dist=gnd_kdtree_radius)
-
         comp_nets[d['label']] = nets_found
-        debug_log("TERMINAL", f"{d['label']}({d['component']}) -> nets={sorted(nets_found)} "
-                  f"r={radius} pins={pin_pts}{' [fallback-bbox]' if used_fallback else ' [real-pin]'}")
+        debug_log("TERMINAL", f"{d['label']}({d['component']}) -> nets={sorted(nets_found)} r={radius}")
 
     G = nx.Graph()
     for d in details:
@@ -2046,7 +1938,7 @@ with gr.Blocks(
     theme=gr.themes.Base(primary_hue="blue", neutral_hue="slate",
                           font=[gr.themes.GoogleFont("DM Sans"), "sans-serif"],
                           font_mono=[gr.themes.GoogleFont("JetBrains Mono"), "monospace"]),
-    css=css, title="Circuit Detector v25"
+    css=css, title="Circuit Detector v24"
 ) as app:
     base_state = gr.State([])
     gr.HTML("""
@@ -2059,7 +1951,7 @@ with gr.Blocks(
       <span class="badge b1">YOLOv8 3-pass</span>
       <span class="badge b2">OCR + LLM</span>
       <span class="badge b3">Skeleton + Union-Find + KDTree</span>
-      <span class="badge b4">v25 - pin-level connectivity: real skeleton-endpoint leads, box-edge guess as fallback only</span>
+      <span class="badge b4">v24 - terminal nets now nearest-only (kdtree query, not ball_point) -- fixes spurious multi-net terminals</span>
     </div>""")
 
     with gr.Row():