refactor(engine): extract default and remnant plate fillers

OpenNest.Engine/Jobs/Placement/Fillers/PlateFillerBase.cs

@@ -1,10 +1,12 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Threading;
 using OpenNest.Engine;
 using OpenNest.Engine.Fill;
 using OpenNest.Engine.Strategies;
 using OpenNest.Geometry;
+using OpenNest.Math;
 
 namespace OpenNest.Engine.Jobs.Placement.Fillers;
 
@@ -25,6 +27,11 @@ internal abstract class PlateFillerBase
 
     public NestPhase WinnerPhase { get; protected set; }
 
+    internal void SetWinnerPhase(NestPhase winnerPhase)
+    {
+        WinnerPhase = winnerPhase;
+    }
+
     public List<PhaseResult> PhaseResults { get; } = new();
 
     public List<AngleResult> AngleResults { get; } = new();
@@ -54,6 +61,88 @@ internal abstract class PlateFillerBase
 
     protected FillPolicy BuildPolicy() => new(Comparer, PreferredDirection);
 
+    internal IFillComparer FillComparer => Comparer;
+
+    protected string BuildProgressSummary() => BuildProgressSummary(PhaseResults);
+
+    internal static string BuildProgressSummary(IReadOnlyList<PhaseResult> phaseResults)
+    {
+        if (phaseResults.Count == 0)
+            return null;
+
+        var parts = new List<string>(phaseResults.Count);
+        foreach (var result in phaseResults)
+            parts.Add($"{result.Phase.ShortName()}: {result.PartCount}");
+
+        return string.Join(" | ", parts);
+    }
+
+    protected bool IsBetterFill(List<Part> candidate, List<Part> current, Box workArea) =>
+        IsBetterFill(Comparer, candidate, current, workArea);
+
+    internal static bool IsBetterFill(
+        IFillComparer comparer,
+        List<Part> candidate,
+        List<Part> current,
+        Box workArea
+    ) => comparer.IsBetter(candidate, current, workArea);
+
+    protected bool IsBetterValidFill(List<Part> candidate, List<Part> current, Box workArea)
+    {
+        if (
+            candidate != null
+            && candidate.Count > 0
+            && HasOverlaps(candidate, Plate.PartSpacing)
+        )
+        {
+            Debug.WriteLine(
+                $"[IsBetterValidFill] REJECTED {candidate.Count} parts due to overlaps (current best: {current?.Count ?? 0})"
+            );
+            return false;
+        }
+
+        return IsBetterFill(candidate, current, workArea);
+    }
+
+    internal static bool HasOverlaps(List<Part> parts, double spacing)
+    {
+        if (parts == null || parts.Count <= 1)
+            return false;
+
+        for (var i = 0; i < parts.Count; i++)
+        {
+            var box1 = parts[i].BoundingBox;
+
+            for (var j = i + 1; j < parts.Count; j++)
+            {
+                var box2 = parts[j].BoundingBox;
+
+                var overlapX = System.Math.Min(box1.Right, box2.Right)
+                    - System.Math.Max(box1.Left, box2.Left);
+                var overlapY = System.Math.Min(box1.Top, box2.Top)
+                    - System.Math.Max(box1.Bottom, box2.Bottom);
+
+                if (overlapX <= Tolerance.Epsilon || overlapY <= Tolerance.Epsilon)
+                    continue;
+
+                List<Vector> points;
+                if (parts[i].Intersects(parts[j], out points))
+                {
+                    var first = parts[i].BoundingBox;
+                    var second = parts[j].BoundingBox;
+                    Debug.WriteLine(
+                        $"[HasOverlaps] Overlap: part[{i}] ({parts[i].BaseDrawing?.Name}) @ ({first.Left:F2},{first.Bottom:F2})-({first.Right:F2},{first.Top:F2}) rot={parts[i].Rotation:F2}"
+                            + $" vs part[{j}] ({parts[j].BaseDrawing?.Name}) @ ({second.Left:F2},{second.Bottom:F2})-({second.Right:F2},{second.Top:F2}) rot={parts[j].Rotation:F2}"
+                            + $" intersections={points?.Count ?? 0}"
+                    );
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     public virtual List<Part> Fill(
         NestItem item,
         Box workArea,