using OpenNest.CNC; using OpenNest.CNC.CuttingPlanning; using OpenNest.Converters; using OpenNest.Engine.CuttingPlanning; using OpenNest.Geometry; namespace OpenNest.Tests.CuttingPlanning; /// /// A supplied blank (a purchased door) whose outline is a display perimeter: shown and treated as /// material, never cut. Only its cutouts are cut, each as a hole. /// public class DisplayPerimeterTests { // The door fills a 30 x 20 sheet: new Size(width, length) puts Length (30) along X. private static Plate DoorPlate(Program program) { var plate = new Plate(new Size(20, 30)); plate.Parts.Add(new Part(new Drawing("door", program), Vector.Zero)); return plate; } internal static Program Door(LayerType outline = LayerType.DisplayPerimeter, bool cutouts = true, LayerType? lastEdge = null) { var program = new Program(); program.Codes.Add(new RapidMove(0, 0)); program.Codes.Add(new LinearMove(0, 20) { Layer = outline }); program.Codes.Add(new LinearMove(30, 20) { Layer = outline }); program.Codes.Add(new LinearMove(30, 0) { Layer = outline }); program.Codes.Add(new LinearMove(0, 0) { Layer = lastEdge ?? outline }); if (cutouts) AddCutouts(program); return program; } private static void AddCutouts(Program program) { program.MoveTo(5, 5); program.LineTo(5, 10); program.LineTo(10, 10); program.LineTo(10, 5); program.LineTo(5, 5); program.MoveTo(15, 5); program.LineTo(15, 12); program.LineTo(25, 12); program.LineTo(25, 5); program.LineTo(15, 5); program.MoveTo(9.5, 15); program.Codes.Add(new ArcMove(new Vector(9.5, 15), new Vector(8, 15), RotationType.CW)); } // Cutout extents, for checking where pierces and cuts land. private static readonly Box[] Cutouts = [ new Box(5, 5, 5, 5), new Box(15, 5, 10, 7), new Box(6.5, 13.5, 3, 3), ]; private static bool InsideACutout(Vector point) => Cutouts.Any(box => point.X >= box.Left - 1e-6 && point.X <= box.Right + 1e-6 && point.Y >= box.Bottom - 1e-6 && point.Y <= box.Top + 1e-6); [Fact] public void Door_PlansEveryCutoutAsAHoleAndNeverCutsTheOutline() { var plate = DoorPlate(Door()); var part = plate.Parts[0]; var proposal = CuttingPlanBatch.Capture([plate], ExplicitContourTests.Parameters(), false).Plan(); var result = Assert.Single(proposal.Plates).Result; Assert.True(proposal.CanApply, string.Join("\n", proposal.Describe("in"))); Assert.Equal(CuttingPlanStatus.Ready, result.Status); Assert.True(result.IndependentlyReplayed); Assert.Equal(CuttingCommitStatus.Applied, proposal.Apply(acceptWarnings: false).Status); var motions = ExecutionMotionReader.Read(part.Program, part.Location, null, default).Motions; Assert.DoesNotContain(motions, m => m.Layer == LayerType.DisplayPerimeter); var pierces = motions.Where((m, i) => m.Layer == LayerType.Leadin && m.Start is { } && (i == 0 || motions[i - 1].Rapid)) .Select(m => m.Start!.Value).ToArray(); Assert.Equal(3, pierces.Length); Assert.All(pierces, p => Assert.True(InsideACutout(p), $"Pierce ({p.X}, {p.Y}) is on the door.")); Assert.All(motions.Where(m => !m.Rapid), m => Assert.True(InsideACutout(m.End), $"Cut to ({m.End.X}, {m.End.Y}) leaves the cutouts.")); } private static (Plate Plate, Part Part) PlannedDoor() { var plate = DoorPlate(Door()); var proposal = CuttingPlanBatch.Capture([plate], ExplicitContourTests.Parameters(), false).Plan(); Assert.True(proposal.CanApply, string.Join("\n", proposal.Describe("in"))); Assert.Equal(CuttingCommitStatus.Applied, proposal.Apply(acceptWarnings: false).Status); return (plate, plate.Parts[0]); } [Fact] public void AfterApply_TheDoorKeepsItsOutlineAsANeverCutTail() { var (_, part) = PlannedDoor(); Assert.Equal(30, part.BoundingBox.Length, 6); Assert.Equal(20, part.BoundingBox.Width, 6); Assert.True(DisplayPerimeterTail.HasTail(part.Program)); var executed = DisplayPerimeterTail.ForPosting(part.Program, "Part 1"); Assert.False(DisplayPerimeterTail.HasDisplayPerimeterMotion(executed)); // Posting and executed reads agree: the tail is the only thing either leaves out. var full = ExecutionMotionReader.Read(part.Program, part.Location, null, default).Motions; var posted = ExecutionMotionReader.Read(executed, part.Location, null, default).Motions; Assert.Equal(full.Count, posted.Count); Assert.True(executed.Codes.Count < part.Program.Codes.Count); } [Fact] public void AfterApply_AutomaticCutOffsStillAddNoLineAcrossTheBlank() { var (plate, _) = PlannedDoor(); var staging = AutomaticCutOffBatch.Stage([plate], new AutomaticCutOffOptions { Spacing = 10, MinimumStripLength = 5 }, new CutOffSettings()); Assert.Empty(Assert.Single(staging.Plans).Definitions); } [Fact] public void AfterApply_TheDoorPlansAgainWithTheSameHoles() { var (plate, _) = PlannedDoor(); var again = CuttingPlanBatch.Capture([plate], ExplicitContourTests.Parameters(), false).Plan(); Assert.True(again.CanApply, string.Join("\n", again.Describe("in"))); } [Fact] public void AfterApply_TimingRapidsAndSimulationIgnoreTheTail() { var (plate, part) = PlannedDoor(); var executed = DisplayPerimeterTail.WithoutTail(part.Program); Assert.Equal(Timing.GetTimingInfo(executed).PierceCount, Timing.GetTimingInfo(part.Program).PierceCount); Assert.Equal(Timing.GetTimingInfo(executed).CutDistance, Timing.GetTimingInfo(part.Program).CutDistance, 9); // The tail starts at the outline's first corner (0, 0); no rapid may travel there. var rapids = RapidEnumerator.Enumerate(plate.Parts); Assert.DoesNotContain(rapids, r => r.To.DistanceTo(Vector.Zero) < 1e-9); var simulation = CutSimulation.Build(plate, new CutParameters { Feedrate = 100, RapidTravelRate = 600, PierceTime = TimeSpan.FromSeconds(1), Units = Units.Inches, }); Assert.Equal(3, simulation.Steps.Count(step => step.Kind == CutSimulationStepKind.Pierce)); Assert.DoesNotContain(simulation.Steps, step => step.Layer == LayerType.DisplayPerimeter); } [Fact] public void ManualAndLegacyLeadIns_RefuseADisplayPerimeterAndLeaveThePartAlone() { var part = new Part(new Drawing("door", Door()), Vector.Zero); var before = ExplicitContourTests.Fingerprint(part.Program); var edge = ConvertProgram.ToGeometry(part.Program).First(e => e.Layer == SpecialLayers.DisplayPerimeter); var hole = ConvertProgram.ToGeometry(part.Program).First(e => e.Layer == SpecialLayers.Cut); var onEdge = Assert.Throws(() => part.ApplySingleLeadIn( ExplicitContourTests.Parameters(), new Vector(0, 10), edge, OpenNest.CNC.CuttingStrategy.ContourType.External)); Assert.Throws(() => part.ApplySingleLeadIn( ExplicitContourTests.Parameters(), new Vector(5, 7), hole, OpenNest.CNC.CuttingStrategy.ContourType.Internal)); Assert.Throws(() => part.ApplyLeadIns(ExplicitContourTests.Parameters(), Vector.Zero)); Assert.Contains("Plan Cutting", onEdge.Message); Assert.False(part.HasManualLeadIns); Assert.Equal(before, ExplicitContourTests.Fingerprint(part.Program)); } private static Program SquareThenMarker(bool displayTail, bool markerInSubProgram = false) { var cuts = new Program(); cuts.MoveTo(1, 1); cuts.LineTo(1, 2); cuts.LineTo(2, 2); cuts.LineTo(2, 1); cuts.LineTo(1, 1); cuts.Codes.Add(new Comment(DisplayPerimeterTail.Marker)); cuts.Codes.Add(new RapidMove(3, 3)); var layer = displayTail ? LayerType.DisplayPerimeter : LayerType.Cut; foreach (var (x, y) in new[] { (3.0, 4.0), (4.0, 4.0), (4.0, 3.0), (3.0, 3.0) }) cuts.Codes.Add(new LinearMove(x, y) { Layer = layer }); if (!markerInSubProgram) return cuts; var main = new Program(); main.Codes.Add(new SubProgramCall(cuts, 0) { Id = 1 }); main.SubPrograms[1] = cuts; return main; } // A tail marker anywhere but the end of the top-level program, or followed by anything but // a rapid and the outline, is a malformed program: nothing may silently drop cuts after it. [Theory] [InlineData(false, false)] [InlineData(true, true)] [InlineData(false, true)] public void MalformedTailMarker_IsRefusedByPostsAndVerification(bool displayTail, bool inSubProgram) { var program = SquareThenMarker(displayTail, inSubProgram); Assert.Throws(() => DisplayPerimeterTail.ForPosting(program, "Part 1")); Assert.Throws(() => ExecutionMotionReader.Read(program, Vector.Zero, null, default)); Assert.True(DisplayPerimeterTail.HasTail(SquareThenMarker(displayTail: true))); } [Fact] public void Posting_RefusesAnUnplannedDisplayPerimeter() { var error = Assert.Throws(() => DisplayPerimeterTail.ForPosting(Door(), "Part 4")); Assert.Contains("Part 4", error.Message); Assert.Contains("Plan Cutting", error.Message); var holesOnly = Door(LayerType.Cut); Assert.Same(holesOnly, DisplayPerimeterTail.ForPosting(holesOnly, "Part 1")); } // A sparse support bed and a pierce zone both steer perimeter-led paths (support tabs, scrap // pierces); a blank has no cut perimeter, so neither may reach it. [Theory] [InlineData("supportBed")] [InlineData("pierceZone")] public void Door_PlansWithSupportTabsOrAPierceZoneAndStillNeverTouchesTheOutline(string setting) { var plate = DoorPlate(Door()); var parameters = ExplicitContourTests.Parameters(); if (setting == "supportBed") { plate.SupportBed = new OpenNest.Support.SupportGrid(25, 100, 2, 2, stabilityMargin: 0.1); parameters.SupportTabs = true; parameters.TabConfig = new OpenNest.CNC.CuttingStrategy.NormalTab { Size = 0.05 }; } else parameters.PierceDiameter = 0.1; var part = plate.Parts[0]; var proposal = CuttingPlanBatch.Capture([plate], parameters, false).Plan(); Assert.True(proposal.CanApply, string.Join("\n", proposal.Describe("in"))); Assert.Equal(CuttingCommitStatus.Applied, proposal.Apply(acceptWarnings: false).Status); var motions = ExecutionMotionReader.Read(part.Program, part.Location, null, default).Motions; Assert.All(motions.Where(m => !m.Rapid), m => Assert.True(InsideACutout(m.End), $"({m.End.X}, {m.End.Y}) leaves the cutouts.")); } // PEP draws a supplied blank a few hundred-thousandths of an inch past its sheet (an outline // skew of 0.000006 plus placements rounded to 0.001). The outline is never cut, so automatic // cut-offs accept it within DisplayPerimeterSheetAllowance; anything larger, or the same overhang // on geometry that is cut, is still refused. [Theory] [InlineData(LayerType.DisplayPerimeter, 3e-5, 0, true)] [InlineData(LayerType.DisplayPerimeter, 0, 3e-5, true)] [InlineData(LayerType.DisplayPerimeter, 2e-4, 0, false)] [InlineData(LayerType.Cut, 3e-5, 0, false)] public void AutomaticCutOffs_AcceptOnlyADisplayPerimeterWithinTheAllowancePastTheSheet( LayerType outline, double overRight, double overBottom, bool accepted) { var plate = new Plate(new Size(20, 30 - overRight)); plate.Parts.Add(new Part(new Drawing("door", Door(outline)), new Vector(0, -overBottom))); var create = () => AutomaticCutOffPlanner.Create(plate, new AutomaticCutOffOptions { Spacing = 35, MinimumStripLength = 17.5, MinimumTailLength = 12 }, new CutOffSettings()); if (!accepted) { var refusal = Assert.Throws(create); Assert.Contains("outside the physical sheet", refusal.Message); return; } // The blank fills the sheet: nothing is left to cut off. Assert.Empty(create().Definitions); } // Cut-offs are staged before planning checks the door, so a malformed one can still carry a // cut past the sheet while its outline is inside: the allowance covers the outline only. [Fact] public void AutomaticCutOffs_RefuseACutPastTheSheetEvenOnADisplayPerimeterPart() { var program = Door(); program.MoveTo(29, 1); program.LineTo(30.00003, 1); program.LineTo(30.00003, 2); program.LineTo(29, 2); program.LineTo(29, 1); var plate = new Plate(new Size(20, 30)); plate.Parts.Add(new Part(new Drawing("door", program), Vector.Zero)); var refusal = Assert.Throws(() => AutomaticCutOffPlanner.Create(plate, new AutomaticCutOffOptions { Spacing = 35, MinimumStripLength = 17.5, MinimumTailLength = 12 }, new CutOffSettings())); Assert.Contains("outside the physical sheet", refusal.Message); } private static AutomaticCutOffPlan StageCutOffs(Plate plate) => AutomaticCutOffPlanner.Create(plate, new AutomaticCutOffOptions { Spacing = 35, MinimumStripLength = 17.5, MinimumTailLength = 12 }, new CutOffSettings()); // The allowance belongs to the outline alone: a scribe (lasered) or a rapid past the sheet on a // door is refused at the ordinary tolerance, except a rapid ending on the outline itself. [Theory] [InlineData("scribe")] [InlineData("rapid")] public void AutomaticCutOffs_RefuseAScribeOrRapidPastTheSheetOnADisplayPerimeterPart(string motion) { var program = Door(); if (motion == "scribe") { program.Codes.Add(new RapidMove(29, 1)); program.Codes.Add(new LinearMove(30.00003, 1) { Layer = LayerType.Scribe }); program.Codes.Add(new RapidMove(29, 2)); } else program.Codes.Add(new RapidMove(30.00005, 1)); var plate = new Plate(new Size(20, 30)); plate.Parts.Add(new Part(new Drawing("door", program), Vector.Zero)); var refusal = Assert.Throws(() => StageCutOffs(plate)); Assert.Contains("outside the physical sheet", refusal.Message); } // The door's rapid to its outline's first corner, in the drawing and again in an applied // program's display tail, ends on the outline, so it shares the outline's allowance. [Fact] public void AutomaticCutOffs_AcceptTheRapidToAnOverhangingOutlineBeforeAndAfterApply() { var plate = new Plate(new Size(20, 30 - 3e-5)); var part = new Part(new Drawing("door", Door()), new Vector(-3e-5, 0)); plate.Parts.Add(part); Assert.Empty(StageCutOffs(plate).Definitions); var proposal = CuttingPlanBatch.Capture([plate], ExplicitContourTests.Parameters(), false).Plan(); Assert.Equal(CuttingCommitStatus.Applied, proposal.Apply(acceptWarnings: false).Status); Assert.True(DisplayPerimeterTail.HasTail(part.Program)); Assert.Empty(StageCutOffs(plate).Definitions); } [Fact] public void Door_AutomaticCutOffsAddNoLineAcrossTheBlank() { var plate = DoorPlate(Door()); var staging = AutomaticCutOffBatch.Stage([plate], new AutomaticCutOffOptions { Spacing = 10, MinimumStripLength = 5 }, new CutOffSettings()); Assert.False(staging.IsBlocked); Assert.Empty(Assert.Single(staging.Plans).Definitions); } [Theory] [InlineData("mixed", "one whole closed contour")] [InlineData("hole", "enclose every other contour")] [InlineData("nothing", "display perimeter with no cutouts")] [InlineData("notch", "enclose every other contour")] [InlineData("second", "enclose every other contour")] [InlineData("tabbedOnly", "closed cutout without tabs")] [InlineData("circleOverEdge", "enclose every other contour")] [InlineData("edgeOverNotch", "enclose every other contour")] public void InvalidDisplayPerimeters_AreRefusedWithTheirReason(string layout, string reason) { var program = layout switch { "mixed" => Door(lastEdge: LayerType.Cut), "nothing" => Door(cutouts: false), "notch" => NotchedDoor(), "second" => SecondDisplayRing(), "tabbedOnly" => TabbedOnly(), "circleOverEdge" => CircleOverEdge(), "edgeOverNotch" => EdgeOverNotch(), _ => HoleOnDisplay(), }; var plate = DoorPlate(program); var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, confirmedParameters: ExplicitContourTests.Parameters())); Assert.NotEqual(CuttingPlanStatus.Ready, result.Status); Assert.Contains(result.Findings, f => f.Message.Contains(reason, StringComparison.OrdinalIgnoreCase)); // Not even an unverified plan: nothing about a refused blank may be applied. var proposal = CuttingPlanBatch.Capture([DoorPlate(program)], ExplicitContourTests.Parameters(), false).Plan(); Assert.False(proposal.CanApply); Assert.False(proposal.CanApplyWithWarnings); // An L-shaped blank with a cutout in its notch: inside the outline's box, outside the blank. static Program NotchedDoor() { var program = new Program(); Ring(program, LayerType.DisplayPerimeter, (0, 0), (0, 20), (15, 20), (15, 10), (30, 10), (30, 0)); Ring(program, LayerType.Cut, (2, 2), (2, 6), (6, 6), (6, 2)); Ring(program, LayerType.Cut, (20, 14), (20, 18), (25, 18), (25, 14)); return program; } // A round cutout whose start lies on the blank but whose arc runs past its edge. static Program CircleOverEdge() { var program = Door(cutouts: false); program.Codes.Add(new RapidMove(3, 10)); program.Codes.Add(new ArcMove(new Vector(3, 10), new Vector(1, 10), RotationType.CW)); return program; } // Every corner on an L-shaped blank, but the long edge crosses its notch. static Program EdgeOverNotch() { var program = new Program(); Ring(program, LayerType.DisplayPerimeter, (0, 0), (0, 20), (15, 20), (15, 10), (30, 10), (30, 0)); Ring(program, LayerType.Cut, (2, 19), (29, 2), (2, 2)); return program; } static Program SecondDisplayRing() { var program = Door(); Ring(program, LayerType.DisplayPerimeter, (26, 14), (26, 18), (28, 18), (28, 14)); return program; } static Program TabbedOnly() { var program = Door(cutouts: false); program.Codes.Add(new RapidMove(5, 5)); program.Codes.Add(new LinearMove(5, 10) { Layer = LayerType.Cut }); program.Codes.Add(new LinearMove(10, 10) { Layer = LayerType.Tab }); program.Codes.Add(new LinearMove(10, 5) { Layer = LayerType.Cut }); program.Codes.Add(new LinearMove(5, 5) { Layer = LayerType.Cut }); return program; } static Program HoleOnDisplay() { var program = Door(LayerType.Cut, cutouts: false); program.MoveTo(5, 5); foreach (var (x, y) in new[] { (5.0, 10.0), (10.0, 10.0), (10.0, 5.0), (5.0, 5.0) }) program.Codes.Add(new LinearMove(x, y) { Layer = LayerType.DisplayPerimeter }); return program; } } private static void Ring(Program program, LayerType layer, params (double X, double Y)[] points) { program.Codes.Add(new RapidMove(points[0].X, points[0].Y)); foreach (var (x, y) in points.Skip(1).Append(points[0])) program.Codes.Add(new LinearMove(x, y) { Layer = layer }); } [Fact] public void Preparation_HasNoCutPerimeterAndTreatsEveryContourAsAHole() { var prepared = PreparedContours.Capture(Door(), ExplicitContourTests.Parameters()); Assert.False(prepared.HasCutPerimeter); Assert.Equal(3, prepared.Count); Assert.Equal(prepared.Count, prepared.PerimeterOrdinal); Assert.True(PreparedContours.Capture(Door(LayerType.Cut), ExplicitContourTests.Parameters()).HasCutPerimeter); } [Fact] public void CleanBounds_IncludeTheDisplayPerimeter() { var bounds = NestedPartContainment.CleanBounds(Door(), Vector.Zero, default); Assert.Equal(30, bounds.Length, 9); Assert.Equal(20, bounds.Width, 9); } [Fact] public void Replay_RefusesAProgramThatCutsTheDisplayPerimeter() { var material = LeadMaterialSnapshot.Capture(Door(), Vector.Zero); Assert.True(material.IsComplete, material.Reason); var holesOnly = new Program(); AddCutouts(holesOnly); var cutsOutline = Door(LayerType.Cut); Assert.True(ContourProgramVerifier.Verify( ExecutionMotionReader.ReadSupported(holesOnly, Vector.Zero, null, default), material, null, default)); Assert.False(ContourProgramVerifier.Verify( ExecutionMotionReader.ReadSupported(cutsOutline, Vector.Zero, null, default), material, null, default)); // Same count of cut rings as a valid plan: the outline in place of the circular cutout. var outlineForAHole = Door(LayerType.Cut, cutouts: false); outlineForAHole.MoveTo(5, 5); outlineForAHole.LineTo(5, 10); outlineForAHole.LineTo(10, 10); outlineForAHole.LineTo(10, 5); outlineForAHole.LineTo(5, 5); outlineForAHole.MoveTo(15, 5); outlineForAHole.LineTo(15, 12); outlineForAHole.LineTo(25, 12); outlineForAHole.LineTo(25, 5); outlineForAHole.LineTo(15, 5); Assert.False(ContourProgramVerifier.Verify( ExecutionMotionReader.ReadSupported(outlineForAHole, Vector.Zero, null, default), material, null, default)); } }