diff --git a/OpenNest.Core/CNC/CuttingPlanning/ReleasedContourState.cs b/OpenNest.Core/CNC/CuttingPlanning/ReleasedContourState.cs
index 23c990be..07e03823 100644
--- a/OpenNest.Core/CNC/CuttingPlanning/ReleasedContourState.cs
+++ b/OpenNest.Core/CNC/CuttingPlanning/ReleasedContourState.cs
@@ -24,6 +24,25 @@ public sealed class ReleasedContourState
private int partContours;
private bool partClosed;
+ ///
+ /// Parts (by caller part number) whose tabbed outside is an obstacle once the part ends, closed
+ /// across its tab gap, as if the part were cut free. A tabbed part stays in the sheet and may be
+ /// passed over, but a route around it is safer: planning looks for one first and lets rapids
+ /// cross only the tabbed parts it finds no way around. It is asked at each rapid, so a part can
+ /// become crossable after it was cut, in this state and its copies alike. Null avoids none.
+ ///
+ internal Func AvoidTabbedPart { get; init; }
+
+ ///
+ /// The part whose tabbed outside 's rapid crosses, when that outside is
+ /// an obstacle only because tabbed parts are avoided (); null otherwise.
+ ///
+ internal static int? AvoidedTabbedPart(PostVerificationFinding finding) =>
+ finding is { Kind: PostVerificationKind.RapidCrossing, OtherPartNumber: { } part }
+ && finding.Message.EndsWith(TabbedOutside(part), StringComparison.Ordinal) ? part : null;
+
+ private static string TabbedOutside(int part) => $"the tabbed outside of part {part}.";
+
/// Why a lead-out after an open cut is refused when the open-cut proof cannot clear it.
internal const string LeadOutRetentionMessage =
"A lead-out follows an open cutting contour and may cut through its retention gap. "
@@ -58,6 +77,7 @@ public sealed class ReleasedContourState
{
var copy = new ReleasedContourState(reportMissingLeadIns, tabMayNotHold, commonLineMember)
{
+ AvoidTabbedPart = AvoidTabbedPart,
partContours = partContours,
partClosed = partClosed,
};
@@ -229,6 +249,9 @@ public sealed class ReleasedContourState
// A rapid well clear of a contour's extent can neither cross nor touch it.
if (reach.IsClearOf(obstacle.Extent))
continue;
+ // A tabbed part is avoided only while planning still looks for a way around it.
+ if (obstacle.Tabbed && AvoidTabbedPart?.Invoke(obstacle.Part) != true)
+ continue;
// A rapid leaving an overcut departs from its retraced tail, which lies on the first
// cut only within the seam tolerance its arcs were matched at. Contact within that
// much of the departure is the departure itself.
@@ -244,6 +267,8 @@ public sealed class ReleasedContourState
? $"the tabbed outside of part {obstacle.Part}, which its tab may not hold level."
: obstacle.TabCutFree
? $"the tabbed outside of part {obstacle.Part}, whose lead-out may cut its tab free."
+ : obstacle.Tabbed
+ ? TabbedOutside(obstacle.Part)
: $"completed untabbed contour {obstacle.Contour} of part {obstacle.Part}."))
{
Location = (start + move.End) * 0.5,
@@ -391,13 +416,19 @@ public sealed class ReleasedContourState
curves.Add(PostVerificationGeometry.Curve.Create(curves[^1].End, curves[0].Start, null, false));
obstacles.Add(new(part, contourNumber, curves, null));
}
- else if (!cutoff && unfinished.Count > 0 && (cutFree || tabMayNotHold?.Invoke(part) == true))
+ else if (!cutoff && unfinished.Count > 0 && (cutFree || AvoidTabbedPart != null || tabMayNotHold?.Invoke(part) == true))
{
var perimeter = unfinished.MaxBy(chain => chain.Curves.Sum(curve => curve.Length));
var curves = perimeter.Curves.ToList();
if (curves[^1].End.DistanceTo(curves[0].Start) > PostVerificationGeometry.Epsilon)
curves.Add(PostVerificationGeometry.Curve.Create(curves[^1].End, curves[0].Start, null, false));
- obstacles.Add(new(part, contourNumber, curves, null) { TabMayNotHold = !cutFree, TabCutFree = cutFree });
+ var mayNotHold = !cutFree && tabMayNotHold?.Invoke(part) == true;
+ obstacles.Add(new(part, contourNumber, curves, null)
+ {
+ TabMayNotHold = mayNotHold,
+ TabCutFree = cutFree,
+ Tabbed = !cutFree && !mayNotHold,
+ });
}
partContours = contourNumber;
partClosed = !cutoff && isFixed == null && unfinished.Count == 0 && deferred.Count == 0 && !reportedTab
@@ -682,5 +713,8 @@ public sealed class ReleasedContourState
/// A tabbed perimeter closed across its tab gap, whose lead-out may cut the tab free.
internal bool TabCutFree { get; init; }
+
+ /// A tabbed perimeter closed across its tab gap, avoided while another route exists.
+ internal bool Tabbed { get; init; }
}
}
diff --git a/OpenNest.Engine/CuttingPlanning/CuttingPlanBatch.cs b/OpenNest.Engine/CuttingPlanning/CuttingPlanBatch.cs
index 83a9f160..b005cb23 100644
--- a/OpenNest.Engine/CuttingPlanning/CuttingPlanBatch.cs
+++ b/OpenNest.Engine/CuttingPlanning/CuttingPlanBatch.cs
@@ -265,9 +265,11 @@ public sealed class CuttingPlanBatch
// A replayed proposal whose only warnings are fixed emissions passed every strict
// check; fixed emissions never steer the search, so the full pass cannot improve it.
// A plan keeping tab lead-outs is not taken from the short pass: the full pass may
- // still find a clean route.
+ // still find a clean route. Nor is one that passes over tabbed parts: the full pass
+ // may still find a route around them.
if (first.IndependentlyReplayed && first.Status is CuttingPlanStatus.Ready or CuttingPlanStatus.BestEffort
&& !first.Findings.Any(f => f.Kind == PostVerificationKind.TabLeadOut)
+ && (first.Snapshot is { AvoidsTabbedParts: true, CrossableTabbedParts.Count: 0 } || !snapshot.HasTabbedParts)
|| first.Status == CuttingPlanStatus.Canceled)
return first;
}
diff --git a/OpenNest.Engine/CuttingPlanning/CuttingPlanModels.cs b/OpenNest.Engine/CuttingPlanning/CuttingPlanModels.cs
index a018f0b0..eb484219 100644
--- a/OpenNest.Engine/CuttingPlanning/CuttingPlanModels.cs
+++ b/OpenNest.Engine/CuttingPlanning/CuttingPlanModels.cs
@@ -91,10 +91,51 @@ public sealed class CuttingPlanSnapshot
///
/// An empty rapid checker for this capture. A tabbed part counts as steady once cut, so
- /// rapids may cross it as its retained material allows.
+ /// rapids may cross it as its retained material allows; with
+ /// its outside is an obstacle all the same.
///
internal ReleasedContourState NewReleasedState() =>
- new(reportMissingLeadIns: false, null, CommonLineMembers.Count == 0 ? null : CommonLineMembers.Contains);
+ new(reportMissingLeadIns: false, null, CommonLineMembers.Count == 0 ? null : CommonLineMembers.Contains)
+ {
+ AvoidTabbedPart = AvoidsTabbedParts ? part => !CrossableTabbedParts.Contains(part) : null,
+ };
+
+ ///
+ /// Whether rapids keep off tabbed parts already cut, as they do off parts cut free. Planning
+ /// tries this first () and lets rapids cross only the
+ /// tabbed parts it finds no way around ().
+ ///
+ internal bool AvoidsTabbedParts { get; init; }
+
+ ///
+ /// With , the part numbers (source ordinal + 1) of the tabbed
+ /// parts rapids may still pass over. The one search planning this capture adds the parts it
+ /// finds no route around (); its checkers, cut-off placement and the
+ /// replay of its plan all read this same set. Nothing else may change it.
+ ///
+ internal HashSet CrossableTabbedParts { get; init; } = [];
+
+ ///
+ /// Lets rapids pass over tabbed part from here on. False when
+ /// this capture does not avoid tabbed parts or the part was crossable already.
+ ///
+ internal bool AllowCrossing(int partNumber) => AvoidsTabbedParts && CrossableTabbedParts.Add(partNumber);
+
+ /// Whether any regenerated part's outside is tabbed, so avoiding tabbed parts changes the search.
+ internal bool HasTabbedParts => Placements.Any(placement => placement.Prepared is { PerimeterTabbed: true });
+
+ /// The same capture planned with rapids kept off tabbed parts already cut.
+ internal CuttingPlanSnapshot WithTabbedPartsAvoided() =>
+ new(Placements, StartPoint, ExpansionBudget, Failure, Findings, Regeneration,
+ PreservePartOrder, MaxEntries, ExpansionObserver, PlateState, OwnedParameters,
+ Dependencies, BestEffort)
+ {
+ SupportTabsSkipped = SupportTabsSkipped,
+ CommonLineMembers = CommonLineMembers,
+ CommonLineOrder = CommonLineOrder,
+ AcceptsTabLeadOuts = AcceptsTabLeadOuts,
+ AvoidsTabbedParts = true,
+ };
///
/// Part numbers (source ordinal + 1) of the members of common-line groups cut once
@@ -146,6 +187,8 @@ public sealed class CuttingPlanSnapshot
CommonLineMembers = CommonLineMembers,
CommonLineOrder = CommonLineOrder,
AcceptsTabLeadOuts = AcceptsTabLeadOuts,
+ AvoidsTabbedParts = AvoidsTabbedParts,
+ CrossableTabbedParts = [.. CrossableTabbedParts],
};
///
@@ -162,6 +205,8 @@ public sealed class CuttingPlanSnapshot
CommonLineMembers = CommonLineMembers,
CommonLineOrder = CommonLineOrder,
AcceptsTabLeadOuts = true,
+ AvoidsTabbedParts = AvoidsTabbedParts,
+ CrossableTabbedParts = [.. CrossableTabbedParts],
};
/// Whether this capture accepts tab lead-outs (see ).
@@ -180,6 +225,8 @@ public sealed class CuttingPlanSnapshot
CommonLineMembers = CommonLineMembers,
CommonLineOrder = CommonLineOrder,
AcceptsTabLeadOuts = AcceptsTabLeadOuts,
+ AvoidsTabbedParts = AvoidsTabbedParts,
+ CrossableTabbedParts = [.. CrossableTabbedParts],
};
}
diff --git a/OpenNest.Engine/CuttingPlanning/CuttingPlanService.cs b/OpenNest.Engine/CuttingPlanning/CuttingPlanService.cs
index ca8f7017..0fb40240 100644
--- a/OpenNest.Engine/CuttingPlanning/CuttingPlanService.cs
+++ b/OpenNest.Engine/CuttingPlanning/CuttingPlanService.cs
@@ -290,6 +290,22 @@ public static class CuttingPlanService
/// Worker-only planning uses owned values; live identities are never dereferenced.
public static CuttingPlanResult Plan(CuttingPlanSnapshot snapshot, CancellationToken token = default)
{
+ // A tabbed part stays in the sheet and may be passed over, but a route around it is safer:
+ // look for one first, with tabbed parts as obstacles, and cross them only without it.
+ // Where the search finds no way around one, that part alone becomes crossable and the
+ // search goes on, so a boxed-in part does not give up the rest. A plan it still cannot
+ // find is searched for as before, with every tabbed part crossable.
+ if (snapshot is { AvoidsTabbedParts: false, Regeneration: true, BestEffort: false, Failure: null, HasTabbedParts: true })
+ {
+ var avoiding = snapshot.WithTabbedPartsAvoided();
+ var clear = PlanCaptured(avoiding, token);
+ if (clear.IndependentlyReplayed && clear.Status is CuttingPlanStatus.Ready or CuttingPlanStatus.BestEffort
+ || clear.Status == CuttingPlanStatus.Canceled)
+ {
+ clear.Snapshot = avoiding;
+ return clear;
+ }
+ }
var result = PlanCaptured(snapshot, token);
result.Snapshot = snapshot;
// Refused only for configured lead-outs that may cut their tabs free: plan again keeping
diff --git a/OpenNest.Engine/CuttingPlanning/JointCuttingPlanSearch.cs b/OpenNest.Engine/CuttingPlanning/JointCuttingPlanSearch.cs
index 492f86b1..ff230042 100644
--- a/OpenNest.Engine/CuttingPlanning/JointCuttingPlanSearch.cs
+++ b/OpenNest.Engine/CuttingPlanning/JointCuttingPlanSearch.cs
@@ -94,16 +94,36 @@ internal static class JointCuttingPlanSearch
if (snapshot.PreservePartOrder)
{
var keptSequence = Enumerable.Range(0, count).ToArray();
- if (preferEndpoints)
+ // The order is fixed, so a tabbed part an approach cannot get around is passed over:
+ // each pass that stops at one goes on from there with that part crossable.
+ Node keptResume = null;
+ while (true)
{
- var preferred = walk.Follow(keptSequence, stall, null, preferredOnly: true);
- if (preferred.Order != null)
- return walk.Ready(preferred.Order);
- var recovered = walk.Follow(keptSequence, stall, null, contourRecovery: true);
- if (recovered.Order != null)
- return walk.Ready(recovered.Order);
+ var stopped = new List();
+ if (preferEndpoints)
+ {
+ var preferred = walk.Follow(keptSequence, stall, keptResume, preferredOnly: true);
+ if (preferred.Order != null)
+ return walk.Ready(preferred.Order);
+ var recovered = walk.Follow(keptSequence, stall, keptResume, contourRecovery: true);
+ if (recovered.Order != null)
+ return walk.Ready(recovered.Order);
+ stopped.AddRange([preferred, recovered]);
+ }
+ else
+ {
+ // The full pass below never stalls; this one only finds where a tabbed part blocks.
+ var plain = snapshot.AvoidsTabbedParts ? walk.Follow(keptSequence, stall, keptResume) : null;
+ if (plain?.Order != null)
+ return walk.Ready(plain.Order);
+ if (plain != null)
+ stopped.Add(plain);
+ }
+ if (PassOver(snapshot, stopped) is not { } onward)
+ break;
+ keptResume = onward;
}
- var kept = walk.Follow(keptSequence, null, null, expansionLimit: FallbackLimit());
+ var kept = walk.Follow(keptSequence, null, keptResume, expansionLimit: FallbackLimit());
return kept.Order != null ? walk.Ready(kept.Order) : walk.Exhausted();
}
@@ -129,6 +149,7 @@ internal static class JointCuttingPlanSearch
// A pass that teaches an order rule ends the round: the heavier passes would
// only repeat the same blocked approach along the same order.
Attempt attempt = null;
+ Node onward = null;
foreach (var (preferredOnly, contourRecovery) in preferEndpoints
? new[] { (true, false), (false, true), (false, false) }
: doorAlone ? [(false, true), (false, false)] : [(false, false)])
@@ -136,12 +157,24 @@ internal static class JointCuttingPlanSearch
var pass = walk.Follow(sequence, stall, resume, preferredOnly, contourRecovery, prerequisites);
if (pass.Order != null)
return walk.Ready(pass.Order);
+ // Stopped at a tabbed part still avoided, after trying the entries that might
+ // clear it: pass over it and go on from there along the same order. It teaches
+ // no order rule, and the heavier passes are not tried first: on a plate of
+ // tabbed parts either costs far more search than it saves crossings.
+ onward = PassOver(snapshot, [pass]);
+ if (onward != null)
+ break;
if (Learn(pass, sequence, prerequisites, revoked, swaps))
{
attempt = pass;
break;
}
}
+ if (onward != null)
+ {
+ resume = onward;
+ continue;
+ }
// Nothing new to learn after a swap: take back the newest swap and learn the plain
// rule its attempt would have taught instead, backing up from that attempt.
while (attempt == null && swaps.Count != 0)
@@ -232,6 +265,29 @@ internal static class JointCuttingPlanSearch
}, token, exits);
}
+ // Whether the pass stopped at a part whose approach crossed a tabbed part the capture still
+ // avoids (see CuttingPlanSnapshot.AvoidsTabbedParts).
+ private static bool StoppedAtTabbed(CuttingPlanSnapshot snapshot, Attempt pass) =>
+ snapshot.AvoidsTabbedParts && pass.Blocked != null
+ && pass.CrossedTabbed.Any(part => !snapshot.CrossableTabbedParts.Contains(part + 1));
+
+ // Lets rapids pass over the tabbed parts still avoided that the heaviest of these stopped
+ // passes crossed on its blocked approach. Returns the part boundary that pass was blocked at,
+ // to go on from; null when no pass stopped at a tabbed part still avoided.
+ private static Node PassOver(CuttingPlanSnapshot snapshot, IReadOnlyList stopped)
+ {
+ for (var index = stopped.Count - 1; index >= 0; index--)
+ {
+ var pass = stopped[index];
+ if (!StoppedAtTabbed(snapshot, pass))
+ continue;
+ foreach (var part in pass.CrossedTabbed.Order())
+ snapshot.AllowCrossing(part + 1);
+ return pass.Boundary;
+ }
+ return null;
+ }
+
// When the approach crossed the part cut just before the one it left from, and no part but
// those two, the tool went on past that part and came back across it: "cut those two the
// other way round", so the tool leaves from the nearer one (two stacked strips, cut far one
@@ -1791,6 +1847,15 @@ internal static class JointCuttingPlanSearch
/// Parts whose completed contours the blocked part's motions crossed (it can be among them).
internal HashSet Crossed { get; } = [];
+ ///
+ /// The parts among whose tabbed outside was crossed while tabbed parts
+ /// are avoided ().
+ ///
+ internal HashSet CrossedTabbed { get; } = [];
+
+ /// The deepest whole-part boundary reached, where the blocked part's approach starts.
+ internal Node Boundary => Deepest;
+
// Records a node that gets further along the order than any before. True when it does.
internal bool Advance(Node node)
{
@@ -1802,6 +1867,7 @@ internal static class JointCuttingPlanSearch
{
Deepest = node;
Crossed.Clear();
+ CrossedTabbed.Clear();
}
return true;
}
@@ -1811,6 +1877,7 @@ internal static class JointCuttingPlanSearch
progress = -1;
Deepest = null;
Crossed.Clear();
+ CrossedTabbed.Clear();
}
internal void NoteCrossings(int ordinal, IEnumerable findings)
@@ -1819,7 +1886,11 @@ internal static class JointCuttingPlanSearch
return;
foreach (var finding in findings)
if (finding.Kind == PostVerificationKind.RapidCrossing && finding.OtherPartNumber is int other)
+ {
Crossed.Add(other - 1);
+ if (ReleasedContourState.AvoidedTabbedPart(finding) != null)
+ CrossedTabbed.Add(other - 1);
+ }
}
/// The part boundary at on the way to the deepest one.
diff --git a/OpenNest.Tests/CuttingPlanning/PlanningCharacterizationTests.cs b/OpenNest.Tests/CuttingPlanning/PlanningCharacterizationTests.cs
index 30cadf29..4922ccf5 100644
--- a/OpenNest.Tests/CuttingPlanning/PlanningCharacterizationTests.cs
+++ b/OpenNest.Tests/CuttingPlanning/PlanningCharacterizationTests.cs
@@ -44,7 +44,7 @@ public class PlanningCharacterizationTests
[InlineData("holes-grid", "5410ECC55639AC89E49361D2D65E58C79FF940C65F5513F7E3A54EF04715BB25")]
[InlineData("holes-grid-kept-order", "07B70B43549E95C65407B24944DA8F7262B784CFC4ABF86241C10DD8272B1780")]
[InlineData("rounded-circle-leads", "73677429BFC950669D238E834CAE48F54A483759BE4E0BB1437D096F0AF7F3DA")]
- [InlineData("tabbed-perimeters", "6858C09A02D73E4531D0D59B6CD1CFFFA2C9C8BA5F48CF4943D9C4AEC17195BA")]
+ [InlineData("tabbed-perimeters", "BE84012043FDCA472AFC8E5508CEB49D7A18F1FC964717D8F6938D46E412065F")]
[InlineData("locked-among-regenerated", "42AFCF0DE942F501D8542C091C9D4407EAE41DE9442F75300348DCDB4FF0C733")]
public void FocusedFixture_PlansExactlyAsBefore(string name, string expected)
{
diff --git a/OpenNest.Tests/CuttingPlanning/TabbedPartAvoidanceTests.cs b/OpenNest.Tests/CuttingPlanning/TabbedPartAvoidanceTests.cs
new file mode 100644
index 00000000..1da7219a
--- /dev/null
+++ b/OpenNest.Tests/CuttingPlanning/TabbedPartAvoidanceTests.cs
@@ -0,0 +1,93 @@
+using OpenNest.CNC.CuttingPlanning;
+using OpenNest.CNC.CuttingStrategy;
+using OpenNest.Diagnostics;
+using OpenNest.Engine.CuttingPlanning;
+using OpenNest.Geometry;
+
+namespace OpenNest.Tests.CuttingPlanning;
+
+///
+/// A tabbed part stays in the sheet, so a rapid may pass over it, but Plan Cutting looks for a
+/// route around it first and passes over only the tabbed parts it finds no way around.
+///
+public class TabbedPartAvoidanceTests
+{
+ private static CuttingParameters Tabbed()
+ {
+ var parameters = ExplicitContourTests.Parameters();
+ parameters.TabsEnabled = true;
+ parameters.TabConfig = new NormalTab { Size = 0.2 };
+ return parameters;
+ }
+
+ // The parts whose tabbed outside a rapid of the planned route passes over, by part number.
+ private static int[] PassedOver(CuttingPlanResult result, Vector start)
+ {
+ var checker = new ReleasedContourState(reportMissingLeadIns: false) { AvoidTabbedPart = _ => true };
+ var position = start;
+ var crossed = new List();
+ foreach (var proposal in result.ProposedOrder)
+ {
+ var execution = ExecutionMotionReader.Read(proposal.CopyProgram(), proposal.Location, position, default);
+ crossed.AddRange(checker.Check(execution, position, proposal.SourceOrdinal + 1)
+ .Select(ReleasedContourState.AvoidedTabbedPart).OfType());
+ position = execution.DeparturePoint;
+ }
+ return crossed.Distinct().Order().ToArray();
+ }
+
+ [Fact]
+ public void TabbedParts_AreRoutedAround_WhenARouteExists()
+ {
+ // Four tabbed 10 x 10 squares in a 2 x 2 grid: left tabbed-crossable, the plan left each
+ // square across the square itself.
+ var plate = new Plate(300, 300);
+ var square = new Drawing("square", ExplicitContourTests.Square(false));
+ foreach (var i in Enumerable.Range(0, 4))
+ plate.Parts.Add(new Part(square, new Vector(1 + i % 2 * 11, 1 + i / 2 * 11)));
+
+ var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, new Vector(0, 0),
+ confirmedParameters: Tabbed()));
+
+ Assert.True(result.Status == CuttingPlanStatus.Ready, string.Join("\n", result.Findings.Select(f => f.Message)));
+ Assert.True(result.IndependentlyReplayed);
+ Assert.Empty(PassedOver(result, new Vector(0, 0)));
+ }
+
+ [Fact]
+ public void TabbedPart_IsPassedOver_OnlyWhereNoRouteGoesAround()
+ {
+ // A tabbed 0.8 x 10 upright strip between squares, in a kept order that goes left, strip,
+ // right, then back left: that last rapid can only cross the strip.
+ var plate = new Plate(20, 20);
+ var square = new Drawing("square", LeadPathValidationTests.Rectangle(0, 0, 1, 1));
+ plate.Parts.Add(new Part(square, new Vector(1, 2)));
+ plate.Parts.Add(new Part(new Drawing("strip", LeadPathValidationTests.Rectangle(0, 0, 0.8, 10)), new Vector(4, 1)));
+ plate.Parts.Add(new Part(square, new Vector(7, 4)));
+ plate.Parts.Add(new Part(square, new Vector(1, 8)));
+
+ var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, new Vector(0, 0),
+ confirmedParameters: Tabbed(), preservePartOrder: true));
+
+ Assert.True(result.Status == CuttingPlanStatus.Ready, string.Join("\n", result.Findings.Select(f => f.Message)));
+ Assert.True(result.IndependentlyReplayed);
+ Assert.Equal([2], PassedOver(result, new Vector(0, 0)));
+ }
+
+ [Fact]
+ public void WithoutTabs_NothingIsAvoidedOrPassedOver()
+ {
+ var plate = new Plate(300, 300);
+ var square = new Drawing("square", ExplicitContourTests.Square(false));
+ foreach (var i in Enumerable.Range(0, 4))
+ plate.Parts.Add(new Part(square, new Vector(1 + i % 2 * 11, 1 + i / 2 * 11)));
+
+ var snapshot = CuttingPlanService.Capture(CuttingPlanRequest.ForPlate(plate, new Vector(0, 0),
+ confirmedParameters: ExplicitContourTests.Parameters()));
+ var result = CuttingPlanService.Plan(snapshot);
+
+ Assert.Equal(CuttingPlanStatus.Ready, result.Status);
+ Assert.False(snapshot.HasTabbedParts);
+ Assert.False(result.Snapshot.AvoidsTabbedParts);
+ }
+}
diff --git a/docs/cutting-planner.md b/docs/cutting-planner.md
index 6c5f8310..fb070cba 100644
--- a/docs/cutting-planner.md
+++ b/docs/cutting-planner.md
@@ -39,7 +39,7 @@ var result = CuttingPlanService.Plan(snapshot, cancellationToken);
the plate's own under `ForPlate`), each regenerated part the bed cannot hold level gets a
tabbed perimeter whose automatic entries prefer points where the tab steadies it. A tabbed
part counts as steady wherever its tab is: it is never warned about and stays crossable once
- cut. A tab in an inside corner is noted on the plan without changing its status. A part no
+ cut, though the plan [goes around it where it can](#tabbed-parts-are-avoided-first). A tab in an inside corner is noted on the plan without changing its status. A part no
longer than `TabHeldMaxLength` is held by its tab
alone, so any tab clear of inside corners steadies it. Without a bed, or with
`CuttingParameters.TabBySize`, the parts whose width is in `TabSizeMinWidth`..`TabSizeMaxWidth`
@@ -294,6 +294,30 @@ expansion budget; exhausting it still returns a refusal from the service, never
best-effort upgrade. Only the batch then looks for the separate
[safest route](#safest-route-fallback-when-the-search-runs-out).
+### Tabbed parts are avoided first
+
+A tabbed part stays in the sheet, so a rapid may pass over it, but a route around it is safer.
+When any regenerated part's outside is tabbed (support tabs or the settings' own tabs),
+`CuttingPlanService.Plan` first searches with every tabbed outside as an obstacle once its part
+is cut, closed across its tab gap (`CuttingPlanSnapshot.WithTabbedPartsAvoided`,
+`ReleasedContourState.AvoidTabbedPart`). Entry backtracking then leaves a tabbed part on a
+side that clears it, where its catalog has one.
+
+A pass along the order that stalls at a part whose approach crosses a tabbed part still avoided
+makes just the crossed parts crossable (`CuttingPlanSnapshot.CrossableTabbedParts`) and goes on
+from there along the same order. It learns no order rule from a tabbed part: on a plate of
+tabbed parts, reordering around each one spent the whole budget without finding a plan. So a
+tabbed part is passed over only where no entry of the parts on that order avoids it, typically
+a part whose only level-holding tab point faces away from the next cut. The checkers of that
+search, cut-off placement and the independent replay all read the same set, so the replayed
+plan is the one searched. Its hard obstacles are unchanged: a tabbed part's holes, parts cut
+free, and tabbed outsides whose lead-out may cut the tab free.
+
+A capture this search cannot plan is planned again as before, with every tabbed part crossable.
+The desktop batch's short first pass is kept only when it passed over no tabbed part; otherwise
+the full pass looks for a route around them. The safest-route fallback and the pre-post review
+do not avoid tabbed parts. A plate with no tabbed outside is searched once, exactly as before.
+
### Cutoff segments
A cutoff segment is a fixed open cut that is cut the same way wherever it goes and is
diff --git a/docs/support-tabs.md b/docs/support-tabs.md
index 238ca5e1..8f99c507 100644
--- a/docs/support-tabs.md
+++ b/docs/support-tabs.md
@@ -184,7 +184,9 @@ its steadying entries.
A tabbed part counts as steady wherever its tab is: the steadiest entries above are preferences,
never a warning. No message says a tab cannot steady its part, and once cut a tabbed part stays
-crossable, as its retained material allows, whether or not its tab holds it level. The pre-post
+crossable, as its retained material allows, whether or not its tab holds it level. Plan Cutting
+still routes around tabbed parts where it can and passes over only those it finds no way around
+(see [tabbed parts are avoided first](cutting-planner.md#tabbed-parts-are-avoided-first)). The pre-post
review does not read support settings for rapids, so it checks rapid crossings against untabbed
contours only.