aj/OpenNest
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

refactor(engine): extract default and remnant plate fillers

Browse Source
This commit is contained in:
aj
2026-09-21 15:27:03 -04:00
parent eafa0fab01
commit e69ec07830
8 changed files with 1003 additions and 533 deletions
Download Patch File Download Diff File Expand all files Collapse all files
OpenNest.Engine/DefaultNestEngine.cs
+124 -427
View File
@@ -1,20 +1,18 @@
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using OpenNest.Engine;
using OpenNest.Engine.BestFit;
using OpenNest.Engine.Fill;
using OpenNest.Engine.Jobs.Placement.Fillers;
using OpenNest.Engine.Strategies;
using OpenNest.Geometry;
using OpenNest.Math;
using OpenNest.Engine.RectanglePacking;
namespace OpenNest.Engine
{
public class DefaultNestEngine : NestEngineBase
{
private DefaultPlateFiller filler;
private bool forceFullAngleSweep;
public DefaultNestEngine(Plate plate)
: base(plate) { }
@@ -23,29 +21,70 @@ namespace OpenNest.Engine
public override string Description =>
"Multi-phase nesting (Linear, Pairs, RectBestFit, Extents)";
private readonly AngleCandidateBuilder angleBuilder = new();
public override NestPhase WinnerPhase
{
get => Filler.WinnerPhase;
protected set => Filler.SetWinnerPhase(value);
}
public override List<PhaseResult> PhaseResults => Filler.PhaseResults;
public override List<AngleResult> AngleResults => Filler.AngleResults;
public bool ForceFullAngleSweep
{
get => angleBuilder.ForceFullSweep;
set => angleBuilder.ForceFullSweep = value;
get => forceFullAngleSweep;
set
{
forceFullAngleSweep = value;
if (filler != null)
filler.ForceFullAngleSweep = value;
}
}
private DefaultPlateFiller Filler
{
get
{
if (filler == null || !ReferenceEquals(filler.Plate, Plate))
{
filler = CreateFiller(Plate);
filler.ForceFullAngleSweep = forceFullAngleSweep;
}
return filler;
}
}
private DefaultPlateFiller PrepareFiller()
{
var current = Filler;
current.PlateNumber = PlateNumber;
current.NestDirection = NestDirection;
return current;
}
internal virtual DefaultPlateFiller CreateFiller(Plate plate) =>
new LegacyDefaultPlateFiller(this, plate);
internal DefaultPlateFiller CreateRemnantFiller(Plate plate, RemnantFillPolicy policy) =>
new LegacyRemnantPlateFiller(this, plate, policy);
protected override IFillComparer CreateComparer() => Filler.CreateComparerCore();
public override NestDirection? PreferredDirection => null;
public override ShrinkAxis TrimAxis => ShrinkAxis.Width;
public override List<double> BuildAngles(
NestItem item,
ClassificationResult classification,
Box workArea
)
{
return angleBuilder.Build(item, classification, workArea);
}
) => Filler.BuildAnglesCore(item, classification, workArea);
protected override void RecordProductiveAngles(List<AngleResult> angleResults)
{
angleBuilder.RecordProductive(angleResults);
}
protected override void RecordProductiveAngles(List<AngleResult> angleResults) =>
Filler.RecordProductiveAnglesCore(angleResults);
// --- Public Fill API ---
protected virtual void RunPipeline(FillContext context) => Filler.RunPipelineCore(context);
public override List<Part> Fill(
NestItem item,
@@ -54,305 +93,8 @@ namespace OpenNest.Engine
CancellationToken token
)
{
PhaseResults.Clear();
AngleResults.Clear();
// Replace the item's Drawing with a canonical copy for the duration of this fill.
// All internal methods see canonical geometry; this wrapper un-canonicalizes the final result.
var originalDrawing = item.Drawing;
var canonicalItem = new NestItem
{
Drawing = CanonicalFrame.AsCanonicalCopy(item.Drawing),
Quantity = item.Quantity,
Priority = item.Priority,
RotationStart = item.RotationStart,
RotationEnd = item.RotationEnd,
StepAngle = item.StepAngle,
};
// Fast path for qty 1-2.
if (canonicalItem.Quantity > 0 && canonicalItem.Quantity <= 2)
{
var fast = TryFillSmallQuantity(canonicalItem, workArea);
if (fast != null && fast.Count >= canonicalItem.Quantity)
{
Debug.WriteLine(
$"[Fill] Fast path: placed {fast.Count} parts for qty={canonicalItem.Quantity}"
);
WinnerPhase = NestPhase.Pairs;
fast = RebindAndUnCanonicalize(fast, originalDrawing);
ReportProgress(
progress,
new ProgressReport
{
Phase = WinnerPhase,
PlateNumber = PlateNumber,
Parts = fast,
WorkArea = workArea,
Description = $"Fast path: {fast.Count} parts",
IsOverallBest = true,
}
);
return fast;
}
}
var effectiveWorkArea = workArea;
if (canonicalItem.Quantity > 0)
{
effectiveWorkArea = ShrinkWorkArea(canonicalItem, workArea, Plate.PartSpacing);
if (effectiveWorkArea != workArea)
Debug.WriteLine(
$"[Fill] Low-qty shrink: {canonicalItem.Quantity} requested, "
+ $"from {workArea.Width:F1}x{workArea.Length:F1} "
+ $"to {effectiveWorkArea.Width:F1}x{effectiveWorkArea.Length:F1}"
);
}
var best = RunFillPipeline(canonicalItem, effectiveWorkArea, progress, token);
if (
canonicalItem.Quantity > 0
&& best.Count < canonicalItem.Quantity
&& effectiveWorkArea != workArea
)
{
Debug.WriteLine(
$"[Fill] Low-qty fallback: got {best.Count}, need {canonicalItem.Quantity}, retrying full area"
);
PhaseResults.Clear();
AngleResults.Clear();
best = RunFillPipeline(canonicalItem, workArea, progress, token);
}
if (canonicalItem.Quantity > 0 && best.Count > canonicalItem.Quantity)
best = ShrinkFiller.TrimToCount(best, canonicalItem.Quantity, TrimAxis);
best = RebindAndUnCanonicalize(best, originalDrawing);
ReportProgress(
progress,
new ProgressReport
{
Phase = WinnerPhase,
PlateNumber = PlateNumber,
Parts = best,
WorkArea = workArea,
Description = BuildProgressSummary(),
IsOverallBest = true,
}
);
return best;
}
/// <summary>
/// Single exit point for canonical -> source frame conversion. Rebinds every Part to the
/// original Drawing (so consumers see the user's drawing identity, not the transient canonical copy)
/// and composes the canonical angle onto each Part's rotation via CanonicalFrame.RebindToOriginal.
/// </summary>
private static List<Part> RebindAndUnCanonicalize(List<Part> parts, Drawing original) =>
CanonicalFrame.RebindToOriginal(parts, original);
/// <summary>
/// Fast path for qty 1-2: place a single part or a best-fit pair
/// without running the full strategy pipeline.
/// </summary>
private List<Part> TryFillSmallQuantity(NestItem item, Box workArea)
{
if (item.Quantity == 1)
return TryPlaceSingle(item.Drawing, workArea);
if (item.Quantity == 2)
return TryPlaceBestFitPair(item.Drawing, workArea);
return null;
}
private static List<Part> TryPlaceSingle(Drawing drawing, Box workArea)
{
var part = Part.CreateAtOrigin(drawing);
if (
part.BoundingBox.Width > workArea.Width + Tolerance.Epsilon
|| part.BoundingBox.Length > workArea.Length + Tolerance.Epsilon
)
return null;
part.Offset(workArea.Location - part.BoundingBox.Location);
return new List<Part> { part };
}
private List<Part> TryPlaceBestFitPair(Drawing drawing, Box workArea)
{
var bestFits = BestFitCache.GetOrCompute(
drawing,
Plate.Size.Length,
Plate.Size.Width,
Plate.PartSpacing
);
// Build pair candidates with a canonical drawing so their geometry matches
// the coordinate frame of the cached fit results.
var canonicalDrawing = CanonicalFrame.AsCanonicalCopy(drawing);
List<Part> bestPlacement = null;
foreach (var fit in bestFits)
{
if (!fit.Keep)
continue;
// Skip pairs that can't possibly fit the work area in either orientation.
if (
fit.ShortestSide
> System.Math.Min(workArea.Width, workArea.Length) + Tolerance.Epsilon
)
continue;
if (
fit.LongestSide
> System.Math.Max(workArea.Width, workArea.Length) + Tolerance.Epsilon
)
continue;
var landscape = fit.BuildParts(canonicalDrawing);
var portrait = RotatePair90(landscape);
var lFits = TryOffsetToWorkArea(landscape, workArea);
var pFits = TryOffsetToWorkArea(portrait, workArea);
// Pick the better orientation for this pair.
List<Part> candidate = null;
if (lFits && pFits)
candidate = IsBetterFill(portrait, landscape, workArea) ? portrait : landscape;
else if (lFits)
candidate = landscape;
else if (pFits)
candidate = portrait;
if (candidate == null)
continue;
if (bestPlacement == null || IsBetterFill(candidate, bestPlacement, workArea))
bestPlacement = candidate;
}
// Parts are returned in canonical frame, bound to the canonical drawing.
// The outer Fill wrapper (Task 7) rebinds to `drawing` and composes sourceAngle onto rotation.
return bestPlacement;
}
private static List<Part> RotatePair90(List<Part> parts)
{
var rotated = new List<Part>(parts.Count);
foreach (var p in parts)
rotated.Add((Part)p.Clone());
var bbox = ((IEnumerable<IBoundable>)rotated).GetBoundingBox();
var center = bbox.Center;
foreach (var p in rotated)
p.Rotate(-Angle.HalfPI, center);
var newBbox = ((IEnumerable<IBoundable>)rotated).GetBoundingBox();
var offset = new Vector(-newBbox.Left, -newBbox.Bottom);
foreach (var p in rotated)
{
p.Offset(offset);
p.UpdateBounds();
}
return rotated;
}
private static bool TryOffsetToWorkArea(List<Part> parts, Box workArea)
{
var bbox = ((IEnumerable<IBoundable>)parts).GetBoundingBox();
if (
bbox.Width > workArea.Width + Tolerance.Epsilon
|| bbox.Length > workArea.Length + Tolerance.Epsilon
)
return false;
var offset = workArea.Location - bbox.Location;
foreach (var p in parts)
{
p.Offset(offset);
p.UpdateBounds();
}
return true;
}
/// <summary>
/// Shrinks the work area in both dimensions proportionally when the
/// requested quantity is much less than the plate capacity.
/// </summary>
private static Box ShrinkWorkArea(NestItem item, Box workArea, double spacing)
{
var bbox = item.Drawing.Program.BoundingBox();
if (bbox.Width <= 0 || bbox.Length <= 0)
return workArea;
var bin = new Bin { Size = new Size(workArea.Width, workArea.Length) };
var packItem = new Item
{
Size = new Size(bbox.Width + spacing, bbox.Length + spacing),
};
var packer = new FillBestFit(bin);
packer.Fill(packItem);
var fullCount = bin.Items.Count;
if (fullCount <= 0 || fullCount <= item.Quantity)
return workArea;
// Scale both dimensions by sqrt(ratio) so the area shrinks
// proportionally. 2x margin gives strategies room to optimize.
var ratio = (double)item.Quantity / fullCount;
var scale = System.Math.Sqrt(ratio) * 2.0;
var newWidth = workArea.Width * scale;
var newLength = workArea.Length * scale;
// Ensure at least one part fits.
var minWidth = bbox.Width + spacing * 2;
var minLength = bbox.Length + spacing * 2;
newWidth = System.Math.Max(newWidth, minWidth);
newLength = System.Math.Max(newLength, minLength);
// Clamp to original dimensions.
newWidth = System.Math.Min(newWidth, workArea.Width);
newLength = System.Math.Min(newLength, workArea.Length);
if (newWidth >= workArea.Width && newLength >= workArea.Length)
return workArea;
return new Box(workArea.X, workArea.Y, newLength, newWidth);
}
private List<Part> RunFillPipeline(
NestItem item,
Box workArea,
IProgress<NestProgress> progress,
CancellationToken token
)
{
var context = new FillContext
{
Item = item,
WorkArea = workArea,
Plate = Plate,
PlateNumber = PlateNumber,
Token = token,
Progress = progress,
Policy = BuildPolicy(),
MaxQuantity = item.Quantity,
};
RunPipeline(context);
AngleResults.AddRange(context.AngleResults);
WinnerPhase = context.WinnerPhase;
return context.CurrentBest ?? new List<Part>();
var current = PrepareFiller();
return current.Fill(item, workArea, progress, token);
}
public override List<Part> Fill(
@@ -362,45 +104,10 @@ namespace OpenNest.Engine
CancellationToken token
)
{
if (groupParts == null || groupParts.Count == 0)
return new List<Part>();
// Single part: delegate to the strategy pipeline.
if (groupParts.Count == 1)
{
var nestItem = new NestItem { Drawing = groupParts[0].BaseDrawing };
return Fill(nestItem, workArea, progress, token);
}
// Multi-part group: linear pattern fill only.
PhaseResults.Clear();
var engine = new FillLinear(workArea, Plate.PartSpacing) { Label = "GroupPattern" };
var angles = RotationAnalysis.FindHullEdgeAngles(groupParts);
var best = FillHelpers.FillPattern(engine, groupParts, angles, workArea, Comparer);
PhaseResults.Add(new PhaseResult(NestPhase.Linear, best?.Count ?? 0, 0));
Debug.WriteLine(
$"[Fill(groupParts,Box)] Linear pattern: {best?.Count ?? 0} parts | WorkArea: {workArea.Width:F1}x{workArea.Length:F1}"
);
ReportProgress(
progress,
new ProgressReport
{
Phase = NestPhase.Linear,
PlateNumber = PlateNumber,
Parts = best,
WorkArea = workArea,
Description = BuildProgressSummary(),
IsOverallBest = true,
}
);
return best ?? new List<Part>();
var current = PrepareFiller();
return current.Fill(groupParts, workArea, progress, token);
}
// --- Pack API ---
public override List<Part> PackArea(
Box box,
List<NestItem> items,
@@ -408,87 +115,77 @@ namespace OpenNest.Engine
CancellationToken token
)
{
var binItems = BinConverter.ToItems(items, Plate.PartSpacing, Plate.Area());
var bin = BinConverter.CreateBin(box, Plate.PartSpacing);
var engine = new PackBottomLeft(bin);
engine.Pack(binItems);
return BinConverter.ToParts(bin, items);
var current = PrepareFiller();
return current.PackArea(box, items, progress, token);
}
// --- RunPipeline: strategy-based orchestration ---
protected virtual void RunPipeline(FillContext context)
public override List<Part> Nest(
List<NestItem> items,
IProgress<NestProgress> progress,
CancellationToken token
)
{
var classification = PartClassifier.Classify(context.Item.Drawing);
context.PartType = classification.Type;
context.SharedState["BestRotation"] = classification.PrimaryAngle;
context.SharedState["Classification"] = classification;
return base.Nest(items, progress, token);
}
var angles = BuildAngles(context.Item, classification, context.WorkArea);
context.SharedState["AngleCandidates"] = angles;
private sealed class LegacyDefaultPlateFiller : DefaultPlateFiller
{
private readonly DefaultNestEngine engine;
try
internal LegacyDefaultPlateFiller(DefaultNestEngine engine, Plate plate)
: base(plate)
{
foreach (var strategy in FillStrategyRegistry.Strategies)
{
context.Token.ThrowIfCancellationRequested();
context.ActivePhase = strategy.Phase;
var sw = Stopwatch.StartNew();
var result = strategy.Fill(context);
sw.Stop();
var phaseResult = new PhaseResult(
strategy.Phase,
result?.Count ?? 0,
sw.ElapsedMilliseconds
);
context.PhaseResults.Add(phaseResult);
// Keep engine's PhaseResults in sync so BuildProgressSummary() works
// during progress reporting.
PhaseResults.Add(phaseResult);
// FillContext.ReportProgress updates CurrentBest during the
// strategy's angle sweep. This catches strategies that return a
// result without reporting it (e.g. RectBestFit).
var improved = context.Policy.Comparer.IsBetter(
result,
context.CurrentBest,
context.WorkArea
);
if (improved)
{
context.CurrentBest = result;
context.CurrentBestScore = FillScore.Compute(result, context.WorkArea);
context.WinnerPhase = strategy.Phase;
}
if (improved && context.CurrentBest != null && context.CurrentBest.Count > 0)
{
ReportProgress(
context.Progress,
new ProgressReport
{
Phase = context.WinnerPhase,
PlateNumber = PlateNumber,
Parts = context.CurrentBest,
WorkArea = context.WorkArea,
Description = BuildProgressSummary(),
IsOverallBest = true,
}
);
}
}
}
catch (OperationCanceledException)
{
Debug.WriteLine("[RunPipeline] Cancelled, returning current best");
this.engine = engine;
}
RecordProductiveAngles(context.AngleResults);
protected override IFillComparer CreateComparer() => engine.CreateComparer();
public override NestDirection? PreferredDirection => engine.PreferredDirection;
public override ShrinkAxis TrimAxis => engine.TrimAxis;
public override List<double> BuildAngles(
NestItem item,
ClassificationResult classification,
Box workArea
) => engine.BuildAngles(item, classification, workArea);
protected override void RecordProductiveAngles(List<AngleResult> angleResults) =>
engine.RecordProductiveAngles(angleResults);
protected override void RunPipeline(FillContext context) => engine.RunPipeline(context);
}
private sealed class LegacyRemnantPlateFiller : RemnantPlateFiller
{
private readonly DefaultNestEngine engine;
internal LegacyRemnantPlateFiller(
DefaultNestEngine engine,
Plate plate,
RemnantFillPolicy policy
)
: base(plate, policy)
{
this.engine = engine;
}
protected override IFillComparer CreateComparer() => engine.CreateComparer();
public override NestDirection? PreferredDirection => engine.PreferredDirection;
public override ShrinkAxis TrimAxis => engine.TrimAxis;
public override List<double> BuildAngles(
NestItem item,
ClassificationResult classification,
Box workArea
) => engine.BuildAngles(item, classification, workArea);
protected override void RecordProductiveAngles(List<AngleResult> angleResults) =>
engine.RecordProductiveAngles(angleResults);
protected override void RunPipeline(FillContext context) => engine.RunPipeline(context);
}
}
}