mirror of
https://github.com/ajisaacs/OpenNest.git
synced 2026-11-22 04:17:40 -05:00
fix(cutting): rank every support-tabbed part's entries by the route
A part a single tab could hold level kept its outside entry to the points where the tab steadied it, so the head detoured to them and often left the part back over itself. Tabs hold most parts wherever they land, a part whose tab does not is still tabbed and avoided once cut, and the detour costs every part. Every support-tabbed perimeter now offers each entry clear of inside corners (plus its best tab point), ranked toward the next cut like an untabbed part's. Only when none of those fits a lead-in does the search fall back to every entry, steadiest first. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
60f9f1cc56
commit
18ab2f2cbb
7 files changed
+76
-91
No files matched your search
@@ -64,10 +64,10 @@ internal enum AutomaticEntryKind
|
||||
/// </summary>
|
||||
internal enum SupportEntries
|
||||
{
|
||||
/// <summary>Entries whose tab steadies the part, clear of inside corners, plus its best tab point.</summary>
|
||||
Steadying,
|
||||
|
||||
/// <summary>Every entry clear of inside corners: the fallback when no steadying entry fits.</summary>
|
||||
/// <summary>
|
||||
/// Every entry clear of inside corners, plus the best tab point: the route decides among
|
||||
/// them, not how well the tab steadies the part.
|
||||
/// </summary>
|
||||
ClearOfInsideCorners,
|
||||
|
||||
/// <summary>Every entry: the last fallback, when nothing clear of inside corners fits.</summary>
|
||||
|
||||
@@ -190,8 +190,8 @@ public sealed class PreparedContours
|
||||
/// <summary>
|
||||
/// A copy whose perimeter is tabbed with <paramref name="tab"/> where it steadies the part
|
||||
/// on its support bed: <paramref name="support"/> analyzed this part's material placed at
|
||||
/// <paramref name="location"/>, and the perimeter's automatic entries keep to points it
|
||||
/// accepts (<see cref="PartSupport.AcceptsTabAt"/>) plus its best tab point. A pinned
|
||||
/// <paramref name="location"/>, and the perimeter's automatic entries keep clear of inside
|
||||
/// corners, with its best tab point added. A pinned
|
||||
/// perimeter keeps its pin's entry, leads and tab (the drawing wins); the copy only keeps
|
||||
/// the analysis, so replay can report a pin that leaves the part unsteady.
|
||||
/// </summary>
|
||||
@@ -733,7 +733,7 @@ public sealed class PreparedContours
|
||||
return new[] { new ContourEntryCandidate(fixedEntry, AutomaticEntryKind.Pinned) };
|
||||
if (IsSingleCircle(shape))
|
||||
throw new ArgumentException("Circles have no preferred corners or joints; use the fallback catalog.");
|
||||
return SupportFiltered(contourOrdinal, PreferredCandidates(shape, contourOrdinal, token), SupportEntries.Steadying);
|
||||
return SupportFiltered(contourOrdinal, PreferredCandidates(shape, contourOrdinal, token), SupportEntries.ClearOfInsideCorners);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -751,7 +751,7 @@ public sealed class PreparedContours
|
||||
int contourOrdinal,
|
||||
Vector? lookAhead = null,
|
||||
CancellationToken token = default,
|
||||
SupportEntries supportEntries = SupportEntries.Steadying)
|
||||
SupportEntries supportEntries = SupportEntries.ClearOfInsideCorners)
|
||||
{
|
||||
token.ThrowIfCancellationRequested();
|
||||
var shape = GetShape(contourOrdinal);
|
||||
@@ -768,7 +768,7 @@ public sealed class PreparedContours
|
||||
|
||||
/// <summary>
|
||||
/// Whether this preparation tabs its perimeter for support (see <see cref="WithSupportTab"/>):
|
||||
/// its automatic catalog then keeps to steadying points unless asked for a fallback.
|
||||
/// its automatic catalog then keeps clear of inside corners unless asked for every entry.
|
||||
/// </summary>
|
||||
internal bool HasSupportTab => support != null && !IsPinned(PerimeterOrdinal);
|
||||
|
||||
@@ -791,7 +791,7 @@ public sealed class PreparedContours
|
||||
/// The perimeter entry at <paramref name="exit"/> (local), where the straight line from the
|
||||
/// cutout cut last to the next cut leaves the part: an entry on that line makes the way from
|
||||
/// the cutout through the outside to the next cut as short as it can be. Null for a pinned
|
||||
/// perimeter, a reflex or cusp vertex, or a point the perimeter's support tab may not take
|
||||
/// perimeter, a reflex or cusp vertex, or a support tab's point too near an inside corner
|
||||
/// (the same rule as its automatic catalog).
|
||||
/// </summary>
|
||||
internal ContourEntryCandidate ShortestPathEntry(Vector exit)
|
||||
@@ -802,34 +802,24 @@ public sealed class PreparedContours
|
||||
var choice = ClosestEntry(PerimeterOrdinal, exit);
|
||||
if (IsForbiddenVertex(GetShape(PerimeterOrdinal), choice.Point))
|
||||
return null;
|
||||
if (support != null && !(support.TabCanSupport
|
||||
? support.AcceptsTabAt(choice.Point + supportOrigin)
|
||||
: IsClearOfInsideCorners(choice)))
|
||||
if (!IsClearOfInsideCorners(choice))
|
||||
return null;
|
||||
return new ContourEntryCandidate(choice, AutomaticEntryKind.ShortestPath);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Whether this perimeter is tabbed for support but no single tab can hold the part level
|
||||
/// (see <see cref="PartSupport.TabCanSupport"/>). No entry then steadies it enough to be
|
||||
/// worth a detour, so its steadying catalog is every entry clear of inside corners.
|
||||
/// </summary>
|
||||
internal bool HasUntenableSupportTab => HasSupportTab && !support.TabCanSupport;
|
||||
|
||||
// A perimeter tabbed for support keeps the candidates whose tab steadies the part, and gains
|
||||
// the outline's best tab point. When no single tab can hold it level, every candidate clear
|
||||
// of inside corners counts as steadying: led by the steadiest instead, a long strip resting
|
||||
// on one line of contacts starts mid-length or on its side away from the next cut. The
|
||||
// search's fallbacks, when none of them has a lead-in that fits, keep every candidate clear
|
||||
// of inside corners and then every candidate, still tabbed.
|
||||
// A perimeter tabbed for support keeps every candidate clear of inside corners and gains the
|
||||
// outline's best tab point; the route, not how well the tab steadies the part, ranks them.
|
||||
// A tab holds most parts wherever it is, and one that does not is still tabbed and avoided
|
||||
// once cut, so a detour to steady it costs every part a longer way for the few that drop.
|
||||
// Led by the steadiest instead, a long strip starts mid-length or on its side away from the
|
||||
// next cut. When no candidate has a lead-in that fits, the search's fallback offers every
|
||||
// candidate, still tabbed.
|
||||
private IReadOnlyList<ContourEntryCandidate> SupportFiltered(int contourOrdinal,
|
||||
List<ContourEntryCandidate> candidates, SupportEntries entries)
|
||||
{
|
||||
if (support == null || contourOrdinal != PerimeterOrdinal || entries == SupportEntries.Any)
|
||||
return MergeByGeometry(candidates);
|
||||
if (entries == SupportEntries.ClearOfInsideCorners || !support.TabCanSupport)
|
||||
return MergeByGeometry(candidates.Where(c => IsClearOfInsideCorners(c.Choice)).ToList());
|
||||
var kept = candidates.Where(c => support.AcceptsTabAt(c.Choice.Point + supportOrigin)).ToList();
|
||||
var kept = candidates.Where(c => IsClearOfInsideCorners(c.Choice)).ToList();
|
||||
var best = ClosestEntry(PerimeterOrdinal, support.BestTabPoint!.Value - supportOrigin);
|
||||
if (!IsForbiddenVertex(GetShape(PerimeterOrdinal), best.Point))
|
||||
kept.Add(new ContourEntryCandidate(best, AutomaticEntryKind.SupportTab));
|
||||
|
||||
@@ -832,8 +832,6 @@ internal static class JointCuttingPlanSearch
|
||||
// Placement origins are authored program coordinates, not a downstream cut.
|
||||
// Use the same material-center look-ahead as the retained entry search.
|
||||
var toward = target ?? node.RoutePosition - source.Location;
|
||||
// When no single tab can hold the part level, the steadying catalog is every entry
|
||||
// clear of inside corners (PreparedContours.HasUntenableSupportTab).
|
||||
var ranked = prepared.AutomaticEntryCandidatesWithFallbacks(prepared.PerimeterOrdinal, token: token)
|
||||
.OrderBy(c => c.Choice.Point.DistanceTo(toward)).ToArray();
|
||||
// As in SelectEntries, the entry on the shortest way from the cutouts to the next cut leads.
|
||||
@@ -1383,10 +1381,9 @@ internal static class JointCuttingPlanSearch
|
||||
private IReadOnlyList<ContourChoice> SelectEntries(FixedProgramPlacement source, int contour,
|
||||
Vector? target, Vector arrival, Vector[] sightTargets = null, Vector? shortestExit = null)
|
||||
{
|
||||
// When no single tab can hold the part level, its steadying catalog is already every
|
||||
// entry clear of inside corners (PreparedContours.HasUntenableSupportTab), ranked
|
||||
// toward the next cut like any other part's.
|
||||
var ordered = RankedEntries(source, contour, target, arrival, sightTargets, SupportEntries.Steadying);
|
||||
// A support-tabbed perimeter's catalog is every entry clear of inside corners, ranked
|
||||
// toward the next cut like any other part's: the route matters more than the tab.
|
||||
var ordered = RankedEntries(source, contour, target, arrival, sightTargets, SupportEntries.ClearOfInsideCorners);
|
||||
// The outside entry on the shortest way from the cutout cut last to the next cut is tried first.
|
||||
if (contour == source.Prepared.PerimeterOrdinal && shortestExit is { } exit
|
||||
&& source.Prepared.ShortestPathEntry(exit - source.Location) is { } shortest)
|
||||
@@ -1394,20 +1391,15 @@ internal static class JointCuttingPlanSearch
|
||||
c.Choice.Point.DistanceTo(shortest.Choice.Point) > OpenNest.Math.Tolerance.Epsilon)];
|
||||
var selection = ContourEntrySelection.Select(ordered,
|
||||
candidate => Evaluate(source, candidate), snapshot.MaxEntries, token);
|
||||
// No steadying point of a support-tabbed perimeter has a lead-in that fits: it is
|
||||
// still tabbed, where a lead-in fits and the tab steadies it most, clear of inside
|
||||
// corners unless no entry clear of them fits.
|
||||
if (contour == source.Prepared.PerimeterOrdinal && source.Prepared.HasSupportTab)
|
||||
foreach (var fallback in new[] { SupportEntries.ClearOfInsideCorners, SupportEntries.Any })
|
||||
{
|
||||
if (selection.Choices.Count != 0 || selection.UncertainChoices.Count != 0)
|
||||
break;
|
||||
if (fallback == SupportEntries.ClearOfInsideCorners && source.Prepared.HasUntenableSupportTab)
|
||||
continue;
|
||||
ordered = RankedEntries(source, contour, target, arrival, sightTargets, fallback);
|
||||
selection = Steadiest(source.Prepared, ContourEntrySelection.Select(ordered,
|
||||
candidate => Evaluate(source, candidate), snapshot.MaxEntries, token));
|
||||
}
|
||||
// No entry of a support-tabbed perimeter clear of inside corners has a lead-in that
|
||||
// fits: it is still tabbed, where a lead-in fits and the tab steadies it most.
|
||||
if (contour == source.Prepared.PerimeterOrdinal && source.Prepared.HasSupportTab
|
||||
&& selection.Choices.Count == 0 && selection.UncertainChoices.Count == 0)
|
||||
{
|
||||
ordered = RankedEntries(source, contour, target, arrival, sightTargets, SupportEntries.Any);
|
||||
selection = Steadiest(source.Prepared, ContourEntrySelection.Select(ordered,
|
||||
candidate => Evaluate(source, candidate), snapshot.MaxEntries, token));
|
||||
}
|
||||
// No configured lead-in fits a cutout: pierce where eroding it leaves room.
|
||||
string erodedReason = null;
|
||||
// Entries the check could not settle are no fit either: a clear pierce outranks them.
|
||||
@@ -1478,7 +1470,7 @@ internal static class JointCuttingPlanSearch
|
||||
.ToArray();
|
||||
}
|
||||
|
||||
// One contour's automatic catalog ranked toward the next cut, before lead checks. A
|
||||
// One contour's automatic catalog ranked toward the next cut, before lead checks. The
|
||||
// support fallback leads with the entries whose tab steadies the part most.
|
||||
private IReadOnlyList<ContourEntryCandidate> RankedEntries(FixedProgramPlacement source, int contour,
|
||||
Vector? target, Vector arrival, Vector[] sightTargets, SupportEntries supportEntries)
|
||||
@@ -1503,7 +1495,7 @@ internal static class JointCuttingPlanSearch
|
||||
// pierce clears the hole itself lead.
|
||||
if (target is { } next && contour != source.Prepared.PerimeterOrdinal)
|
||||
ordered = ordered.DepartingClear(source.Prepared, next, token);
|
||||
if (supportEntries != SupportEntries.Steadying && contour == source.Prepared.PerimeterOrdinal)
|
||||
if (supportEntries == SupportEntries.Any && contour == source.Prepared.PerimeterOrdinal)
|
||||
ordered = ordered.OrderByDescending(c => source.Prepared.SupportMarginAt(c.Choice)).ToList();
|
||||
return ordered;
|
||||
}
|
||||
|
||||
@@ -10,7 +10,7 @@ namespace OpenNest.Tests.CuttingPlanning;
|
||||
|
||||
/// <summary>
|
||||
/// A holed part's outside entry lies where the straight line from its cutout to the next
|
||||
/// part's cutout leaves it, and a support tab that cannot hold a part level does not pull the
|
||||
/// part's cutout leaves it, and a support tab does not pull the
|
||||
/// entry elsewhere.
|
||||
/// </summary>
|
||||
public class ShortestPathEntryTests
|
||||
@@ -77,12 +77,16 @@ public class ShortestPathEntryTests
|
||||
AssertEntersBesideTheHole(result, 2);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ATabThatCannotHoldTheStripDoesNotPullItsEntryAway()
|
||||
[Theory]
|
||||
// Not enough: no single tab can hold the strip level.
|
||||
[InlineData(0.25, false)]
|
||||
// Enough: a tab on the left edge would hold it level, yet the route still decides.
|
||||
[InlineData(0.1, true)]
|
||||
public void ASupportTabDoesNotPullTheStripsEntryAway(double stabilityMargin, bool tabCanHold)
|
||||
{
|
||||
// Grid columns 2 apart, offset so the first strip rests on one line of contacts just right
|
||||
// of its center of gravity: only a tab on its left edge would steady it, and not enough.
|
||||
var bed = new SupportGrid(2, 2, offsetX: 0.7, stabilityMargin: 0.25);
|
||||
// of its center of gravity: only a tab on its left edge would steady it.
|
||||
var bed = new SupportGrid(2, 2, offsetX: 0.7, stabilityMargin: stabilityMargin);
|
||||
var parameters = Parameters();
|
||||
parameters.SupportTabs = true;
|
||||
parameters.TabHeldMaxLength = 0;
|
||||
@@ -90,7 +94,10 @@ public class ShortestPathEntryTests
|
||||
var snapshot = CuttingPlanService.Capture(new CuttingPlanRequest(parts, Start, confirmedParameters: parameters,
|
||||
preservePartOrder: true)
|
||||
{ SupportBed = bed });
|
||||
Assert.True(snapshot.Placements[0].Prepared.HasUntenableSupportTab);
|
||||
Assert.True(snapshot.Placements[0].Prepared.HasSupportTab);
|
||||
var support = SupportAnalyzer.Analyze(bed, 1, parts[0]);
|
||||
Assert.Equal(tabCanHold, support.TabCanSupport);
|
||||
Assert.False(support.HoldsLevelWithTabAt(new Vector(1, HoleY)));
|
||||
|
||||
var result = Plan(parts, parameters, bed);
|
||||
|
||||
|
||||
@@ -10,7 +10,8 @@ namespace OpenNest.Tests.CuttingPlanning;
|
||||
|
||||
/// <summary>
|
||||
/// 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.
|
||||
/// hold is tabbed where its route enters it, not where the tab steadies it most; a supported
|
||||
/// part is left untabbed.
|
||||
/// </summary>
|
||||
public class SupportTabPlanningTests
|
||||
{
|
||||
@@ -42,22 +43,24 @@ public class SupportTabPlanningTests
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void StripOnOneRowOfContacts_IsTabbedOnTheEdgeAcrossItsCenterFromTheRow()
|
||||
public void StripOnOneRowOfContacts_IsTabbedWhereTheRouteEntersIt()
|
||||
{
|
||||
// One row of grid points at y = 2.25 runs under the strip (y 2..3), below its center.
|
||||
// One row of grid points at y = 2.25 runs under the strip (y 2..3), below its center: a tab
|
||||
// on its top edge would hold it level, but the tool comes from below, so it enters there.
|
||||
var bed = new SupportGrid(2, 4, 0, 2.25, stabilityMargin: 0.1);
|
||||
var (plate, part) = Strip(bed);
|
||||
var support = SupportAnalyzer.Analyze(bed, plate.Quadrant, part);
|
||||
Assert.False(support.IsSupported);
|
||||
Assert.True(support.TabCanSupport);
|
||||
|
||||
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(2, 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);
|
||||
Assert.DoesNotContain(result.Findings, f => f.Kind == PostVerificationKind.PartSupport);
|
||||
}
|
||||
|
||||
// A 10 x 1 strip with a 2 x 0.2 bump on its top edge: inside corners at (4, 1) and (6, 1).
|
||||
@@ -92,7 +95,7 @@ public class SupportTabPlanningTests
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BlockedSteadyingSide_TabsTheSteadiestEntryThatFits()
|
||||
public void BlockedSteadyingSide_TabsAnEntryThatFits()
|
||||
{
|
||||
// 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.
|
||||
@@ -110,11 +113,9 @@ public class SupportTabPlanningTests
|
||||
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.
|
||||
// An entry the route reaches, on the open lower half, though its tab cannot hold the strip level.
|
||||
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.True(entry.Y < 2.5, $"entry {entry}");
|
||||
Assert.False(support.HoldsLevelWithTabAt(entry));
|
||||
Assert.DoesNotContain(result.Findings, f => f.Kind == PostVerificationKind.PartSupport);
|
||||
}
|
||||
@@ -281,7 +282,8 @@ public class SupportTabPlanningTests
|
||||
|
||||
Assert.Contains(any, NearACorner);
|
||||
Assert.DoesNotContain(clear, NearACorner);
|
||||
Assert.Equal(any.Count(c => !NearACorner(c)), clear.Count);
|
||||
// The catalog clear of inside corners also offers the best tab point.
|
||||
Assert.Equal(any.Count(c => !NearACorner(c)), clear.Count(c => c.Kind != AutomaticEntryKind.SupportTab));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
||||
@@ -37,7 +37,8 @@ var result = CuttingPlanService.Plan(snapshot, cancellationToken);
|
||||
- `preservePartOrder` fixes whole-part order, not eligible internal contour choices.
|
||||
- With `CuttingParameters.SupportTabs` and a support bed (`CuttingPlanRequest.SupportBed`,
|
||||
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
|
||||
tabbed perimeter whose automatic entries are ranked by the route, clear of inside corners,
|
||||
not by how well the tab steadies it. A tabbed
|
||||
part counts as steady wherever its tab is: it is never warned about and stays crossable once
|
||||
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
|
||||
|
||||
+13
-20
@@ -3,7 +3,7 @@
|
||||
A cut part drops onto the machine's support bed. If its center of gravity is not over the
|
||||
points it rests on, it can tip into the head's path or fall through. OpenNest models the bed,
|
||||
checks every part against it, and can tab only the parts the bed cannot hold level, at the
|
||||
perimeter point where one tab steadies the part most.
|
||||
perimeter point where the cutting route enters the part.
|
||||
|
||||
## The support bed
|
||||
|
||||
@@ -119,9 +119,14 @@ treated as cut free for later rapids, and the plan is UNVERIFIED, so applying it
|
||||
acceptance. A lead-out that would cut its tab is fixed in the cutting settings: shorten or turn
|
||||
it, or enlarge the tab. Programs judged as they are (locked, fixed or posted) keep the
|
||||
incomplete-check finding.
|
||||
A support-tabbed perimeter's automatic entries are therefore limited to catalog points the
|
||||
analysis accepts, plus the closest native point to its best tab point (`AutomaticEntryKind.SupportTab`,
|
||||
never on a reflex or cusp vertex). Ranking and lead checks are unchanged.
|
||||
A support-tabbed perimeter's automatic entries are every catalog point clear of inside corners,
|
||||
plus the closest native point to its best tab point (`AutomaticEntryKind.SupportTab`, never on a
|
||||
reflex or cusp vertex), ranked toward the next cut like any untabbed part's, in the search and in
|
||||
contour recovery. How well the tab would steady the part does not rank them: the route matters
|
||||
more. A tab holds most parts wherever it is, and one that does not is still tabbed and avoided
|
||||
once cut, while a detour to the steadiest point lengthens the way for every part. Led by the
|
||||
steadiest instead, a long strip resting on one line of contacts started mid-length, or on its
|
||||
side away from the next cut, so the head left it back over the strip. Lead checks are unchanged.
|
||||
|
||||
## Parts the tab alone holds
|
||||
|
||||
@@ -173,23 +178,11 @@ settings and the cutting panel): a plate's recorded parameters and drawing pins
|
||||
`TabsEnabled` and replay as planned.
|
||||
|
||||
If none of those entries has a lead-in that fits, the part is still tabbed. The search falls
|
||||
back first to every catalog entry clear of inside corners, then to every entry
|
||||
(`SupportEntries`), each ordered by how well the tab steadies the part; of the entries whose
|
||||
lead-in fits, it keeps every one that holds the part level, or else only the steadiest. The
|
||||
open-scrap pierce fallback then tries the last of those catalogs.
|
||||
back to every entry (`SupportEntries.Any`), ordered by how well the tab steadies the part; of
|
||||
the entries whose lead-in fits, it keeps every one that holds the part level, or else only the
|
||||
steadiest. The open-scrap pierce fallback then tries that catalog.
|
||||
|
||||
When no single tab can hold the part level (it rests on no contacts, or too few, so even the best
|
||||
tab misses the stability margin; `PreparedContours.HasUntenableSupportTab`), no entry steadies it
|
||||
enough to be worth a detour: its automatic entries are every catalog point clear of inside corners,
|
||||
ranked toward the next cut like any untabbed part's, in the search and in contour recovery. Led by
|
||||
the steadiest instead, a long strip resting on one line of contacts started mid-length, or on its
|
||||
side away from the next cut, so the head left it back over the strip. A part boxed in by its
|
||||
neighbors, such as the upper of two strips nested in a cutout, is left toward the next cut too. It
|
||||
is still tabbed, and it is still avoided once cut (`tabMayNotHold`). A part a tab can hold level
|
||||
keeps to 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
|
||||
A tabbed part counts as steady wherever its tab is: where its tab lands is 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. 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
|
||||
|
||||
Reference in new issue
Block a user