feat(cutting): start the owner's outline on its common line

The part cut first no longer makes a separate uncompensated centerline
cut with its own lead-in and lead-out, then re-pierces for its
remainder. It cuts its outside compensated, which puts its shared edge
on the kerf centerline, starting on the common line: a straight lead-in
from the scrap along the shared edge, then the line and on round its
perimeter with no lead-out. A member with spans already cut stops in
that kerf and cuts its last stretch from it, ending beside the part it
is cut before. Partners still cut only their remainders.

Replay's tabbed-ring accounting now accepts pieces that tile each span
exactly once, and the pre-post review counts a span as cut by a
member's compensated edge (or an older centerline cut).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
ajandClaude Opus 5.5 committed 2026-11-08 16:57:35 -05:00
1 parent bff11dbc3c
commit 74937b7952
15 files changed
+530 -337

No files matched your search

+13 -11
View File
@@ -73,23 +73,25 @@ uses the Cincinnati machine-sample convention, not a generic TF5200 laser API:
A [common line cut once](common-line-cutting.md#cutting-each-shared-line-once) posts in plate
order, member by member, each member's holes first:
- **Shared cut** (`CommonLine` motions): the cut-off form with a real lead-in. `/L "L0"`, restart
number, rapid to the pierce on the span's axis, `/L "L4"`, the straight lead-in `G1`, `/L "L6"`,
the centerline `G1`, the straight lead-out `G1` when there is one, and `/L "ZHSOFF"`. No
`G41`/`G42` is selected: the line is the beam centerline between the two parts.
- **Owner's outside**: the part that cuts a common line starts its outside on it. With no span
cut before it, it is a normal closed perimeter (`G41`/`G42` from its travel), whose straight
lead-in runs up the shared edge's axis, so the common line is its first cut.
- **Remainder** (an open contour after a `COMMON LINE REMAINDER` comment): the normal contour
form with the perimeter macro, `/L "L4"`, `G41` for a clockwise perimeter or `G42` for a
counterclockwise one (the side its whole perimeter would get), the straight lead-in that starts
in the shared kerf, `/L "L6"`, the open path and `/L "ZHSOFF"`. A member's closed contours are
all holes; the post picks no perimeter among them.
counterclockwise one (the side its whole perimeter would get), the straight lead-in, `/L "L6"`,
the open path and `/L "ZHSOFF"`. A member's closed contours are then all holes; the post picks
no perimeter among them. An owner whose outside stops in an earlier member's kerf writes each
of its pieces this way.
- **Shared cut** (`CommonLine` motions, programs planned before the owner cut its own edge): the
cut-off form with a real lead-in, no `G41`/`G42`.
**Unconfirmed on the machine** (release gate, see [common-line cutting](common-line-cutting.md)):
- compensation start-up on a remainder whose lead-in starts in void (the kerf the shared cut
opened) and runs along it;
- compensation start-up on a remainder whose lead-in starts in void (the kerf the owner's cut
opened) and runs along it, and on the owner's lead-in collinear with its shared edge;
- compensation cancel where a remainder ends in that kerf, and that the next contour starts
uncompensated, since the post writes no `G40` (the macros cancel compensation);
- whether `L4` runs correctly before an uncompensated shared cut, as for cut-offs.
- whether `L4` runs correctly before an older program's uncompensated shared cut, as for cut-offs.
Verify on a 3/16 stainless coupon pair on the CI FIBER 4020 and record the result here.
@@ -153,7 +155,7 @@ transforms/formatting, lead-in rejection,
cut-off sequencing and output, table bounds, suppression/scribe handling, and
multi-sheet output in both modes.
[Common-line post tests](../OpenNest.Tests/CommonLines/CommonLinePostTests.cs) hold a golden
program for a planned two-part pair (shared cut and both remainders), the remainders'
program for a planned two-part pair (the owner's perimeter starting on the common line, and the partner's remainder), the remainders'
compensation side for either winding, and the refusals of posts without support.
[Sample regression tests](../OpenNest.Tests/CincinnatiCIFiber/CIFiberSampleRegressionTests.cs)
post a nest rebuilt from a Cincinnati machine sample, whose parts carry the
+48 -38
View File
@@ -46,44 +46,52 @@ planned member's open program changes no utilization, quantity, overlap or spaci
order that cuts the partner first is a `ConstraintConflict` naming "the common-line partner").
The tour treats each such pair like a nested part and its host, so a group is cut as one run.
A rule the search learns later may still separate members; the dependency always holds.
- **The common line is the owner's own edge.** Each member cuts its outside compensated like any
perimeter. Because the parts lie exactly one kerf apart, the owner's compensated shared edge
runs on the kerf centerline: that cut is the common line, and it opens the partner's edge too.
No cut is made without compensation. A Z or L path is cut through its corners as the owner's
own edges; at each corner the kerf leaves the member on the outside of the turn a fillet of
about half a kerf's radius where its nominal corner is sharp.
- **Each member is cut** as: its holes (and break cuts and tabbed cutouts, as for any part), then
the shared cuts it owns, then its **remainder**: its perimeter minus every span it shares, in
the perimeter's own direction, as one open piece per stretch between spans. Shared cuts are
never all cut first: each is cut where the route passes its owner. A Z or L path is one shared
cut, owned and cut as a whole.
- **Shared cut:** an open cut on the centerline (`LayerType.CommonLine`), cut without kerf
compensation. It is pierced in scrap on its first leg's axis, the external lead-in's reach
before the path, and entered with a straight lead-in through the end notch; a Z or L path is
then cut through its corners in one pass, one `CommonLine` move per leg. It leaves the same way
at the far end, along its last leg, with a straight lead-out as long as the external lead-out's
reach (none with no lead-out). At each corner the kerf leaves the member on the outside of the
turn a fillet of half a kerf's radius where its nominal corner is sharp; the member on the
inside keeps a sharp corner. Capture tries each end in turn: the lead-in, cut and lead-out may touch no
material, and the pierce keeps the pierce zone. When no end fits, planning refuses with
`UnsupportedGeometry` naming both parts and the span. Leads are never shortened.
- **Remainder:** each piece starts where a shared span ends. It is pierced in that span's kerf,
on the centerline, the external lead-in's reach back along the span, and enters along a straight
lead-in to the piece's start, so compensation starts inside the kerf the shared cut opened (for
a Z or L path, the kerf of its last leg before the piece); the
pierce meets nothing. The comment `COMMON LINE REMAINDER CW` (or `CCW`) after its rapid names
the perimeter's winding, so posts compensate it on the perimeter's side. It has no lead-out: it
ends in the kerf at the next span. A span shorter than the lead-in's reach, or an external
lead-in with no length, refuses with `UnsupportedGeometry`.
- **Accounting.** The planner marks each member's shared spans on its owned clean copy as `Tab`
spans (`CommonLineCutting.MarkSharedSpans`): material the member never cuts. At a path's corner
each leg's span runs on to the member's own vertex there, so a Z or L is one run of tabs. Replay's contour
accounting proves each stretch between them is cut whole, once, as for
[tabbed cutouts](tabbed-cutouts.md#verification), and refuses a member that also cuts a span.
- **Rapids.** A shared cut is never a rapid obstacle and takes no part in the open-cut retention
proof. When a member's program ends, its remainder pieces, joined across its spans, become one
obstacle: the part is cut free then.
its outside, in the perimeter's own direction, never cutting a span an earlier member cut:
- **Starting on its common line.** A member that owns a shared cut starts its outside there:
pierced in scrap the external lead-in's reach back along the axis of the edge on which its
travel enters the path, a straight lead-in to that edge's start vertex, then the common line
and on round its perimeter with no lead-out. With no span cut before it (the group's first
member), that is its whole perimeter, closing where it began: a normal closed contour. Otherwise
it stops in the first earlier member's kerf it reaches, and its other stretches follow as
remainder pieces, the stretch before its start last, ending at it, beside the partner it is
cut before. Capture tries the start of each path it owns: the lead-in may touch no material and
the pierce keeps the pierce zone. When none fits, planning refuses with `UnsupportedGeometry`
naming both parts and the line. Leads are never shortened, and an external lead-in with no
length refuses.
- **Remainder:** a member that owns nothing cuts only its perimeter minus the spans earlier
members cut, as one open piece per stretch between them. Each piece starts where such a span
ends. It is pierced in that span's kerf, on the centerline, the external lead-in's reach back
along the span, and enters along a straight lead-in to the piece's start, so compensation
starts inside the opened kerf (for a Z or L path, the kerf of its last leg before the piece);
the pierce meets nothing. It has no lead-out: it ends in the kerf at the next span. A span
shorter than the lead-in's reach refuses with `UnsupportedGeometry`.
- Every open piece (a remainder, or a starting stretch that stops in a kerf) is preceded by the
comment `COMMON LINE REMAINDER CW` (or `CCW`), naming the perimeter's winding, so posts
compensate it on the perimeter's side.
- **Accounting.** The planner marks the spans earlier members cut on each member's owned clean
copy as `Tab` spans (`CommonLineCutting.MarkSharedSpans`): material the member never cuts. At a
path's corner each leg's span runs on to the member's own vertex there, so a Z or L is one run
of tabs. Replay's contour accounting proves each stretch between them is cut exactly once, as
for [tabbed cutouts](tabbed-cutouts.md#verification): its pieces tile it with no gap or overlap
(two pieces where a member starts on its common line inside a stretch), and it refuses a member
that also cuts a span.
- **Rapids.** When a member's program ends, its pieces, joined across the spans earlier members
cut, become one obstacle: the part is cut free then. Older programs' uncompensated `CommonLine`
centerline cuts are never rapid obstacles.
- **Refusals.** A broken group, and a locked member or one a caller left out of the plan, cannot
be cut once: rejoin, unlock or include it, or cut the plate's lines twice. A drawing pin on a
member's outside is not applied (a warning makes the plan UNVERIFIED); pins on its holes are.
Members are never support-tabbed. Remainder pierces in the kerf are held to the pierce zone like
any other, so a pierce diameter wider than the kerf refuses them.
- **Apply** installs each member's program (holes, shared cuts, remainder); nothing is added to
the plate.
- **Apply** installs each member's program (holes, then its outside); nothing is added to the
plate.
### Cut common lines twice
@@ -181,14 +189,16 @@ Auto Nest, the server's nesting worker and Fill Area can place parts on common l
- a group whose kerf differs from the plate's cutting parameters' kerf (when the plate has
them) by more than `GapTolerance`. A group at the wrong kerf would leave a web or cut a sliver.
Rejoin it at the current kerf;
- a lead-in, lead-out or shared cut of a member that touches or enters another member's
- a lead-in, lead-out or (older programs') centerline shared cut of a member that touches or enters another member's
material. A lead on a shared edge would cut the partner one kerf away. An unreadable lead
check is incomplete, never clear;
- on a plate that cuts its lines once, a span no member's program cuts on its centerline (for
example a plate never planned, which would cut it twice), a span cut more than once, and a
span cut after the partner whose remainder ends in it;
- on a plate set to cut its lines twice, a member program that still cuts one once.
- The rapid check treats members' remainders and shared cuts as planning does.
- on a plate that cuts its lines once, a span no member's program cuts, a span cut more than
once (both members cutting their edge along it, as a plate not planned since the parts were
joined does), and a span cut after the partner whose remainder ends in it. A span counts as cut
by a member whose compensated edge covers it half a kerf off the centerline, or by an older
program's uncompensated centerline cut;
- on a plate set to cut its lines twice, a member program that still cuts one once (a remainder).
- The rapid check treats members' remainders as planning does.
## Posting
+6 -5
View File
@@ -130,11 +130,12 @@ their canonical content, like the other nesting settings, so it never changes a
A plate's optional `cutCommonLinesTwice` (`Plate.CutCommonLinesTwice`) is `true` when its
common lines are cut twice; it is omitted when false, the default, in which Plan Cutting cuts
each shared span once. A program planned that way saves its shared cuts as motions tagged
`:COMMONLINE` and puts a `COMMON LINE REMAINDER CW` or `CCW` comment after the rapid into each
remainder piece. Versions without single-pass support read those motions as ordinary cuts,
which a post would cut with compensation, so such a nest must not be posted from an older
version.
each shared span once. A program planned that way puts a `COMMON LINE REMAINDER CW` or `CCW`
comment after the rapid into each remainder piece; the part that cuts the common line saves an
ordinary compensated perimeter. Programs planned by earlier versions may also hold uncompensated
shared cuts as motions tagged `:COMMONLINE`, which still read and post. Versions without
single-pass support read a remainder as an ordinary open cut, so such a nest must not be posted
from an older version.
## Plate cutting parameters
+4 -2
View File
@@ -57,8 +57,10 @@ and before the contours, never in single-contour probes:
## Verification
Plan Cutting certifies tabbed cutouts. Its contour accounting
(`ContourProgramVerifier`) requires each piece to start exactly where a span between tabs
starts and to cover that span whole, once; the ring counts as cut when every span is.
(`ContourProgramVerifier`) requires each piece to follow one span between tabs without
crossing a tab, and the pieces to tile every span with no gap or overlap; the ring counts as cut
when every span is. A tabbed cutout's pieces each cover their span whole; only a
[common-line](common-line-cutting.md) member that starts on its common line cuts one span in two.
Lead validation treats a piece's start like any contour joint. The released-contour check
proves the open pieces retain their slug with the same open-cut proof pre-post review uses
(see [pre-post verification](post-verification.md)); planning still refuses its own tabs