mirror of
https://github.com/ajisaacs/OpenNest.git
synced 2026-11-16 17:15:33 -05:00
fix(cutting): keep configured tab lead-outs and warn; count every tabbed part as steady
5776fa80 dropped a tabbed outside's lead-out when it would reach the lead-in,
which silently changed the user's cutting settings. The emitter now keeps the
lead-out as configured again. Plan Cutting plans strictly first, as before;
only when that is refused because such a lead-out may cut its tab free does it
plan again keeping the lead-outs. Each affected part gets a "Tab lead-out"
issue (new PostVerificationKind.TabLeadOut), is treated as cut free for later
rapids, and the plan is UNVERIFIED, so applying it needs explicit acceptance.
The short reorder pass never settles for such a plan, so a clean route still
wins. Locked, fixed and posted programs keep the incomplete-check finding.
The "no single tab can steady it" support warnings caused more trouble than
they solved, so a tabbed part now counts as steady wherever its tab is: Plan
Cutting and the pre-post review warn only about a part cut with no tab at
all, and a tabbed part stays crossable once cut instead of being avoided as
one that may tip. Entry choice still prefers the steadiest tab point.
The problem-nest corpus is unchanged except N26-2AM, whose baseline is now
BestEffort with 15 tab lead-out warnings.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
7894b74cb7
commit
e1ccd69291
25 files changed
+349
-327
No files matched your search
@@ -24,6 +24,11 @@ public sealed class ReleasedContourState
|
||||
private int partContours;
|
||||
private bool partClosed;
|
||||
|
||||
/// <summary>Why a lead-out after an open cut is refused when the open-cut proof cannot clear it.</summary>
|
||||
internal const string LeadOutRetentionMessage =
|
||||
"A lead-out follows an open cutting contour and may cut through its retention gap. "
|
||||
+ "Rapid safety for that contour requires manual review.";
|
||||
|
||||
public ReleasedContourState() : this(true) { }
|
||||
|
||||
/// <param name="reportMissingLeadIns">Keep pre-post warnings by default. Planning
|
||||
@@ -69,8 +74,17 @@ public sealed class ReleasedContourState
|
||||
/// being open, never become obstacles.
|
||||
/// </summary>
|
||||
public IReadOnlyList<PostVerificationFinding> Check(OwnedExecution execution, Vector? arrival,
|
||||
int partNumber, bool cutoff, CancellationToken token = default) =>
|
||||
Check(execution, arrival, partNumber, cutoff, null, token).Strict;
|
||||
int partNumber, bool cutoff, CancellationToken token = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(execution);
|
||||
if (arrival is { } point)
|
||||
PostVerificationGeometry.Validate(point);
|
||||
var moves = execution.Motions.ToArray();
|
||||
moves[0] = moves[0].WithStart(arrival);
|
||||
var findings = new List<PostVerificationFinding>();
|
||||
AnalyzeMoves(moves, cutoff, findings, 1, partNumber, token, fixedFindings: new(), raisedFindings: new());
|
||||
return findings.AsReadOnly();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// As <see cref="Check(OwnedExecution, Vector?, int, bool, CancellationToken)"/>, but a
|
||||
@@ -78,11 +92,15 @@ public sealed class ReleasedContourState
|
||||
/// returned apart: a fixed emission is accepted as given and only reported. The checker
|
||||
/// state advances exactly as it would without ownership. Crossings made by a rapid with the
|
||||
/// head raised are returned apart as well, as Raised: they are the raise's reason, not a fault.
|
||||
/// With <paramref name="settingsLeadOuts"/>, the program was emitted from the cutting settings:
|
||||
/// a lead-out no fixed emission owns that may cut its tabbed outside free is returned apart as
|
||||
/// Warnings (<see cref="PostVerificationKind.TabLeadOut"/>), kept as configured and reported,
|
||||
/// and the part then counts as cut free. Otherwise such a lead-out stays an incomplete check.
|
||||
/// </summary>
|
||||
internal (IReadOnlyList<PostVerificationFinding> Strict, IReadOnlyList<PostVerificationFinding> Fixed,
|
||||
IReadOnlyList<PostVerificationFinding> Raised) Check(
|
||||
IReadOnlyList<PostVerificationFinding> Raised, IReadOnlyList<PostVerificationFinding> Warnings) Check(
|
||||
OwnedExecution execution, Vector? arrival, int partNumber, bool cutoff, Func<int, bool> isFixed,
|
||||
CancellationToken token)
|
||||
CancellationToken token, bool settingsLeadOuts = false)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(execution);
|
||||
if (arrival is { } point)
|
||||
@@ -92,9 +110,10 @@ public sealed class ReleasedContourState
|
||||
var findings = new List<PostVerificationFinding>();
|
||||
var fixedFindings = new List<PostVerificationFinding>();
|
||||
var raisedFindings = new List<PostVerificationFinding>();
|
||||
var warnings = new List<PostVerificationFinding>();
|
||||
AnalyzeMoves(moves, cutoff, findings, 1, partNumber, token, isFixed, fixedFindings,
|
||||
raisedFindings: raisedFindings);
|
||||
return (findings.AsReadOnly(), fixedFindings.AsReadOnly(), raisedFindings.AsReadOnly());
|
||||
raisedFindings: raisedFindings, warnings: settingsLeadOuts ? warnings : null);
|
||||
return (findings.AsReadOnly(), fixedFindings.AsReadOnly(), raisedFindings.AsReadOnly(), warnings.AsReadOnly());
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -120,10 +139,13 @@ public sealed class ReleasedContourState
|
||||
return partClosed ? findings.AsReadOnly() : null;
|
||||
}
|
||||
|
||||
// warnings: where a configured lead-out that may cut its tabbed outside free is reported (see
|
||||
// Check); without it, as for programs judged as they are, it stays an incomplete check.
|
||||
internal void AnalyzeMoves(IReadOnlyList<ExecutionMotion> moves, bool cutoff,
|
||||
List<PostVerificationFinding> findings, int plate, int part, CancellationToken token,
|
||||
Func<int, bool> isFixed = null, List<PostVerificationFinding> fixedFindings = null,
|
||||
int contoursBefore = 0, List<PostVerificationFinding> raisedFindings = null)
|
||||
int contoursBefore = 0, List<PostVerificationFinding> raisedFindings = null,
|
||||
List<PostVerificationFinding> warnings = null)
|
||||
{
|
||||
var current = new CutGroup();
|
||||
var unfinished = new List<CutGroup>();
|
||||
@@ -135,6 +157,8 @@ public sealed class ReleasedContourState
|
||||
var leadIns = new List<PostVerificationGeometry.Curve>();
|
||||
CutGroup previous = null;
|
||||
var deferred = new List<(List<PostVerificationFinding> Target, int Index, PostVerificationFinding Finding)>();
|
||||
// The lead-outs those findings withheld, with the cut each was added to.
|
||||
var deferredLeadOuts = new List<(CutGroup Group, PostVerificationGeometry.Curve Curve, bool Fixed)>();
|
||||
var hasLead = false;
|
||||
var contourNumber = contoursBefore;
|
||||
var inBreakCut = false;
|
||||
@@ -218,6 +242,8 @@ public sealed class ReleasedContourState
|
||||
obstacle.Part, (move.HeadRaised ? "Head-raised" : "Direct") + " XY rapid crosses or touches "
|
||||
+ (obstacle.TabMayNotHold
|
||||
? $"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."
|
||||
: $"completed untabbed contour {obstacle.Contour} of part {obstacle.Part}."))
|
||||
{
|
||||
Location = (start + move.End) * 0.5,
|
||||
@@ -246,9 +272,10 @@ public sealed class ReleasedContourState
|
||||
{
|
||||
// Withheld until the part ends, where the open-cut proof may show it cuts no gap.
|
||||
if (current.Curves.Count > 0 && !PostVerificationGeometry.Closed(current.Curves))
|
||||
Defer(new(PostVerificationKind.Incomplete, plate, part, null,
|
||||
"A lead-out follows an open cutting contour and may cut through its retention gap. " +
|
||||
"Rapid safety for that contour requires manual review."), owned);
|
||||
{
|
||||
Defer(new(PostVerificationKind.Incomplete, plate, part, null, LeadOutRetentionMessage), owned);
|
||||
deferredLeadOuts.Add((previous ?? loose, move.Curve, owned));
|
||||
}
|
||||
(previous ?? loose).Leads.Add(move.Curve);
|
||||
if (previous != null && ReferenceEquals(previous, lastClosed))
|
||||
{
|
||||
@@ -323,6 +350,21 @@ public sealed class ReleasedContourState
|
||||
&& OpenCutsEncloseNothing(closed, unfinished
|
||||
.Concat(otherOpen.Where(group => !CutsOnlySlug(group, closed, unfinished, token)))
|
||||
.Append(loose).ToList(), token));
|
||||
// A tabbed outside whose configured lead-out the proof cannot clear: the lead-out may run
|
||||
// over the tab gap into the lead-in and cut the part free. The lead-out is kept as
|
||||
// configured and reported, and the part counts as cut free from here on.
|
||||
var cutFree = warnings != null && !retained && !cutoff && !member && unfinished.Count == 1
|
||||
&& deferredLeadOuts.Count > 0 && !deferredLeadOuts.Any(lead => lead.Fixed) && !unfinished[0].Fixed
|
||||
&& IsOutside(unfinished[0], closed);
|
||||
if (cutFree)
|
||||
{
|
||||
deferred.Clear();
|
||||
warnings.Add(new(PostVerificationKind.TabLeadOut, plate, part, null,
|
||||
"The lead-out of this tabbed outside runs past its tab gap toward the lead-in and may cut the "
|
||||
+ "tab free, so the part is treated as cut free. Shorten or turn the lead-out, or enlarge the tab, "
|
||||
+ "to keep the part in the sheet.")
|
||||
{ Location = deferredLeadOuts[0].Curve.Start });
|
||||
}
|
||||
for (var i = deferred.Count - 1; i >= 0 && !retained; i--)
|
||||
deferred[i].Target.Insert(deferred[i].Index, deferred[i].Finding);
|
||||
// Only one open fragment per part can be the planner's own certified tab, so a
|
||||
@@ -349,13 +391,13 @@ 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 && tabMayNotHold?.Invoke(part) == true)
|
||||
else if (!cutoff && unfinished.Count > 0 && (cutFree || 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 = true });
|
||||
obstacles.Add(new(part, contourNumber, curves, null) { TabMayNotHold = !cutFree, TabCutFree = cutFree });
|
||||
}
|
||||
partContours = contourNumber;
|
||||
partClosed = !cutoff && isFixed == null && unfinished.Count == 0 && deferred.Count == 0 && !reportedTab
|
||||
@@ -445,6 +487,16 @@ public sealed class ReleasedContourState
|
||||
/// behind the start it enters. A lead that curls into the gap can cut the tab with its kerf
|
||||
/// even where its centerline does not touch the next cut.
|
||||
/// </summary>
|
||||
// Whether the open cut is the part's outside: no closed cut's extent reaches beyond its own.
|
||||
private static bool IsOutside(CutGroup open, IReadOnlyList<CutGroup> closed)
|
||||
{
|
||||
static PostVerificationGeometry.Extent Extent(CutGroup cut) =>
|
||||
cut.Curves.Aggregate(PostVerificationGeometry.Extent.None, (sum, curve) => sum.Union(curve.Extent));
|
||||
var outside = Extent(open);
|
||||
return closed.All(cut => Extent(cut) is var inner && inner.MinX >= outside.MinX && inner.MinY >= outside.MinY
|
||||
&& inner.MaxX <= outside.MaxX && inner.MaxY <= outside.MaxY);
|
||||
}
|
||||
|
||||
private static bool LeadsClearOpenEnds(CutGroup group)
|
||||
{
|
||||
var start = group.Curves[0].Start;
|
||||
@@ -627,5 +679,8 @@ public sealed class ReleasedContourState
|
||||
|
||||
/// <summary>A tabbed perimeter closed across its tab gap, for a part its tab may not hold level.</summary>
|
||||
internal bool TabMayNotHold { get; init; }
|
||||
|
||||
/// <summary>A tabbed perimeter closed across its tab gap, whose lead-out may cut the tab free.</summary>
|
||||
internal bool TabCutFree { get; init; }
|
||||
}
|
||||
}
|
||||
@@ -1,7 +1,6 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Linq;
|
||||
using OpenNest.Converters;
|
||||
using OpenNest.Geometry;
|
||||
using OpenNest.Math;
|
||||
|
||||
@@ -631,15 +630,9 @@ namespace OpenNest.CNC.CuttingStrategy
|
||||
Parameters.GetEffectivePierceClearance(), out leadOutNormal);
|
||||
}
|
||||
|
||||
var leadInCodes = leadIn.Generate(point, leadInNormal, turn);
|
||||
program.Codes.AddRange(leadInCodes);
|
||||
program.Codes.AddRange(leadIn.Generate(point, leadInNormal, turn));
|
||||
program.Codes.AddRange(ConvertShapeToMoves(reindexedShape, point));
|
||||
var leadOutCodes = leadOut.Generate(leadOutPoint, leadOutNormal, turn);
|
||||
// A run-out angled toward the tab can reach the lead-in on the tab's far side, and the
|
||||
// two cuts then sever the tab: the cut stops at its tab instead.
|
||||
if (tabbed && Parameters.TabConfig.Size > Tolerance.Epsilon
|
||||
&& LeadsMeet(leadInCodes, point, leadOutCodes, leadOutPoint, Parameters.Kerf))
|
||||
leadOutCodes = [];
|
||||
program.Codes.AddRange(leadOutCodes);
|
||||
return contourType != ContourType.External && leadOutCodes.Count > 0;
|
||||
}
|
||||
@@ -1057,60 +1050,6 @@ namespace OpenNest.CNC.CuttingStrategy
|
||||
return true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Whether a tabbed outside's lead-out, leaving from <paramref name="leadOutStart"/>,
|
||||
/// touches its lead-in, which enters at <paramref name="entry"/>, or passes within
|
||||
/// <paramref name="kerf"/> of it. Either way the two cuts close across the tab gap
|
||||
/// and cut the part free.
|
||||
/// </summary>
|
||||
private static bool LeadsMeet(List<ICode> leadInCodes, Vector entry, List<ICode> leadOutCodes,
|
||||
Vector leadOutStart, double kerf)
|
||||
{
|
||||
var leadIn = LeadEntities(leadInCodes, entry);
|
||||
var leadOut = LeadEntities(leadOutCodes, leadOutStart);
|
||||
if (leadIn.Count == 0 || leadOut.Count == 0)
|
||||
return false;
|
||||
var reach = double.IsFinite(kerf) && kerf > 0 ? kerf : 0;
|
||||
foreach (var cut in leadOut)
|
||||
{
|
||||
foreach (var lead in leadIn)
|
||||
{
|
||||
if (Crosses(cut, lead) || reach > 0 && (Near(cut, lead) || Near(lead, cut)))
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
|
||||
static bool Crosses(Entity a, Entity b) => b switch
|
||||
{
|
||||
Line line => a.Intersects(line),
|
||||
Arc arc => a.Intersects(arc),
|
||||
_ => false,
|
||||
};
|
||||
|
||||
bool Near(Entity a, Entity b) =>
|
||||
Ends(a).Any(end => b.ClosestPointTo(end).DistanceTo(end) < reach - Tolerance.Epsilon);
|
||||
}
|
||||
|
||||
// A lead's cutting motions as entities; a lead-in starts at its own rapid to the pierce.
|
||||
private static List<Entity> LeadEntities(List<ICode> codes, Vector start)
|
||||
{
|
||||
var program = new Program(Mode.Absolute);
|
||||
if (codes.Count == 0 || codes[0] is not RapidMove)
|
||||
program.Codes.Add(new RapidMove(start));
|
||||
program.Codes.AddRange(codes);
|
||||
return ConvertProgram.ToGeometry(program)
|
||||
.Where(e => e.Layer != SpecialLayers.Rapid && e is Line or Arc)
|
||||
.ToList();
|
||||
}
|
||||
|
||||
private static IEnumerable<Vector> Ends(Entity entity) => entity switch
|
||||
{
|
||||
Line line => [line.StartPoint, line.EndPoint],
|
||||
Arc arc => [arc.StartPoint(), arc.EndPoint()],
|
||||
_ => [],
|
||||
};
|
||||
|
||||
private static Vector EntityEndPoint(Entity entity)
|
||||
{
|
||||
if (entity is Line line)
|
||||
|
||||
@@ -44,11 +44,11 @@ internal static class PartSupportReview
|
||||
}
|
||||
if (support.IsSupported)
|
||||
continue;
|
||||
var tab = OutsideTab(ExecutionMotionReader.Read(part.Program, part.Location, null, token));
|
||||
if (tab is { } point && support.IsSteadiedByTabAt(point))
|
||||
// A tabbed part counts as steady wherever its tab is.
|
||||
if (OutsideTab(ExecutionMotionReader.Read(part.Program, part.Location, null, token)) != null)
|
||||
continue;
|
||||
findings.Add(new(PostVerificationKind.PartSupport, plateNumber, partNumber, null,
|
||||
Message(support, tab))
|
||||
Message(support))
|
||||
{ Location = support.CenterOfGravity });
|
||||
}
|
||||
catch (Exception exception) when (exception is ArgumentException or InvalidOperationException
|
||||
@@ -100,32 +100,22 @@ internal static class PartSupportReview
|
||||
return (first + last) * 0.5;
|
||||
}
|
||||
|
||||
private static string Message(PartSupport support, Vector? tab)
|
||||
private static string Message(PartSupport support)
|
||||
{
|
||||
// Without a bed, or for a part its tab alone holds, any tab steadies the part, so the only
|
||||
// failure is no tab at all.
|
||||
if (!support.HasBed || support.IsHeldByTab)
|
||||
return (support.HasBed
|
||||
? FormattableString.Invariant(
|
||||
$"The part is {support.Length:0.####} long, short enough for its tab alone to hold, ")
|
||||
: FormattableString.Invariant(
|
||||
$"The part is {support.Width:0.####} wide, in the width range tabbed by size, "))
|
||||
+ "and it has no tab; it may tip once cut free."
|
||||
+ (support.BestTabPoint is { } suggested
|
||||
? FormattableString.Invariant($" Tab it near ({suggested.X:0.####}, {suggested.Y:0.####}).")
|
||||
: "");
|
||||
var held = support.Margin == double.NegativeInfinity
|
||||
var held = !support.HasBed
|
||||
? FormattableString.Invariant($"is {support.Width:0.####} wide, in the width range tabbed by size,")
|
||||
: support.IsHeldByTab
|
||||
? FormattableString.Invariant($"is {support.Length:0.####} long, short enough for its tab alone to hold,")
|
||||
: support.Margin == double.NegativeInfinity
|
||||
? "rests on no support contact"
|
||||
: support.Margin < 0
|
||||
? FormattableString.Invariant($"has its center of gravity {-support.Margin:0.####} outside its support contacts")
|
||||
: FormattableString.Invariant($"has its center of gravity only {support.Margin:0.####} inside its support contacts");
|
||||
var tabText = tab is { } point
|
||||
? FormattableString.Invariant($"its tab at ({point.X:0.####}, {point.Y:0.####}) does not steady it")
|
||||
: "it has no tab";
|
||||
var best = support.BestTabPoint is { } bestPoint && support.TabCanSupport
|
||||
? FormattableString.Invariant($" A tab near ({bestPoint.X:0.####}, {bestPoint.Y:0.####}) would.")
|
||||
: " No single tab can steady it.";
|
||||
return FormattableString.Invariant($"The part {held} (needs {support.RequiredMargin:0.####}) and {tabText}; ")
|
||||
+ "it may tip once cut free." + best;
|
||||
var needs = support.HasBed && !support.IsHeldByTab
|
||||
? FormattableString.Invariant($" (needs {support.RequiredMargin:0.####})") : "";
|
||||
return $"The part {held}{needs} and it has no tab; it may tip once cut free."
|
||||
+ (support.BestTabPoint is { } suggested
|
||||
? FormattableString.Invariant($" Tab it near ({suggested.X:0.####}, {suggested.Y:0.####}).")
|
||||
: "");
|
||||
}
|
||||
}
|
||||
@@ -58,7 +58,13 @@ public enum PostVerificationKind
|
||||
/// A common-line group (see docs/common-line-cutting.md) no longer shares its spans one kerf
|
||||
/// apart, was placed for another kerf, or a member's lead runs into its partner.
|
||||
/// </summary>
|
||||
CommonLine
|
||||
CommonLine,
|
||||
|
||||
/// <summary>
|
||||
/// A tabbed outside's configured lead-out crosses its lead-in, or meets it past the tab gap, so
|
||||
/// it may cut the tab free (see docs/support-tabs.md). The lead-out is kept as configured.
|
||||
/// </summary>
|
||||
TabLeadOut
|
||||
}
|
||||
|
||||
/// <summary>Plate and part numbers are one-based; plate zero denotes a whole-post limitation.</summary>
|
||||
@@ -116,6 +122,8 @@ public sealed class PostVerificationReport
|
||||
Summary(PostVerificationKind.EdgeSpacing, "Outside work area");
|
||||
if (Findings.Any(finding => finding.Kind == PostVerificationKind.CommonLine))
|
||||
Summary(PostVerificationKind.CommonLine, "Common lines");
|
||||
if (Findings.Any(finding => finding.Kind == PostVerificationKind.TabLeadOut))
|
||||
Summary(PostVerificationKind.TabLeadOut, "Tab lead-outs");
|
||||
foreach (var finding in Findings)
|
||||
{
|
||||
text.Append(finding.PlateNumber == 0 ? "Post processor" : $"Plate {finding.PlateNumber}");
|
||||
|
||||
@@ -58,7 +58,7 @@ internal static class CutOffInsertion
|
||||
var placement = planned[gap];
|
||||
states[gap + 1] = states[gap].Copy();
|
||||
states[gap + 1].Check(placement.Execution, arrivals[gap], placement.SourceOrdinal + 1,
|
||||
placement.IsCutOff, placement.FixedMotions(placement.Execution), token);
|
||||
placement.IsCutOff, placement.FixedMotions(placement.Execution), token, snapshot.WarnsTabLeadOuts(placement));
|
||||
arrivals[gap + 1] = placement.Execution.DeparturePoint;
|
||||
}
|
||||
var position = new Dictionary<int, int>();
|
||||
@@ -91,7 +91,8 @@ internal static class CutOffInsertion
|
||||
{
|
||||
var next = planned[gap];
|
||||
var findings = states[gap].Copy().Check(next.Execution, cut.Execution.DeparturePoint,
|
||||
next.SourceOrdinal + 1, next.IsCutOff, next.FixedMotions(next.Execution), token).Strict;
|
||||
next.SourceOrdinal + 1, next.IsCutOff, next.FixedMotions(next.Execution), token,
|
||||
snapshot.WarnsTabLeadOuts(next)).Strict;
|
||||
if (findings.Count != 0)
|
||||
continue;
|
||||
}
|
||||
|
||||
@@ -264,7 +264,10 @@ public sealed class CuttingPlanBatch
|
||||
var first = CuttingPlanService.Plan(snapshot.WithSearchLimits(firstPassBudget, FirstPassEntries), token);
|
||||
// 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.
|
||||
if (first.IndependentlyReplayed && first.Status is CuttingPlanStatus.Ready or CuttingPlanStatus.BestEffort
|
||||
&& !first.Findings.Any(f => f.Kind == PostVerificationKind.TabLeadOut)
|
||||
|| first.Status == CuttingPlanStatus.Canceled)
|
||||
return first;
|
||||
}
|
||||
@@ -510,16 +513,25 @@ public sealed class CuttingPlanProposal
|
||||
}
|
||||
|
||||
// What an unverified plan whose motions all passed asks the operator to review: its fixed
|
||||
// lead-ins, parts its support bed cannot hold level, or both.
|
||||
// lead-ins, lead-outs that may cut their tabs free, parts its support bed cannot hold level.
|
||||
private static (string Headline, string Plate) Unverified(IEnumerable<CuttingPlanPlateResult> plates)
|
||||
{
|
||||
var kinds = plates.SelectMany(p => p.Result.Findings).Select(f => f.Kind).Where(k => k != null).ToHashSet();
|
||||
return kinds.Count == 1 && kinds.Contains(PostVerificationKind.PartSupport)
|
||||
? ("a part may tip once cut free.", "a part may tip once cut free.")
|
||||
: kinds.Contains(PostVerificationKind.PartSupport)
|
||||
? ("fixed lead-ins could not be certified, and a part may tip once cut free.",
|
||||
"fixed lead-ins need review, and a part may tip once cut free.")
|
||||
: ("fixed lead-ins could not be certified.", "fixed lead-ins need review.");
|
||||
var named = new[] { PostVerificationKind.TabLeadOut, PostVerificationKind.PartSupport };
|
||||
var reasons = new List<(string Headline, string Plate)>();
|
||||
if (kinds.Any(k => !named.Contains(k.Value)) || !kinds.Overlaps(named.Cast<PostVerificationKind?>()))
|
||||
reasons.Add(("fixed lead-ins could not be certified", "fixed lead-ins need review"));
|
||||
if (kinds.Contains(PostVerificationKind.TabLeadOut))
|
||||
reasons.Add(("a lead-out may cut its tab free", "a lead-out may cut its tab free"));
|
||||
if (kinds.Contains(PostVerificationKind.PartSupport))
|
||||
reasons.Add(("a part may tip once cut free", "a part may tip once cut free"));
|
||||
return (Join(reasons.Select(r => r.Headline)), Join(reasons.Select(r => r.Plate)));
|
||||
|
||||
static string Join(IEnumerable<string> parts)
|
||||
{
|
||||
var list = parts.ToList();
|
||||
return (list.Count == 1 ? list[0] : string.Join(", ", list.Take(list.Count - 1)) + ", and " + list[^1]) + ".";
|
||||
}
|
||||
}
|
||||
|
||||
private static IEnumerable<string> DescribePlate(CuttingPlanPlateResult plate, string unit, string changeSettings)
|
||||
|
||||
@@ -87,23 +87,14 @@ public sealed class CuttingPlanSnapshot
|
||||
PreservePartOrder = preservePartOrder;
|
||||
MaxEntries = maxEntries;
|
||||
ExpansionObserver = expansionObserver;
|
||||
tabMayNotHold = Placements
|
||||
.Where(p => p.Prepared is { Support.TabCanSupport: false, PerimeterTabbed: true })
|
||||
.Select(p => p.SourceOrdinal + 1).ToHashSet();
|
||||
}
|
||||
|
||||
// Part numbers (source ordinal + 1, as every checker is keyed) of support-tabbed parts that no
|
||||
// single tab can steady.
|
||||
private readonly HashSet<int> tabMayNotHold;
|
||||
|
||||
/// <summary>
|
||||
/// An empty rapid checker for this capture. A support-tabbed part no single tab can steady may
|
||||
/// tip once cut, so its tabbed outside is an obstacle from then on, as an untabbed one is;
|
||||
/// rapids may still cross parts their tab holds level.
|
||||
/// 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.
|
||||
/// </summary>
|
||||
internal ReleasedContourState NewReleasedState() =>
|
||||
new(reportMissingLeadIns: false, tabMayNotHold.Count == 0 ? null : tabMayNotHold.Contains,
|
||||
CommonLineMembers.Count == 0 ? null : CommonLineMembers.Contains);
|
||||
new(reportMissingLeadIns: false, null, CommonLineMembers.Count == 0 ? null : CommonLineMembers.Contains);
|
||||
|
||||
/// <summary>
|
||||
/// Part numbers (source ordinal + 1) of the members of common-line groups cut once
|
||||
@@ -154,8 +145,31 @@ public sealed class CuttingPlanSnapshot
|
||||
SupportTabsSkipped = SupportTabsSkipped,
|
||||
CommonLineMembers = CommonLineMembers,
|
||||
CommonLineOrder = CommonLineOrder,
|
||||
AcceptsTabLeadOuts = AcceptsTabLeadOuts,
|
||||
};
|
||||
|
||||
/// <summary>
|
||||
/// The same capture planned again accepting tab lead-outs: a regenerated tabbed outside whose
|
||||
/// configured lead-out may cut its tab free is kept, warned about
|
||||
/// (<see cref="PostVerificationKind.TabLeadOut"/>) and counted as cut free, instead of refused.
|
||||
/// </summary>
|
||||
internal CuttingPlanSnapshot WithTabLeadOuts() =>
|
||||
new(Placements, StartPoint, ExpansionBudget, Failure, Findings, Regeneration,
|
||||
PreservePartOrder, MaxEntries, ExpansionObserver, PlateState, OwnedParameters,
|
||||
Dependencies, BestEffort)
|
||||
{
|
||||
SupportTabsSkipped = SupportTabsSkipped,
|
||||
CommonLineMembers = CommonLineMembers,
|
||||
CommonLineOrder = CommonLineOrder,
|
||||
AcceptsTabLeadOuts = true,
|
||||
};
|
||||
|
||||
/// <summary>Whether this capture accepts tab lead-outs (see <see cref="WithTabLeadOuts"/>).</summary>
|
||||
internal bool AcceptsTabLeadOuts { get; init; }
|
||||
|
||||
/// <summary>Whether the checker may report <paramref name="placement"/>'s tab lead-outs as warnings.</summary>
|
||||
internal bool WarnsTabLeadOuts(FixedProgramPlacement placement) => AcceptsTabLeadOuts && placement.Prepared != null;
|
||||
|
||||
/// <summary>The same capture planned along its current part order.</summary>
|
||||
internal CuttingPlanSnapshot WithPreservedOrder() =>
|
||||
new(Placements, StartPoint, ExpansionBudget, Failure, Findings, Regeneration,
|
||||
@@ -165,6 +179,7 @@ public sealed class CuttingPlanSnapshot
|
||||
SupportTabsSkipped = SupportTabsSkipped,
|
||||
CommonLineMembers = CommonLineMembers,
|
||||
CommonLineOrder = CommonLineOrder,
|
||||
AcceptsTabLeadOuts = AcceptsTabLeadOuts,
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -292,6 +292,22 @@ public static class CuttingPlanService
|
||||
{
|
||||
var result = PlanCaptured(snapshot, token);
|
||||
result.Snapshot = snapshot;
|
||||
// Refused only for configured lead-outs that may cut their tabs free: plan again keeping
|
||||
// them as warnings, since the settings give no other lead-out. A clean plan always wins.
|
||||
if (snapshot is { AcceptsTabLeadOuts: false, Regeneration: true }
|
||||
&& result.Status is CuttingPlanStatus.NoSolutionWithinBudget or CuttingPlanStatus.ConstraintConflict
|
||||
or CuttingPlanStatus.UnsupportedGeometry
|
||||
&& result.Findings.Any(f => f.Kind == PostVerificationKind.Incomplete
|
||||
&& f.Message == ReleasedContourState.LeadOutRetentionMessage))
|
||||
{
|
||||
var relaxed = snapshot.WithTabLeadOuts();
|
||||
var retry = PlanCaptured(relaxed, token);
|
||||
if (retry.Status is CuttingPlanStatus.Ready or CuttingPlanStatus.BestEffort or CuttingPlanStatus.Canceled)
|
||||
{
|
||||
retry.Snapshot = relaxed;
|
||||
return retry;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@@ -528,12 +544,14 @@ public static class CuttingPlanService
|
||||
findings: [JointCuttingPlanSearch.Finding(source, PostVerificationKind.Incomplete, ex.Message)], expansions: expansions);
|
||||
}
|
||||
var isFixed = proposal.FixedMotions(execution);
|
||||
var (strict, fixedFindings, raised) = checker.Check(execution, position, source.SourceOrdinal + 1,
|
||||
source.IsCutOff, isFixed, token);
|
||||
var (strict, fixedFindings, raised, tabLeadOuts) = checker.Check(execution, position,
|
||||
source.SourceOrdinal + 1, source.IsCutOff, isFixed, token, snapshot.WarnsTabLeadOuts(source));
|
||||
raises.AddRange(RaisedRapids.Notes(snapshot, source, raised));
|
||||
raisedRapids += RaisedRapids.Count(raised);
|
||||
findings.AddRange(JointCuttingPlanSearch.Map(snapshot, strict));
|
||||
warnings.AddRange(fixedFindings.Select(f => FixedLeadWarnings.FromChecker(snapshot, source, f)));
|
||||
// A configured lead-out that cuts its tab free is kept and reported, never refused.
|
||||
warnings.AddRange(JointCuttingPlanSearch.Map(snapshot, tabLeadOuts));
|
||||
var fixedLeads = new List<FixedLeadFailure>();
|
||||
var lead = source.IsCutOff ? new LeadPathValidationResult(true, true, null)
|
||||
: LeadPathValidator.Check(execution, source.Material, materials, isFixed, fixedLeads, token,
|
||||
|
||||
@@ -1733,7 +1733,8 @@ internal static class JointCuttingPlanSearch
|
||||
ReleasedContourState checker, IReadOnlyList<ContourChoice> choices = null)
|
||||
{
|
||||
var isFixed = source.FixedMotions(execution, choices);
|
||||
var findings = checker.Check(execution, arrival, source.SourceOrdinal + 1, source.IsCutOff, isFixed, token).Strict;
|
||||
var findings = checker.Check(execution, arrival, source.SourceOrdinal + 1, source.IsCutOff, isFixed, token,
|
||||
snapshot.WarnsTabLeadOuts(source)).Strict;
|
||||
var lead = source.IsCutOff ? new LeadPathValidationResult(true, true, null)
|
||||
: LeadPathValidator.Check(execution, source.Material, materials, isFixed, [], token, leadContacts,
|
||||
snapshot.PierceZoneRadius);
|
||||
@@ -1753,7 +1754,8 @@ internal static class JointCuttingPlanSearch
|
||||
// violations neither reject this candidate nor teach an order rule. Final replay
|
||||
// reports them as warnings. Every planner-chosen motion stays strict.
|
||||
var isFixed = source.FixedMotions(execution, choices);
|
||||
var findings = checker.Check(execution, arrival, source.SourceOrdinal + 1, source.IsCutOff, isFixed, token).Strict;
|
||||
var findings = checker.Check(execution, arrival, source.SourceOrdinal + 1, source.IsCutOff, isFixed, token,
|
||||
snapshot.WarnsTabLeadOuts(source)).Strict;
|
||||
rejected.AddRange(Map(snapshot, findings));
|
||||
attempt.NoteCrossings(source.SourceOrdinal, findings);
|
||||
// A fixed cutoff has no material or leads to certify; its rapids are still checked.
|
||||
|
||||
@@ -36,7 +36,7 @@ internal static class RaisedRapids
|
||||
var execution = ExecutionMotionReader.Read(program, proposal.Location, position, token);
|
||||
var placement = proposal;
|
||||
var rapids = proposal.Prepared == null || proposal.IsCutOff ? []
|
||||
: Crossing(checker.Copy(), proposal, execution, position, token);
|
||||
: Crossing(checker.Copy(), proposal, execution, position, snapshot.WarnsTabLeadOuts(proposal), token);
|
||||
if (rapids.Count != 0)
|
||||
{
|
||||
var raised = HeadRaise.Mark(program, rapids);
|
||||
@@ -44,7 +44,7 @@ internal static class RaisedRapids
|
||||
placement = proposal.Propose(raised, execution, proposal.ContourChoices, token);
|
||||
}
|
||||
checker.Check(execution, position, proposal.SourceOrdinal + 1, proposal.IsCutOff,
|
||||
proposal.FixedMotions(execution), token);
|
||||
proposal.FixedMotions(execution), token, snapshot.WarnsTabLeadOuts(proposal));
|
||||
marked.Add(placement);
|
||||
position = execution.DeparturePoint;
|
||||
}
|
||||
@@ -54,10 +54,11 @@ internal static class RaisedRapids
|
||||
// The own-code indices of the planner's rapids that cross parts already cut: the rapid itself,
|
||||
// or the call of the sub-program the rapid arrives at.
|
||||
private static HashSet<int> Crossing(ReleasedContourState checker, FixedProgramPlacement proposal,
|
||||
OwnedExecution execution, Vector arrival, CancellationToken token)
|
||||
OwnedExecution execution, Vector arrival, bool tabLeadOuts, CancellationToken token)
|
||||
{
|
||||
var isFixed = proposal.FixedMotions(execution);
|
||||
var strict = checker.Check(execution, arrival, proposal.SourceOrdinal + 1, false, isFixed, token).Strict;
|
||||
var strict = checker.Check(execution, arrival, proposal.SourceOrdinal + 1, false, isFixed, token,
|
||||
tabLeadOuts).Strict;
|
||||
var codes = new HashSet<int>();
|
||||
foreach (var finding in strict)
|
||||
{
|
||||
|
||||
@@ -46,7 +46,7 @@ internal static class SupportTabCapture
|
||||
/// <summary>
|
||||
/// A note for a planned support-tabbed part whose tab, at its perimeter entry, sits in an
|
||||
/// inside corner because no lead-in fits clear of one. Advisory: it never refuses or
|
||||
/// downgrades a plan. A tab that cannot steady its part is <see cref="Review"/>'s warning.
|
||||
/// downgrades a plan. A part cut with no tab at all is <see cref="Review"/>'s warning.
|
||||
/// </summary>
|
||||
internal static IEnumerable<CuttingPlanFinding> Notes(FixedProgramPlacement planned)
|
||||
{
|
||||
@@ -64,9 +64,9 @@ internal static class SupportTabCapture
|
||||
|
||||
/// <summary>
|
||||
/// A <see cref="PostVerificationKind.PartSupport"/> warning when a regenerated part its bed
|
||||
/// cannot hold level is cut without a tab that keeps it level: its pin has no tab or a tab
|
||||
/// elsewhere, no steadying entry had a lead-in that fits, or no single tab can steady it.
|
||||
/// Null otherwise. Like other warnings it makes the proposal UNVERIFIED.
|
||||
/// cannot hold level is cut with no tab at all: its drawing pin cuts its outside untabbed.
|
||||
/// A tabbed part counts as steady wherever its tab is. Null otherwise. Like other warnings it
|
||||
/// makes the proposal UNVERIFIED.
|
||||
/// </summary>
|
||||
internal static CuttingPlanFinding Review(FixedProgramPlacement source, IReadOnlyList<ContourChoice> choices)
|
||||
{
|
||||
@@ -76,8 +76,7 @@ internal static class SupportTabCapture
|
||||
var perimeter = choices.FirstOrDefault(c => c.ContourOrdinal == prepared.PerimeterOrdinal);
|
||||
if (perimeter == null)
|
||||
return null;
|
||||
var tab = perimeter.Point + prepared.SupportOrigin;
|
||||
if (prepared.PerimeterTabbed && support.IsSteadiedByTabAt(tab))
|
||||
if (prepared.PerimeterTabbed)
|
||||
return null;
|
||||
var part = source.SourceOrdinal + 1;
|
||||
var held = !support.HasBed
|
||||
@@ -89,13 +88,7 @@ internal static class SupportTabCapture
|
||||
: support.Margin < 0
|
||||
? FormattableString.Invariant($"has its center of gravity {-support.Margin:0.####} outside its support contacts")
|
||||
: FormattableString.Invariant($"has its center of gravity only {support.Margin:0.####} inside its support contacts");
|
||||
var why = !prepared.PerimeterTabbed
|
||||
? $"drawing pin {prepared.PinNumberOf(prepared.PerimeterOrdinal)} cuts its outside without a tab"
|
||||
: prepared.IsPinned(prepared.PerimeterOrdinal)
|
||||
? $"drawing pin {prepared.PinNumberOf(prepared.PerimeterOrdinal)} puts its tab where it does not steady the part"
|
||||
: support.TabCanSupport
|
||||
? "no lead-in fits at a point where its tab would steady the part"
|
||||
: "no single tab can steady it";
|
||||
var why = $"drawing pin {prepared.PinNumberOf(prepared.PerimeterOrdinal)} cuts its outside without a tab";
|
||||
var needs = support.HasBed && !support.IsHeldByTab ? FormattableString.Invariant($" (needs {support.RequiredMargin:0.####})") : "";
|
||||
return new CuttingPlanFinding(source.SourceOrdinal, source.SourcePart, null, null,
|
||||
PostVerificationKind.PartSupport, $"Part {part} {held}{needs} and {why}; it may tip once cut free.");
|
||||
|
||||
@@ -99,7 +99,7 @@ public class CutoutLeadOutTests
|
||||
[Fact]
|
||||
public void ARaisedRapidOutOfASlugIsTheDesignedWayOut()
|
||||
{
|
||||
var (strict, _, raised) = new ReleasedContourState()
|
||||
var (strict, _, raised, _) = new ReleasedContourState()
|
||||
.Check(SlugExit(raised: true), Vector.Zero, 1, false, null, default);
|
||||
|
||||
Assert.Empty(strict);
|
||||
@@ -124,7 +124,7 @@ public class CutoutLeadOutTests
|
||||
program.Codes.Add(new RapidMove(4.2, 2));
|
||||
var execution = ExecutionMotionReader.Read(program, Vector.Zero, Vector.Zero, default);
|
||||
|
||||
var (_, _, raised) = new ReleasedContourState().Check(execution, Vector.Zero, 1, false, null, default);
|
||||
var (_, _, raised, _) = new ReleasedContourState().Check(execution, Vector.Zero, 1, false, null, default);
|
||||
|
||||
Assert.Contains(raised, f => f.Kind == PostVerificationKind.RapidCrossing);
|
||||
}
|
||||
|
||||
@@ -94,21 +94,26 @@ public class CuttingPlanMessageTests
|
||||
Assert.Same(program, part.Program);
|
||||
}
|
||||
[Fact]
|
||||
public void Describe_OnlyAnUnsteadyPart_SaysItMayTipNotThatLeadsNeedReview()
|
||||
public void Describe_OnlyTabLeadOuts_SaysALeadOutMayCutItsTabNotThatLeadsNeedReview()
|
||||
{
|
||||
// Nothing of the grid runs under the strip, so no single tab can hold it level.
|
||||
var plate = new Plate(20, 20) { SupportBed = new OpenNest.Support.SupportGrid(1, 1, 0, 0.9, stabilityMargin: 0.1) };
|
||||
plate.Parts.Add(new Part(new Drawing("strip", LeadPathValidationTests.Rectangle(0, 0, 10, 0.8)), new Vector(2, 2)));
|
||||
// Wound counterclockwise and support-tabbed, the strip's 60 degree lead-out runs past its
|
||||
// 0.03 tab into the lead-in, at every entry.
|
||||
var plate = new Plate(20, 20) { SupportBed = new OpenNest.Support.SupportGrid(2, 4, 0, 2.25, stabilityMargin: 0.1) };
|
||||
var clean = new OpenNest.CNC.Program(OpenNest.CNC.Mode.Absolute);
|
||||
clean.MoveTo(0, 0); clean.LineTo(10, 0); clean.LineTo(10, 1); clean.LineTo(0, 1); clean.LineTo(0, 0);
|
||||
plate.Parts.Add(new Part(new Drawing("strip", clean), new Vector(2, 2)));
|
||||
var settings = ExplicitContourTests.Parameters();
|
||||
settings.SupportTabs = true;
|
||||
settings.TabConfig = new NormalTab { Size = 0.2 };
|
||||
settings.TabConfig = new NormalTab { Size = 0.03 };
|
||||
settings.ExternalLeadIn = new LineLeadIn { Length = 0.15, ApproachAngle = 60 };
|
||||
settings.ExternalLeadOut = new LineLeadOut { Length = 0.1, ApproachAngle = 60 };
|
||||
|
||||
var proposal = CuttingPlanBatch.Capture([plate], settings, false).Plan();
|
||||
var text = string.Join("\n", proposal.Describe("in"));
|
||||
|
||||
Assert.True(proposal.RequiresWarningAcceptance, text);
|
||||
Assert.StartsWith("Unverified plan available: a part may tip once cut free.", text);
|
||||
Assert.Contains("Plate 1: unverified: a part may tip once cut free.", text);
|
||||
Assert.StartsWith("Unverified plan available: a lead-out may cut its tab free.", text);
|
||||
Assert.Contains("Plate 1: unverified: a lead-out may cut its tab free.", text);
|
||||
Assert.DoesNotContain("fixed lead-ins", text);
|
||||
}
|
||||
|
||||
|
||||
@@ -72,7 +72,7 @@ public class HeadRaisePlanningTests
|
||||
checker.Check(ExecutionMotionReader.Read(wall, Vector.Zero, null, default), null, 1);
|
||||
|
||||
var execution = ExecutionMotionReader.Read(program, Vector.Zero, new Vector(0, 11), default);
|
||||
var (strict, _, raised) = checker.Check(execution, new Vector(0, 11), 2, false, null, default);
|
||||
var (strict, _, raised, _) = checker.Check(execution, new Vector(0, 11), 2, false, null, default);
|
||||
|
||||
Assert.True(execution.Motions[0].HeadRaised);
|
||||
Assert.Null(execution.Motions[0].Code);
|
||||
@@ -133,7 +133,7 @@ public class HeadRaisePlanningTests
|
||||
checker.Check(ExecutionMotionReader.Read(wall, Vector.Zero, null, default), null, 1);
|
||||
|
||||
var execution = ExecutionMotionReader.Read(rapid, Vector.Zero, new Vector(0, 11), default);
|
||||
var (strict, _, raised) = checker.Check(execution, new Vector(0, 11), 2, false, null, default);
|
||||
var (strict, _, raised, _) = checker.Check(execution, new Vector(0, 11), 2, false, null, default);
|
||||
|
||||
Assert.True(execution.Motions[0].HeadRaised);
|
||||
Assert.Equal(1, execution.Motions[0].Code);
|
||||
|
||||
@@ -169,14 +169,15 @@ public class HoleLookAheadTests
|
||||
var fingerprint = ExplicitContourTests.Fingerprint(part.Program);
|
||||
var result = CuttingPlanService.Plan(new CuttingPlanRequest([part], Start,
|
||||
confirmedParameters: parameters, preservePartOrder: true));
|
||||
Assert.True(result.Status == CuttingPlanStatus.Ready, Describe(result));
|
||||
// Tabbed, the arc lead-out may cut through the tab into the lead-in: it is kept as set and warned.
|
||||
Assert.True(result.Status == (tabs ? CuttingPlanStatus.BestEffort : CuttingPlanStatus.Ready), Describe(result));
|
||||
Assert.True(result.IndependentlyReplayed);
|
||||
Assert.Equal(tabs, result.Findings.Any(f => f.Kind == PostVerificationKind.TabLeadOut));
|
||||
var actual = result.ProposedOrder[0];
|
||||
Assert.Equal(2, actual.ContourChoices[^1].ContourOrdinal);
|
||||
Assert.Equal(3, actual.ContourChoices.Select(c => c.ContourOrdinal).Distinct().Count());
|
||||
Assert.Single(actual.Execution.Motions.Where(m => !m.Rapid && m.Layer == LayerType.Scribe));
|
||||
// The arc lead-out would cut through the tab into the lead-in, so a tabbed outside has none.
|
||||
Assert.Equal(!tabs, actual.Execution.Motions.Any(m => m.Layer == LayerType.Leadout));
|
||||
Assert.Contains(actual.Execution.Motions, m => m.Layer == LayerType.Leadout);
|
||||
Assert.Equal(fingerprint, ExplicitContourTests.Fingerprint(part.Program));
|
||||
}
|
||||
|
||||
|
||||
@@ -315,21 +315,29 @@ public class JointCuttingPlanTests
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TabbedArcCandidate_LeadOutThatWouldCutTheTab_IsLeftOutAndPlanned()
|
||||
public void TabbedArcCandidate_LeadOutThatMayCutTheTab_IsRefusedStrictlyThenKeptAndWarned()
|
||||
{
|
||||
// The arc lead-out would run over the tab gap into the lead-in, so the cut stops at its tab.
|
||||
// The arc lead-out runs over the tab gap into the lead-in. The strict search refuses it;
|
||||
// planning then keeps the settings' lead-out and warns instead of changing it.
|
||||
var parameters = ExplicitContourTests.Parameters();
|
||||
parameters.TabsEnabled = true; parameters.TabConfig = new NormalTab { Size = 0.2 };
|
||||
parameters.ExternalLeadOut = new ArcLeadOut { Radius = 0.2 };
|
||||
var part = new Part(new Drawing("tabbed", LeadPathValidationTests.Rectangle(0, 0, 10, 10)));
|
||||
var result = CuttingPlanService.Plan(new CuttingPlanRequest([part], new Vector(-2, 5), confirmedParameters: parameters));
|
||||
Assert.Equal(CuttingPlanStatus.Ready, result.Status);
|
||||
var request = new CuttingPlanRequest([part], new Vector(-2, 5), confirmedParameters: parameters);
|
||||
var strict = JointCuttingPlanSearch.Run(CuttingPlanService.Capture(request), default);
|
||||
Assert.Equal(CuttingPlanStatus.NoSolutionWithinBudget, strict.Status);
|
||||
Assert.Contains(strict.Findings, f => f.Kind == PostVerificationKind.Incomplete && f.Message.Contains("retention gap"));
|
||||
|
||||
var result = CuttingPlanService.Plan(request);
|
||||
|
||||
Assert.Equal(CuttingPlanStatus.BestEffort, result.Status);
|
||||
Assert.True(result.IndependentlyReplayed);
|
||||
Assert.DoesNotContain(Assert.Single(result.ProposedOrder).Execution.Motions, m => m.Layer == LayerType.Leadout);
|
||||
Assert.Equal(PostVerificationKind.TabLeadOut, Assert.Single(result.Findings).Kind);
|
||||
Assert.Contains(Assert.Single(result.ProposedOrder).Execution.Motions, m => m.Layer == LayerType.Leadout);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void TabbedPerimeter_LeadOutCrossingItsLeadIn_IsRefusedAsCuttingTheRetentionGap()
|
||||
public void TabbedPerimeter_LeadOutCrossingItsLeadIn_IsIncompleteUnlessEmittedFromSettings()
|
||||
{
|
||||
// Wound counterclockwise, entered at (0, 5) and stopped 0.2 short of it: the lead-out runs
|
||||
// forward over the tab gap and crosses the lead-in, cutting the tab free.
|
||||
@@ -338,8 +346,20 @@ public class JointCuttingPlanTests
|
||||
program.Codes.Add(new LinearMove(0, 5) { Layer = LayerType.Leadin });
|
||||
program.LineTo(0, 0); program.LineTo(10, 0); program.LineTo(10, 10); program.LineTo(0, 10); program.LineTo(0, 5.2);
|
||||
program.Codes.Add(new LinearMove(-0.3, 4.9) { Layer = LayerType.Leadout });
|
||||
var findings = new ReleasedContourState().Check(Read(program, Vector.Zero), Vector.Zero, 1);
|
||||
var execution = Read(program, Vector.Zero);
|
||||
var findings = new ReleasedContourState().Check(execution, Vector.Zero, 1);
|
||||
Assert.Contains(findings, f => f.Kind == PostVerificationKind.Incomplete && f.Message.Contains("retention gap"));
|
||||
|
||||
// Emitted from the settings, the lead-out is a warning and the part counts as cut free.
|
||||
var checker = new ReleasedContourState(false);
|
||||
var (strict, _, _, warnings) = checker.Check(execution, Vector.Zero, 1, false, null, default, settingsLeadOuts: true);
|
||||
Assert.Empty(strict);
|
||||
Assert.Equal(PostVerificationKind.TabLeadOut, Assert.Single(warnings).Kind);
|
||||
var across = new Program(Mode.Absolute);
|
||||
across.Codes.Add(new RapidMove(5, -1));
|
||||
across.Codes.Add(new RapidMove(5, 11));
|
||||
Assert.Contains(checker.Check(Read(across, Vector.Zero), new Vector(-0.3, 4.9), 2),
|
||||
f => f.Kind == PostVerificationKind.RapidCrossing && f.Message.Contains("may cut its tab free"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
||||
@@ -92,7 +92,7 @@ public class SupportTabPlanningTests
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BlockedSteadyingSide_TabsTheSteadiestEntryThatFitsAndReportsIt()
|
||||
public void BlockedSteadyingSide_TabsTheSteadiestEntryThatFits()
|
||||
{
|
||||
// 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.
|
||||
@@ -105,7 +105,8 @@ public class SupportTabPlanningTests
|
||||
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)));
|
||||
// Tabbed, the strip counts as steady even where its tab cannot hold it level.
|
||||
Assert.True(result.Status == CuttingPlanStatus.Ready, 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);
|
||||
@@ -115,13 +116,11 @@ public class SupportTabPlanningTests
|
||||
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"));
|
||||
Assert.DoesNotContain(result.Findings, f => f.Kind == PostVerificationKind.PartSupport);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PartNoSingleTabCanHold_IsTabbedAndReported()
|
||||
public void PartNoSingleTabCanHold_IsTabbedWithoutAWarning()
|
||||
{
|
||||
// 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);
|
||||
@@ -132,13 +131,10 @@ public class SupportTabPlanningTests
|
||||
var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, new Vector(0, 0),
|
||||
confirmedParameters: Parameters()));
|
||||
|
||||
Assert.Equal(CuttingPlanStatus.BestEffort, result.Status);
|
||||
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);
|
||||
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);
|
||||
Assert.DoesNotContain(result.Findings, f => f.Kind == PostVerificationKind.PartSupport);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
@@ -162,6 +158,39 @@ public class SupportTabPlanningTests
|
||||
Assert.Equal(LayerType.Leadout, motions[^1].Layer);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void StripWhoseLeadOutMayCutItsTab_KeepsTheLeadOutAndWarns()
|
||||
{
|
||||
// Wound counterclockwise, every entry's 60 degree lead-out runs 0.05 along the edge, past
|
||||
// the 0.03 tab, into the lead-in. The settings' lead-out is kept as configured and the
|
||||
// plan is unverified, with a warning on the part.
|
||||
var bed = new SupportGrid(2, 4, 0, 2.25, stabilityMargin: 0.1);
|
||||
var plate = new Plate(20, 20) { SupportBed = bed };
|
||||
var clean = new Program(Mode.Absolute);
|
||||
clean.MoveTo(0, 0); clean.LineTo(10, 0); clean.LineTo(10, 1); clean.LineTo(0, 1); clean.LineTo(0, 0);
|
||||
plate.Parts.Add(new Part(new Drawing("strip", clean), new Vector(2, 2)));
|
||||
var parameters = Parameters();
|
||||
parameters.Kerf = 0.014;
|
||||
parameters.TabConfig = new NormalTab { Size = 0.03 };
|
||||
parameters.ExternalLeadIn = new LineLeadIn { Length = 0.15, ApproachAngle = 60 };
|
||||
parameters.ExternalLeadOut = new LineLeadOut { Length = 0.1, ApproachAngle = 60 };
|
||||
|
||||
var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, new Vector(0, 0),
|
||||
confirmedParameters: parameters));
|
||||
|
||||
Assert.Equal(CuttingPlanStatus.BestEffort, result.Status);
|
||||
Assert.True(result.IndependentlyReplayed);
|
||||
var warning = Assert.Single(result.Findings);
|
||||
Assert.Equal(PostVerificationKind.TabLeadOut, warning.Kind);
|
||||
var proposal = Assert.Single(result.ProposedOrder);
|
||||
var (entry, cutEnd) = EntryAndCutEnd(proposal);
|
||||
Assert.Equal(0.03, entry.DistanceTo(cutEnd), 6);
|
||||
var motions = ExecutionMotionReader.Read(proposal.CopyProgram(), proposal.Location, null, default).Motions;
|
||||
var leadOut = motions[^1];
|
||||
Assert.Equal(LayerType.Leadout, leadOut.Layer);
|
||||
Assert.Equal(0.1, leadOut.Start!.Value.DistanceTo(leadOut.End), 6);
|
||||
}
|
||||
|
||||
// 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()
|
||||
@@ -189,12 +218,11 @@ public class SupportTabPlanningTests
|
||||
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)));
|
||||
Assert.True(result.Status == CuttingPlanStatus.Ready, 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"));
|
||||
Assert.DoesNotContain(result.Findings, f => f.Kind == PostVerificationKind.PartSupport);
|
||||
}
|
||||
|
||||
// A 0.8 x 10 upright strip at x 4..4.8 between squares cut before and after it on either side.
|
||||
@@ -212,32 +240,26 @@ public class SupportTabPlanningTests
|
||||
}
|
||||
|
||||
[Theory]
|
||||
// No grid column runs under the strip: no single tab can hold it, so once cut it may tip.
|
||||
// No grid column runs under the strip: no single tab can hold it level, yet tabbed it counts as steady.
|
||||
[InlineData(0.9, false)]
|
||||
// A column runs under it, off its center line: its tab holds it level, so it stays crossable.
|
||||
// A column runs under it, off its center line: its tab holds it level.
|
||||
[InlineData(0.25, true)]
|
||||
public void PartNoSingleTabCanHold_IsNotCrossedOnceCut(double columnOffset, bool crossable)
|
||||
public void TabbedPart_StaysCrossableOnceCut_WhetherOrNotItsTabHoldsItLevel(double columnOffset, bool holdsLevel)
|
||||
{
|
||||
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);
|
||||
Assert.Equal(holdsLevel, 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(kept.Status == CuttingPlanStatus.Ready, string.Join("\n", kept.Findings.Select(f => f.Message)));
|
||||
Assert.True(free.Status == CuttingPlanStatus.Ready, 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]
|
||||
|
||||
@@ -9,18 +9,19 @@ namespace OpenNest.Tests.CuttingStrategy;
|
||||
/// <summary>
|
||||
/// A tab trims the perimeter short of its entry, so the lead-out leaves from where the
|
||||
/// trimmed cut actually ends. Generating it from the nominal entry emitted an arc whose
|
||||
/// start was off its own radius. A lead-out that would reach the lead-in across the tab gap
|
||||
/// would cut the tab free, so the cut then stops at its tab with no lead-out.
|
||||
/// start was off its own radius.
|
||||
/// </summary>
|
||||
public class TabbedLeadOutTests
|
||||
{
|
||||
private const double TabSize = 0.2;
|
||||
private const double LeadRadius = 0.2;
|
||||
|
||||
[Fact]
|
||||
public void ArcLeadOut_LeavesTangentlyFromTheTrimmedCutEnd()
|
||||
[Theory]
|
||||
[InlineData(false)]
|
||||
[InlineData(true)]
|
||||
public void ArcLeadOut_LeavesTangentlyFromTheTrimmedCutEnd(bool reversed)
|
||||
{
|
||||
var execution = Emit(ExplicitContourTests.Square(false), new Vector(-2, 5),
|
||||
var execution = Emit(ExplicitContourTests.Square(reversed), new Vector(-2, 5),
|
||||
new ArcLeadOut { Radius = LeadRadius }, tabs: true);
|
||||
var (cuts, leadout) = Split(execution);
|
||||
|
||||
@@ -30,65 +31,11 @@ public class TabbedLeadOutTests
|
||||
Assert.Equal(end, leadout.Start!.Value);
|
||||
var arc = Assert.IsType<Arc>(leadout.Curve.ToEntity());
|
||||
Assert.Equal(LeadRadius, arc.Radius, 9);
|
||||
// Centered on the actual end's outward normal, so it touches the edge only where it starts.
|
||||
// Centerd on the actual end's outward normal, so it touches the edge only where it starts.
|
||||
Assert.Equal(-LeadRadius, arc.Center.X, 9);
|
||||
Assert.Equal(end.Y, arc.Center.Y, 9);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ArcLeadOut_ThatWouldCrossTheLeadIn_IsLeftOut()
|
||||
{
|
||||
// Wound the other way, the arc runs forward over the tab gap and through the lead-in.
|
||||
var execution = Emit(ExplicitContourTests.Square(true), new Vector(-2, 5),
|
||||
new ArcLeadOut { Radius = LeadRadius }, tabs: true);
|
||||
|
||||
var cuts = execution.Motions.Where(m => m.Layer == LayerType.Display && !m.Rapid).ToArray();
|
||||
Assert.Equal(TabSize, System.Math.Abs(cuts[^1].End.Y - 5), 9);
|
||||
Assert.DoesNotContain(execution.Motions, m => m.Layer == LayerType.Leadout);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(false)]
|
||||
[InlineData(true)]
|
||||
public void LineLeadOut_AngledIntoASmallTab_IsLeftOutOnlyWhenItWouldCrossTheLeadIn(bool reversed)
|
||||
{
|
||||
// A strip tabbed for support with 60 degree leads and a tab shorter than the lead-out's
|
||||
// forward run: wound one way the lead-out angles away from the tab, the other way it
|
||||
// crosses the lead-in and would cut the tab free.
|
||||
var clean = new Program(Mode.Absolute);
|
||||
if (reversed)
|
||||
{
|
||||
clean.MoveTo(0, 0); clean.LineTo(11.8, 0); clean.LineTo(11.8, 3.8); clean.LineTo(0, 3.8); clean.LineTo(0, 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
clean.MoveTo(0, 0); clean.LineTo(0, 3.8); clean.LineTo(11.8, 3.8); clean.LineTo(11.8, 0); clean.LineTo(0, 0);
|
||||
}
|
||||
var parameters = new CuttingParameters
|
||||
{
|
||||
Kerf = 0.014,
|
||||
ExternalLeadIn = new LineLeadIn { Length = 0.15, ApproachAngle = 60 },
|
||||
ExternalLeadOut = new LineLeadOut { Length = 0.1, ApproachAngle = 60 },
|
||||
InternalLeadIn = new LineLeadIn { Length = 0.15, ApproachAngle = 60 },
|
||||
InternalLeadOut = new NoLeadOut(),
|
||||
TabsEnabled = true,
|
||||
TabConfig = new NormalTab { Size = 0.03 },
|
||||
};
|
||||
var emitted = new ContourCuttingStrategy { Parameters = parameters }.Apply(clean, new Vector(5, -2));
|
||||
var execution = ExecutionMotionReader.Read(emitted.Program, Vector.Zero, null, default);
|
||||
|
||||
var leadIn = Assert.Single(execution.Motions.Where(m => m.Layer == LayerType.Leadin));
|
||||
var leadOuts = execution.Motions.Where(m => m.Layer == LayerType.Leadout).ToArray();
|
||||
if (reversed)
|
||||
Assert.Empty(leadOuts);
|
||||
else
|
||||
{
|
||||
var leadOut = Assert.Single(leadOuts);
|
||||
Assert.False(new Line(leadIn.Start!.Value, leadIn.End).Intersects(new Line(leadOut.Start!.Value, leadOut.End)));
|
||||
}
|
||||
Assert.Empty(new ReleasedContourState().Check(execution, new Vector(5, -2), 1));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ArcLeadOut_OnCurvedPerimeter_IsTangentAtTheTrimmedEnd()
|
||||
{
|
||||
@@ -137,20 +84,30 @@ public class TabbedLeadOutTests
|
||||
Assert.Equal(5, arc.Center.Y, 9);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LineLeads_TabWrappingAFilletedCorner_ShareTheCornerBisector()
|
||||
[Theory]
|
||||
[InlineData(false)]
|
||||
[InlineData(true)]
|
||||
public void LineLeads_TabWrappingAFilletedCorner_ShareTheCornerBisector(bool reversed)
|
||||
{
|
||||
// Entered at the fillet joint the tab trims back around: on its own edge's normal the
|
||||
// lead-in and lead-out would sit 150 degrees apart, not the 60 degree V of a straight edge.
|
||||
const double fillet = 0.015;
|
||||
const double tab = 0.03;
|
||||
var clean = new Program(Mode.Absolute);
|
||||
clean.MoveTo(0, 0); clean.LineTo(0, 10 - fillet);
|
||||
clean.ArcTo(fillet, 10, fillet, 10 - fillet, RotationType.CW);
|
||||
clean.LineTo(10, 10); clean.LineTo(10, 0); clean.LineTo(0, 0);
|
||||
if (reversed)
|
||||
{
|
||||
clean.MoveTo(fillet, 10); clean.ArcTo(0, 10 - fillet, fillet, 10 - fillet, RotationType.CCW);
|
||||
clean.LineTo(0, 0); clean.LineTo(10, 0); clean.LineTo(10, 10); clean.LineTo(fillet, 10);
|
||||
}
|
||||
else
|
||||
{
|
||||
clean.MoveTo(0, 0); clean.LineTo(0, 10 - fillet);
|
||||
clean.ArcTo(fillet, 10, fillet, 10 - fillet, RotationType.CW);
|
||||
clean.LineTo(10, 10); clean.LineTo(10, 0); clean.LineTo(0, 0);
|
||||
}
|
||||
var part = new Part(new Drawing("tabbed-fillet", clean));
|
||||
var perimeter = LeadInTestHelpers.Profile(part).Perimeter;
|
||||
var entry = new Vector(fillet, 10);
|
||||
var entry = reversed ? new Vector(0, 10 - fillet) : new Vector(fillet, 10);
|
||||
var entity = perimeter.Entities.OfType<Line>().First(l => l.StartPoint.DistanceTo(entry) < 1e-9);
|
||||
var parameters = new CuttingParameters
|
||||
{
|
||||
@@ -168,7 +125,7 @@ public class TabbedLeadOutTests
|
||||
LeadInTestHelpers.AssertPoint(entry, leadIn.EndPoint);
|
||||
Assert.Equal(tab, leadOut.StartPoint.DistanceTo(entry), 9);
|
||||
// The cut stops on the other edge, past the corner.
|
||||
Assert.Equal(0, leadOut.StartPoint.X, 9);
|
||||
Assert.Equal(0, reversed ? 10 - leadOut.StartPoint.Y : leadOut.StartPoint.X, 9);
|
||||
|
||||
const double bisector = 3 * System.Math.PI / 4;
|
||||
var spread = OpenNest.Math.Angle.ToRadians(30);
|
||||
@@ -176,36 +133,6 @@ public class TabbedLeadOutTests
|
||||
LeadInTestHelpers.AssertPoint(leadOut.StartPoint + Polar(0.1, bisector + spread), leadOut.EndPoint);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LineLeads_TabWrappingAFilletedCornerTheOtherWay_LeaveOutTheLeadOutThatCrossesTheLeadIn()
|
||||
{
|
||||
// Wound the other way, the shared bisector puts the lead-out across the lead-in.
|
||||
const double fillet = 0.015;
|
||||
var clean = new Program(Mode.Absolute);
|
||||
clean.MoveTo(fillet, 10); clean.ArcTo(0, 10 - fillet, fillet, 10 - fillet, RotationType.CCW);
|
||||
clean.LineTo(0, 0); clean.LineTo(10, 0); clean.LineTo(10, 10); clean.LineTo(fillet, 10);
|
||||
var part = new Part(new Drawing("tabbed-fillet", clean));
|
||||
var perimeter = LeadInTestHelpers.Profile(part).Perimeter;
|
||||
var entry = new Vector(0, 10 - fillet);
|
||||
var entity = perimeter.Entities.OfType<Line>().First(l => l.StartPoint.DistanceTo(entry) < 1e-9);
|
||||
var parameters = new CuttingParameters
|
||||
{
|
||||
ExternalLeadIn = new LineLeadIn { Length = 0.15, ApproachAngle = 60 },
|
||||
ExternalLeadOut = new LineLeadOut { Length = 0.1, ApproachAngle = 60 },
|
||||
TabsEnabled = true,
|
||||
TabConfig = new NormalTab { Size = 0.03 },
|
||||
};
|
||||
|
||||
part.ApplySingleLeadIn(parameters, entry, entity, ContourType.External);
|
||||
|
||||
var geometry = part.Program.ToGeometry();
|
||||
var leadIn = Assert.IsType<Line>(Assert.Single(geometry.Where(e => e.Layer == SpecialLayers.Leadin)));
|
||||
LeadInTestHelpers.AssertPoint(entry, leadIn.EndPoint);
|
||||
LeadInTestHelpers.AssertPoint(entry + Polar(0.15, 3 * System.Math.PI / 4 - OpenNest.Math.Angle.ToRadians(30)),
|
||||
leadIn.StartPoint);
|
||||
Assert.DoesNotContain(geometry, e => e.Layer == SpecialLayers.Leadout);
|
||||
}
|
||||
|
||||
private static Vector Polar(double length, double angle) =>
|
||||
new(length * System.Math.Cos(angle), length * System.Math.Sin(angle));
|
||||
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
using OpenNest.CNC;
|
||||
using OpenNest.CNC.CuttingPlanning;
|
||||
using OpenNest.CNC.CuttingStrategy;
|
||||
using OpenNest.Diagnostics;
|
||||
using OpenNest.Engine.CuttingPlanning;
|
||||
@@ -9,8 +10,8 @@ using OpenNest.Tests.CuttingPlanning;
|
||||
namespace OpenNest.Tests.Support;
|
||||
|
||||
/// <summary>
|
||||
/// Parts the support grid cannot hold level: hand-placed lead-ins tab them, Plan Cutting warns
|
||||
/// when it cannot steady them, and the pre-post review warns about any without a steadying tab.
|
||||
/// Parts the support grid cannot hold level: hand-placed lead-ins tab them, and a tabbed part
|
||||
/// counts as steady wherever its tab is, so only one cut with no tab at all is warned about.
|
||||
/// </summary>
|
||||
public class SupportReviewTests
|
||||
{
|
||||
@@ -79,18 +80,18 @@ public class SupportReviewTests
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PrePost_AcceptsATabThatSteadiesThePart_AndWarnsAboutOneThatDoesNot()
|
||||
public void PrePost_AcceptsATabAnywhere_EvenWhereItDoesNotHoldThePartLevel()
|
||||
{
|
||||
var (steadied, _, top) = Strip(OneRow);
|
||||
PlaceLeadIn(top, Parameters(tabs: true), new Vector(5, 1), new Line(new Vector(0, 1), new Vector(10, 1)));
|
||||
// On the edge beside the row of contacts the tab cannot hold the strip level; tabbed, it still counts as steady.
|
||||
var (unsteady, _, bottom) = Strip(OneRow);
|
||||
PlaceLeadIn(bottom, Parameters(tabs: true), new Vector(5, 0), new Line(new Vector(10, 0), new Vector(0, 0)));
|
||||
|
||||
Assert.DoesNotContain(PostVerificationAnalyzer.Analyze(steadied).Findings,
|
||||
f => f.Kind == PostVerificationKind.PartSupport);
|
||||
var finding = Assert.Single(PostVerificationAnalyzer.Analyze(unsteady).Findings,
|
||||
Assert.DoesNotContain(PostVerificationAnalyzer.Analyze(unsteady).Findings,
|
||||
f => f.Kind == PostVerificationKind.PartSupport);
|
||||
Assert.Contains("does not steady it", finding.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
@@ -109,16 +110,18 @@ public class SupportReviewTests
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PlanCutting_WarnsWhenNoSingleTabCanSteadyThePart()
|
||||
public void PlanCutting_TabsAPartNoSingleTabCanSteady_WithoutAWarning()
|
||||
{
|
||||
// The 10 x 0.8 strip lies between grid rows: it rests on nothing, so a tab only hangs it.
|
||||
// The 10 x 0.8 strip lies between grid rows: it rests on nothing. Tabbed, it counts as steady.
|
||||
var (_, plate, _) = Strip(new SupportGrid(1, 1, 0, 0.9, stabilityMargin: 0.1), height: 0.8);
|
||||
|
||||
var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, Vector.Zero,
|
||||
confirmedParameters: Parameters()));
|
||||
|
||||
Assert.Equal(CuttingPlanStatus.BestEffort, result.Status);
|
||||
var finding = Assert.Single(result.Findings, f => f.Kind == PostVerificationKind.PartSupport);
|
||||
Assert.Contains("no single tab can steady it", finding.Message);
|
||||
Assert.True(result.Status == CuttingPlanStatus.Ready, string.Join("\n", result.Findings.Select(f => f.Message)));
|
||||
Assert.DoesNotContain(result.Findings, f => f.Kind == PostVerificationKind.PartSupport);
|
||||
var proposal = Assert.Single(result.ProposedOrder);
|
||||
Assert.NotNull(PartSupportReview.OutsideTab(
|
||||
ExecutionMotionReader.Read(proposal.CopyProgram(), proposal.Location, null, default)));
|
||||
}
|
||||
}
|
||||
@@ -124,15 +124,16 @@ public class TabHeldSupportTabTests
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void PlanCutting_WarnsAboutAShortPartNoTabCanSteady_WithoutTheLimit()
|
||||
public void PlanCutting_TabsAShortPartNoTabCanSteady_WithoutTheLimit_AndDoesNotWarn()
|
||||
{
|
||||
var (_, plate, _) = Square(Parameters(0));
|
||||
|
||||
var result = CuttingPlanService.Plan(CuttingPlanRequest.ForPlate(plate, Vector.Zero,
|
||||
confirmedParameters: Parameters(0)));
|
||||
|
||||
Assert.Equal(CuttingPlanStatus.BestEffort, result.Status);
|
||||
Assert.Contains("no single tab can steady it", Assert.Single(result.Findings).Message);
|
||||
// Tabbed, a part counts as steady wherever its tab is.
|
||||
Assert.True(result.Status == CuttingPlanStatus.Ready, string.Join("\n", result.Findings.Select(f => f.Message)));
|
||||
Assert.Empty(result.Findings);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
||||
@@ -646,6 +646,7 @@ internal sealed class CuttingInspectionPanel : UserControl
|
||||
PostVerificationKind.OffPlate => "Off the plate",
|
||||
PostVerificationKind.EdgeSpacing => "Outside work area",
|
||||
PostVerificationKind.CommonLine => "Common line",
|
||||
PostVerificationKind.TabLeadOut => "Tab lead-out",
|
||||
_ => kind.ToString(),
|
||||
};
|
||||
|
||||
@@ -715,6 +716,7 @@ internal sealed class CuttingInspectionPanel : UserControl
|
||||
PostVerificationKind.OffPlate => "The ring marks where the part leaves the plate.",
|
||||
PostVerificationKind.EdgeSpacing => "The ring marks where the part leaves the work area, inside the edge spacing.",
|
||||
PostVerificationKind.CommonLine => "The ring marks the common-line part or lead to review.",
|
||||
PostVerificationKind.TabLeadOut => "The ring marks where the lead-out leaves the tab.",
|
||||
_ => "The ring marks the affected part; the exact spot is not known."
|
||||
};
|
||||
|
||||
|
||||
@@ -32,6 +32,7 @@ public partial class PostVerificationForm : Form
|
||||
(PostVerificationKind.EdgeSpacing, "Outside work area"),
|
||||
(PostVerificationKind.PartSupport, "Part support"),
|
||||
(PostVerificationKind.CommonLine, "Common lines"),
|
||||
(PostVerificationKind.TabLeadOut, "Tab lead-outs"),
|
||||
};
|
||||
|
||||
internal static PostVerificationKind[] ListedKinds => Categories.Select(c => c.Kind).ToArray();
|
||||
|
||||
@@ -37,10 +37,10 @@ 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 keep to points where the tab steadies it. A tab
|
||||
that still cannot hold its part level, or sits in an inside corner, is noted on the plan
|
||||
without changing its status. A part no single tab can hold level may tip once cut, so its
|
||||
tabbed outside is a rapid obstacle from then on, like an untabbed one. A part no longer than `TabHeldMaxLength` is held by its tab
|
||||
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
|
||||
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`
|
||||
are tabbed instead, and with no range set the plan notes that nothing was tabbed; see
|
||||
|
||||
@@ -108,8 +108,8 @@ shows the first three check categories, even when there are no findings:
|
||||
incomplete for leads near it. This line appears in the summary only when there is such
|
||||
a finding.
|
||||
- **Part support:** on a plate with a support bed, a part set for support tabs that the bed
|
||||
cannot hold level and whose outside cut leaves no tab that keeps it level; the marker is its
|
||||
center of gravity. See [support tabs](support-tabs.md#pre-post-review).
|
||||
cannot hold level and whose outside cut leaves no tab at all (any tab counts as steadying
|
||||
it); the marker is its center of gravity. See [support tabs](support-tabs.md#pre-post-review).
|
||||
- **Part spacing:** two parts closer than the plate's part spacing without sharing material
|
||||
(overlapping pairs are reported only as overlaps). Candidate pairs come from each part's
|
||||
clean nesting material (leads excluded) tested exactly as Auto Nest's layout check tests
|
||||
@@ -190,7 +190,8 @@ rounded (see [cutting dependencies](cutting-planner.md#cutting-dependencies)): t
|
||||
never mistakes a fillet's joint for a loop. Plan
|
||||
Cutting runs the same proof, so its own [tabbed cutouts](tabbed-cutouts.md) (pieces without
|
||||
lead-outs) pass, and so do its tabbed perimeters followed by a lead-out that stays out of the
|
||||
tab. A program that still has a tabbed cutout's `Tab` motions (never planned) is
|
||||
tab. A configured lead-out that may cut its tab free is a warning in Plan Cutting instead (see
|
||||
[support tabs](support-tabs.md#support-tabs-in-plan-cutting)), and stays incomplete here. A program that still has a tabbed cutout's `Tab` motions (never planned) is
|
||||
incomplete: a post may cut through them.
|
||||
|
||||
## Explicit override
|
||||
|
||||
+26
-21
@@ -104,11 +104,17 @@ plate settings, so parts that need no tab are not tabbed.
|
||||
|
||||
The emitter tabs a perimeter at its entry: the cut stops short of the entry by the tab size. A
|
||||
round perimeter, one circle, is cut as an arc that stops the tab's chord short of its entry.
|
||||
The lead-out leaves from where the cut stops. One that touches the lead-in, or passes within the
|
||||
kerf of it, would cut the tab free, so the emitter leaves it out and the cut ends at its tab. A
|
||||
line lead-out angled forward does that whenever its run along the edge is longer than the tab,
|
||||
as a 0.1 lead-out at 60 degrees (0.05 along the edge) beside a 0.03 tab does. This holds for every
|
||||
tabbed outside, support-tabbed or not.
|
||||
The lead-out leaves from where the cut stops, as configured; Plan Cutting never shortens or drops
|
||||
it. A line lead-out angled forward runs toward the lead-in whenever its run along the edge is
|
||||
longer than the tab, as a 0.1 lead-out at 60 degrees (0.05 along the edge) beside a 0.03 tab
|
||||
does on a counterclockwise outside, and can then cut the tab free. The strict search refuses
|
||||
such an entry and looks for another. Only when that refusal is all that stops a plan does Plan
|
||||
Cutting plan again keeping those lead-outs (`CuttingPlanSnapshot.WithTabLeadOuts`): each such
|
||||
part gets a `PostVerificationKind.TabLeadOut` warning (Plan Cutting's "Tab lead-out" issue), is
|
||||
treated as cut free for later rapids, and the plan is UNVERIFIED, so applying it needs explicit
|
||||
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.
|
||||
@@ -173,22 +179,20 @@ entry is only a preference: its other fitting entries clear of inside corners fo
|
||||
toward the next cut, in the search and in contour recovery (ranked steadiest first, the shortlist
|
||||
of a long strip resting on one line of contacts would all lie on its far side). A part boxed in
|
||||
by its neighbors, such as the upper of two strips nested in a cutout, can then be left toward the
|
||||
next cut instead of blocking the plan. It is still tabbed and still warned about as one that may
|
||||
tip. A part a tab can hold level keeps to its steadying entries.
|
||||
next cut instead of blocking the plan. It is still tabbed. A part a tab can hold level keeps to
|
||||
its steadying entries.
|
||||
|
||||
Once cut, such a part may tip into the head's path, so Plan Cutting treats its tabbed outside as a
|
||||
rapid obstacle, closed across its tab gap, exactly as an untabbed part: no later rapid may cross
|
||||
it, and the search reorders around it (a row of long strips is cut after the parts beside them,
|
||||
each strip left toward the next). Parts their tab holds level stay crossable, as the retained
|
||||
material allows. The pre-post review does not read support settings for rapids, so it still
|
||||
checks rapid crossings against untabbed contours only.
|
||||
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
|
||||
review does not read support settings for rapids, so it checks rapid crossings against untabbed
|
||||
contours only.
|
||||
|
||||
A drawing pin on the perimeter wins: its entry, leads and tab are kept as pinned, and the
|
||||
analysis is only carried for review. Replay and best-effort plans (`SupportTabCapture.Review`)
|
||||
warn with `PostVerificationKind.PartSupport` whenever an unsupported part's emitted perimeter is
|
||||
untabbed or its entry does not steady the part: its pin has no tab or a tab elsewhere, no
|
||||
steadying entry had a lead-in that fits, or no single tab can steady it. Like every planner
|
||||
warning, this makes the proposal UNVERIFIED, so applying it needs explicit acceptance.
|
||||
warn with `PostVerificationKind.PartSupport` only when an unsupported part's emitted perimeter
|
||||
is untabbed, which happens when its pin has no tab. Like every planner warning, this makes the
|
||||
proposal UNVERIFIED, so applying it needs explicit acceptance.
|
||||
|
||||
A planned tab that sits in an inside corner, because no lead-in fits clear of one, gets an
|
||||
advisory note instead (`SupportTabCapture.Notes`; never for a pin): a Ready plan keeps its
|
||||
@@ -252,13 +256,14 @@ settings (its own, else the plate's) ask for support tabs and that needs one (th
|
||||
cannot hold it level or, by size, its width is in the size range) is checked, however its
|
||||
program was made. The tab is the gap between
|
||||
the end and the start of the program's outside cut (the chain of cutting motions with the
|
||||
largest extent). A part with no such gap, or whose gap does not steady it (by size,
|
||||
or for a part its tab alone holds, any gap does), gets a `PartSupport` warning at its center of gravity naming the best tab point; posting needs
|
||||
consent as for every warning. A part whose material cannot be read is reported as not checked.
|
||||
largest extent). A part with no such gap gets a `PartSupport` warning at its center of gravity
|
||||
naming the best tab point; posting needs consent as for every warning. Any gap counts as a tab
|
||||
that steadies the part, wherever it is. A part whose material cannot be read is reported as not
|
||||
checked.
|
||||
|
||||
Not covered yet:
|
||||
|
||||
- Locked or ineligible parts keep their programs in Plan Cutting; the pre-post review still
|
||||
checks them.
|
||||
- Only one perimeter tab per part. A part that needs more (one tab cannot reach the stability
|
||||
margin) gets the best single tab and a warning.
|
||||
margin) gets the best single tab, and no warning.
|
||||
Reference in new issue
Block a user