diff --git a/OpenNest.Core/Geometry/MaximalRectangles.cs b/OpenNest.Core/Geometry/MaximalRectangles.cs
index e03fe5d9..a8f3253f 100644
--- a/OpenNest.Core/Geometry/MaximalRectangles.cs
+++ b/OpenNest.Core/Geometry/MaximalRectangles.cs
@@ -1,6 +1,7 @@
using System;
using System.Collections.Generic;
using System.Linq;
+using System.Threading;
using Clipper2Lib;
namespace OpenNest.Geometry;
@@ -29,11 +30,20 @@ public static class MaximalRectangles
/// Rectangles narrower than this in either axis are dropped.
/// Even subdivisions of the region's bounds per axis, which bound the
/// staircase loss along slanted edges.
+ /// Results wanted: the search stops once it has this many, keeping
+ /// every further result as large as the last of them, so the results returned are exactly
+ /// those of the full search whose area is at least the area of its result at that rank.
+ /// A region with many edges can have very many candidate rectangles, and ruling out the
+ /// dominated ones costs time quadratic in them, so ask only for what is used.
+ /// Checked throughout; the search is long for a region with many edges.
/// Rectangles not contained in another result, largest area first.
- public static List InRegion(PathsD region, double minDimension = 0, int divisions = 64)
+ public static List InRegion(PathsD region, double minDimension = 0, int divisions = 64,
+ int largest = int.MaxValue, CancellationToken token = default)
{
ArgumentNullException.ThrowIfNull(region);
ArgumentOutOfRangeException.ThrowIfLessThan(divisions, 1);
+ ArgumentOutOfRangeException.ThrowIfLessThan(largest, 1);
+ token.ThrowIfCancellationRequested();
var paths = region.Where(path => path.Count >= 3).ToList();
if (paths.Count == 0)
@@ -52,6 +62,7 @@ public static class MaximalRectangles
var crossed = new bool[rows, cols];
foreach (var path in paths)
{
+ token.ThrowIfCancellationRequested();
var previous = path[^1];
foreach (var current in path)
{
@@ -67,6 +78,7 @@ public static class MaximalRectangles
// Even-odd scan along the row's center line. No vertex lies on it, and an edge that
// meets it strictly inside a cell has already marked that cell crossed, so each
// uncrossed cell is on the same side as its center.
+ token.ThrowIfCancellationRequested();
var y = (ys[r] + ys[r + 1]) / 2;
crossings.Clear();
foreach (var path in paths)
@@ -91,7 +103,8 @@ public static class MaximalRectangles
}
}
- return FromGrid(xs, ys, empty, minDimension);
+ var merged = MergeCells(xs, ys, empty, token);
+ return RemoveDominated(FilterBySize(merged, minDimension), largest, token);
}
///
@@ -111,9 +124,9 @@ public static class MaximalRectangles
double minDimension = 0
)
{
- var merged = MergeCells(xs, ys, empty);
+ var merged = MergeCells(xs, ys, empty, default);
var sized = FilterBySize(merged, minDimension);
- return RemoveDominated(sized);
+ return RemoveDominated(sized, int.MaxValue, default);
}
private static List GridLines(IEnumerable vertices, double min, double max, int divisions)
@@ -206,7 +219,8 @@ public static class MaximalRectangles
return true;
}
- private static List MergeCells(IReadOnlyList xs, IReadOnlyList ys, bool[,] empty)
+ private static List MergeCells(IReadOnlyList xs, IReadOnlyList ys, bool[,] empty,
+ CancellationToken token)
{
var rows = empty.GetLength(0);
var cols = empty.GetLength(1);
@@ -222,6 +236,7 @@ public static class MaximalRectangles
for (var r = 0; r < rows; r++)
{
+ token.ThrowIfCancellationRequested();
var stack = new Stack<(int startCol, int h)>();
for (var c = 0; c <= cols; c++)
@@ -268,13 +283,21 @@ public static class MaximalRectangles
return result;
}
- private static List RemoveDominated(List boxes)
+ ///
+ /// The boxes not within a larger one, largest first. Stops at the first box smaller than the
+ /// result at rank : boxes are taken in order, each against the
+ /// results before it, so the results kept up to there are those of the full pass.
+ ///
+ private static List RemoveDominated(List boxes, int largest, CancellationToken token)
{
boxes.Sort((a, b) => b.Area().CompareTo(a.Area()));
var results = new List();
foreach (var box in boxes)
{
+ if (results.Count >= largest && box.Area() < results[largest - 1].Area())
+ break;
+ token.ThrowIfCancellationRequested();
var dominated = false;
foreach (var larger in results)
diff --git a/OpenNest.Engine.Tests/NestingEngines/IrregularDeadlineTests.cs b/OpenNest.Engine.Tests/NestingEngines/IrregularDeadlineTests.cs
new file mode 100644
index 00000000..f81bcd5f
--- /dev/null
+++ b/OpenNest.Engine.Tests/NestingEngines/IrregularDeadlineTests.cs
@@ -0,0 +1,135 @@
+using System.Diagnostics;
+using OpenNest.CNC;
+using OpenNest.Engine.Jobs;
+using OpenNest.Engine.NestingEngines;
+using OpenNest.Engine.NestingEngines.Irregular;
+using OpenNest.Geometry;
+using static OpenNest.Engine.Tests.NestingEngines.JobBuilder;
+
+namespace OpenNest.Engine.Tests.NestingEngines;
+
+///
+/// Irregular under : it stops soon after the limit. A dense
+/// sheet of detailed parts once held it in the free-rectangle search for Lattice blocks, which
+/// neither checked the token nor scaled, for many minutes past a 30 s limit.
+///
+public class IrregularDeadlineTests
+{
+ /// A gear: square teeth on a disc, with four square holes.
+ private static Program Gear(double radius, int teeth)
+ {
+ var program = new Program();
+ var outline = new List<(double X, double Y)>();
+ var root = radius * 0.85;
+ for (var i = 0; i < teeth; i++)
+ {
+ var a = 2 * System.Math.PI * i / teeth;
+ var step = 2 * System.Math.PI / teeth / 4;
+ outline.Add(Polar(root, a));
+ outline.Add(Polar(radius, a + step));
+ outline.Add(Polar(radius, a + 2 * step));
+ outline.Add(Polar(root, a + 3 * step));
+ }
+ Contour(program, outline);
+ var hole = radius * 0.15;
+ foreach (var (cx, cy) in new[] { (0.4, 0.0), (-0.4, 0.0), (0.0, 0.4), (0.0, -0.4) })
+ {
+ var x = radius + cx * radius;
+ var y = radius + cy * radius;
+ Contour(program, new[] { (x - hole, y - hole), (x - hole, y + hole), (x + hole, y + hole), (x + hole, y - hole) });
+ }
+ return program;
+
+ (double X, double Y) Polar(double r, double angle) =>
+ (radius + r * System.Math.Cos(angle), radius + r * System.Math.Sin(angle));
+ }
+
+ private static void Contour(Program program, IReadOnlyList<(double X, double Y)> points)
+ {
+ program.Codes.Add(new RapidMove(points[0].X, points[0].Y));
+ foreach (var (x, y) in points.Skip(1))
+ program.Codes.Add(new LinearMove(x, y));
+ program.Codes.Add(new LinearMove(points[0].X, points[0].Y));
+ }
+
+ /// A bar with a serrated long edge ( teeth) and four square holes.
+ private static Program Serrated(double length, double width, int teeth)
+ {
+ var program = new Program();
+ var outline = new List<(double X, double Y)> { (0, 0), (length, 0), (length, width) };
+ var pitch = length / teeth;
+ for (var i = teeth - 1; i >= 0; i--)
+ {
+ outline.Add((i * pitch + pitch * 0.75, width));
+ outline.Add((i * pitch + pitch * 0.5, width - pitch * 0.4));
+ outline.Add((i * pitch + pitch * 0.25, width));
+ }
+ outline.Add((0, width));
+ Contour(program, outline);
+ var hole = width * 0.12;
+ foreach (var fx in new[] { 0.15, 0.4, 0.6, 0.85 })
+ {
+ var x = fx * length;
+ var y = width * 0.4;
+ Contour(program, new[] { (x - hole, y - hole), (x - hole, y + hole), (x + hole, y + hole), (x + hole, y - hole) });
+ }
+ return program;
+ }
+
+ [Fact]
+ public void StopsSoonAfterTheLimitOnADenseJobOfDetailedParts()
+ {
+ // About 450 bars a sheet; a sheet and a half of them.
+ var part = Part("bar", Serrated(5, 1.75, 24), 680, RotationPolicy.Automatic);
+ var stock = Stock("sheet", 60, 120, spacing: 0.25, edge: new Spacing(0.25, 0.75, 0.25, 0.25));
+ var job = Job(new[] { part }, new[] { stock });
+
+ var limit = TimeSpan.FromSeconds(3);
+ var engine = new DeadlineNestingEngine(new IrregularNestingEngine(), limit);
+ var watch = Stopwatch.StartNew();
+ NestJobResult? result = null;
+ try
+ {
+ result = engine.Solve(job);
+ }
+ catch (TimeoutException)
+ {
+ // No valid plan by the limit is an answer too; the point is how soon it comes.
+ }
+ watch.Stop();
+
+ Assert.True(watch.Elapsed < limit + TimeSpan.FromSeconds(3),
+ $"The solve took {watch.Elapsed.TotalSeconds:0.0} s against a {limit.TotalSeconds:0} s limit.");
+ if (result != null)
+ LayoutAssert.Valid(job, result);
+ }
+
+ ///
+ /// The frame that held a 30 s solve for over 1,000 s in the flag sweep: a sheet fill offering
+ /// Lattice blocks looks for the free rectangles beside hundreds of detailed parts already on
+ /// the sheet. Uncancelled, the free region alone takes about 20 s here.
+ ///
+ [Fact]
+ public void BlockPreparationBesideACrowdedSheetStopsWhenCancelled()
+ {
+ var stock = Stock("sheet", 60, 120, spacing: 0.25);
+ var job = Job(new[] { Part("gear", Gear(1.25, 24), 400, RotationPolicy.Fixed(0)) }, new[] { stock });
+ var types = PartCatalog.Build(job);
+ var orientation = types[0].Orientations[0];
+ var seated = new List();
+ for (var x = 0.0; x + 2.75 <= 120; x += 2.75)
+ for (var y = 0.0; y + 2.75 <= 50; y += 2.75)
+ seated.Add(new Placed(orientation, x, y));
+ var pairs = new Dictionary>();
+ using var blocks = new BlockCatalog(0.25, types, pairs, new WorkCounter(), long.MaxValue);
+ var packer = new FrontierPacker(types, new NoFitCache(0.25), pairs, stock, PackAxis.X, 1,
+ new WorkCounter(), blocks);
+ // Seating the parts takes under a second; the limit falls in the block preparation after it.
+ var limit = TimeSpan.FromSeconds(2);
+ using var cancel = new CancellationTokenSource(limit);
+ var watch = Stopwatch.StartNew();
+
+ Assert.ThrowsAny(() => packer.Fill(new[] { 400 }, cancel.Token, seated));
+ Assert.True(watch.Elapsed < limit + TimeSpan.FromSeconds(2), $"Took {watch.Elapsed.TotalSeconds:0.0} s.");
+ }
+}
diff --git a/OpenNest.Engine/NestingEngines/Irregular/BlockCatalog.cs b/OpenNest.Engine/NestingEngines/Irregular/BlockCatalog.cs
index f7bc19d1..836918a8 100644
--- a/OpenNest.Engine/NestingEngines/Irregular/BlockCatalog.cs
+++ b/OpenNest.Engine/NestingEngines/Irregular/BlockCatalog.cs
@@ -201,13 +201,16 @@ internal sealed class BlockCatalog : IDisposable
///
/// The free rectangles of a work area blocks are offered: the largest clear of the parts
- /// placed, their spacing included.
+ /// placed, their spacing included. Only the largest are searched for: on a sheet of many
+ /// detailed parts, sorting out every maximal rectangle takes minutes.
///
- internal static IReadOnlyList Rectangles(Box work, IReadOnlyList placed, double spacing) =>
- MaximalRectangles.InRegion(FreeRegion(work, placed, spacing)).OrderByDescending(b => b.Area())
+ internal static IReadOnlyList Rectangles(Box work, IReadOnlyList placed, double spacing,
+ CancellationToken token = default) =>
+ MaximalRectangles.InRegion(FreeRegion(work, placed, spacing, token), largest: MaxRectangles, token: token)
+ .OrderByDescending(b => b.Area())
.ThenBy(b => b.Left).ThenBy(b => b.Bottom).ThenBy(b => b.Length).Take(MaxRectangles).ToArray();
- private static PathsD FreeRegion(Box work, IReadOnlyList placed, double spacing)
+ private static PathsD FreeRegion(Box work, IReadOnlyList placed, double spacing, CancellationToken token)
{
var free = new PathsD { new PathD
{
@@ -216,6 +219,7 @@ internal sealed class BlockCatalog : IDisposable
} };
foreach (var part in placed)
{
+ token.ThrowIfCancellationRequested();
// Physical occupied material, not a reference-point region for any moving part.
// The catalog currently prepares solid outlines; future profile preparation owns holes.
var blocked = Clipper.InflatePaths(new PathsD { part.Orientation.Outline },
diff --git a/OpenNest.Engine/NestingEngines/Irregular/FrontierPacker.cs b/OpenNest.Engine/NestingEngines/Irregular/FrontierPacker.cs
index f9123207..bfb16d7f 100644
--- a/OpenNest.Engine/NestingEngines/Irregular/FrontierPacker.cs
+++ b/OpenNest.Engine/NestingEngines/Irregular/FrontierPacker.cs
@@ -336,7 +336,7 @@ internal sealed class FrontierPacker
if (blocks == null || sheet.BlockPreparations++ >= MaxBlockPreparations)
return;
var left = sheet.Left;
- var rectangles = BlockCatalog.Rectangles(work, sheet.Placed, stock.PartSpacing);
+ var rectangles = BlockCatalog.Rectangles(work, sheet.Placed, stock.PartSpacing, sheet.Token);
foreach (var type in types.Where(t => left[t.Index] >= MinBlockCopies)
.OrderByDescending(t => t.Area * left[t.Index]).ThenBy(t => t.Index).Take(MaxBlockTypes))
foreach (var rectangle in rectangles)
diff --git a/OpenNest.Tests/Geometry/MaximalRectanglesTests.cs b/OpenNest.Tests/Geometry/MaximalRectanglesTests.cs
index e2904132..3f6ff035 100644
--- a/OpenNest.Tests/Geometry/MaximalRectanglesTests.cs
+++ b/OpenNest.Tests/Geometry/MaximalRectanglesTests.cs
@@ -104,6 +104,42 @@ public class MaximalRectanglesTests
Assert.Empty(MaximalRectangles.InRegion(new PathsD()));
}
+ [Fact]
+ public void InRegion_Largest_KeepsTheFullSearchsResultsDownToThatRank()
+ {
+ // A sheet with holes punched in a staggered grid: many maximal rectangles, with ties.
+ var paths = new List { Rect(0, 0, 60, 40) };
+ for (var x = 3; x < 57; x += 7)
+ for (var y = 3 + x % 3; y < 36; y += 6)
+ {
+ var hole = Rect(x, y, x + 2.5, y + 1.5 + x % 2);
+ hole.Reverse();
+ paths.Add(hole);
+ }
+ var region = Region(paths.ToArray());
+
+ var full = MaximalRectangles.InRegion(region);
+ foreach (var largest in new[] { 1, 2, 5, 20 })
+ {
+ var cut = full[largest - 1].Area();
+ var expected = full.Where(b => b.Area() >= cut).ToList();
+ var result = MaximalRectangles.InRegion(region, largest: largest);
+
+ Assert.Equal(expected.Count, result.Count);
+ Assert.All(expected, box => Assert.Contains(result, r => Matches(r, box.Left, box.Bottom, box.Length, box.Width)));
+ }
+ }
+
+ [Fact]
+ public void InRegion_CancelledToken_Throws()
+ {
+ using var cancelled = new CancellationTokenSource();
+ cancelled.Cancel();
+
+ Assert.ThrowsAny(() =>
+ MaximalRectangles.InRegion(Region(Rect(0, 0, 10, 10)), token: cancelled.Token));
+ }
+
private static PathsD Region(params PathD[] paths) => new(paths);
private static PathD Rect(double left, double bottom, double right, double top) =>