Files
OpenNest/OpenNest.Engine/CuttingPlanning/SupportTabCapture.cs
T
ajandClaude Opus 5.5 e1ccd69291 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>
2026-11-16 12:34:34 -05:00

111 lines
6.2 KiB
C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using OpenNest.CNC;
using OpenNest.CNC.CuttingPlanning;
using OpenNest.Diagnostics;
using OpenNest.Geometry;
using OpenNest.Support;
namespace OpenNest.Engine.CuttingPlanning;
/// <summary>
/// Capture-time support tabs for one regenerated part (docs/support-tabs.md): with
/// <see cref="CNC.CuttingStrategy.CuttingParameters.SupportTabs"/> on, a part the support bed
/// cannot hold level, or by size (no bed, or <see cref="CNC.CuttingStrategy.CuttingParameters.TabBySize"/>)
/// a part in the size range (<see cref="SupportTabSettings.Analyze"/>), has its perimeter tabbed where the tab steadies
/// it; a pinned perimeter
/// keeps its pin (the drawing wins) and only carries the analysis for replay to review. A
/// supported part, a missing tab configuration or material the analyzer cannot read leave the
/// preparation as it was.
/// </summary>
internal static class SupportTabCapture
{
internal static PreparedContours Prepare(PreparedContours prepared, Program ownedClean, Vector location,
CuttingPlanRequest request, CancellationToken token)
{
var parameters = request.ConfirmedParameters;
// A display perimeter is a supplied blank: it is never cut free, so it needs no tab.
// A common-line member is never support-tabbed: its outside is cut from its shared spans.
if (prepared == null || !prepared.HasCutPerimeter || prepared.IsCommonLinePerimeter || parameters?.TabConfig == null
|| !SupportTabSettings.CanTab(parameters, request.SupportBed))
return prepared;
token.ThrowIfCancellationRequested();
// The clean program is the drawing's own, rotated as placed: its material at the
// part's location is the material that drops onto the bed. The tab keeps clear of
// inside corners by twice its size.
var support = SupportTabSettings.Analyze(parameters, request.SupportBed, request.SupportQuadrant,
SupportMaterial.FromProgram(ownedClean, location),
SupportAnalyzer.InsideCornerClearance(parameters.TabConfig.Size));
if (support is not { IsComplete: true, IsSupported: false } || support.BestTabPoint == null)
return prepared;
return prepared.WithSupportTab(support, location, parameters.TabConfig);
}
/// <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 part cut with no tab at all is <see cref="Review"/>'s warning.
/// </summary>
internal static IEnumerable<CuttingPlanFinding> Notes(FixedProgramPlacement planned)
{
var prepared = planned.Prepared;
if (prepared?.Support == null || prepared.IsPinned(prepared.PerimeterOrdinal)
|| planned.ContourChoices.FirstOrDefault(c => c.ContourOrdinal == prepared.PerimeterOrdinal) is not { } entry
|| prepared.IsClearOfInsideCorners(entry))
yield break;
var tab = entry.Point + planned.Location;
var at = FormattableString.Invariant($"({tab.X:0.####}, {tab.Y:0.####})");
yield return JointCuttingPlanSearch.Finding(planned, null,
$"Its support tab at {at} is in an inside corner, because no lead-in fits clear of one; "
+ "its nub will be hard to grind flush.");
}
/// <summary>
/// A <see cref="PostVerificationKind.PartSupport"/> warning when a regenerated part its bed
/// 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)
{
var prepared = source.Prepared;
if (prepared?.Support is not { } support || choices == null)
return null;
var perimeter = choices.FirstOrDefault(c => c.ContourOrdinal == prepared.PerimeterOrdinal);
if (perimeter == null)
return null;
if (prepared.PerimeterTabbed)
return null;
var part = source.SourceOrdinal + 1;
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 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.");
}
/// <summary>
/// One plan note when support tabs are on but go by size (no support bed, or by size chosen)
/// and the settings set no size range, so no part was tabbed. Advisory, like <see cref="Notes"/>.
/// </summary>
internal static IEnumerable<CuttingPlanFinding> Skipped(CuttingPlanSnapshot snapshot)
{
if (snapshot.SupportTabsSkipped)
yield return new CuttingPlanFinding(null, null, null, null, null,
snapshot.OwnedParameters?.TabBySize == true
? "Tabs by size are on, but no width range is set, so no part was tabbed."
: "Support tabs are on, but the plate has no support bed and no width range is set for "
+ "plates without one, so no part was tabbed.");
}
}