perf(fill): skip feature extraction without an angle model

2026-09-26 10:02:15 -04:00
parent d70505b7c0
commit 1e8e532063
9 changed files with 869 additions and 42 deletions
@@ -1,10 +1,13 @@
 using OpenNest.Engine;
 using OpenNest.Engine.Fill;
+using OpenNest.Engine.ML;
 using OpenNest.Geometry;
 using OpenNest.Math;

 namespace OpenNest.Tests.Fill;

+// The Debug integration check uses process-wide PerfCounters.
+[Collection(nameof(OpenNest.Tests.BestFit.FillCacheCollection))]
 public class AngleCandidateBuilderTests
 {
    private static Drawing MakeRectDrawing(double w, double h)
@@ -23,6 +26,387 @@ public class AngleCandidateBuilderTests
        PartType type = PartType.Irregular
    ) => new ClassificationResult { PrimaryAngle = primaryAngle, Type = type };

+    [Theory]
+    [InlineData(PartType.Circle)]
+    [InlineData(PartType.Rectangle)]
+    public void Characterization_ClassifiedParts_PreserveExactBaseAngleOrder(PartType type)
+    {
+        var builder = new AngleCandidateBuilder();
+        var item = new NestItem { Drawing = MakeRectDrawing(20, 10) };
+        var primary = Angle.ToRadians(7);
+
+        var angles = builder.Build(item, MakeClassification(primary, type), new Box(0, 0, 100, 50));
+
+        var expected = type == PartType.Circle ? new[] { 0.0 } : new[] { primary, primary + Angle.HalfPI };
+        Assert.Equal(expected, angles);
+    }
+
+    [Theory]
+    [InlineData(PartType.Circle)]
+    [InlineData(PartType.Rectangle)]
+    [InlineData(PartType.Irregular)]
+    public void Characterization_Constraints_OverrideEveryClassification(PartType type)
+    {
+        var builder = new AngleCandidateBuilder();
+        var item = new NestItem
+        {
+            Drawing = MakeRectDrawing(20, 10),
+            RotationStart = 0,
+            RotationEnd = Angle.HalfPI,
+            StepAngle = Angle.ToRadians(30),
+        };
+
+        var angles = builder.Build(item, MakeClassification(0.1, type), new Box(0, 0, 100, 50));
+
+        AssertAngleOrder(new[] { 0.0, 30, 60, 90 }.Select(Angle.ToRadians), angles);
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(-1)]
+    public void Characterization_NonpositiveConstraintStep_UsesFiveDegrees(double step)
+    {
+        var builder = new AngleCandidateBuilder();
+        var item = new NestItem
+        {
+            Drawing = MakeRectDrawing(20, 10),
+            RotationStart = Angle.ToRadians(10),
+            RotationEnd = Angle.ToRadians(20),
+            StepAngle = step,
+        };
+
+        var angles = builder.Build(item, MakeClassification(), new Box(0, 0, 100, 50));
+
+        AssertAngleOrder(new[] { 10.0, 15, 20 }.Select(Angle.ToRadians), angles);
+    }
+
+    [Fact]
+    public void Characterization_ReversedConstraints_FallBackToStart()
+    {
+        var builder = new AngleCandidateBuilder();
+        var item = new NestItem
+        {
+            Drawing = MakeRectDrawing(20, 10),
+            RotationStart = Angle.ToRadians(40),
+            RotationEnd = Angle.ToRadians(10),
+        };
+
+        var angles = builder.Build(item, MakeClassification(), new Box(0, 0, 100, 50));
+
+        Assert.Equal(new[] { item.RotationStart }, angles);
+    }
+
+    [Fact]
+    public void Characterization_KnownGoodAngles_PreserveBaseOrderAndPruning()
+    {
+        var builder = new AngleCandidateBuilder();
+        builder.RecordProductive(new List<AngleResult>
+        {
+            new() { AngleDeg = 0, PartCount = 1 },
+            new() { AngleDeg = 45, PartCount = 2 },
+            new() { AngleDeg = 45, PartCount = 3 },
+            new() { AngleDeg = 97, PartCount = 1 },
+            new() { AngleDeg = 65, PartCount = 0 },
+            new() { AngleDeg = 120, PartCount = -1 },
+        });
+        var item = new NestItem { Drawing = MakeRectDrawing(20, 10) };
+
+        var angles = builder.Build(item, MakeClassification(Angle.ToRadians(7)), new Box(0, 0, 100, 50));
+
+        AssertAngleOrder(new[] { 7.0, 97, 0, 45 }.Select(Angle.ToRadians), angles);
+    }
+
+    private static void AssertAngleOrder(IEnumerable<double> expected, List<double> actual)
+    {
+        var values = expected.ToArray();
+        Assert.Equal(values.Length, actual.Count);
+        for (var i = 0; i < values.Length; i++)
+            Assert.Equal(values[i], actual[i], precision: 12);
+    }
+
+    // These delegates are deterministic control-flow doubles, not ONNX accuracy evidence.
+    private sealed class PredictionCalls
+    {
+        public bool Available { get; set; } = true;
+        public PartFeatures? Features { get; set; } = new();
+        public List<double>? Prediction { get; set; }
+        public List<string> Calls { get; } = new();
+        public Drawing? ExtractedDrawing { get; private set; }
+        public bool? IncludeBitmask { get; private set; }
+        public PartFeatures? PredictedFeatures { get; private set; }
+        public double SheetWidth { get; private set; }
+        public double SheetHeight { get; private set; }
+
+        public AngleCandidateBuilder CreateBuilder() => new(
+            () =>
+            {
+                Calls.Add("available");
+                return Available;
+            },
+            (drawing, includeBitmask) =>
+            {
+                Calls.Add("extract");
+                ExtractedDrawing = drawing;
+                IncludeBitmask = includeBitmask;
+                return Features!;
+            },
+            (features, width, height) =>
+            {
+                Calls.Add("predict");
+                PredictedFeatures = features;
+                SheetWidth = width;
+                SheetHeight = height;
+                return Prediction!;
+            });
+    }
+
+    // The existing repeated-add sweep includes a final value just below PI (near 180°).
+    // Preserve it: replacing the loop with 36 integer-indexed samples changes behavior.
+    private static IEnumerable<double> FallbackAngles() =>
+        new[] { 7.0, 97 }.Concat(Enumerable.Range(0, 37).Select(i => i * 5.0)).Select(Angle.ToRadians);
+
+    [Fact]
+    public void Build_Unavailable_SkipsExtractionAndPrediction_PreservesFallbackOrder()
+    {
+        var calls = new PredictionCalls { Available = false };
+        var builder = calls.CreateBuilder();
+        var item = new NestItem { Drawing = MakeRectDrawing(20, 10) };
+
+        var angles = builder.Build(item, MakeClassification(Angle.ToRadians(7)), new Box(0, 0, 100, 50));
+
+        Assert.Equal(new[] { "available" }, calls.Calls);
+        AssertAngleOrder(FallbackAngles(), angles);
+    }
+
+    [Fact]
+    public void Build_Available_ExtractsScalarsOnce_ThenForwardsFeaturesAndWorkAreaDimensions()
+    {
+        var calls = new PredictionCalls();
+        var builder = calls.CreateBuilder();
+        var item = new NestItem { Drawing = MakeRectDrawing(20, 10) };
+        var workArea = new Box(3, 5, 123, 47);
+
+        var angles = builder.Build(item, MakeClassification(Angle.ToRadians(7)), workArea);
+
+        Assert.Equal(new[] { "available", "extract", "predict" }, calls.Calls);
+        Assert.Same(item.Drawing, calls.ExtractedDrawing);
+        Assert.Equal(false, calls.IncludeBitmask);
+        Assert.Same(calls.Features, calls.PredictedFeatures);
+        // Box.Width is Y and Box.Length is X; preserve this existing argument order.
+        Assert.Equal(47, calls.SheetWidth);
+        Assert.Equal(123, calls.SheetHeight);
+        AssertAngleOrder(FallbackAngles(), angles);
+    }
+
+    [Fact]
+    public void Build_NullFeatures_SkipsPrediction_PreservesFallbackOrder()
+    {
+        var calls = new PredictionCalls { Features = null };
+        var builder = calls.CreateBuilder();
+        var item = new NestItem { Drawing = MakeRectDrawing(20, 10) };
+
+        var angles = builder.Build(item, MakeClassification(Angle.ToRadians(7)), new Box(0, 0, 100, 50));
+
+        Assert.Equal(new[] { "available", "extract" }, calls.Calls);
+        Assert.Equal(false, calls.IncludeBitmask);
+        AssertAngleOrder(FallbackAngles(), angles);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void Build_NullOrEmptyPrediction_PreservesFallbackOrder(bool empty)
+    {
+        var calls = new PredictionCalls { Prediction = empty ? new List<double>() : null };
+        var builder = calls.CreateBuilder();
+        var item = new NestItem { Drawing = MakeRectDrawing(20, 10) };
+
+        var angles = builder.Build(item, MakeClassification(Angle.ToRadians(7)), new Box(0, 0, 100, 50));
+
+        Assert.Equal(new[] { "available", "extract", "predict" }, calls.Calls);
+        AssertAngleOrder(FallbackAngles(), angles);
+        if (empty)
+        {
+            Assert.Empty(calls.Prediction!);
+            Assert.NotSame(calls.Prediction, angles);
+        }
+    }
+
+    [Fact]
+    public void Build_NonemptyPrediction_PreservesPredictionThenBaseThenSweepOrder()
+    {
+        var predicted = new[] { 42.0, 0, 97 }.Select(Angle.ToRadians).ToList();
+        var original = predicted.ToArray();
+        var calls = new PredictionCalls { Prediction = predicted };
+        var builder = calls.CreateBuilder();
+        var item = new NestItem { Drawing = MakeRectDrawing(20, 10) };
+
+        var angles = builder.Build(item, MakeClassification(Angle.ToRadians(7)), new Box(0, 0, 100, 50));
+
+        var expected = new[] { 42.0, 0, 97, 7 }
+            .Concat(Enumerable.Range(1, 36).Select(i => i * 5.0))
+            .Select(Angle.ToRadians);
+        AssertAngleOrder(expected, angles);
+        Assert.Equal(original, predicted);
+        Assert.NotSame(predicted, angles);
+        Assert.Equal(new[] { "available", "extract", "predict" }, calls.Calls);
+    }
+
+    [Fact]
+    public void Build_DuplicatePrediction_KeepsPredictionDuplicates_ButDeduplicatesAddedAnglesByTolerance()
+    {
+        var primary = Angle.ToRadians(7);
+        var predicted = new List<double>
+        {
+            Angle.ToRadians(42), Angle.ToRadians(42), primary + Tolerance.Epsilon / 2, Angle.HalfPI,
+        };
+        var original = predicted.ToArray();
+        var calls = new PredictionCalls { Prediction = predicted };
+        var builder = calls.CreateBuilder();
+        var item = new NestItem { Drawing = MakeRectDrawing(20, 10) };
+
+        var angles = builder.Build(item, MakeClassification(primary), new Box(0, 0, 100, 50));
+
+        // Existing behavior preserves the prediction prefix verbatim, even duplicates.
+        var expected = original.Concat(new[] { primary + Angle.HalfPI })
+            .Concat(Enumerable.Range(0, 37).Where(i => i != 18).Select(i => Angle.ToRadians(i * 5)));
+        AssertAngleOrder(expected, angles);
+        Assert.Equal(original, angles.Take(original.Length));
+        Assert.Equal(original, predicted);
+        Assert.NotSame(predicted, angles);
+    }
+
+    [Fact]
+    public void Build_Unavailable_WithCardinalBase_DeduplicatesSweepWithoutReordering()
+    {
+        var calls = new PredictionCalls { Available = false };
+        var item = new NestItem { Drawing = MakeRectDrawing(20, 10) };
+
+        var angles = calls.CreateBuilder().Build(item, MakeClassification(), new Box(0, 0, 100, 50));
+
+        var expected = new[] { 0.0, 90 }
+            .Concat(Enumerable.Range(1, 36).Where(i => i != 18).Select(i => i * 5.0))
+            .Select(Angle.ToRadians);
+        AssertAngleOrder(expected, angles);
+        Assert.Equal(new[] { "available" }, calls.Calls);
+    }
+
+    [Theory]
+    [InlineData("circle")]
+    [InlineData("rectangle")]
+    [InlineData("constraints-circle")]
+    [InlineData("constraints-rectangle")]
+    [InlineData("constraints-irregular")]
+    [InlineData("known-good")]
+    public void Build_BypassBranches_DoNotCheckAvailabilityOrExtractOrPredict(string branch)
+    {
+        var calls = new PredictionCalls();
+        var builder = calls.CreateBuilder();
+        var item = new NestItem { Drawing = MakeRectDrawing(20, 10) };
+        var classification = MakeClassification(Angle.ToRadians(7));
+        var expected = new[] { 7.0, 97, 45 };
+        if (branch.EndsWith("circle"))
+        {
+            classification.Type = PartType.Circle;
+            expected = new[] { 0.0 };
+        }
+        else if (branch.EndsWith("rectangle"))
+        {
+            classification.Type = PartType.Rectangle;
+            expected = new[] { 7.0, 97 };
+        }
+        if (branch.StartsWith("constraints-"))
+        {
+            item.RotationStart = Angle.ToRadians(10);
+            item.RotationEnd = Angle.ToRadians(20);
+            item.StepAngle = 0;
+            expected = new[] { 10.0, 15, 20 };
+        }
+        if (branch == "known-good")
+            builder.RecordProductive(new List<AngleResult> { new() { AngleDeg = 45, PartCount = 1 } });
+
+        var angles = builder.Build(item, classification, new Box(0, 0, 100, 50));
+
+        Assert.Empty(calls.Calls);
+        AssertAngleOrder(expected.Select(Angle.ToRadians), angles);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void Build_ForceFullSweep_IgnoresKnownGoodPruning_AndStillHonorsAvailability(bool available)
+    {
+        var calls = new PredictionCalls { Available = available };
+        var builder = calls.CreateBuilder();
+        builder.ForceFullSweep = true;
+        builder.RecordProductive(new List<AngleResult> { new() { AngleDeg = 45, PartCount = 1 } });
+        var item = new NestItem { Drawing = MakeRectDrawing(20, 10) };
+
+        var angles = builder.Build(item, MakeClassification(Angle.ToRadians(7)), new Box(0, 0, 100, 50));
+
+        AssertAngleOrder(FallbackAngles(), angles);
+        Assert.Equal(available ? new[] { "available", "extract", "predict" } : new[] { "available" }, calls.Calls);
+    }
+
+    [Fact]
+    public void Build_OnlyNonproductiveAngles_DoNotPruneOrBypassAvailability()
+    {
+        var calls = new PredictionCalls { Available = false };
+        var builder = calls.CreateBuilder();
+        builder.RecordProductive(new List<AngleResult>
+        {
+            new() { AngleDeg = 45, PartCount = 0 },
+            new() { AngleDeg = 60, PartCount = -1 },
+        });
+        var item = new NestItem { Drawing = MakeRectDrawing(20, 10) };
+
+        var angles = builder.Build(item, MakeClassification(Angle.ToRadians(7)), new Box(0, 0, 100, 50));
+
+        AssertAngleOrder(FallbackAngles(), angles);
+        Assert.Equal(new[] { "available" }, calls.Calls);
+    }
+
+#if DEBUG
+    [Fact]
+    public void Build_Available_RealExtraction_DoesNotScanBitmaskCells()
+    {
+        var extractionCalls = 0;
+        var predictionCalls = 0;
+        var predictedFeatures = (PartFeatures?)null;
+        var builder = new AngleCandidateBuilder(
+            () => true,
+            (drawing, includeBitmask) =>
+            {
+                extractionCalls++;
+                return FeatureExtractor.Extract(drawing, includeBitmask);
+            },
+            (features, width, height) =>
+            {
+                predictionCalls++;
+                predictedFeatures = features;
+                return null!;
+            });
+        var item = new NestItem { Drawing = MakeRectDrawing(20, 10) };
+
+        PerfCounters.Reset();
+        try
+        {
+            var angles = builder.Build(item, MakeClassification(Angle.ToRadians(7)), new Box(0, 0, 100, 50));
+
+            Assert.Equal(1, extractionCalls);
+            Assert.Equal(1, predictionCalls);
+            Assert.Equal(0, PerfCounters.FeatureBitmaskCells);
+            Assert.NotNull(predictedFeatures);
+            Assert.Null(predictedFeatures.Bitmask);
+            AssertAngleOrder(FallbackAngles(), angles);
+        }
+        finally
+        {
+            PerfCounters.Reset();
+        }
+    }
+#endif
+
    [Fact]
    public void Build_ReturnsAtLeastTwoAngles()
    {