diff --git a/OpenNest.Engine.Tests/NestingEngines/RectanglesLargeFirstTests.cs b/OpenNest.Engine.Tests/NestingEngines/RectanglesLargeFirstTests.cs new file mode 100644 index 00000000..913f9fa1 --- /dev/null +++ b/OpenNest.Engine.Tests/NestingEngines/RectanglesLargeFirstTests.cs @@ -0,0 +1,60 @@ +using System.Linq; +using OpenNest.Engine.Jobs; +using OpenNest.Engine.NestingEngines.Rectangles; +using static OpenNest.Engine.Tests.NestingEngines.JobBuilder; +using static OpenNest.Engine.Tests.NestingEngines.Shapes; + +namespace OpenNest.Engine.Tests.NestingEngines; + +/// +/// A job mixing large plates with small parts: cost alone picks the densest sheet first, a sheet of +/// small parts, and leaves the large plates' sheets nothing to fill their gaps with. The large-first +/// run nests the plates first and fills their gaps, so no sheet is spent on small parts alone. +/// +public class RectanglesLargeFirstTests +{ + private static NestJob BrazeCasing() => Job( + new[] + { + Part("side-a", Rectangle(56.93, 88.99), 3), + Part("side-b", Rectangle(58.7, 56.93), 2), + Part("angle", Rectangle(5.3, 28.28), 30), + Part("tab", Rectangle(9, 3.75), 40), + }, + new[] + { + Stock("60x120", 60, 120, spacing: 0.25), + Stock("72x144", 72, 144, spacing: 0.25), + }); + + private static readonly string[] Large = { "side-a", "side-b" }; + + [Fact] + public void CostAloneSpendsTheFirstSheetOnSmallParts() + { + var job = BrazeCasing(); + + var result = new RectanglesNestingEngine { LargeFirstRuns = false }.Solve(job); + + LayoutAssert.Valid(job, result); + Assert.DoesNotContain(result.Plates[0].Placements, p => Large.Contains(p.PartId)); + } + + [Fact] + public void SmallPartsFillTheLargePlatesSheets() + { + var job = BrazeCasing(); + + var result = new RectanglesNestingEngine().Solve(job); + var costFirst = new RectanglesNestingEngine { LargeFirstRuns = false }.Solve(job); + + LayoutAssert.Valid(job, result); + Assert.Equal(NestJobStatus.Complete, result.Status); + Assert.True(NestJobCost.Evaluate(job, result) <= NestJobCost.Evaluate(job, costFirst)); + // Only the last sheet may hold small parts alone: those its predecessors had no room for. + Assert.All(result.Plates.Take(result.Plates.Count - 1), + sheet => Assert.Contains(sheet.Placements, p => Large.Contains(p.PartId))); + Assert.All(result.Plates.Take(result.Plates.Count - 1), + sheet => Assert.Contains(sheet.Placements, p => !Large.Contains(p.PartId))); + } +} diff --git a/OpenNest.Engine/NestingEngines/Rectangles/RectanglesNestingEngine.cs b/OpenNest.Engine/NestingEngines/Rectangles/RectanglesNestingEngine.cs index 76479a7e..d27b711d 100644 --- a/OpenNest.Engine/NestingEngines/Rectangles/RectanglesNestingEngine.cs +++ b/OpenNest.Engine/NestingEngines/Rectangles/RectanglesNestingEngine.cs @@ -35,6 +35,8 @@ public sealed class RectanglesNestingEngine : INestingEngine // Instance-owned diagnostics; no process-global counters or mutable solver state. internal Action? SheetPacked { get; init; } internal Action? BatchSelected { get; init; } + /// Tests turn the large-first runs off to compare against the cost-first run alone. + internal bool LargeFirstRuns { get; init; } = true; public NestJobResult Solve( NestJob job, @@ -55,7 +57,22 @@ public sealed class RectanglesNestingEngine : INestingEngine var demand = types.Select(t => new SheetDemand(t.Index, t.Id, t.Priority, t.MaterialArea)).ToArray(); // One run makes one whole-job plan: report it, then its commits, as the other engines do. var forward = progress == null ? null : new CandidateProgress(progress); - var result = SheetByStock.Run(job, demand, remaining, Pack, forward, token, BatchSelected); + var result = SheetByStock.Run(job, demand, remaining.ToArray(), Pack, forward, token, BatchSelected); + // Sheet by sheet, cost picks the densest sheet, which on a job mixing large plates with + // small parts packs the small parts onto early sheets of their own and leaves the large + // plates' sheets nothing to fill their gaps. Large-first runs nest the large parts alone, + // fill each of their sheets' gaps with the small parts, and only then start new sheets for + // what is left. The cheapest whole job wins; ties keep the cost-first run. + var best = Score(result, 0); + var order = 1; + foreach (var split in LargeFirstRuns ? LargeSplits(types, remaining) : Enumerable.Empty()) + { + token.ThrowIfCancellationRequested(); + var scored = Score(LargeFirst(split), order++); + if (scored.IsBetterThan(best)) + best = scored; + } + result = best.Result; CandidateProgress.ReportPlan(result, progress); CandidateProgress.ReportCommits(result, progress, token); return result; @@ -85,10 +102,82 @@ public sealed class RectanglesNestingEngine : INestingEngine return plans; } + NestJobResult LargeFirst(double split) + { + var large = types.Select(t => t.BoxArea >= split).ToArray(); + var small = remaining.Select((r, i) => large[i] ? 0 : r).ToArray(); + var sheets = SheetByStock.Run(job, demand, remaining.Select((r, i) => large[i] ? r : 0).ToArray(), + Pack, forward, token); + var stocks = job.Plates.ToDictionary(p => p.Id, StringComparer.Ordinal); + var index = types.ToDictionary(t => t.Id, t => t.Index, StringComparer.Ordinal); + var filled = new List(sheets.Plates.Count); + foreach (var sheet in sheets.Plates) + { + token.ThrowIfCancellationRequested(); + var stock = stocks[sheet.StockId]; + var own = new int[types.Count]; + foreach (var p in sheet.Placements) + own[index[p.PartId]]++; + var poses = sheet.Placements.Select(p => (p.PartId, p.X, p.Y, p.Rotation)).ToArray(); + var layout = new SheetLayout(stock, poses, types.Sum(t => own[t.Index] * t.MaterialArea), null); + if (small.Any(r => r > 0)) + { + // Repack the sheet's own large parts with every small part still waiting; + // a plan counts only if it keeps all of the sheet's large parts. + var wanted = own.Select((n, i) => n + small[i]).ToArray(); + SheetPlan? fill = null; + foreach (var plan in PackAll(stock, wanted, null, null)) + { + var counts = new int[types.Count]; + foreach (var p in plan.Parts) + counts[p.Type.Index]++; + if (types.Any(t => large[t.Index] && counts[t.Index] < own[t.Index])) + continue; + if (fill == null || plan.MaterialArea > fill.MaterialArea) + fill = plan; + } + if (fill != null && fill.MaterialArea > layout.MaterialArea) + { + layout = Layout(fill); + foreach (var p in fill.Parts) + if (!large[p.Type.Index]) + small[p.Type.Index]--; + } + } + filled.Add(layout); + } + return SheetByStock.Run(job, demand, small, Pack, forward, token, prefix: filled); + } + + // Both runs come from the same validated box packer, so they rank on demand met, cost and + // offcut without a layout check. + CandidateScore Score(NestJobResult r, int at) + { + var unplaced = System.Math.Max(0, job.Parts.Sum(p => p.Quantity) - r.Plates.Sum(p => p.Placements.Count)); + return new CandidateScore(r, true, unplaced, NestJobCost.Evaluate(job, r), + NestJobCost.CompactnessOffcut(job, r), at, NestJobCost.UsesExplicitCosts(job)); + } + static SheetLayout Layout(SheetPlan plan) => new(plan.Stock, plan.Poses().ToArray(), plan.MaterialArea, plan.Envelope); } + /// Box-area thresholds splitting the job's types into large and small: below each of + /// the widest drops in box area (to half or less of the next larger type), at most + /// , widest first. + private static IEnumerable LargeSplits(IReadOnlyList types, int[] remaining) + { + var areas = types.Where(t => remaining[t.Index] > 0).Select(t => t.BoxArea) + .Distinct().OrderByDescending(a => a).ToArray(); + return Enumerable.Range(1, System.Math.Max(0, areas.Length - 1)) + .Where(i => areas[i] <= areas[i - 1] * 0.5) + .OrderBy(i => areas[i] / areas[i - 1]).ThenBy(i => i) + .Take(MaxLargeSplits) + .Select(i => areas[i - 1]); + } + + private const int MaxLargeSplits = 3; + private static bool FitsStock(NestPlateStock stock, BoxOrientation o) { if (stock.Outline != null) diff --git a/OpenNest.Engine/NestingEngines/SheetByStock.cs b/OpenNest.Engine/NestingEngines/SheetByStock.cs index 181f5597..0e3ba3d3 100644 --- a/OpenNest.Engine/NestingEngines/SheetByStock.cs +++ b/OpenNest.Engine/NestingEngines/SheetByStock.cs @@ -38,6 +38,8 @@ internal static class SheetByStock /// packer's completed search, not budget-limited output, so a repeat is safe. /// When set, only this stock is tried while it is available and /// takes a layout; the others are tried only once it cannot. + /// Sheets already chosen, committed first in order and counted against + /// stock and plate limits; must already exclude their parts. public static NestJobResult Run( NestJob job, IReadOnlyList types, @@ -46,12 +48,18 @@ internal static class SheetByStock IProgress? progress, CancellationToken token, Action? batchSelected = null, - NestPlateStock? preferred = null) + NestPlateStock? preferred = null, + IReadOnlyList? prefix = null) { var used = job.Plates.ToDictionary(s => s.Id, _ => 0, StringComparer.Ordinal); var parts = job.Parts.ToDictionary(p => p.Id, StringComparer.Ordinal); var priority = types.ToDictionary(t => t.Id, t => t.Priority, StringComparer.Ordinal); var result = new NestJobResultBuilder(job, progress); + foreach (var sheet in prefix ?? Array.Empty()) + { + result.AddSheet(sheet.Stock, sheet.Poses); + used[sheet.Stock.Id]++; + } NestJobStopReason reason; while (true) diff --git a/docs/nesting-engines.md b/docs/nesting-engines.md index e7e727ac..11347b81 100644 --- a/docs/nesting-engines.md +++ b/docs/nesting-engines.md @@ -12,7 +12,7 @@ in `OpenNest.Engine/NestingEngines//`, its tests in `OpenNest.Engine.Tests | Engine | Best for | Method | |---|---|---| | Default | Any job; used when no engine is named | Runs Irregular, Rectangles and Circles, checks each layout with the layout check and keeps the best: valid first, then fewest unplaced parts, then lowest salvage-credited cost, then the largest compactness offcut; remaining ties keep the engine listed first here | -| Rectangles | Plain and near-rectangular plates | Each part packed as the box of its material at its minimum-area rotation, using a maximal-rectangles free list; the sheet that finishes the job is also squeezed into a shorter or narrower bin; stock chosen sheet by sheet by salvage-credited look-ahead cost | +| Rectangles | Plain and near-rectangular plates | Each part packed as the box of its material at its minimum-area rotation, using a maximal-rectangles free list; the sheet that finishes the job is also squeezed into a shorter or narrower bin; stock chosen sheet by sheet by salvage-credited look-ahead cost, and the whole job also run large parts first with the small parts filling their sheets' gaps | | Circles | Round parts: blanks, washers, flanges, gears by their tip circle | Each part packed as its minimum enclosing circle at centers tangent to two of walls, placed discs and clamp keep-outs, with hexagonal and square lattice seeds; bids only when every part is round; stock chosen as Rectangles does, plus whole-job runs preferring each stock and a tail re-plan | | Irregular | Irregular profiles | No-fit-polygon frontier packing with gap filling and best-fit pairs, six whole-job strategy variants (each also keeping a stock that finished the job when the per-sheet estimate passed it over for a plan that ended up dearer) and a tail re-plan, then grouped variants that pack like parts together, then a banded variant that packs each sheet in full-height strips, each group as its Lattice band or each strip from the largest parts down, then a sheet-reduction pass that packs edge parts first and turns a key part by its contacts, then a squeeze that packs the last sheet again, largest part first, in ever shorter strips; under a time limit it first reports a quick plan without Lattice blocks, and after its search keeps trying seeded variants until the limit | | FlatBar | Flat bar: parts about as wide as the bar | Each stock read as a bar and cut in one row: the CutList cut-list packer and a best-fill search on part lengths less their self-nesting gain, then a slide-left pass that nests shaped ends and refills freed length; stock chosen bar by bar by whole-plan cost | @@ -64,6 +64,24 @@ Rectangles places irregular parts validly, but only as their bounding boxes; it notch or hole. Box sides account for how the layout check flattens arcs, so round-edged parts stay valid at box contact. +#### Large parts first + +Picking each sheet by its look-ahead cost favors the densest sheet, and a sheet of small parts +packs densest. On a job mixing large plates with small parts that spends the first sheets on the +small parts alone and leaves each large plate a sheet with an empty strip beside it. On one real +job (a braze casing in 3/16 steel: 35 x 57 to 65 x 89 side and cover plates, 5 x 28 angles and +9 x 4 tabs, 219 parts on five stock sizes) sheet 1 held 109 small parts and the plates followed +one or two to a sheet, 28 sheets and 220,032 sq in in all. + +So Rectangles also runs the job large parts first. The part types are split at a wide drop in box +area (to half or less of the next larger type; the three widest drops are each tried). The large +types nest alone, sheet by sheet as usual; then each of their sheets, in order, is packed again with +its own large parts and every small part still waiting, keeping the packing that places the most +material without dropping one of its large parts; whatever small parts are left get new sheets of +their own. The cheapest whole job wins (then the larger compactness offcut); a tie keeps the +cost-first run. The braze casing now takes 27 sheets and 203,616 sq in, every sheet but the last +holding a plate with small parts in its gaps. + #### Squeezing the last sheet The fit rules pack into the whole sheet, so when the last sheet has room to spare they spread the