using OpenNest.CNC; using OpenNest.CNC.CuttingPlanning; using OpenNest.CNC.CuttingStrategy; using OpenNest.Diagnostics; using OpenNest.Engine.CuttingPlanning; using OpenNest.Geometry; using OpenNest.Support; namespace OpenNest.Tests.CuttingPlanning; /// /// Plan Cutting with "Tab parts the support grid cannot hold level": a part the grid cannot /// hold is tabbed where the tab steadies it; a supported part is left untabbed. /// public class SupportTabPlanningTests { private const double TabSize = 0.2; private static CuttingParameters Parameters() { var parameters = ExplicitContourTests.Parameters(); parameters.SupportTabs = true; parameters.TabConfig = new NormalTab { Size = TabSize }; return parameters; } // A 10 x 1 strip at the origin; the start is beside its lower-left corner. private static (Plate Plate, Part Part) Strip(SupportBed bed) { var plate = new Plate(20, 20) { SupportBed = bed }; var part = new Part(new Drawing("strip", LeadPathValidationTests.Rectangle(0, 0, 10, 1)), new Vector(2, 2)); plate.Parts.Add(part); return (plate, part); } private static (Vector Entry, Vector CutEnd) EntryAndCutEnd(FixedProgramPlacement proposal) { var motions = ExecutionMotionReader.Read(proposal.CopyProgram(), proposal.Location, null, default).Motions; var entry = motions.Last(m => m.Layer == LayerType.Leadin).End; var cutEnd = motions.Last(m => !m.Rapid && m.Layer is LayerType.Cut or LayerType.Display).End; return (entry, cutEnd); } [Fact] public void StripOnOneRowOfContacts_IsTabbedOnTheEdgeAcrossItsCenterFromTheRow() { // One row of grid points at y = 2.25 runs under the strip (y 2..3), below its center. var bed = new SupportGrid(2, 4, 0, 2.25, stabilityMargin: 0.1); var (plate, part) = Strip(bed); var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, new Vector(0, 0), confirmedParameters: Parameters())); Assert.True(result.Status == CuttingPlanStatus.Ready, string.Join("\n", result.Findings.Select(f => f.Message))); var (entry, cutEnd) = EntryAndCutEnd(Assert.Single(result.ProposedOrder)); Assert.Equal(3, entry.Y, 6); Assert.Equal(TabSize, entry.DistanceTo(cutEnd), 6); var support = SupportAnalyzer.Analyze(bed, plate.Quadrant, part); Assert.False(support.IsSupported); Assert.True(support.MarginWith(entry) >= bed.StabilityMargin); } // A 10 x 1 strip with a 2 x 0.2 bump on its top edge: inside corners at (4, 1) and (6, 1). private static Program BumpedStrip() { var program = new Program(); program.MoveTo(0, 0); program.LineTo(0, 1); program.LineTo(4, 1); program.LineTo(4, 1.2); program.LineTo(6, 1.2); program.LineTo(6, 1); program.LineTo(10, 1); program.LineTo(10, 0); program.LineTo(0, 0); return program; } [Fact] public void BumpedStrip_IsNotTabbedInAnInsideCorner() { // The bump's base corners tie with the top edge as tab points; the tab keeps clear. var bed = new SupportGrid(2, 4, 0, 2.25, stabilityMargin: 0.1); var plate = new Plate(20, 20) { SupportBed = bed }; plate.Parts.Add(new Part(new Drawing("bumped", BumpedStrip()), new Vector(2, 2))); var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, new Vector(0, 0), confirmedParameters: Parameters())); Assert.True(result.Status == CuttingPlanStatus.Ready, string.Join("\n", result.Findings.Select(f => f.Message))); var (entry, cutEnd) = EntryAndCutEnd(Assert.Single(result.ProposedOrder)); Assert.Equal(TabSize, entry.DistanceTo(cutEnd), 6); foreach (var corner in new[] { new Vector(6, 3), new Vector(8, 3) }) { Assert.True(entry.DistanceTo(corner) >= 2 * TabSize, $"entry {entry}"); Assert.True(cutEnd.DistanceTo(corner) >= TabSize, $"cut end {cutEnd}"); } } [Fact] public void BlockedSteadyingSide_TabsTheSteadiestEntryThatFitsAndReportsIt() { // Only the middle of the top edge steadies the strip by 0.2. Parts 0.1 above it and beside // its upper half leave no room for a lead-in there or at its top corners. var bed = new SupportGrid(2, 4, 0, 2.25, stabilityMargin: 0.2); var (plate, strip) = Strip(bed); plate.Parts.Add(new Part(new Drawing("above", LeadPathValidationTests.Rectangle(0, 0, 14, 2)), new Vector(0, 3.1))); plate.Parts.Add(new Part(new Drawing("left", LeadPathValidationTests.Rectangle(0, 0, 1.9, 0.5)), new Vector(0, 2.5))); plate.Parts.Add(new Part(new Drawing("right", LeadPathValidationTests.Rectangle(0, 0, 1.9, 0.5)), new Vector(12.1, 2.5))); var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, new Vector(7, 0), confirmedParameters: Parameters())); Assert.True(result.Status == CuttingPlanStatus.BestEffort, string.Join("\n", result.Findings.Select(f => f.Message))); var proposal = result.ProposedOrder.Single(p => ReferenceEquals(p.SourcePart, strip)); var (entry, cutEnd) = EntryAndCutEnd(proposal); Assert.Equal(TabSize, entry.DistanceTo(cutEnd), 6); // The steadiest entry that fits: halfway up an end, not the bottom corner nearer the start. var support = SupportAnalyzer.Analyze(bed, plate.Quadrant, strip); Assert.True(support.MarginWith(entry) > support.MarginWith(new Vector(7, 2)), $"entry {entry}"); Assert.True(entry.Y > 2.5 - 1e-9, $"entry {entry}"); Assert.True(support.MarginWith(entry) > support.MarginWith(new Vector(12, 2)), $"entry {entry}"); Assert.False(support.HoldsLevelWithTabAt(entry)); Assert.Contains(result.Findings, f => ReferenceEquals(f.SourcePart, strip) && f.Kind == PostVerificationKind.PartSupport && f.Message.Contains("no lead-in fits at a point where its tab would steady the part")); } [Fact] public void PartNoSingleTabCanHold_IsTabbedAndReported() { // The grid's rows run either side of the strip: nothing under it, so one tab can only balance it. var bed = new SupportGrid(1, 1, 0, 0.9, stabilityMargin: 0.1); var plate = new Plate(20, 20) { SupportBed = bed }; var strip = new Part(new Drawing("strip", LeadPathValidationTests.Rectangle(0, 0, 10, 0.8)), new Vector(2, 2)); plate.Parts.Add(strip); var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, new Vector(0, 0), confirmedParameters: Parameters())); Assert.Equal(CuttingPlanStatus.BestEffort, result.Status); var (entry, cutEnd) = EntryAndCutEnd(Assert.Single(result.ProposedOrder)); Assert.Equal(TabSize, entry.DistanceTo(cutEnd), 6); var warning = Assert.Single(result.Findings); Assert.Same(strip, warning.SourcePart); Assert.Equal(PostVerificationKind.PartSupport, warning.Kind); Assert.Contains("no single tab can steady it", warning.Message); } [Fact] public void StripWithALeadOut_IsTabbedAndPlanned() { // The lead-out leaves the tabbed perimeter from its trimmed end, away from the tab: the // open-cut proof shows it cuts no gap, as pre-post review does. var bed = new SupportGrid(2, 4, 0, 2.25, stabilityMargin: 0.1); var (plate, _) = Strip(bed); var parameters = Parameters(); parameters.ExternalLeadOut = new LineLeadOut { Length = 0.1, ApproachAngle = 60 }; var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, new Vector(0, 0), confirmedParameters: parameters)); Assert.True(result.Status == CuttingPlanStatus.Ready, string.Join("\n", result.Findings.Select(f => f.Message))); var proposal = Assert.Single(result.ProposedOrder); var (entry, cutEnd) = EntryAndCutEnd(proposal); Assert.Equal(TabSize, entry.DistanceTo(cutEnd), 6); var motions = ExecutionMotionReader.Read(proposal.CopyProgram(), proposal.Location, null, default).Motions; Assert.Equal(LayerType.Leadout, motions[^1].Layer); } // A 10 x 0.8 strip with a 9 x 0.4 slot near its bottom edge: no rapid from its top edge // reaches the plate below it without crossing the slot once that is cut. private static Program SlottedStrip() { var program = new Program(); program.Merge(LeadPathValidationTests.Rectangle(0.5, 0.1, 9.5, 0.5)); program.Merge(LeadPathValidationTests.Rectangle(0, 0, 10, 0.8)); return program; } [Fact] public void PartNoSingleTabCanHold_LeavesFromAnotherEntryWhenItsSteadiestIsBoxedIn() { // No grid row runs under the slotted strip, so no tab can hold it; its steadiest tab // point is on its top edge, across the slot from the part cut after it. var bed = new SupportGrid(1, 1, 0, 0.9, stabilityMargin: 0.1); var plate = new Plate(20, 20) { SupportBed = bed }; var slotted = new Part(new Drawing("slotted", SlottedStrip()), new Vector(2, 2)); plate.Parts.Add(slotted); plate.Parts.Add(new Part(new Drawing("below", LeadPathValidationTests.Rectangle(0, 0, 10, 0.8)), new Vector(2, 0.6))); var support = SupportAnalyzer.Analyze(bed, plate.Quadrant, slotted); Assert.False(support.TabCanSupport); Assert.True(support.BestTabPoint!.Value.Y > 2.4, $"best tab {support.BestTabPoint}"); var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, new Vector(0, 0), confirmedParameters: Parameters(), preservePartOrder: true)); Assert.True(result.Status == CuttingPlanStatus.BestEffort, string.Join("\n", result.Findings.Select(f => f.Message))); var (entry, cutEnd) = EntryAndCutEnd(result.ProposedOrder.Single(p => ReferenceEquals(p.SourcePart, slotted))); Assert.Equal(TabSize, entry.DistanceTo(cutEnd), 6); Assert.True(entry.Y < 2.4, $"entry {entry}"); Assert.Contains(result.Findings, f => ReferenceEquals(f.SourcePart, slotted) && f.Kind == PostVerificationKind.PartSupport && f.Message.Contains("no single tab can steady it")); } // A 0.8 x 10 upright strip at x 4..4.8 between squares cut before and after it on either side. // The kept order goes left, strip, right, then back left: that last rapid must cross the strip. private static (Plate Plate, Part Strip) StripBetweenSquares(SupportBed bed) { var plate = new Plate(20, 20) { SupportBed = bed }; var strip = new Part(new Drawing("strip", LeadPathValidationTests.Rectangle(0, 0, 0.8, 10)), new Vector(4, 1)); var square = new Drawing("square", LeadPathValidationTests.Rectangle(0, 0, 1, 1)); plate.Parts.Add(new Part(square, new Vector(1, 2))); plate.Parts.Add(strip); plate.Parts.Add(new Part(square, new Vector(7, 4))); plate.Parts.Add(new Part(square, new Vector(1, 8))); return (plate, strip); } [Theory] // No grid column runs under the strip: no single tab can hold it, so once cut it may tip. [InlineData(0.9, false)] // A column runs under it, off its center line: its tab holds it level, so it stays crossable. [InlineData(0.25, true)] public void PartNoSingleTabCanHold_IsNotCrossedOnceCut(double columnOffset, bool crossable) { var bed = new SupportGrid(1, 1, columnOffset, 0, stabilityMargin: 0.1); var (plate, strip) = StripBetweenSquares(bed); var support = SupportAnalyzer.Analyze(bed, plate.Quadrant, strip); Assert.False(support.IsSupported); Assert.Equal(crossable, support.TabCanSupport); var kept = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, new Vector(0, 0), confirmedParameters: Parameters(), preservePartOrder: true)); var free = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, new Vector(0, 0), confirmedParameters: Parameters())); Assert.Equal(crossable, kept.ProposedOrder.Count != 0); Assert.True(free.ProposedOrder.Count == plate.Parts.Count, string.Join("\n", free.Findings.Select(f => f.Message))); Assert.True(free.IndependentlyReplayed); if (crossable) return; // Free to reorder, the squares on the strip's left side are both cut before it. var stripAt = free.ProposedOrder.ToList().FindIndex(p => ReferenceEquals(p.SourcePart, strip)); Assert.All(free.ProposedOrder.Skip(stripAt + 1), p => Assert.True(p.Location.X > 5, $"{p.Location} after the strip")); } [Fact] public void FallbackCatalog_KeepsClearOfInsideCornersBeforeOfferingEveryEntry() { var bed = new SupportGrid(2, 4, 0, 0.25, stabilityMargin: 0.1); var program = BumpedStrip(); var clearance = SupportAnalyzer.InsideCornerClearance(TabSize); var support = SupportAnalyzer.Analyze(bed, 1, SupportMaterial.FromProgram(program, Vector.Zero), clearance); var prepared = PreparedContours.Capture(program, Parameters()) .WithSupportTab(support, Vector.Zero, new NormalTab { Size = TabSize }); var corners = new[] { new Vector(4, 1), new Vector(6, 1) }; bool NearACorner(ContourEntryCandidate c) => corners.Any(corner => c.Choice.Point.DistanceTo(corner) < clearance); var clear = prepared.AutomaticEntryCandidatesWithFallbacks(prepared.PerimeterOrdinal, supportEntries: SupportEntries.ClearOfInsideCorners); var any = prepared.AutomaticEntryCandidatesWithFallbacks(prepared.PerimeterOrdinal, supportEntries: SupportEntries.Any); Assert.Contains(any, NearACorner); Assert.DoesNotContain(clear, NearACorner); Assert.Equal(any.Count(c => !NearACorner(c)), clear.Count); } [Fact] public void SupportedPart_IsNotTabbed() { var (plate, _) = Strip(new SupportGrid(0.5, 0.5, 0.25, 0.25, stabilityMargin: 0.1)); var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, new Vector(0, 0), confirmedParameters: Parameters())); Assert.Equal(CuttingPlanStatus.Ready, result.Status); var (entry, cutEnd) = EntryAndCutEnd(Assert.Single(result.ProposedOrder)); Assert.Equal(0, entry.DistanceTo(cutEnd), 6); } [Fact] public void WithoutSupportTabs_TheGridChangesNothing() { var bed = new SupportGrid(2, 4, 0, 2.25, stabilityMargin: 0.1); var parameters = Parameters(); parameters.SupportTabs = false; var (withBed, _) = Strip(bed); var (withoutBed, _) = Strip(null); var planned = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(withBed, new Vector(0, 0), confirmedParameters: parameters)); var plain = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(withoutBed, new Vector(0, 0), confirmedParameters: parameters)); Assert.Equal(ExplicitContourTests.Fingerprint(Assert.Single(plain.ProposedOrder).CopyProgram()), ExplicitContourTests.Fingerprint(Assert.Single(planned.ProposedOrder).CopyProgram())); } }