Clean Similar Curves

clean-similar-curves

Dedup the currently selected Rhino curves. SelDup fails when coincident curves differ in object type (LINE vs NURBS vs ARC) — this skill is type-agnostic.

The logic lives in two scripts next to this file so the validated code runs byte-identical every time (no re-typing, no model drift): dedup_dryrun.py (non-destructive) and dedup_delete.py (destructive). You send Rhino a tiny one-line loader that reads+executes the file — the script body never has to be re-emitted.

Procedure (do in order)

1. Resolve the script paths. Glob **/clean-similar-curves/dedup_dryrun.py and **/clean-similar-curves/dedup_delete.py to get their absolute paths on this machine. (Do NOT hardcode a path — it differs per machine/user.)
2. Dry run (non-destructive). Call mcp__rhino__execute_rhinoscript_python_code with just the loader:

   exec(open(r"<ABS_PATH>\dedup_dryrun.py").read())
   

   It diagnoses, clusters, and stashes delete-id lists in sc.sticky. Deletes nothing.
3. Read the report. It prints: doc tolerance + units, nearest-neighbor distance histogram (diagnoses exact-dup vs coordinate-drift), and TWO tiers — Tier A delete_safe (originals fully covered by a kept survivor; deleting loses nothing) and Tier B delete_split + create (overlap trims: delete the overlapping sources, create trimmed segments so the covered span is unchanged). Also reports curved partials left untouched.
4. Confirm scope with the user before applying (destructive). Present:
   • Tier A (safe deletes) → always safe; no geometry created, no holes.
   • Tier A+B (split overlaps) → resolves genuine partial overlaps by trimming (cut at the overlap boundary, keep ONE copy of the shared part). Abutting curves and standalone curves are left whole; split points are preserved. Use AskUserQuestion: {safe only} / {safe + split} / {stop}.
5. Apply by sending the delete loader with KEY set:

   KEY="exact"; exec(open(r"<ABS_PATH>\dedup_delete.py").read())
   

   Then, only if the user approved the split tier:

   KEY="split"; exec(open(r"<ABS_PATH>\dedup_delete.py").read())
   

   KEY="split" CREATES trimmed segments (inheriting each donor's layer/color) then deletes the overlapping originals. New segments are added to the selection.
6. Report survivors (note created-count separately). Offer to keep the selection for visual verify, and offer to save/update the rhino-curve-dedup-method memory.

Fallback: if Rhino can't read the file path (e.g. permission/encoding), open the .py with the Read tool and paste its full contents into the MCP code arg instead of the loader. Same result, more tokens.

Why SelDup misses them (root cause)

SelDup needs identical geometry structure. A LINE and a degree-2 NURBS on the same path are different structures → not matched. v2 detects coincidence by sampling points and testing containment (Curve.ClosestPoint), which is type-agnostic and — unlike GetDistancesBetweenCurves — correctly sees stick-out.

Critical gotchas (baked into dedup_dryrun.py — do not "fix" them out)

• DO NOT use GetDistancesBetweenCurves maxDist to detect containment. It returns maxDistance == 0 for GENUINE partial overlaps too (two curves sharing a middle but each sticking out), not just for full containment — it measures only the shared region and ignores the overhang. The v1 skill used md<=tol and deleted the sticking-out curves → holes ("빵꾸"). v2 uses covered() = sample points along the shorter curve, each must be within tol of the longer via ClosestPoint (which clamps to the longer's domain, so an overhang endpoint → distance > tol → correctly rejected). GetDistancesBetweenCurves is kept ONLY for the diagnostic histogram.
• Arrangement split at overlap boundaries (not min-cover). Straight collinear curves that overlap are clustered, projected to 1-D intervals, and resolved by arrange_plan: split at EVERY overlap boundary and keep ONE copy of each shared piece, e.g. [0-10]+[5-15] -> [0-5]+[5-10]+[10-15] (3 chunks — user's stated intent). Fully-contained fragments (a shorter curve inside a longer) are DELETED, NOT split-through — the long curve stays whole ([0-20]+[5-10] -> [0-20], fragment gone). Abutting / standalone actives (no interior breakpoint) are kept whole. Guarantees: covered span unchanged (no holes), zero overlaps, split points at real meeting points only.
• Survivor constraint. A fragment is delete_safe only if a KEPT-WHOLE survivor covers it; otherwise it goes to delete_split and its cover is realized as a create. Never delete a fragment whose only cover is itself being deleted.
• Curved (non-linear) curves are handled conservatively: exact dups (mutual containment + equal length) are removed; curved partials are LEFT UNTOUCHED (not split) and reported — splitting general curves at overlap is not implemented.
• Diagnose, don't guess tolerance. The nearest-neighbor histogram shows whether dups are sub-micron exact (type issue) or a small nonzero band (coordinate drift, common when coords are far from origin). Raise TOL_DIST/TOL_LEN in the .py if drift.
• Keep priority keeps native LINE/ARC over NURBS for non-linear exact-dup clusters.

Parameters

Edit the # ---- params ---- block at the top of dedup_dryrun.py: TOL_DIST, TOL_LEN (None → doc tolerance), MARGIN (bbox candidate margin), ANG_TOL (collinearity radians), SAMPLES (containment sample count), KEEP_PRIORITY (which type to keep per non-linear cluster).

Reference

• v1 validated 2026-06-30: 181 curves → 56 exact + 30 covered fragments removed → 95.
• v2 (2026-07-01): rewrote overlap handling after md<=tol was found to delete genuine partial overlaps → holes. Now containment-test + arrangement split. Split policy = split at every overlap boundary (partial [0-10]+[5-15] → 3 chunks), contained fragments deleted (long kept whole), abut/standalone kept whole. Verified by in-doc synthetic test with EXACT expected segment lists (partial→3 / chain→5 / subset / exact / abut / standalone) — all pass. Scope this pass: CURVES only, collinear overlaps only (no cross/T-junction shatter, no solids — deferred). See memory rhino-curve-dedup-method.

Not yet implemented (deferred, by user decision 2026-07-01)

• Non-curve types (polysurface / brep / mesh / point / block) dedup — curves only for now.
• Cross / T-junction shatter ("ㅗ": splitting a curve where a different-direction curve crosses or ends on its interior). User chose "overlap boundaries only" this pass; full planar-arrangement shatter via Intersect.CurveCurve + Split + JoinCurves is the next step if wanted. A report-only detector now exists next to this file: tjunction_report.py (glob **/clean-similar-curves/tjunction_report.py) — it flags endpoints landing on another curve's interior (verified: detects the T, ignores end-to-end joins). Run it for a count; the v2 APPLY (Curve.Split at the param + re-join) is still deferred. O(n²) with a bbox prefilter — run on a subset for huge selections.
• Post-shatter smart join of degree-2 passthrough nodes.