Add 45-degree woodpile raster and seam-free split contours

- Grid-split pieces store contour paths clipped from the PARENT outline, so
contour tracing never runs along the cut seams between sibling pieces:
edge pieces trace open arcs of the true outer surface, fully interior
pieces trace nothing, and holes inside one piece stay closed rings; the
contour printer approaches an open arc's nearer end and does not close it
- New "45-degree Woodpile" raster: the sweep rotates 45 degrees per layer
(0/45/90/135), reusing the axis raster in a rotated frame anchored to the
shared scan frame so buffers, valve gating, infill selection, and seam
grid continuity all carry over to the diagonal layers
- Rename patterns to "90 deg Woodpile raster" / "45 deg Woodpile raster"

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

README.md

@@ -94,9 +94,9 @@ The **Multi-Nozzle Split** accordion on the **Shapes & Slicing** tab can split o
 - **Use G1 for all moves**: when enabled, every movement line is emitted as `G1` (no `G0` rapid travel); the WAGO valve still marks where material is dispensed. Applies to all shapes.
 - **Use combined reference outline for motion**: when enabled, every shape's *motion* is taken from the combined reference layer union while each shape's *valve/dispensing* comes from its own layer polygons — so parallel print heads share one synchronized nozzle path and each deposits only its own geometry. The reference union is rebuilt automatically when shapes are sliced. Contour tracing stays synchronized too: every shape traces every traced shape's contour, opening its valve only on its own outline.
 - Every generated file starts with a `; PathOrigin X.. Y..` comment: the world position (in the shape's own frame) that the relative toolpath starts from. Tools use it to place parallel parts so split pieces reassemble.
-- **Raster Pattern**: `X-direction raster` sweeps every layer back-and-forth in X. `Y-direction raster` rasters every layer in Y. `Woodpile raster` alternates the raster axis by layer, switching between X-direction and Y-direction sweeps. `Rectangular Spiral raster` walks each layer from the outer layer bounds toward the center, then reverses from center to edge on the next layer. `Circle Spiral raster` uses a shrinking circular spiral from the layer bounds toward the center, then reverses outward on the next layer. Spiral motion covers the layer bounds; the valve opens only where the path is inside material.
+- **Raster Pattern**: `X-direction raster` sweeps every layer back-and-forth in X. `Y-direction raster` rasters every layer in Y. `90° Woodpile raster` alternates the raster axis by layer, switching between X-direction and Y-direction sweeps. `45° Woodpile raster` rotates the sweep 45 degrees per layer, cycling 0, 45, 90, 135 degrees. `Rectangular Spiral raster` walks each layer from the outer layer bounds toward the center, then reverses from center to edge on the next layer. `Circle Spiral raster` uses a shrinking circular spiral from the layer bounds toward the center, then reverses outward on the next layer. Spiral motion covers the layer bounds; the valve opens only where the path is inside material.
 - **Auto Align Split Parts**: in Nozzle Spacing, computes exact per-connection grid gaps from the split pieces' generated G-code (`PathOrigin` anchors + toolpath bounds), sets the grid columns/rows from the split, and fills the Advanced Grid Spacing table. Works for every raster pattern, filament width, reference-motion setting, and overlapping-layer split. Requires the pieces' G-code to be generated first.
-- **Contour Tracing**: enabled per row in Shape Settings. The app traces the layer polygon's boundary rings (holes traced separately), travels from the layer raster end to the nearest contour point, prints the contour, then returns to the raster endpoint before the next layer.
+- **Contour Tracing**: enabled per row in Shape Settings. The app traces the layer polygon's boundary rings (holes traced separately), travels from the layer raster end to the nearest contour point, prints the contour, then returns to the raster endpoint before the next layer. For grid-split pieces only the parent shape's true outer surface is traced — the cut seams between sibling pieces are excluded (open arcs are printed end-to-end without closing the loop; fully interior pieces get no contour).
 
 ### Print vs Travel Classification
 

stl_slicer.py

@@ -44,6 +44,12 @@ class LayerStack:
     scan_frame: tuple[float, float, float, float] | None = None
     align_center: tuple[float, float] | None = None
     align_grid: float | None = None
+    # Grid-split pieces: per-layer contour polylines from the PARENT shape's
+    # boundary clipped to this piece's cell — cut seams between sibling
+    # pieces are excluded, so contour tracing only outlines the true outer
+    # surface. None means "derive contours from the layer polygons" (whole
+    # shapes). Paths may be open arcs; closed rings keep first == last.
+    contour_paths: list[list[list[tuple[float, float]]]] | None = None
 
 
 def load_mesh(stl_path: str | Path) -> trimesh.Trimesh:

tests/test_vector_gcode.py

@@ -416,6 +416,76 @@ def test_y_direction_raster_prints_each_layer_along_y_axis(tmp_path) -> None:
     assert first_layer_change["start"][:2] == first_layer_change["end"][:2]
 
 
+def test_diagonal_woodpile_rotates_45_degrees_per_layer(tmp_path) -> None:
+    from vector_toolpath import RASTER_PATTERN_DIAGONAL_WOODPILE
+
+    layer = box(0.0, 0.0, 8.0, 8.0)
+    gcode_path = generate_vector_gcode(
+        _stack(layer, layer, layer, layer),
+        shape_name="diagonal",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        layer_height=1.0,
+        raster_pattern=RASTER_PATTERN_DIAGONAL_WOODPILE,
+        output_dir=tmp_path,
+    )
+
+    moves = _moves_with_colors(gcode_path.read_text())
+    directions_by_layer: dict[float, set[float]] = {}
+    intercepts_45: set[float] = set()
+    for move in moves:
+        if move["color"] != 255:
+            continue
+        z = round(move["start"][2], 6)
+        dx = move["end"][0] - move["start"][0]
+        dy = move["end"][1] - move["start"][1]
+        angle = round(math.degrees(math.atan2(dy, dx)) % 180.0, 1)
+        directions_by_layer.setdefault(z, set()).add(angle)
+        if z == 1.0:
+            intercepts_45.add(
+                round((move["start"][1] - move["start"][0]) / math.sqrt(2), 5)
+            )
+
+    # The raster angle cycles 0 -> 45 -> 90 -> 135 across layers.
+    assert directions_by_layer == {
+        0.0: {0.0},
+        1.0: {45.0},
+        2.0: {90.0},
+        3.0: {135.0},
+    }
+    # Diagonal lines keep an exact one-fil perpendicular pitch.
+    ordered = sorted(intercepts_45)
+    assert len(ordered) > 3
+    assert {round(b - a, 4) for a, b in zip(ordered, ordered[1:])} == {1.0}
+
+
+def test_diagonal_woodpile_shares_reference_motion(tmp_path) -> None:
+    from vector_toolpath import RASTER_PATTERN_DIAGONAL_WOODPILE
+
+    big = _stack(*([box(0.0, 0.0, 8.0, 8.0)] * 4), name="big")
+    small = _stack(*([box(2.0, 2.0, 6.0, 6.0)] * 4), name="small")
+    reference = build_reference_stack([big, small], grid=1.0)
+
+    totals = []
+    for stack, label in ((big, "dbig"), (small, "dsmall")):
+        gcode_path = generate_vector_gcode(
+            stack,
+            shape_name=label,
+            pressure=25,
+            valve=7,
+            port=3,
+            fil_width=1.0,
+            motion=reference,
+            raster_pattern=RASTER_PATTERN_DIAGONAL_WOODPILE,
+            output_dir=tmp_path / label,
+        )
+        totals.append(_total_length(_moves_with_colors(gcode_path.read_text())))
+
+    assert abs(totals[0] - totals[1]) < 1e-2
+
+
 def test_raster_crosses_interior_holes_with_valve_off(tmp_path) -> None:
     hollow = Polygon(
         box(0.0, 0.0, 6.0, 6.0).exterior.coords,
@@ -1059,6 +1129,93 @@ def test_split_overlap_seam_raster_distance_is_equal_on_both_sides() -> None:
         assert abs(left_distance - right_distance) < 1e-9
 
 
+def test_split_contour_paths_exclude_the_cut_seams() -> None:
+    layer = MultiPolygon([box(0.0, 0.0, 9.0, 4.0)])
+    stack = _stack(layer, name="bar")
+
+    left, middle, right = split_layer_stack_grid(stack, columns=3, rows=1, grid=1.0)
+
+    # Middle piece: only the parent's top and bottom edges, as open arcs —
+    # no vertical paths along the cuts at x=3 and x=6.
+    assert middle.contour_paths[0] == [
+        [(3.0, 0.0), (6.0, 0.0)],
+        [(3.0, 4.0), (6.0, 4.0)],
+    ]
+    # Edge pieces get one open C-shaped path around their outer three sides.
+    (left_path,) = left.contour_paths[0]
+    assert left_path[0] != left_path[-1]
+    assert all(abs(x - 3.0) > 1e-9 or y in (0.0, 4.0) for x, y in left_path)
+
+    # A fully interior piece has no contour at all.
+    grid = split_layer_stack_grid(
+        _stack(MultiPolygon([box(0.0, 0.0, 9.0, 9.0)]), name="sq"),
+        columns=3,
+        rows=3,
+        grid=1.0,
+    )
+    assert grid[4].contour_paths[0] == []
+
+    # A hole entirely inside one piece stays a closed ring.
+    hollow = MultiPolygon(
+        [
+            Polygon(
+                box(0.0, 0.0, 9.0, 4.0).exterior.coords,
+                [list(box(1.0, 1.0, 2.0, 2.0).exterior.coords)],
+            )
+        ]
+    )
+    hole_left, _hm, _hr = split_layer_stack_grid(
+        _stack(hollow, name="hollow"), columns=3, rows=1, grid=1.0
+    )
+    closed_paths = [p for p in hole_left.contour_paths[0] if p[0] == p[-1]]
+    assert len(closed_paths) == 1
+
+
+def test_split_contour_gcode_never_traces_the_cuts(tmp_path) -> None:
+    layer = MultiPolygon([box(0.0, 0.0, 9.0, 4.0)])
+    stack = _stack(layer, layer, name="bar")
+    pieces = split_layer_stack_grid(stack, columns=3, rows=1, grid=1.0)
+    reference = build_reference_stack(pieces, grid=1.0)
+    sources = [
+        ContourSource(owner_idx=index + 1, stack=piece)
+        for index, piece in enumerate(pieces)
+    ]
+
+    all_moves = []
+    for index, piece in enumerate(pieces):
+        gcode_path = generate_vector_gcode(
+            piece,
+            shape_name=f"seam{index}",
+            pressure=25,
+            valve=4 + index,
+            port=3,
+            fil_width=1.0,
+            motion=reference,
+            contour_sources=sources,
+            active_contour_owner=index + 1,
+            output_dir=tmp_path / f"seam{index}",
+        )
+        all_moves.append(_moves_with_colors(gcode_path.read_text()))
+
+    # All heads still share one motion path, contours included.
+    totals = {round(_total_length(moves), 4) for moves in all_moves}
+    assert len(totals) == 1
+    assert len({moves[-1]["end"] for moves in all_moves}) == 1
+
+    # The middle piece's contour arcs are horizontal: with the horizontal
+    # X-raster infill, it must emit NO vertical print move at all (a vertical
+    # print could only be a traced cut seam).
+    middle = all_moves[1]
+    vertical_prints = [
+        move
+        for move in middle
+        if move["color"] == 255
+        and abs(move["end"][0] - move["start"][0]) < 1e-9
+        and abs(move["end"][1] - move["start"][1]) > 1e-9
+    ]
+    assert vertical_prints == []
+
+
 def test_split_layer_stack_grid_overlap_alternates_between_layers() -> None:
     layer = box(0.0, 0.0, 4.0, 2.0)
     stack = _stack(layer, layer, name="interlock")

vector_gcode.py

@@ -17,6 +17,7 @@ from stl_slicer import LayerStack
 from vector_toolpath import (
     RASTER_PATTERN_CHOICES,
     RASTER_PATTERN_CIRCLE_SPIRAL,
+    RASTER_PATTERN_DIAGONAL_WOODPILE,
     RASTER_PATTERN_RECTANGULAR_SPIRAL,
     RASTER_PATTERN_SAME_DIRECTION,
     RASTER_PATTERN_WOODPILE,
@@ -25,7 +26,6 @@ from vector_toolpath import (
     _centering_delta,
     _lead_in_moves,
     _normalize_raster_pattern,
-    _scan_anchor,
     align_stack_to,
     build_contour_layers,
     plan_layer_moves,
@@ -34,6 +34,7 @@ from vector_toolpath import (
 __all__ = [
     "RASTER_PATTERN_CHOICES",
     "RASTER_PATTERN_CIRCLE_SPIRAL",
+    "RASTER_PATTERN_DIAGONAL_WOODPILE",
     "RASTER_PATTERN_RECTANGULAR_SPIRAL",
     "RASTER_PATTERN_SAME_DIRECTION",
     "RASTER_PATTERN_WOODPILE",
@@ -240,18 +241,16 @@ def generate_vector_gcode(
         reference=contour_reference,
     )
 
-    # Anchor the raster scan grid to the motion stack's frame (a split
-    # piece's frame is its parent shape's bounds) so lines stack across
-    # layers and stay on one continuous grid across split pieces.
+    # Anchor the raster scan grid (and the diagonal-raster pivot) to the
+    # motion stack's frame (a split piece's frame is its parent shape's
+    # bounds) so lines stack across layers and stay on one continuous grid
+    # across split pieces.
     frame_stack = motion if motion is not None else shape
     if frame_stack.scan_frame is not None:
-        frame_x_min, frame_y_min, frame_x_max, frame_y_max = frame_stack.scan_frame
+        scan_frame = frame_stack.scan_frame
     else:
         (frame_x_min, frame_y_min, _fz), (frame_x_max, frame_y_max, _fz2) = frame_stack.bounds
-    scan_anchors = (
-        _scan_anchor(frame_x_min, frame_x_max, fil_width),
-        _scan_anchor(frame_y_min, frame_y_max, fil_width),
-    )
+        scan_frame = (frame_x_min, frame_y_min, frame_x_max, frame_y_max)
 
     gcode_list, toolpath_origin = plan_layer_moves(
         motion_layers,
@@ -262,7 +261,7 @@ def generate_vector_gcode(
         contour_layers,
         active_contour_owner,
         shared_motion=motion is not None,
-        scan_anchors=scan_anchors,
+        scan_frame=scan_frame,
         infill_fraction=max(0.0, min(1.0, float(infill))),
     )
 

vector_toolpath.py

@@ -13,10 +13,10 @@ import math
 from dataclasses import dataclass
 
 from shapely import prepare
-from shapely.affinity import translate
-from shapely.geometry import LineString, MultiPolygon, Point, box
+from shapely.affinity import rotate, translate
+from shapely.geometry import LineString, MultiLineString, MultiPolygon, Point, box
 from shapely.geometry.polygon import orient
-from shapely.ops import unary_union
+from shapely.ops import linemerge, unary_union
 
 from stl_slicer import LayerStack, _as_multipolygon
 
@@ -25,13 +25,15 @@ EPS = 1e-6
 
 RASTER_PATTERN_SAME_DIRECTION = "X-direction raster"
 RASTER_PATTERN_Y_DIRECTION = "Y-direction raster"
-RASTER_PATTERN_WOODPILE = "Woodpile raster"
+RASTER_PATTERN_WOODPILE = "90° Woodpile raster"
+RASTER_PATTERN_DIAGONAL_WOODPILE = "45° Woodpile raster"
 RASTER_PATTERN_RECTANGULAR_SPIRAL = "Rectangular Spiral raster"
 RASTER_PATTERN_CIRCLE_SPIRAL = "Circle Spiral raster"
 RASTER_PATTERN_CHOICES = (
     RASTER_PATTERN_SAME_DIRECTION,
     RASTER_PATTERN_Y_DIRECTION,
     RASTER_PATTERN_WOODPILE,
+    RASTER_PATTERN_DIAGONAL_WOODPILE,
     RASTER_PATTERN_RECTANGULAR_SPIRAL,
     RASTER_PATTERN_CIRCLE_SPIRAL,
 )
@@ -56,9 +58,25 @@ def _raster_axis_for_pattern(pattern: str, layer_number: int) -> str:
         return "Y"
     if pattern == RASTER_PATTERN_WOODPILE and layer_number % 2 == 1:
         return "Y"
+    if pattern == RASTER_PATTERN_DIAGONAL_WOODPILE and layer_number % 4 == 2:
+        return "Y"
     return "X"
 
 
+def _diagonal_layer_angle(layer_number: int) -> float | None:
+    """Diagonal-woodpile raster angle for a layer; None for the axis layers.
+
+    The pattern cycles 0, 45, 90, 135 degrees: axis layers (0/90) go through
+    the regular X/Y raster; only the odd layers need the rotated raster.
+    """
+    phase = layer_number % 4
+    if phase == 1:
+        return 45.0
+    if phase == 3:
+        return 135.0
+    return None
+
+
 def _iter_linestrings(geometry: object):
     if geometry is None or getattr(geometry, "is_empty", True):
         return
@@ -496,6 +514,76 @@ def _oriented_axis_raster_segments(
     )
 
 
+def _rotated_raster_segments(
+    motion: MultiPolygon,
+    valve: MultiPolygon,
+    fil_width: float,
+    angle_degrees: float,
+    current_x: float,
+    current_y: float,
+    prefer_default: bool,
+    frame: tuple[float, float, float, float],
+    infill_keep=None,
+) -> list[Seg]:
+    """Snake raster at an arbitrary angle, reusing the axis raster machinery.
+
+    Rotates motion/valve by -angle about the scan frame's centre, rasters
+    with the standard X-axis sweep (snake, buffers, valve gating, scan grid,
+    infill selection all identical), then rotates the segments back. The
+    pivot and the rotated scan anchor both derive from the shared frame, so
+    split pieces and reference-motion shapes keep one continuous diagonal
+    line grid across seams.
+    """
+    if motion is None or motion.is_empty:
+        return []
+
+    pivot_x = (frame[0] + frame[2]) / 2.0
+    pivot_y = (frame[1] + frame[3]) / 2.0
+    pivot = (pivot_x, pivot_y)
+
+    rotated_motion = _as_multipolygon(rotate(motion, -angle_degrees, origin=pivot))
+    if valve is motion:
+        rotated_valve = rotated_motion
+    elif valve is None or valve.is_empty:
+        rotated_valve = MultiPolygon()
+    else:
+        rotated_valve = _as_multipolygon(rotate(valve, -angle_degrees, origin=pivot))
+
+    rotated_frame_bounds = rotate(box(*frame), -angle_degrees, origin=pivot).bounds
+    anchor = _scan_anchor(rotated_frame_bounds[1], rotated_frame_bounds[3], fil_width)
+
+    theta = math.radians(-angle_degrees)
+    cos_f, sin_f = math.cos(theta), math.sin(theta)
+    rotated_current_x = pivot_x + (current_x - pivot_x) * cos_f - (current_y - pivot_y) * sin_f
+    rotated_current_y = pivot_y + (current_x - pivot_x) * sin_f + (current_y - pivot_y) * cos_f
+
+    segments = _oriented_axis_raster_segments(
+        rotated_motion,
+        rotated_valve,
+        fil_width,
+        "X",
+        rotated_current_x,
+        rotated_current_y,
+        prefer_default=prefer_default,
+        scan_anchor=anchor,
+        infill_keep=infill_keep,
+    )
+
+    theta_back = math.radians(angle_degrees)
+    cos_b, sin_b = math.cos(theta_back), math.sin(theta_back)
+
+    def back(x: float, y: float) -> tuple[float, float]:
+        return (
+            pivot_x + (x - pivot_x) * cos_b - (y - pivot_y) * sin_b,
+            pivot_y + (x - pivot_x) * sin_b + (y - pivot_y) * cos_b,
+        )
+
+    return [
+        (*back(x0, y0), *back(x1, y1), color)
+        for x0, y0, x1, y1, color in segments
+    ]
+
+
 def _extend_polyline_ends(
     points: list[tuple[float, float]],
     length: float,
@@ -834,6 +922,29 @@ def build_contour_layers(
         if stack is None or not stack.layers:
             continue
 
+        if reference is not None:
+            delta_x, delta_y = _centering_delta(stack, reference)
+        else:
+            delta_x = delta_y = 0.0
+
+        if stack.contour_paths is not None:
+            # Split pieces carry seam-free contour paths computed from the
+            # parent shape's outline; use them directly.
+            for layer_number in range(min(n_layers, len(stack.contour_paths))):
+                contours = [
+                    [(x + delta_x, y + delta_y) for x, y in path]
+                    for path in stack.contour_paths[layer_number]
+                    if len(path) >= 2
+                ]
+                if contours:
+                    contour_layers[layer_number].append(
+                        {
+                            "owner_idx": source.owner_idx,
+                            "contours": contours,
+                        }
+                    )
+            continue
+
         if reference is not None:
             layers = align_stack_to(stack, reference, n_layers)
         else:
@@ -918,15 +1029,28 @@ def _append_layer_contours(
             else:
                 nearest_x, nearest_y = current_x, current_y
                 approach_dx, approach_dy = 0.0, 0.0
-            contour = _rotate_closed_contour_to_nearest_border(
-                contour,
-                nearest_x,
-                nearest_y,
-                approach_dx,
-                approach_dy,
-            )
-            if contour[0] != contour[-1]:
-                contour = [*contour, contour[0]]
+            is_closed = len(contour) >= 4 and contour[0] == contour[-1]
+            if is_closed:
+                contour = _rotate_closed_contour_to_nearest_border(
+                    contour,
+                    nearest_x,
+                    nearest_y,
+                    approach_dx,
+                    approach_dy,
+                )
+                if contour[0] != contour[-1]:
+                    contour = [*contour, contour[0]]
+            else:
+                # Open arc (a split piece's seam-free outline): approach the
+                # nearer end and print to the other. Never close the loop —
+                # the closing chord would run along the cut seam this path
+                # deliberately excludes.
+                if _point_distance_sq(
+                    nearest_x, nearest_y, contour[-1][0], contour[-1][1]
+                ) < _point_distance_sq(
+                    nearest_x, nearest_y, contour[0][0], contour[0][1]
+                ):
+                    contour = list(reversed(contour))
             start_x, start_y = contour[0]
             use_infill_reference = False
             current_x, current_y = _append_relative_move(
@@ -1000,13 +1124,14 @@ def plan_layer_moves(
     contour_layers: list[list[dict]] | None = None,
     active_contour_owner: int | None = None,
     shared_motion: bool = False,
-    scan_anchors: tuple[float, float] | None = None,
+    scan_frame: tuple[float, float, float, float] | None = None,
     infill_fraction: float = 1.0,
 ) -> tuple[list[dict], tuple[float, float]]:
     """Assemble per-layer segments into a relative move list for all patterns.
 
-    `scan_anchors` = (x_anchor, y_anchor) pins the axis rasters' scanlines to
-    a global grid so lines stack across layers and across split pieces.
+    `scan_frame` (an XY box) pins the rasters' scanlines to a global grid so
+    lines stack across layers and across split pieces, and provides the
+    rotation pivot for diagonal layers.
 
     `infill_fraction` < 1 skips dispensing on evenly-distributed lines (grid
     lines for axis rasters, rings/revolutions for spirals) while the motion
@@ -1018,6 +1143,11 @@ def plan_layer_moves(
     """
     raster_pattern = _normalize_raster_pattern(raster_pattern)
     infill_keep = _infill_line_keep(infill_fraction)
+    if scan_frame is not None:
+        anchor_x = _scan_anchor(scan_frame[0], scan_frame[2], fil_width)
+        anchor_y = _scan_anchor(scan_frame[1], scan_frame[3], fil_width)
+    else:
+        anchor_x = anchor_y = None
     gcode_list: list[dict] = []
     current_x = 0.0
     current_y = 0.0
@@ -1079,14 +1209,28 @@ def plan_layer_moves(
                     return infill_keep(max(0, int(round(inset / fil_width))))
 
             segments = _classify_polyline(points, valve, keep_point=keep_point)
+        elif (
+            raster_pattern == RASTER_PATTERN_DIAGONAL_WOODPILE
+            and _diagonal_layer_angle(layer_number) is not None
+        ):
+            angle = _diagonal_layer_angle(layer_number)
+            frame = scan_frame if scan_frame is not None else motion.bounds
+            segments = _rotated_raster_segments(
+                motion,
+                valve,
+                fil_width,
+                angle,
+                current_x,
+                current_y,
+                prefer_default=not raster_origin_initialized,
+                frame=frame,
+                infill_keep=infill_keep,
+            )
         else:
             raster_axis = _raster_axis_for_pattern(raster_pattern, layer_number)
-            if scan_anchors is None:
-                axis_anchor = None
-            else:
-                # Axis "X" sweeps along X with rows stacked in Y, so its
-                # scanlines use the Y anchor (and vice versa).
-                axis_anchor = scan_anchors[0] if raster_axis == "Y" else scan_anchors[1]
+            # Axis "X" sweeps along X with rows stacked in Y, so its
+            # scanlines use the Y anchor (and vice versa).
+            axis_anchor = anchor_x if raster_axis == "Y" else anchor_y
             segments = _oriented_axis_raster_segments(
                 motion,
                 valve,
@@ -1409,6 +1553,44 @@ def _shifted_split_edges(
     return adjusted
 
 
+def _clip_contour_paths(
+    source_lines: object,
+    cell: object,
+) -> list[list[tuple[float, float]]]:
+    """Contour polylines of a split piece: the parent outline inside the cell.
+
+    Clipping the PARENT's boundary linework (instead of taking the piece
+    polygon's own boundary) excludes the cut seams between sibling pieces —
+    only the true outer surface remains. Results are merged into maximal
+    polylines and ordered/oriented deterministically so pieces sharing
+    reference motion trace them identically.
+    """
+    clipped = source_lines.intersection(cell)
+    pieces = list(_iter_linestrings(clipped))
+    if not pieces:
+        return []
+    merged = linemerge(MultiLineString(pieces)) if len(pieces) > 1 else pieces[0]
+
+    paths: list[list[tuple[float, float]]] = []
+    for line in _iter_linestrings(merged):
+        coords = [(float(x), float(y)) for x, y in line.coords]
+        if len(coords) < 2 or LineString(coords).length <= EPS:
+            continue
+        # Normalize open-path orientation (closed rings keep first == last).
+        if coords[0] != coords[-1] and coords[-1] < coords[0]:
+            coords.reverse()
+        paths.append(coords)
+
+    paths.sort(
+        key=lambda path: (
+            min(point[1] for point in path),
+            min(point[0] for point in path),
+            -len(path),
+        )
+    )
+    return paths
+
+
 def split_layer_stack_grid(
     stack: LayerStack,
     columns: int,
@@ -1458,9 +1640,11 @@ def split_layer_stack_grid(
             x_cell = col_index - 1
 
             layers: list[MultiPolygon] = []
+            contour_paths: list[list[list[tuple[float, float]]]] = []
             for layer_number, layer in enumerate(stack.layers):
                 if layer is None or layer.is_empty:
                     layers.append(MultiPolygon())
+                    contour_paths.append([])
                     continue
                 x_edges = layer_x_edges[layer_number]
                 y_edges = layer_y_edges[layer_number]
@@ -1472,6 +1656,22 @@ def split_layer_stack_grid(
                 )
                 layers.append(_as_multipolygon(layer.intersection(cell)))
 
+                # Contours come from the parent's outline (or, when
+                # re-splitting a piece, its already-seam-free paths) so the
+                # cut lines between siblings are never traced.
+                if stack.contour_paths is not None:
+                    parent_paths = (
+                        stack.contour_paths[layer_number]
+                        if layer_number < len(stack.contour_paths)
+                        else []
+                    )
+                    source_lines = MultiLineString(
+                        [path for path in parent_paths if len(path) >= 2]
+                    )
+                else:
+                    source_lines = layer.boundary
+                contour_paths.append(_clip_contour_paths(source_lines, cell))
+
             pieces.append(
                 LayerStack(
                     layers=layers,
@@ -1483,6 +1683,7 @@ def split_layer_stack_grid(
                     layer_height=stack.layer_height,
                     name=f"{base_name}_r{row_index:02d}_c{col_index:02d}",
                     scan_frame=scan_frame,
+                    contour_paths=contour_paths,
                 )
             )