diff --git a/OpenNest.Engine/Fill/FillLinear.cs b/OpenNest.Engine/Fill/FillLinear.cs index 761a0413..7d169e44 100644 --- a/OpenNest.Engine/Fill/FillLinear.cs +++ b/OpenNest.Engine/Fill/FillLinear.cs @@ -60,6 +60,13 @@ namespace OpenNest.Engine.Fill /// public int MaxParts { get; init; } + /// + /// When true (the default), a multi-part tiling may move off the work area's leading + /// edge to add parts of the copy before it (see ). Only + /// characterization against fillers frozen before that change turns it off. + /// + internal bool LeadingParts { get; init; } = true; + private static Vector MakeOffset(NestDirection direction, double distance) { return direction == NestDirection.Horizontal @@ -227,6 +234,83 @@ namespace OpenNest.Engine.Fill public double CopyDistance(Pattern pattern, NestDirection direction) => FindPatternCopyDistance(pattern, direction, new OffsetPerimeterCache(HalfSpacing)); + /// + /// Tiles a pattern along the given axis, returning the whole tiling: the pattern's own + /// parts first, then the copies. For multi-part patterns, also adds the parts of the + /// copies just before and after the whole ones that fit within the work area (see + /// ). The pattern's own parts are returned as given unless + /// leading parts moved the tiling. + /// + private List Tile( + Pattern basePattern, + NestDirection direction, + OffsetPerimeterCache cache, + int maxParts = 0 + ) + { + var tiling = new List(basePattern.Parts); + tiling.AddRange(TilePattern(basePattern, direction, cache, maxParts, out var copyDistance)); + if (LeadingParts && basePattern.Parts.Count > 1 && !(maxParts > 0 && tiling.Count >= maxParts) + && copyDistance > Tolerance.Epsilon && !double.IsPositiveInfinity(copyDistance)) + tiling = AddLeadingParts(basePattern, tiling, direction, copyDistance); + return tiling; + } + + /// + /// Adds the parts of the copies before the pattern that fit once the whole tiling moves + /// forward into the room left past its far end. A tiling always starts with the + /// pattern's leading edge on the work area's, so the copy before it never fits, though + /// some of its parts may: when an interlocked pair of reversed parts can only be tiled + /// with one row first, its partner row below it fits with that row raised slightly. The + /// tiling moves the least distance that adds the most parts; with none added it stays. + /// + private List AddLeadingParts( + Pattern basePattern, + List tiling, + NestDirection direction, + double copyDistance + ) + { + var start = GetStart(WorkArea, direction); + var end = double.MinValue; + foreach (var part in tiling) + end = System.Math.Max(end, GetStart(part.BoundingBox, direction) + + GetDimension(part.BoundingBox, direction)); + var room = GetLimit(direction) - end; + if (room < -Tolerance.Epsilon) + return tiling; + + var leading = new List<(Part Part, double Back, double Shift)>(); + foreach (var part in basePattern.Parts) + { + var ahead = GetStart(part.BoundingBox, direction) - start; + for (var copies = 1; ; copies++) + { + var back = copies * copyDistance; + var shift = back - ahead; + if (shift > room + Tolerance.Epsilon) + break; + leading.Add((part, back, shift)); + } + } + + if (leading.Count == 0) + return tiling; + + var move = 0.0; + foreach (var candidate in leading) + move = System.Math.Max(move, candidate.Shift); + move = System.Math.Min(move, System.Math.Max(room, 0)); + + var moved = new List(tiling.Count + leading.Count); + var offset = MakeOffset(direction, move); + foreach (var part in tiling) + moved.Add(move > 0 ? part.CloneAtOffset(offset) : part); + foreach (var (part, back, _) in leading) + moved.Add(part.CloneAtOffset(MakeOffset(direction, move - back))); + return moved; + } + /// /// Tiles a pattern along the given axis, returning the cloned parts /// (does not include the original pattern's parts). For multi-part @@ -237,10 +321,11 @@ namespace OpenNest.Engine.Fill Pattern basePattern, NestDirection direction, OffsetPerimeterCache cache, - int maxParts = 0 + int maxParts, + out double copyDistance ) { - var copyDistance = FindPatternCopyDistance(basePattern, direction, cache, + copyDistance = FindPatternCopyDistance(basePattern, direction, cache, UsefulCopyDistance(basePattern, direction, maxParts)); if (copyDistance <= 0 || double.IsPositiveInfinity(copyDistance)) @@ -314,10 +399,20 @@ namespace OpenNest.Engine.Fill var useful = GetLimit(direction) - GetStart(box, direction) - GetDimension(box, direction); var partial = basePattern.Parts.Count > 1 && !(maxParts > 0 && basePattern.Parts.Count >= maxParts); if (partial) + { + // A part of the copy before the pattern fits once the tiling moves forward + // into the room past the pattern, which only shrinks as copies are added. + var room = GetLimit(direction) - GetStart(box, direction) - GetDimension(box, direction); foreach (var part in basePattern.Parts) + { useful = System.Math.Max(useful, direction == NestDirection.Horizontal ? WorkArea.Right - part.BoundingBox.Right : WorkArea.Top - part.BoundingBox.Top); + if (LeadingParts) + useful = System.Math.Max(useful, + room + GetStart(part.BoundingBox, direction) - GetStart(WorkArea, direction)); + } + } return useful + 2 * Tolerance.Epsilon; } @@ -434,8 +529,7 @@ namespace OpenNest.Engine.Fill var rowIsVerified = false; // Step 1: Tile along primary axis - var row = new List(pattern.Parts); - row.AddRange(TilePattern(pattern, direction, cache)); + var row = Tile(pattern, direction, cache); if (pattern.Parts.Count > 1 && HasOverlappingParts(row, out var a1, out var b1)) { @@ -451,7 +545,7 @@ namespace OpenNest.Engine.Fill // If primary tiling didn't produce copies, just tile along perpendicular if (row.Count <= pattern.Parts.Count) { - row.AddRange(TilePattern(pattern, perpAxis, cache, MaxParts)); + row = Tile(pattern, perpAxis, cache, MaxParts); if (pattern.Parts.Count > 1 && HasOverlappingParts(row, out var a2, out var b2)) { @@ -474,8 +568,7 @@ namespace OpenNest.Engine.Fill rowPattern.Parts.AddRange(row); rowPattern.UpdateBounds(); - var gridResult = new List(rowPattern.Parts); - gridResult.AddRange(TilePattern(rowPattern, perpAxis, cache, MaxParts)); + var gridResult = Tile(rowPattern, perpAxis, cache, MaxParts); // Only the unchanged row is covered by Step 1's clean verdict: skip Step 2 // only when the perpendicular tiling appended zero parts, so gridResult diff --git a/OpenNest.Tests/Fill/FillLinearGeometryReuseTests.cs b/OpenNest.Tests/Fill/FillLinearGeometryReuseTests.cs index c5b266a3..46b15d9d 100644 --- a/OpenNest.Tests/Fill/FillLinearGeometryReuseTests.cs +++ b/OpenNest.Tests/Fill/FillLinearGeometryReuseTests.cs @@ -34,7 +34,7 @@ public class FillLinearGeometryReuseTests var drawing = Fixture(shape); var before = ProgramValues(drawing.Program); var area = new Box(3.1, -5.3, 42, 29); - var filler = new FillLinear(area, spacing); + var filler = new FillLinear(area, spacing) { LeadingParts = false }; var legacy = new LegacyFillLinear(area, spacing); var inputs = new[] { drawing.Program }; var expected = legacy.Fill(drawing, angle, direction); @@ -59,7 +59,7 @@ public class FillLinearGeometryReuseTests { var pattern = MakePattern(kind); var before = Snapshot(pattern); - var filler = new FillLinear(new Box(-7.1, 11.3, 52, 39), spacing); + var filler = new FillLinear(new Box(-7.1, 11.3, 52, 39), spacing) { LeadingParts = false }; var legacy = new LegacyFillLinear(filler.WorkArea, spacing); var inputs = pattern.Parts.Select(p => p.Program).ToArray(); var expected = legacy.Fill(pattern, direction); @@ -99,7 +99,7 @@ public class FillLinearGeometryReuseTests var area = new Box(3.1, 5.3, direction == NestDirection.Horizontal ? size : 10, direction == NestDirection.Vertical ? size : 8); var legacy = new LegacyFillLinear(area, spacing); - var filler = new FillLinear(area, spacing); + var filler = new FillLinear(area, spacing) { LeadingParts = false }; var expected = legacy.FillRow(drawing, 0, direction).Parts; counts.Add(expected.Count); AssertLayout(expected, filler.FillRow(drawing, 0, direction).Parts, new[] { drawing.Program }); @@ -126,14 +126,14 @@ public class FillLinearGeometryReuseTests fallback.AddRange((List)FillExtentsTests.Invoke(legacy, "TilePatternBbox", pattern, NestDirection.Horizontal)); var inputs = pattern.Parts.Select(p => p.Program).ToArray(); AssertLayout(fallback, legacy.Fill(pattern, NestDirection.Horizontal), inputs); - AssertLayout(fallback, new FillLinear(area, 0.5).Fill(pattern, NestDirection.Horizontal), inputs); + AssertLayout(fallback, new FillLinear(area, 0.5) { LeadingParts = false }.Fill(pattern, NestDirection.Horizontal), inputs); } [Fact] public void EmptyAndNoFit_MatchFrozenLegacy() { var area = new Box(3, 5, 1, 1); - var filler = new FillLinear(area, 0.5); + var filler = new FillLinear(area, 0.5) { LeadingParts = false }; var legacy = new LegacyFillLinear(area, 0.5); var drawing = Fixture("rectangle"); var pattern = MakePattern("rotated"); @@ -152,7 +152,7 @@ public class FillLinearGeometryReuseTests { var patterns = new[] { MakePattern("shared"), MakePattern("rotated"), MakePattern("built-pair") }; var before = patterns.Select(Snapshot).ToArray(); - var filler = new FillLinear(new Box(3.1, 5.3, 52, 39), 0.5); + var filler = new FillLinear(new Box(3.1, 5.3, 52, 39), 0.5) { LeadingParts = false }; var expected = patterns.Select(p => new[] { filler.Fill(p, NestDirection.Horizontal), filler.Fill(p, NestDirection.Vertical) }).ToArray(); Parallel.For(0, 48, new ParallelOptions { MaxDegreeOfParallelism = 4 }, i => @@ -245,7 +245,7 @@ public class FillLinearGeometryReuseTests var area = mode is "row" or "drawing" ? new Box(3, 5, 31.5, 17) : new Box(3, 5, 42.5, 25); var pattern = MakePattern(mode == "shared" ? "shared" : "rotated", drawing); var legacy = new LegacyFillLinear(area, 0.5); - var filler = new FillLinear(area, 0.5); + var filler = new FillLinear(area, 0.5) { LeadingParts = false }; PerfCounters.Reset(); try { diff --git a/OpenNest.Tests/Fill/FillLinearLeadingPartsTests.cs b/OpenNest.Tests/Fill/FillLinearLeadingPartsTests.cs new file mode 100644 index 00000000..8ef035a6 --- /dev/null +++ b/OpenNest.Tests/Fill/FillLinearLeadingPartsTests.cs @@ -0,0 +1,131 @@ +using System.Collections.Generic; +using System.Linq; +using OpenNest.CNC; +using OpenNest.Engine; +using OpenNest.Engine.Fill; +using OpenNest.Geometry; +using OpenNest.Math; + +namespace OpenNest.Tests.Fill; + +/// +/// A tiling starts with its pattern on the work area's leading edge, so the copy before it +/// never fits whole; once the tiling moves into the room left past its far end, some of +/// that copy's parts can. +/// +public class FillLinearLeadingPartsTests +{ + private static Drawing Rectangle(double length, double width) + { + var pgm = new Program(); + pgm.Codes.Add(new RapidMove(new Vector(0, 0))); + pgm.Codes.Add(new LinearMove(new Vector(length, 0))); + pgm.Codes.Add(new LinearMove(new Vector(length, width))); + pgm.Codes.Add(new LinearMove(new Vector(0, width))); + pgm.Codes.Add(new LinearMove(new Vector(0, 0))); + return new Drawing("rect", pgm); + } + + /// + /// A 10 x 8.5 arch: a band between a 5 radius and a 4.28 radius arc, its legs ending in + /// 0.125 radius rounds. Turned 180 degrees it is a cup, and a cup row drops 2.1 below + /// an arch row, each arch's legs inside two cups. + /// + private static Drawing Arch() + { + var pgm = new Program(); + pgm.Codes.Add(new RapidMove(new Vector(0, 0))); + pgm.Codes.Add(new ArcMove(new Vector(-0.1894982776, 0.1624029578), + new Vector(-0.0899707487, 0.0867770959), RotationType.CW)); + pgm.Codes.Add(new ArcMove(new Vector(-7.0081616203, 0.1624029578), + new Vector(-3.5988299489, 2.7529791426), RotationType.CCW)); + pgm.Codes.Add(new ArcMove(new Vector(-7.1976598979, 0), + new Vector(-7.1076891492, 0.0867770959), RotationType.CW)); + pgm.Codes.Add(new ArcMove(new Vector(0, 0), + new Vector(-3.5988299489, 3.4710838363), RotationType.CW)); + return new Drawing("arch", pgm); + } + + private static Pattern PatternOf(params Part[] parts) + { + var pattern = new Pattern(); + foreach (var part in parts) + { + part.UpdateBounds(); + pattern.Parts.Add(part); + } + pattern.UpdateBounds(); + return pattern; + } + + private static void AssertInside(Box area, List parts) + { + foreach (var part in parts) + { + var box = part.BoundingBox; + Assert.True(box.Left >= area.Left - Tolerance.Epsilon && box.Right <= area.Right + Tolerance.Epsilon + && box.Bottom >= area.Bottom - Tolerance.Epsilon && box.Top <= area.Top + Tolerance.Epsilon, + $"part at ({box.Left:F4},{box.Bottom:F4})-({box.Right:F4},{box.Top:F4}) is outside the area"); + } + } + + [Fact] + public void Tiling_MovesForwardToFitAPartOfTheCopyBeforeIt() + { + // Two 4 x 4 squares side by side, the right one 3 higher: copies stack 4.5 apart. + // In 20, three whole copies and the next copy's left square fit, leaving 2.5 at + // the top; raising the tiling 1.5 fits the previous copy's right square below. + var square = Rectangle(4, 4); + var pattern = PatternOf(new Part(square, new Vector(0, 0)), new Part(square, new Vector(5, 3))); + var area = new Box(0, 0, 9, 20); + + var parts = new FillLinear(area, 0.5).Fill(pattern, NestDirection.Vertical); + + Assert.Equal(8, parts.Count); + AssertInside(area, parts); + Assert.Equal(new[] { 1.5, 6, 10.5, 15 }, Bottoms(parts, left: true)); + Assert.Equal(new[] { 0, 4.5, 9, 13.5 }, Bottoms(parts, left: false)); + } + + [Fact] + public void Tiling_WithoutRoomForThePreviousCopy_StaysOnTheLeadingEdge() + { + // The same squares in 18.5: no room past the far end, so nothing moves. + var square = Rectangle(4, 4); + var pattern = PatternOf(new Part(square, new Vector(0, 0)), new Part(square, new Vector(5, 3))); + var area = new Box(0, 0, 9, 17.5); + + var parts = new FillLinear(area, 0.5).Fill(pattern, NestDirection.Vertical); + + Assert.Equal(7, parts.Count); + Assert.Equal(new[] { 0, 4.5, 9, 13.5 }, Bottoms(parts, left: true)); + Assert.Equal(new[] { 3, 7.5, 12 }, Bottoms(parts, left: false)); + } + + [Fact] + public void ArchesAndCups_FitTheCupRowBelowTheFirstArchRow() + { + // A cup resting on a row of arches tiles 10.3 along the row and 9.53 across it, but + // the pair starts with an arch row: in 58.375 it holds five pairs and a last arch + // row (121). The cup row of the pair before fits under it with the tiling raised + // 2.1, making twelve rows. + var arch = Arch(); + var cup = new Part(arch); + cup.Rotate(System.Math.PI); + cup.Location = new Vector(-2.047654897931384, 15.862226444770164); + var pattern = PatternOf(new Part(arch, new Vector(0, 0)), cup); + var area = new Box(0.3, 1.375, 119.4, 58.375); + + var parts = new FillLinear(area, 0.3).Fill(pattern, NestDirection.Horizontal); + + Assert.Equal(132, parts.Count); + AssertInside(area, parts); + Assert.Empty(PartOverlapChecker.FindOverlappingPairs(parts)); + } + + private static double[] Bottoms(List parts, bool left) => + parts.Where(p => p.BoundingBox.Left < 1 == left) + .Select(p => System.Math.Round(p.BoundingBox.Bottom, 6)) + .OrderBy(y => y) + .ToArray(); +} diff --git a/OpenNest.Tests/Fill/FillLinearValidationPerformanceTests.cs b/OpenNest.Tests/Fill/FillLinearValidationPerformanceTests.cs index 503d4235..16367b73 100644 --- a/OpenNest.Tests/Fill/FillLinearValidationPerformanceTests.cs +++ b/OpenNest.Tests/Fill/FillLinearValidationPerformanceTests.cs @@ -46,7 +46,7 @@ public class FillLinearValidationPerformanceTests var single = FillHelpers.BuildRotatedPattern(new List { first }, 0.37); var patterns = new[] { pair, pair, pair, pair, single }; var names = new[] { "horizontal-stripe", "vertical-stripe", "full-grid", "partial-only", "single-seed-stripe" }; - var counts = new[] { 8, 19, 36, 29, 8 }; + var counts = new[] { 8, 20, 36, 30, 8 }; var directions = new[] { NestDirection.Horizontal, NestDirection.Vertical, NestDirection.Horizontal, NestDirection.Vertical, NestDirection.Horizontal }; var areas = new[] @@ -83,7 +83,7 @@ public class FillLinearValidationPerformanceTests + "pair at 0/PI, second offset=(10.5,0), BuildRotatedPattern=0.37; spacing=0.5; origin=(0,0). " + "Stripe primary span=96, perpendicular span=exact pattern bbox; full-grid=(96,48); " + "vertical partial-only perpendicular span=1.8*pair.Length; single rotated seed H stripe. " - + "Counts in mode order=8,19,36,29,8; full-grid row=8+28; partial-only row=19+10."); + + "Counts in mode order=8,20,36,30,8; full-grid row=8+28; partial-only row=20+10."); output.WriteLine($"warmup=2 x {warmupCalls} calls/mode; measured={repetitions} x {callsPerBatch} calls/mode. " + "Mode order alternates forward/reverse in warmup and measurement. Real synchronous production Fill only; " + "setup, correctness assertions and output excluded. Geometry, tiling, overlap checks, GC, delegate/loop, " diff --git a/OpenNest.Tests/Fill/FillLinearValidationReuseTests.cs b/OpenNest.Tests/Fill/FillLinearValidationReuseTests.cs index 25d676d1..feabdc57 100644 --- a/OpenNest.Tests/Fill/FillLinearValidationReuseTests.cs +++ b/OpenNest.Tests/Fill/FillLinearValidationReuseTests.cs @@ -39,11 +39,12 @@ public class FillLinearValidationReuseTests var area = new Box(3.1, -5.3, 42, 29); var areaBefore = BoxBits(area); var expected = new PreStep3FillLinear(area, spacing).Fill(drawing, angle, direction); - var filler = new FillLinear(area, spacing); + var filler = new FillLinear(area, spacing) { LeadingParts = false }; AssertLayout(expected, filler.Fill(drawing, angle, direction), new[] { drawing.Program }); Assert.Equal(before, DrawingSnapshot(drawing)); AssertLayout(expected, filler.Fill(drawing, angle, direction), new[] { drawing.Program }); AssertValid(expected, area); + AssertDefaultAddsOnlyValidParts(expected, new FillLinear(area, spacing).Fill(drawing, angle, direction), area); Assert.Equal(before, DrawingSnapshot(drawing)); Assert.Equal(areaBefore, BoxBits(area)); Assert.Equal(areaBefore, BoxBits(filler.WorkArea)); @@ -153,7 +154,7 @@ public class FillLinearValidationReuseTests { var area = Area(size); var frozen = new PreStep3FillLinear(area, 0.5); - var filler = new FillLinear(area, 0.5); + var filler = new FillLinear(area, 0.5) { LeadingParts = false }; var expectedPattern = frozen.Fill(pattern, direction); var expectedDrawing = frozen.Fill(drawing, 0, direction); Assert.Equal(size == rejected ? 2 : 3, expectedPattern.Count); @@ -185,7 +186,7 @@ public class FillLinearValidationReuseTests PerfCounters.Reset(); try { - parts = new FillLinear(area, 0.5).Fill(pattern, direction); + parts = new FillLinear(area, 0.5) { LeadingParts = false }.Fill(pattern, direction); observedExact = PerfCounters.PartIntersects; observedPreparations = PerfCounters.OverlapPolygonPreparations; observedTriangulations = PerfCounters.PolygonTriangulations; @@ -226,7 +227,7 @@ public class FillLinearValidationReuseTests PerfCounters.Reset(); try { - parts = new FillLinear(area, 0.5).Fill(pattern, direction); + parts = new FillLinear(area, 0.5) { LeadingParts = false }.Fill(pattern, direction); observedExact = PerfCounters.PartIntersects; observedPreparations = PerfCounters.OverlapPolygonPreparations; observedTriangulations = PerfCounters.PolygonTriangulations; @@ -257,7 +258,7 @@ public class FillLinearValidationReuseTests PerfCounters.Reset(); try { - parts = new FillLinear(area, 0.5).Fill(pattern, direction); + parts = new FillLinear(area, 0.5) { LeadingParts = false }.Fill(pattern, direction); observed = PerfCounters.PartIntersects; Assert.Equal(exact, observed); Assert.NotEmpty(parts); @@ -284,7 +285,7 @@ public class FillLinearValidationReuseTests var before = PatternSnapshot(pattern); var area = new Box(0, 0, 35, 8.25); var frozen = new PreStep3FillLinear(area, 0.5) { Label = "invalid-frozen" }; - var filler = new FillLinear(area, 0.5) { Label = "invalid-production" }; + var filler = new FillLinear(area, 0.5) { LeadingParts = false, Label = "invalid-production" }; #if DEBUG using var listener = new FallbackListener(); Trace.Listeners.Add(listener); @@ -345,7 +346,7 @@ public class FillLinearValidationReuseTests public void EmptyNoFitAndMalformedInputs_PreserveResultsAndExceptionTypes(NestDirection direction) { var area = new Box(3, 5, 1, 1); - var filler = new FillLinear(area, 0.5); + var filler = new FillLinear(area, 0.5) { LeadingParts = false }; var frozen = new PreStep3FillLinear(area, 0.5); var drawing = MakeDrawing("rectangle"); var pattern = MakePattern("concave", "rotated"); @@ -386,7 +387,7 @@ public class FillLinearValidationReuseTests [Fact] public void ConcurrentIndependentCalls_OneFiller_MatchFrozenAndPreserveInputs() { - var filler = new FillLinear(new Box(3.1, -5.3, 52, 39), 0.5); + var filler = new FillLinear(new Box(3.1, -5.3, 52, 39), 0.5) { LeadingParts = false }; var frozen = new PreStep3FillLinear(filler.WorkArea, 0.5); var patterns = Enumerable.Range(0, 24).Select(i => MakePattern(i % 2 == 0 ? "concave" : "arc", i % 3 == 0 ? "shared" : i % 3 == 1 ? "rotated" : "single")).ToArray(); @@ -453,18 +454,32 @@ public class FillLinearValidationReuseTests Assert.False(FillHelpers.HasOverlappingParts(pattern.Parts)); var expected = new PreStep3FillLinear(area, spacing).Fill(pattern, direction); Assert.Equal(before, PatternSnapshot(pattern)); - var filler = new FillLinear(area, spacing); + var filler = new FillLinear(area, spacing) { LeadingParts = false }; var actual = filler.Fill(pattern, direction); AssertLayout(expected, actual, inputs); Assert.Equal(before, PatternSnapshot(pattern)); AssertLayout(expected, filler.Fill(pattern, direction), inputs); Assert.Equal(before, PatternSnapshot(pattern)); AssertValid(actual, area); + AssertDefaultAddsOnlyValidParts(expected, new FillLinear(area, spacing).Fill(pattern, direction), area); + Assert.Equal(before, PatternSnapshot(pattern)); Assert.Equal(areaBefore, BoxBits(area)); Assert.Equal(areaBefore, BoxBits(filler.WorkArea)); return actual; } + /// + /// The frozen fillers predate , so they are compared + /// with it off; with it on, a fill only adds parts of the copy before its pattern, never + /// holding fewer parts, and stays inside the area without overlaps. + /// + private static void AssertDefaultAddsOnlyValidParts(List frozen, List current, Box area) + { + Assert.True(current.Count >= frozen.Count, $"default fill holds {current.Count}, frozen {frozen.Count}"); + if (current.Count > 0) + AssertValid(current, area); + } + private static void AssertValid(List parts, Box area) { Assert.NotEmpty(parts); diff --git a/OpenNest.Tests/Strategies/FillHelpersTests.cs b/OpenNest.Tests/Strategies/FillHelpersTests.cs index 6cfb893d..78f58980 100644 --- a/OpenNest.Tests/Strategies/FillHelpersTests.cs +++ b/OpenNest.Tests/Strategies/FillHelpersTests.cs @@ -92,10 +92,10 @@ public class FillHelpersTests } [Theory] - [InlineData(5, 9, 8, 7)] - [InlineData(10, 4, 7, 8)] - [InlineData(5, 4, 3, 3)] - [InlineData(7, 6, 8, 8)] + [InlineData(5, 9, 10, 12)] + [InlineData(10, 4, 8, 8)] + [InlineData(5, 4, 4, 4)] + [InlineData(7, 6, 9, 8)] public void FillPattern_DefaultScoring_PreservesWinningLayoutAndInputs( double length, double width, int horizontalCount, int verticalCount) { @@ -308,12 +308,12 @@ public class FillHelpersTests } [Theory] - [InlineData(5, 9, 0, 2)] - [InlineData(5, 9, 1, 0)] - [InlineData(10, 4, 1, 0)] - [InlineData(5, 9, 2, 2)] + [InlineData(5, 9, 0, 2, 12)] + [InlineData(5, 9, 1, 0, 10)] + [InlineData(10, 4, 1, 0, 8)] + [InlineData(5, 9, 2, 2, 10)] public void FillPattern_ScoreWork_OnlyDefaultPathOrComparerComputesScores( - double length, double width, int comparerKind, long expectedComputations) + double length, double width, int comparerKind, long expectedComputations, int count) { var group = MakeGroup(); var workArea = new Box(3, 5, length, width); @@ -329,7 +329,7 @@ public class FillHelpersTests var result = FillHelpers.FillPattern(engine, group, angles, workArea, comparerKind == 0 ? null : comparer); - Assert.Equal(comparerKind == 0 ? 8 : 7, result.Count); + Assert.Equal(count, result.Count); Assert.Equal(comparerKind == 0 ? 0 : 1, comparer.Calls.Count); Assert.Equal(expectedComputations, PerfCounters.FillScoreComputations); } diff --git a/docs/performance/fill-verification.md b/docs/performance/fill-verification.md index a8c725b4..e2edb2d0 100644 --- a/docs/performance/fill-verification.md +++ b/docs/performance/fill-verification.md @@ -53,7 +53,7 @@ OPENNEST_RUN_FILL_PERF=1 dotnet test OpenNest.Tests/OpenNest.Tests.csproj -c Rel --logger 'console;verbosity=detailed' --logger 'trx;LogFileName=linear-validation-perf.trx' ``` -`FillLinearValidationPerformanceTests.cs` is self-contained against base APIs: byte-copy and hash the same file in both trees. It times complete production `Fill` calls (not frozen code or overlap-only helpers): horizontal/vertical stripes, full grid, partial-only additions, and single-seed stripe. The closed concave fixture gives counts **8 / 19 / 36 / 29 / 8**; grid is row 8 + 28 additions, partial-only is row 19 + 10 (no full row). Two 100-call warmups and seven 200-call batches per mode alternate forward/reverse mode order. Retain every raw tick/time/current-thread allocation row, including warmups; setup/assertions/output are excluded, count/last-result consumption is identical. No timing or reduced-work assertions belong in this baseline harness. +`FillLinearValidationPerformanceTests.cs` is self-contained against base APIs: byte-copy and hash the same file in both trees. It times complete production `Fill` calls (not frozen code or overlap-only helpers): horizontal/vertical stripes, full grid, partial-only additions, and single-seed stripe. The closed concave fixture gives counts **8 / 20 / 36 / 30 / 8**; grid is row 8 + 28 additions, partial-only is row 20 + 10 (no full row). Vertical-stripe and partial-only each gain a part of the copy before the pattern (`FillLinear.LeadingParts` moves a tiling into the room past its far end to fit them); the frozen-oracle comparisons and work-count assertions below turn it off and keep the earlier **8 / 19 / 36 / 29 / 8**, and every oracle fixture also checks that the default fill holds at least the frozen count, inside the area and without overlaps. Two 100-call warmups and seven 200-call batches per mode alternate forward/reverse mode order. Retain every raw tick/time/current-thread allocation row, including warmups; setup/assertions/output are excluded, count/last-result consumption is identical. No timing or reduced-work assertions belong in this baseline harness. `PreStep3FillLinear.cs` freezes production `FillLinear` at **1b23ad79f25d77fdd745bfea029de9dff2a91f6d**, separately from the older `LegacyFillLinear`. Reverse only the documented type/constructor rename, namespace/visibility/import additions, nullable directive and import formatting; retain a zero-diff comparison against `git show :OpenNest.Engine/Fill/FillLinear.cs` and SHA-256 hashes. Do not refactor the oracle or use it for before timings. `FillLinearValidationReuseTests` compares ordered IEEE-754 poses/bounds, CNC values/program sharing, drawing references and immutable inputs through both public `Fill` overloads, including concurrent calls on one filler. Valid fixtures assert closed positive-area material and no overlap. The separate invalid overlapping-seed case intentionally remains invalid; in Debug its listener confirms Step1 and Step2 fallback pair `(0,1)` with six parts at each step (zero perpendicular additions). It makes no claim that bbox fallback repairs the seeds.