fix(verify): meet adjacent curves at their shared vertex exactly

Two curves that meet end to end share that vertex, but every contact
check asked the native intersection query about them, and it is
ill-conditioned there: two circles meeting at a shallow angle (a fillet
continuing into a larger arc) or a line meeting its fillet put their root
up to 1e-5 off the joint when the DXF arcs were rounded apart from their
neighbors by 1e-9. Material validation then refused the part as
self-touching, and the open-cut proof read a tabbed perimeter's fillet
joint as a loop, so with support tabs on every such part lost its
retention proof and its plate came back blocked. On a corpus of 1260
production plates this was the largest planner failure class: 61 of 67
NoSolutionWithinBudget plates, all planning once the joint is exact.

Contacts now report an adjacent pair's shared vertex itself and derive
the pair's other intersection from it analytically (two circles meet
again at the vertex's mirror image across the line through their
centers; a line meets a circle again at the far end of its chord),
keeping it only on both finite spans. No tolerance grows: a genuine
second crossing beside the joint is still reported, and overlapping
spans still refuse.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
ajandClaude Fable 5.1 committed 2026-11-02 14:31:44 -05:00
1 parent 81ec6a8125
commit 60d235c8ce
6 files changed
+221 -11

No files matched your search

@@ -392,9 +392,26 @@ internal static class PostVerificationGeometry
|| InteriorWitness(other.Start, this, witness) || InteriorWitness(other.End, this, witness));
if (SameSupport(other))
points.Clear();
// Two curves that meet end to end share that vertex, and the native query is
// ill-conditioned there: circles meeting at a shallow angle, or a line meeting its own
// fillet, put their root up to 1e-5 off the joint, which no joint tolerance can tell
// from a cut that touches beside it. Both shapes are known, so their other
// intersection, if there is one, follows from the shared vertex exactly instead.
var joint = SameSupport(other) ? null : SharedVertex(other);
var adjacent = joint.HasValue;
if (joint is { } vertex)
{
points.Clear();
points.Add(vertex);
if (SecondIntersection(other, vertex) is { } second && second.DistanceTo(vertex) > Epsilon
&& Contains(second) && other.Contains(second)
&& !IsOutsideArcSpan(second) && !other.IsOutsideArcSpan(second))
points.Add(second);
}
foreach (var point in points)
Validate(point);
var nativeContactCount = points.Count;
// Analytic contacts of adjacent curves are certain; the ray guard below is for native queries.
var nativeContactCount = adjacent ? int.MaxValue : points.Count;
foreach (var point in new[] { Start, End, other.Start, other.End })
if (Contains(point) && other.Contains(point)
&& !points.Exists(p => p.DistanceTo(point) <= Epsilon))
@@ -412,6 +429,49 @@ internal static class PostVerificationGeometry
|| (point.DistanceTo(curve.Start) > tolerance && point.DistanceTo(curve.End) > tolerance));
}
/// <summary>
/// The end this curve and <paramref name="other"/> share, within <see cref="Epsilon"/>, as
/// this curve has it; null when they share none or either is a full circle.
/// </summary>
private Vector? SharedVertex(Curve other)
{
if (Center.HasValue && !IsFiniteArc || other.Center.HasValue && !other.IsFiniteArc)
return null;
foreach (var end in new[] { End, Start })
if (end.DistanceTo(other.Start) <= Epsilon || end.DistanceTo(other.End) <= Epsilon)
return end;
return null;
}
/// <summary>
/// Where the supports of this curve and <paramref name="other"/> meet again, given that
/// they meet at <paramref name="vertex"/>: two circles meet again at the vertex's mirror
/// image across the line through their centers, and a line meets a circle again at the
/// far end of its chord through the vertex. Two lines meet only once. The result is on
/// both supports; it may be the vertex itself (tangency) or off either finite span.
/// </summary>
private Vector? SecondIntersection(Curve other, Vector vertex)
{
if (Center is { } center && other.Center is { } otherCenter)
{
var axis = otherCenter - center;
var distance = otherCenter.DistanceTo(center);
if (distance <= Epsilon)
return null;
var unit = axis * (1 / distance);
var foot = center + unit * Dot(vertex - center, unit);
return foot * 2 - vertex;
}
if (Center is null && other.Center is null)
return null;
var line = Center is null ? this : other;
var circle = Center is null ? other.Center!.Value : Center!.Value;
if (line.Length <= Epsilon)
return null;
var direction = (line.End - line.Start) * (1 / line.Length);
return vertex + direction * (2 * Dot(circle - vertex, direction));
}
/// <summary>
/// Whether exact ray semantics find <paramref name="curve"/> touching <paramref name="line"/>
/// anywhere except at a line endpoint the curve contains, which is already a recorded contact.
@@ -20,7 +20,9 @@ public class LeadMaterialSnapshotTests
var arcs = execution.Motions.Where(m => m.Curve?.IsFiniteArc == true).Select(m => m.Curve!).ToArray();
var contacts = arcs[0].Contacts(arcs[1], out var overlap);
Assert.False(overlap);
Assert.Contains(contacts, p => arcs.Any(a => a.IsOutsideArcSpan(p)));
// Adjacent curves meet exactly at their joint: the second crossing of these near-tangent
// circles, 0.000106 away on the radius-18 arc's extension, is off that arc's span.
Assert.Equal(location, Assert.Single(contacts));
var material = LeadMaterialSnapshot.Capture(program, location);
@@ -45,8 +47,8 @@ public class LeadMaterialSnapshotTests
private static Program ArcJoint(double centerOffset, bool reverseSecond, bool atSeam)
{
// Near-tangent circles meet at zero and about 0.000106 away. The native
// angular band of the radius-18 arc admits its extension beyond zero.
// Near-tangent circles meet at zero and about 0.000106 away, on the radius-18 arc's
// extension beyond zero, within the native query's angular band.
var first = new Vector(-18, 18);
var center = new Vector(centerOffset, 1);
var end = center + new Vector(center.DistanceTo(Vector.Zero), 0);
@@ -0,0 +1,102 @@
using OpenNest.Diagnostics;
using OpenNest.Geometry;
namespace OpenNest.Tests.Diagnostics;
/// <summary>
/// Contacts between two curves that meet end to end. The native intersection of their supports
/// is ill-conditioned at such a joint (two circles meeting at a shallow angle, or a line meeting
/// its fillet), so the checks derive the pair's other intersection from the shared vertex instead.
/// </summary>
public class AdjacentCurveContactTests
{
private static PostVerificationGeometry.Curve Arc(Vector start, Vector end, Vector center, bool clockwise = false) =>
PostVerificationGeometry.Curve.Create(start, end, center, clockwise);
private static PostVerificationGeometry.Curve Line(Vector start, Vector end) =>
PostVerificationGeometry.Curve.Create(start, end, null, false);
// A half circle of radius 5 whose center is off by delta, as a DXF arc rounded apart from
// its neighbors is, followed by a quarter circle of radius 3 that continues it tangentially.
// Both ends still meet within the closure epsilon; the circles then cross again beside the
// joint, where the native query puts a contact a few 1e-5 off the vertex.
[Theory]
[InlineData(0)]
[InlineData(-1e-11)]
[InlineData(-2e-11)]
[InlineData(-3e-11)]
[InlineData(4e-9)]
[InlineData(-4e-9)]
public void TangentArcsMeetingEndToEnd_TouchOnlyAtTheirVertex(double delta)
{
var vertex = new Vector(10, 10);
var first = Arc(new Vector(10, 0), vertex, new Vector(10, 5 + delta));
var second = Arc(vertex, new Vector(7, 7), new Vector(10, 7));
var contacts = first.Contacts(second, out var overlap);
var reversed = second.Contacts(first, out var reversedOverlap);
Assert.False(overlap);
Assert.False(reversedOverlap);
Assert.Equal(vertex, Assert.Single(contacts));
Assert.Equal(vertex, Assert.Single(reversed));
}
[Fact]
public void LineMeetingItsFilletEndToEnd_TouchesOnlyAtTheirVertex()
{
var vertex = new Vector(10, 0);
var edge = Line(new Vector(0, 0), vertex);
var fillet = Arc(vertex, new Vector(15, 5), new Vector(10, 5));
Assert.Equal(vertex, Assert.Single(edge.Contacts(fillet, out var overlap)));
Assert.Equal(vertex, Assert.Single(fillet.Contacts(edge, out _)));
Assert.False(overlap);
}
[Fact]
public void ArcsMeetingEndToEnd_StillReportWhereTheyCrossAgain()
{
// The unit circle's upper half and, from the same vertex, a circle through (0, 1).
var vertex = new Vector(1, 0);
var upper = Arc(vertex, new Vector(-1, 0), new Vector(0, 0));
var other = Arc(vertex, new Vector(0, 1), new Vector(1, 1));
var contacts = upper.Contacts(other, out var overlap);
Assert.False(overlap);
Assert.Equal(2, contacts.Count);
Assert.Contains(contacts, p => p.DistanceTo(vertex) <= 1e-9);
Assert.Contains(contacts, p => p.DistanceTo(new Vector(0, 1)) <= 1e-9);
}
[Fact]
public void LineMeetingAnArcEndToEnd_StillReportsTheChordsFarEnd()
{
// A chord of the unit circle from (1, 0) to (0, 1), then the circle's upper three quarters
// from (1, 0) through (0, 1): they share (1, 0) and cross at (0, 1).
var vertex = new Vector(1, 0);
var chord = Line(new Vector(0, 1), vertex);
var arc = Arc(vertex, new Vector(0, -1), new Vector(0, 0));
var contacts = chord.Contacts(arc, out var overlap);
Assert.False(overlap);
Assert.Equal(2, contacts.Count);
Assert.Contains(contacts, p => p.DistanceTo(vertex) <= 1e-9);
Assert.Contains(contacts, p => p.DistanceTo(new Vector(0, 1)) <= 1e-9);
}
[Fact]
public void ArcsMeetingEndToEnd_IgnoreASecondCrossingOffEitherSpan()
{
// The unit circle's right quarter and, from (0, 1), a circle through (-1, 0) that the
// first arc never reaches.
var vertex = new Vector(0, 1);
var quarter = Arc(new Vector(1, 0), vertex, new Vector(0, 0));
var other = Arc(vertex, new Vector(-2, 1), new Vector(-1, 1));
Assert.Equal(vertex, Assert.Single(quarter.Contacts(other, out var overlap)));
Assert.False(overlap);
}
}
@@ -545,6 +545,39 @@ public class PostVerificationAnalyzerTests
|| Find(report, PostVerificationKind.Incomplete).Any());
}
[Fact]
public void Rapid_TabbedPerimeterOfTangentArcsWithALeadOutIsRetained()
{
// A D-shaped part: a half circle of radius 5 continued tangentially by a quarter circle
// of radius 3, the half circle's center off by 2e-11 as a DXF arc rounded apart from its
// neighbor is. The arcs still meet within the closure epsilon, but their circles cross
// again 2e-5 beside the joint, inside the native query's angular padding and past the
// proof's joint tolerance: read as a loop, the open perimeter was not retained. Adjacent
// curves meet exactly, so the tabbed perimeter with its perpendicular lead-out passes.
var clean = new Program();
clean.MoveTo(0, 0);
clean.LineTo(10, 0);
clean.ArcTo(new Vector(10, 10), new Vector(10, 5 - 2e-11), RotationType.CCW);
clean.ArcTo(new Vector(7, 7), new Vector(10, 7), RotationType.CCW);
clean.LineTo(0, 7);
clean.LineTo(0, 0);
var part = new Part(new Drawing("d", clean));
var program = new Program();
program.MoveTo(0, -0.2);
program.Codes.Add(new LinearMove(0, 0) { Layer = LayerType.Leadin });
program.LineTo(10, 0);
program.ArcTo(new Vector(10, 10), new Vector(10, 5 - 2e-11), RotationType.CCW);
program.ArcTo(new Vector(7, 7), new Vector(10, 7), RotationType.CCW);
program.LineTo(0, 7);
program.LineTo(0, 0.2);
program.Codes.Add(new LinearMove(-0.1, 0.2) { Layer = LayerType.Leadout });
part.RestoreLeadInProgram(program, false);
var report = Analyze(part, Scribe(-2, 5), Scribe(16, 5));
Assert.Empty(Find(report, PostVerificationKind.Incomplete));
}
[Theory]
[InlineData(true)]
[InlineData(false)]
+16 -6
View File
@@ -66,12 +66,22 @@ Nominal material validation recognizes contacts at shared endpoints of adjacent
contour segments using `OpenNest.Math.Tolerance.Epsilon` (0.00001 model units).
This avoids false self-intersection warnings from rounding at arc/line joints,
including the contour seam. Overlapping segments and contacts away from those
joints or between separate contours still fail validation. For adjacent finite arcs
with a shared endpoint, material validation filters native contacts against both
actual arc spans: the native query's angular padding can otherwise report a
supporting-circle intersection beyond one arc's endpoint. This does not increase
the joint-distance tolerance, discard overlapping arcs, or waive a second intersection
inside both spans. Lead and rapid checks keep their conservative contact queries.
joints or between separate contours still fail validation. Two curves that meet end to
end (within the check epsilon, 1e-8) are not put to the native intersection query at
all: it is ill-conditioned at such a joint (two circles meeting at a shallow angle, as a
fillet continuing into a larger arc, or a line meeting its fillet), and lands its root up
to 1e-5 off the vertex, which no joint tolerance can tell from a cut that touches beside
the joint. `PostVerificationGeometry.Curve.Contacts` reports the shared vertex itself and
derives the pair's other intersection from it (two circles meet again at the vertex's mirror
image across the line through their centers; a line meets a circle again at the far end of
its chord), keeping it only when it lies on both finite spans. Every consumer of contacts
(material validation, lead checks, nested-part containment and the open-cut proof) sees the
same exact joint, so a part whose DXF arcs were rounded apart from their neighbors by 1e-9
neither fails material validation nor loses its tabbed perimeter's retention proof. For
adjacent finite arcs, material validation still filters any native contact against both
actual arc spans. None of this increases the joint-distance tolerance, discards overlapping
arcs, or waives a second intersection inside both spans. Lead and rapid checks keep their
conservative contact queries.
Source contour closure
in material capture and emitter preparation accepts endpoint gaps up to 0.000001
model units (inches for an inch nest), with a floating-point roundoff allowance
+4 -1
View File
@@ -153,7 +153,10 @@ they may form no loop, counting each closed contour with its leads as one point.
an open end must also stay out of the gap beyond it: a lead-out never reaches ahead of the
end it leaves, and a lead-in never behind the start it enters. Anything else (pieces that
meet exactly, a lead that bridges or curls into a tab, cuts from edge to edge) is reported
as incomplete, needing manual review. Kerf, tab strength and other parts' cuts are not modeled. Plan
as incomplete, needing manual review. Kerf, tab strength and other parts' cuts are not modeled.
Consecutive cuts of one piece meet at their shared vertex exactly, however their arcs were
rounded (see [cutting dependencies](cutting-planner.md#cutting-dependencies)): the proof
never mistakes a fillet's joint for a loop. Plan
Cutting runs the same proof, so its own [tabbed cutouts](tabbed-cutouts.md) (pieces without
lead-outs) pass, and so do its tabbed perimeters followed by a lead-out that stays out of the
tab. A program that still has a tabbed cutout's `Tab` motions (never planned) is