From c48fbd87b87f84aa648e19b30a632136068ff45f Mon Sep 17 00:00:00 2001 From: AJ Isaacs Date: Sat, 21 Nov 2026 13:19:41 -0500 Subject: [PATCH] fix(fill): thin dense spacing outlines and stop near-circle offset joints A braze-casing angle whose 0.98" curve was exported as 199 lines of 0.005" made a single Fill of 33 copies take 8.6 minutes, and Auto Nest's Irregular engine never finished its first plate in 15 minutes: it proposes such fills as Lattice blocks. Two causes. Shape.JoinOffsetLines tested convexity with an unnormalized cross product, so shallow concave turns between tiny lines fell under the epsilon, the nearly parallel offsets missed each other, and the fallback arc swept the long way round: a near circle per joint, 414 entities in the spacing outline. A non-convex turn now gets a straight bridge, as concave corners already do. Spacing outlines with a dense run of tiny entities are also thinned to Douglas-Peucker chords on an offset padded by 0.0015, so every chord stays outside the true spacing outline: clearance can only grow, by at most 0.003 beside the run, and validation still reads true geometry. The angle's outline is now 21 entities; the Fill takes 69 s with no overlaps, and Irregular finishes the whole job (24 sheets in under 5 minutes, 22 by a 15-minute limit, against 28). Problem-nest corpus (auto-nest, fill): all layouts and counts unchanged. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 1 + OpenNest.Core/Geometry/DenseOutline.cs | 203 +++++++++++++++++++ OpenNest.Core/Geometry/Shape.cs | 11 + OpenNest.Core/PartGeometry.cs | 9 + OpenNest.Tests/Geometry/DenseOutlineTests.cs | 124 +++++++++++ docs/geometry/dense-outlines.md | 47 +++++ 6 files changed, 395 insertions(+) create mode 100644 OpenNest.Core/Geometry/DenseOutline.cs create mode 100644 OpenNest.Tests/Geometry/DenseOutlineTests.cs create mode 100644 docs/geometry/dense-outlines.md diff --git a/AGENTS.md b/AGENTS.md index e63c6670..2292f15a 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -69,6 +69,7 @@ Read the relevant contract before changing its behavior: - [Separating parts](docs/separate-parts.md): the CAD Converter splits a file drawing several parts into one drawing per part (`PartBodies`), keeping IDs and refusing a breakoff or tabbed cutout that spans parts - [Irregular stock](docs/irregular-stock.md): outlined sheets, what honors the outline and what refuses it - [Directional slides](docs/geometry/directional-slides.md) and [pair-spacing limits](docs/geometry/pair-spacing.md) +- [Dense outlines](docs/geometry/dense-outlines.md): spacing outlines thin runs of tiny entities (curves exported as polylines) to chords that only add clearance; validation keeps the true geometry - [Lead-in placement](docs/geometry/lead-in-placement.md) (including the planner's eroded pierce for cutouts too small for their lead-in and the stop at a feature's center line) and [pierce zones](docs/geometry/pierce-zone.md): opt-in `PierceDiameter` clearance, the hole pole fallback and the planner's perimeter scrap fallback - [Breakoffs](docs/breakoffs.md): tabbed scrap; `Break`-layer open cuts that are cut but are not material - [Tabbed cutouts](docs/tabbed-cutouts.md): holes cut in pieces around `Tab`-layer spans that are material but never cut; nesting reads material through `NestingMaterial.ForNesting`, so nothing nests in them diff --git a/OpenNest.Core/Geometry/DenseOutline.cs b/OpenNest.Core/Geometry/DenseOutline.cs new file mode 100644 index 00000000..672b5be2 --- /dev/null +++ b/OpenNest.Core/Geometry/DenseOutline.cs @@ -0,0 +1,203 @@ +using System.Collections.Generic; +using OpenNest.Math; + +namespace OpenNest.Geometry +{ + /// + /// Thins spacing outlines whose contour holds a dense run of tiny entities, such as a curve a + /// CAD export wrote as hundreds of 0.005-inch lines. Every slide and fill query costs in + /// proportion to the entities on both sides, so one such run can make Fill of a single part + /// take minutes. + /// + /// The thinned outline only ever adds clearance. It is the contour offset by the spacing plus + /// , with each dense run replaced by chords through points on that offset that + /// stay within of it (arcs sampled within + /// ). Every chord therefore lies outside the outline offset by the + /// spacing alone, so a layout spaced on the thinned outline holds the true spacing, at most + /// 2 * Pad wider at a dense run. Contours without a dense run keep their exact offset. + /// + public static class DenseOutline + { + /// Entities shorter than this count toward a dense run. + public const double ShortLength = 0.02; + + /// Fewest consecutive short entities that make a dense run. + public const int MinRun = 16; + + /// Largest distance a chord may stray from the sampled offset. + public const double ChordTolerance = 0.001; + + /// Largest distance an arc may bulge past the chords it is sampled into. + public const double SampleTolerance = 0.0005; + + /// Extra offset a thinned outline takes so its chords never cut inside the + /// outline at the true spacing. + public const double Pad = ChordTolerance + SampleTolerance; + + /// Whether the closed contour holds a dense run (a run may wrap past its first + /// entity). + public static bool HasDenseRun(IReadOnlyList contour) + { + if (contour.Count < MinRun) + return false; + var start = FirstLong(contour); + if (start < 0) + return true; + var run = 0; + for (var k = 1; k <= contour.Count; k++) + { + if (IsShort(contour[(start + k) % contour.Count])) + { + if (++run >= MinRun) + return true; + } + else + { + run = 0; + } + } + return false; + } + + /// + /// The closed contour with each dense run replaced by chords within + /// of it; other entities are kept as they are. Callers pass a + /// contour already offset by beyond the clearance it must keep. + /// + public static List Thin(IReadOnlyList contour) + { + var result = new List(contour.Count); + var start = FirstLong(contour); + if (start < 0) + { + // Every entity is short (a circle exported as lines): thin it as two halves so + // each run has distinct ends. + var half = contour.Count / 2; + AddChords(contour, 0, half, result); + AddChords(contour, half, contour.Count - half, result); + return result; + } + + // Walk once around the loop from a long entity, so no run is split at index 0. + var k = 0; + while (k < contour.Count) + { + var index = (start + k) % contour.Count; + var entity = contour[index]; + if (!IsShort(entity)) + { + result.Add(entity); + k++; + continue; + } + var length = 0; + while (k + length < contour.Count && IsShort(contour[(start + k + length) % contour.Count])) + length++; + if (length >= MinRun) + { + AddChords(contour, index, length, result); + } + else + { + for (var i = 0; i < length; i++) + result.Add(contour[(index + i) % contour.Count]); + } + k += length; + } + return result; + } + + private static bool IsShort(Entity entity) => + (entity is Line || entity is Arc) && entity.Length < ShortLength; + + private static int FirstLong(IReadOnlyList contour) + { + for (var i = 0; i < contour.Count; i++) + if (!IsShort(contour[i])) + return i; + return -1; + } + + /// Appends the run's chords: a Douglas-Peucker pass over its sampled points + /// that keeps both ends exact. + private static void AddChords(IReadOnlyList contour, int first, int count, List result) + { + var points = new List(); + for (var i = 0; i < count; i++) + Sample(contour[(first + i) % contour.Count], points); + points.Add(End(contour[(first + count - 1) % contour.Count])); + + var keep = new bool[points.Count]; + keep[0] = true; + keep[points.Count - 1] = true; + var spans = new Stack<(int From, int To)>(); + spans.Push((0, points.Count - 1)); + while (spans.Count > 0) + { + var (from, to) = spans.Pop(); + var farthest = -1; + var distance = ChordTolerance; + for (var i = from + 1; i < to; i++) + { + var d = DistanceToSegment(points[i], points[from], points[to]); + if (d > distance) + { + distance = d; + farthest = i; + } + } + if (farthest < 0) + continue; + keep[farthest] = true; + spans.Push((farthest, to)); + spans.Push((from, farthest)); + } + + var previous = points[0]; + for (var i = 1; i < points.Count; i++) + { + if (!keep[i]) + continue; + result.Add(new Line(previous, points[i])); + previous = points[i]; + } + } + + /// Adds the entity's points from its start up to, not including, its end. + private static void Sample(Entity entity, List points) + { + if (entity is Line line) + { + points.Add(line.StartPoint); + return; + } + var arc = (Arc)entity; + var sweep = arc.SweepAngle(); + var segments = 1; + if (arc.Radius > SampleTolerance) + { + // A chord over angle a sags r(1 - cos(a/2)) below its arc. + var step = 2 * PortableMath.Acos(1 - SampleTolerance / arc.Radius); + segments = System.Math.Max(1, (int)System.Math.Ceiling(sweep / step)); + } + var sampled = arc.ToPoints(segments); + for (var i = 0; i < sampled.Count - 1; i++) + points.Add(sampled[i]); + } + + private static Vector End(Entity entity) => + entity is Line line ? line.EndPoint : ((Arc)entity).EndPoint(); + + private static double DistanceToSegment(Vector p, Vector a, Vector b) + { + var dx = b.X - a.X; + var dy = b.Y - a.Y; + var lengthSquared = dx * dx + dy * dy; + if (lengthSquared <= 0) + return p.DistanceTo(a); + var t = ((p.X - a.X) * dx + (p.Y - a.Y) * dy) / lengthSquared; + t = System.Math.Max(0, System.Math.Min(1, t)); + return p.DistanceTo(new Vector(a.X + t * dx, a.Y + t * dy)); + } + } +} diff --git a/OpenNest.Core/Geometry/Shape.cs b/OpenNest.Core/Geometry/Shape.cs index dd2059ee..12080f9c 100644 --- a/OpenNest.Core/Geometry/Shape.cs +++ b/OpenNest.Core/Geometry/Shape.cs @@ -688,6 +688,17 @@ namespace OpenNest.Geometry offsetLine.StartPoint = intersection; lastOffsetLine.EndPoint = intersection; } + else if ( + (side == OffsetSide.Left && cross >= 0) || (side == OffsetSide.Right && cross <= 0) + ) + { + // Nearly parallel lines turning concave by less than the corner test resolves + // (short segments of a polyline curve): an arc between the offsets' ends would + // sweep the long way round the corner, a near circle per joint. A straight + // bridge stays inside the offset envelope, as at any concave corner. + if (lastOffsetLine.EndPoint.DistanceTo(offsetLine.StartPoint) > OpenNest.Math.Tolerance.Epsilon) + offsetShape.Entities.Add(new Line(lastOffsetLine.EndPoint, offsetLine.StartPoint)); + } else { var arc = new Arc( diff --git a/OpenNest.Core/PartGeometry.cs b/OpenNest.Core/PartGeometry.cs index fca663a2..7b42239a 100644 --- a/OpenNest.Core/PartGeometry.cs +++ b/OpenNest.Core/PartGeometry.cs @@ -69,6 +69,15 @@ namespace OpenNest var geoEntities = MaterialEntities(program); var profile = new ShapeProfile(geoEntities); + // A dense run of tiny entities is thinned to a few chords on a slightly wider offset; + // the chords stay outside the true one, so only clearance is added (DenseOutline). + if (DenseOutline.HasDenseRun(profile.Perimeter.Entities)) + { + var padded = profile.Perimeter.OffsetOutward(spacing + DenseOutline.Pad); + if (padded != null) + return DenseOutline.Thin(padded.Entities); + } + var offsetShape = profile.Perimeter.OffsetOutward(spacing); if (offsetShape == null) return new List(); diff --git a/OpenNest.Tests/Geometry/DenseOutlineTests.cs b/OpenNest.Tests/Geometry/DenseOutlineTests.cs new file mode 100644 index 00000000..8574ee0a --- /dev/null +++ b/OpenNest.Tests/Geometry/DenseOutlineTests.cs @@ -0,0 +1,124 @@ +using System.Collections.Generic; +using System.Linq; +using OpenNest.Geometry; +using OpenNest.Math; + +namespace OpenNest.Tests.Geometry; + +/// +/// A plate whose top edge is a curve exported as 200 tiny lines, as CAD exports often write +/// splines. The spacing outline must not grow a near-circle at every joint, and the thinned +/// outline must keep at least the spacing from the part everywhere. +/// +public class DenseOutlineTests +{ + private const double Spacing = 0.125; + + /// A 3 x 1 plate, counterclockwise, whose top edge sags by + /// (negative: bulges out) in 200 lines of 0.015. + private static Shape Plate(double bow) + { + var points = new List { new(0, 0), new(3, 0), new(3, 1) }; + for (var i = 1; i < 200; i++) + { + var x = 3 - 3.0 * i / 200; + points.Add(new Vector(x, 1 - bow * System.Math.Sin(System.Math.PI * x / 3))); + } + points.Add(new Vector(0, 1)); + var shape = new Shape(); + for (var i = 0; i < points.Count; i++) + shape.Entities.Add(new Line(points[i], points[(i + 1) % points.Count])); + return shape; + } + + [Theory] + [InlineData(0.02)] + [InlineData(0.0005)] + public void OffsetOfShallowConcaveJointsHasNoNearCircleArcs(double bow) + { + var offset = Plate(bow).OffsetOutward(Spacing); + + Assert.NotNull(offset); + // The plate's own corners turn a quarter; no joint arc may sweep round its corner. + Assert.All(offset.Entities.OfType(), arc => Assert.True(arc.SweepAngle() < 0.75 * System.Math.PI, + $"arc sweeps {arc.SweepAngle()}")); + } + + [Theory] + [InlineData(0.02)] + [InlineData(-0.02)] + [InlineData(0.0005)] + public void ThinnedOutlineKeepsTheSpacingWithFewEntities(double bow) + { + var plate = Plate(bow); + Assert.True(DenseOutline.HasDenseRun(plate.Entities), "no dense run"); + + var thinned = DenseOutline.Thin(plate.OffsetOutward(Spacing + DenseOutline.Pad).Entities); + + Assert.True(thinned.Count < 40, $"{thinned.Count} entities"); + var edges = plate.Entities.Cast().ToList(); + foreach (var point in Samples(thinned)) + { + var distance = edges.Min(e => Distance(point, e.StartPoint, e.EndPoint)); + Assert.True(distance >= Spacing - 1e-9, $"{point} is {distance} from the plate"); + Assert.True(distance <= Spacing + 2 * DenseOutline.Pad + 1e-6, $"{point} is {distance} from the plate"); + } + } + + [Fact] + public void ThinnedOutlineIsClosed() + { + var thinned = DenseOutline.Thin(Plate(0.02).OffsetOutward(Spacing + DenseOutline.Pad).Entities); + + for (var i = 0; i < thinned.Count; i++) + { + var end = End(thinned[i]); + var next = Start(thinned[(i + 1) % thinned.Count]); + Assert.True(end.DistanceTo(next) < 1e-6, $"gap after entity {i} of {thinned.Count}: {thinned[i]} then {thinned[(i + 1) % thinned.Count]}"); + } + } + + [Fact] + public void ContourWithoutADenseRunIsNotThinned() + { + var square = new Shape(); + square.Entities.Add(new Line(0, 0, 10, 0)); + square.Entities.Add(new Line(10, 0, 10, 10)); + square.Entities.Add(new Line(10, 10, 0, 10)); + square.Entities.Add(new Line(0, 10, 0, 0)); + + Assert.False(DenseOutline.HasDenseRun(square.Entities)); + } + + private static IEnumerable Samples(IEnumerable entities) + { + foreach (var entity in entities) + { + if (entity is Arc arc) + { + foreach (var p in arc.ToPoints(16)) + yield return p; + continue; + } + var line = (Line)entity; + for (var i = 0; i <= 16; i++) + { + var t = i / 16.0; + yield return new Vector(line.StartPoint.X + t * (line.EndPoint.X - line.StartPoint.X), + line.StartPoint.Y + t * (line.EndPoint.Y - line.StartPoint.Y)); + } + } + } + + private static Vector Start(Entity e) => e is Line l ? l.StartPoint : ((Arc)e).StartPoint(); + + private static Vector End(Entity e) => e is Line l ? l.EndPoint : ((Arc)e).EndPoint(); + + private static double Distance(Vector p, Vector a, Vector b) + { + var dx = b.X - a.X; + var dy = b.Y - a.Y; + var t = System.Math.Clamp(((p.X - a.X) * dx + (p.Y - a.Y) * dy) / (dx * dx + dy * dy), 0, 1); + return p.DistanceTo(new Vector(a.X + t * dx, a.Y + t * dy)); + } +} diff --git a/docs/geometry/dense-outlines.md b/docs/geometry/dense-outlines.md new file mode 100644 index 00000000..874df8b3 --- /dev/null +++ b/docs/geometry/dense-outlines.md @@ -0,0 +1,47 @@ +# Dense outlines in spacing geometry + +Fill, best-fit pairs and `Compactor` slide parts against each part's spacing outline: +`PartGeometry.GetOffsetPerimeterEntities`, the perimeter offset outward by the spacing (cutouts +are never part of it). Every slide costs in proportion to the entities on both sides, so a +perimeter carrying a curve that a CAD export wrote as hundreds of tiny lines makes every query +slow. + +## Reproduced case + +A braze-casing angle (`4980 A01 PT71`, 5.30 x 28.28, 3/16 steel) has a 0.98-inch curve of radius +22.9 written as 199 lines of about 0.005 inch. Its spacing outline held 414 entities, and Fill of +33 copies on a 72 x 144 sheet took 8.6 minutes; Auto Nest's Irregular engine, which proposes such +fills as Lattice blocks, never finished its first plate in 15 minutes. + +Two causes, both fixed: + +- **Near-circle joint arcs.** `Shape.JoinOffsetLines` tells a convex corner from a concave one by + an unnormalized cross product against `Tolerance.Epsilon`. Between 0.005-inch lines a shallow + concave turn falls under that threshold, the nearly parallel offsets do not intersect, and the + fallback arc swept the long way round the corner: a near circle of the spacing radius at every + joint. Those circles lie inside the true offset, so layouts stayed valid, but each one is a slide + query. A turn that is not convex now gets a straight bridge between the offsets' ends, as the + general join already does at concave corners; a convex turn keeps its short arc. +- **Dense runs are thinned** (`DenseOutline`). A perimeter holding a run of at least + `MinRun` (16) consecutive lines or arcs shorter than `ShortLength` (0.02 inch) is offset by the + spacing plus `Pad` (0.0015 inch) instead, and each such run is replaced by Douglas-Peucker chords + through points on that offset (arcs sampled within 0.0005, chords within 0.001). Every chord + stays within the pad of the padded offset, so it lies outside the offset at the true spacing: + layouts spaced on the thinned outline keep the spacing, at most twice the pad (0.003 inch) wider + beside a dense run. Perimeters without a dense run keep their exact offset. + +The angle's spacing outline is now 21 entities, and the same Fill takes 69 seconds with every +part passing the overlap check. What remains is mostly the exact overlap check, which still +triangulates the true perimeter and is deliberately not thinned. On the whole braze-casing job +(219 parts, five stock sizes) Irregular now completes its normal search in under 5 minutes +(24 sheets, 88.6%), and searching until a 15-minute limit reaches 22 sheets (89.9%), against +28 sheets (78.3%) before. + +## Boundaries + +- Thinning only ever adds clearance; it never loosens a tolerance. Validation (`NestLayoutCheck`, + `SpacingOutline`, `NativeContours`) and the overlap check still read the true geometry. +- Only the spacing outline is thinned. Drawings, programs, cut paths and posts are unchanged; to + remove the dense run itself, simplify the drawing in the CAD Converter. +- `DenseOutlineTests` covers the joint arcs, the spacing bound on both sides of a dense run, and + closure.