Overlapping Rows interlock, overlap size + direction options, auto-align on generate

- Overlapping Rows: each interior split cut becomes a comb within every
layer - alternate raster rows (riding the shared scanline grid, one
band per row) reach past the seam in opposite directions so
neighbouring pieces interlock like fingers; the phase flips per layer
so teeth also interlock in Z. Exact tiling: no gaps, no double-print.
- Row Overlap Direction: comb only the column seams (X), only the row
seams (Y), or both.
- Overlap (mm) input sets the depth of both the row and layer
interlocks (blank/0 = one filament width), auto-capped so comb
boundaries can never cross.
- Generate G-Code now runs Auto Align Split Parts automatically when
the table holds split pieces, before the parallel re-render - the
Visualization tab comes up already reassembled. No-op for unsplit
tables.

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

README.md

@@ -104,7 +104,9 @@ The **Multi-Nozzle Split** accordion on the **Shapes & G-Code** tab can split on
 - Each layer's geometry is clipped against equal-size grid cells, so every piece keeps exact vector outlines.
 - The selected shape is replaced in Shape Settings by one generated record per grid cell, named by row and column.
 - Nozzle and valve numbers are assigned sequentially from the starting values, and **Generate G-Code** produces separate G-code for each piece.
-- **Overlapping Layers** alternates the interior cut lines by one filament width per layer so neighbouring pieces interlock.
+- **Overlapping Layers** alternates the interior cut lines sideways between layers so stacked pieces interlock.
+- **Overlapping Rows** turns each interior cut into a comb within every layer: alternate raster rows (aligned to the shared scanline grid) reach across the seam in opposite directions, so neighbouring pieces interlock like fingers. **Row Overlap Direction** picks which seams comb: X only (column cuts), Y only (row cuts), or both.
+- **Overlap (mm)** sets the depth of both interlocks (blank or 0 falls back to one filament width). The two options can be combined.
 - **Multi-material assemblies split as one shape**: if the selected shape shares its nozzle with other shapes, the whole group is split together — every material is clipped by the same cell grid over the group's combined bounds. Pieces are emitted cell by cell: each cell's pieces share a nozzle (so every cell is itself a multi-material group, keeping the alignment and seam-free contour behavior), each piece gets its own valve, and cells where a material has no geometry are skipped. Auto Align works on the result like any other split.
 
 ### G-code XY Step Size
@@ -124,7 +126,7 @@ The **Multi-Nozzle Split** accordion on the **Shapes & G-Code** tab can split on
 - **Combined reference outline for motion** (always on): 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 whenever shapes are sliced or G-code is generated. Contour tracing stays synchronized too: every shape traces every traced shape's contour, opening its valve only on its own outline.
 - Generated files contain only machine commands (no metadata comments). The toolpath's world anchor — the position, in the shape's own frame, that the relative moves start from — is kept on the shape's session record and used 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. `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 rectangular loops from the outside toward the center, then reverses from center to edge on the next layer; the loops live on one family anchored to the shape frame, so every layer (and every split sibling) walks the same rectangles and the walls stack — outer loops that cannot touch a layer's material are skipped instead of traveled. `Circle Spiral raster` prints concentric circles stepping inward by one line width per revolution — each revolution stays at a constant radius, so the walls are smooth true circles — then reverses outward on the next layer. The outermost revolution is a perimeter wall hugging the layer's material edge (half a bead inside its farthest boundary point), so the printed silhouette follows the shape smoothly; a matching inner wall hugs a central hole when there is one. The fill rings between the walls come from one global radii grid anchored at the shape frame's center, so interior rings stack exactly across layers, and rings that cannot touch a layer's material (or would overlap a wall bead) are skipped instead of traveled. Walls always dispense even under partial infill, like contour tracing; elsewhere the valve opens only where the path is inside material. Under shared reference motion every shape's own wall radius joins the one shared ring set (all heads travel all walls, each dispenses only its own), and rings that would graze a shape's boundary are suppressed for that shape — so each parallel shape keeps a smooth, complete outer circle regardless of its dimensions.
-- **Auto Align Split Parts**: in Nozzle Spacing, computes exact per-connection grid gaps from the split pieces' generated G-code (world toolpath 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.
+- **Auto Align Split Parts**: in Nozzle Spacing, computes exact per-connection grid gaps from the split pieces' generated G-code (world toolpath 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. **Generate G-Code runs it automatically** whenever the table contains split pieces, so the parallel view comes up already reassembled; the button remains for re-aligning after manual spacing edits.
 - **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). Multi-material assembly parts (shapes sharing a nozzle) work the same way: boundary within half a bead of a sibling material counts as an internal interface and is not contoured — only the assembled shape's true outer surface is traced, and a part fully embedded in the assembly gets no contour at all.
 
 ### Print vs Travel Classification

app.py

@@ -2591,6 +2591,26 @@ def auto_align_split_parts(
     )
 
 
+def auto_align_split_parts_after_generate(
+    records: list[dict] | None,
+    columns: Any,
+    rows: Any,
+    column_spacing: Any,
+    row_spacing: Any,
+) -> tuple:
+    """Auto-run of Auto Align Split Parts right after Generate G-Code.
+
+    Runs before the post-generate parallel render so the Visualization tab
+    comes up with the pieces already reassembled. Silent no-op when the
+    table holds no split pieces, so plain generations leave the spacing
+    controls and status untouched.
+    """
+    records = records or []
+    if not any(record.get("split_group_id") for record in records):
+        return tuple(gr.skip() for _ in range(7))
+    return auto_align_split_parts(records, columns, rows, column_spacing, row_spacing)
+
+
 def update_nozzle_grid_preset(
     preset: str | None,
     records: list[dict] | None,
@@ -3703,6 +3723,9 @@ def _split_group_records(
     split_column_count: int,
     split_row_count: int,
     overlapping_layers: bool,
+    overlapping_rows: bool,
+    overlap_mm: float,
+    row_overlap_axes: str,
     starting_nozzle: Any,
     starting_valve: Any,
     fil_width: float,
@@ -3755,7 +3778,9 @@ def _split_group_records(
                     columns=split_column_count,
                     rows=split_row_count,
                     overlapping_layers=bool(overlapping_layers),
-                    overlap=float(fil_width) if overlapping_layers else 0.0,
+                    overlapping_rows=bool(overlapping_rows),
+                    row_overlap_axes=row_overlap_axes,
+                    overlap=overlap_mm if (overlapping_layers or overlapping_rows) else 0.0,
                     grid=float(fil_width),
                     frame=frame,
                 ),
@@ -3824,12 +3849,47 @@ def _split_group_records(
         f"Each cell's pieces share a nozzle (nozzles {first_nozzle}-"
         f"{first_nozzle + cell_count - 1}); valves {first_valve}-{valve_cursor - 1}."
     )
+    status += _split_overlap_status(
+        overlapping_layers, overlapping_rows, overlap_mm, row_overlap_axes
+    )
+    return _outputs(next_records, split_selected, status)
+
+
+ROW_OVERLAP_AXES_CHOICES = ["Both", "X only", "Y only"]
+
+
+def _row_overlap_axes_value(choice: Any) -> str:
+    """UI direction choice -> engine axes value ("both" | "x" | "y")."""
+    text = str(choice or "").strip().lower()
+    if text.startswith("x"):
+        return "x"
+    if text.startswith("y"):
+        return "y"
+    return "both"
+
+
+def _split_overlap_status(
+    overlapping_layers: bool,
+    overlapping_rows: bool,
+    overlap_mm: float,
+    row_overlap_axes: str = "both",
+) -> str:
+    parts = []
     if overlapping_layers:
-        status += (
-            "  \nOverlapping Layers is enabled: split boundaries alternate by one "
-            "filament width per layer so neighbouring pieces interlock."
+        parts.append(
+            f"  \nOverlapping Layers: split boundaries alternate by {overlap_mm:g} mm "
+            "per layer so stacked pieces interlock."
         )
-    return _outputs(next_records, split_selected, status)
+    if overlapping_rows:
+        seams = {
+            "x": "the column seams (X direction)",
+            "y": "the row seams (Y direction)",
+        }.get(row_overlap_axes, "each seam")
+        parts.append(
+            f"  \nOverlapping Rows: alternate raster rows reach {overlap_mm:g} mm "
+            f"across {seams} so neighbouring pieces interlock within every layer."
+        )
+    return "".join(parts)
 
 
 def split_selected_shape_for_grid(
@@ -3845,8 +3905,17 @@ def split_selected_shape_for_grid(
     layer_height: float = 0.8,
     scale_mode: str | None = None,
     undo_stack: list[list[dict]] | None = None,
+    overlapping_rows: bool = False,
+    overlap_size: float | None = None,
+    row_overlap_direction: str | None = None,
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
+    # Overlap depth for both interlock styles; blank/zero falls back to one
+    # filament width (the pre-option behavior).
+    overlap_mm = round(_coerce_float(overlap_size, float(fil_width)), 3)
+    if overlap_mm <= 0.0:
+        overlap_mm = float(fil_width)
+    row_overlap_axes = _row_overlap_axes_value(row_overlap_direction)
     # One-button flow: shapes are sliced (or re-sliced when their settings
     # changed) straight from the table here, so splitting never needs a
     # separate slicing step.
@@ -3912,6 +3981,9 @@ def split_selected_shape_for_grid(
             split_column_count,
             split_row_count,
             overlapping_layers,
+            overlapping_rows,
+            overlap_mm,
+            row_overlap_axes,
             starting_nozzle,
             starting_valve,
             fil_width,
@@ -3925,7 +3997,9 @@ def split_selected_shape_for_grid(
             columns=split_column_count,
             rows=split_row_count,
             overlapping_layers=bool(overlapping_layers),
-            overlap=float(fil_width) if overlapping_layers else 0.0,
+            overlapping_rows=bool(overlapping_rows),
+            row_overlap_axes=row_overlap_axes,
+            overlap=overlap_mm if (overlapping_layers or overlapping_rows) else 0.0,
             # Whole-fil cells (last piece absorbs the remainder): keeps the
             # required nozzle spacing uniform under shared reference motion.
             grid=float(fil_width),
@@ -3968,11 +4042,9 @@ def split_selected_shape_for_grid(
         f"({split_column_count} columns x {split_row_count} rows).  \n"
         f"Nozzles {first_nozzle}-{first_nozzle + len(pieces) - 1}; valves {first_valve}-{first_valve + len(pieces) - 1}."
     )
-    if overlapping_layers:
-        status += (
-            "  \nOverlapping Layers is enabled: split boundaries alternate by one "
-            "filament width per layer so neighbouring pieces interlock."
-        )
+    status += _split_overlap_status(
+        overlapping_layers, overlapping_rows, overlap_mm, row_overlap_axes
+    )
     return _outputs(next_records, split_selected, status)
 
 
@@ -4973,7 +5045,34 @@ def build_dynamic_demo() -> gr.Blocks:
                     split_rows = gr.Number(label="Rows (Y)", value=1, minimum=1, step=1)
                     split_start_nozzle = gr.Number(label="Starting Nozzle", value=1, minimum=1, step=1)
                     split_start_valve = gr.Number(label="Starting Valve", value=4, minimum=1, step=1)
-                split_overlapping_layers = gr.Checkbox(label="Overlapping Layers", value=False)
+                with gr.Row():
+                    split_overlapping_layers = gr.Checkbox(
+                        label="Overlapping Layers",
+                        info="Cut lines alternate sideways between layers",
+                        value=False,
+                        scale=2,
+                    )
+                    split_overlapping_rows = gr.Checkbox(
+                        label="Overlapping Rows",
+                        info="Alternate raster rows reach across each seam",
+                        value=False,
+                        scale=2,
+                    )
+                    split_row_overlap_direction = gr.Dropdown(
+                        label="Row Overlap Direction",
+                        info="Which seams the rows reach across",
+                        choices=ROW_OVERLAP_AXES_CHOICES,
+                        value=ROW_OVERLAP_AXES_CHOICES[0],
+                        scale=1,
+                    )
+                    split_overlap = gr.Number(
+                        label="Overlap (mm)",
+                        info="Depth of both interlocks; 0 = one filament width",
+                        value=0.8,
+                        minimum=0.0,
+                        step=0.1,
+                        scale=1,
+                    )
                 with gr.Row():
                     split_button = gr.Button("Split Selected Shape into Grid Pieces", variant="primary", scale=3)
                     split_undo_button = gr.Button("Undo Split", variant="secondary", size="sm", scale=1, min_width=110)
@@ -5335,6 +5434,9 @@ def build_dynamic_demo() -> gr.Blocks:
                 layer_height,
                 scale_mode,
                 split_undo,
+                split_overlapping_rows,
+                split_overlap,
+                split_row_overlap_direction,
             ],
             outputs=[
                 shape_records,
@@ -5542,6 +5644,28 @@ def build_dynamic_demo() -> gr.Blocks:
             inputs=stale_inputs,
             outputs=[gcode_stale_banner],
             queue=False,
+        ).then(
+            # Fresh PathOrigins: reassemble split pieces automatically so the
+            # Visualization tab needs no manual Auto Align click. Runs BEFORE
+            # the parallel render below, which reads the spacing table.
+            fn=auto_align_split_parts_after_generate,
+            inputs=[
+                shape_records,
+                nozzle_grid_columns,
+                nozzle_grid_rows,
+                nozzle_grid_column_spacing,
+                nozzle_grid_row_spacing,
+            ],
+            outputs=[
+                nozzle_grid_columns,
+                nozzle_grid_rows,
+                nozzle_grid_column_spacing,
+                nozzle_grid_row_spacing,
+                nozzle_grid_use_individual_spacing,
+                nozzle_grid_spacing_table,
+                nozzle_spacing_status,
+            ],
+            queue=False,
         ).then(
             # Fresh files: refresh the parallel view so the Visualization
             # tab always shows the current print.

tests/test_nozzle_spacing.py

@@ -748,6 +748,29 @@ def test_auto_align_grid_spacing_skips_unsplit_records() -> None:
     assert rows == [["Nozzle 1: Shape 1", "Nozzle 2: Shape 2", 10.0, 0.0]]
 
 
+def test_generate_runs_auto_align_only_for_split_pieces(tmp_path) -> None:
+    from app import auto_align_split_parts_after_generate
+
+    # Plain (unsplit) shapes: a silent skip that touches nothing on the
+    # Visualization tab.
+    plain = [
+        {"idx": 1, "name": "first", "nozzle": 1},
+        {"idx": 2, "name": "second", "nozzle": 2},
+    ]
+    outputs = auto_align_split_parts_after_generate(plain, 2, 1, 5.0, 5.0)
+    assert len(outputs) == 7
+    assert all(output == {"__type__": "update"} for output in outputs)
+
+    # Split pieces with generated G-code: delegates to Auto Align, which
+    # fills the advanced spacing table and reports the alignment.
+    records = _split_piece_records(tmp_path, columns=2, rows=1)
+    outputs = auto_align_split_parts_after_generate(records, 2, 1, 5.0, 5.0)
+    status = outputs[-1]
+    assert "Auto aligned" in status
+    table_update = outputs[5]
+    assert table_update.get("value")
+
+
 def test_grid_spacing_rows_follow_row_major_pattern() -> None:
     records = [
         {"idx": 1, "name": "first", "nozzle": 1},
@@ -1003,6 +1026,62 @@ def test_group_split_splits_all_materials_on_one_shared_grid() -> None:
             assert x <= 10.0 - 0.5 + 1e-9 or y <= 5.0 - 0.5 + 1e-9
 
 
+def test_split_overlapping_rows_option_combs_pieces() -> None:
+    from shapely.geometry import MultiPolygon, box
+
+    from app import _slice_params_snapshot, split_selected_shape_for_grid
+    from stl_slicer import LayerStack
+
+    layer = MultiPolygon([box(0.0, 0.0, 8.0, 6.0)])
+    stack = LayerStack(
+        layers=[layer, layer],
+        z_values=[0.4, 1.2],
+        bounds=((0.0, 0.0, 0.0), (8.0, 6.0, 1.6)),
+        layer_height=0.8,
+        name="comb",
+    )
+    record = {
+        "idx": 1,
+        "name": "comb",
+        "stl_path": "comb.stl",
+        "target_x": 8.0,
+        "target_y": 6.0,
+        "target_z": 1.6,
+        "pressure": 25.0,
+        "valve": 4,
+        "nozzle": 1,
+        "port": 1,
+        "color": "#111111",
+        "layer_stack": stack,
+    }
+    record["slice_params"] = _slice_params_snapshot(record, 0.8, None, None)
+
+    outputs = split_selected_shape_for_grid(
+        [record],
+        None,  # selected -> defaults to the first record
+        None,  # settings table
+        2,  # columns
+        1,  # rows
+        False,  # overlapping layers
+        5,  # starting nozzle
+        9,  # starting valve
+        1.0,  # fil width
+        overlapping_rows=True,
+        overlap_size=0.5,
+    )
+    next_records = outputs[0]
+    status = outputs[7]
+
+    pieces = [rec for rec in next_records if rec.get("split_group_id")]
+    assert len(pieces) == 2
+    left_stack = pieces[0]["layer_stack"]
+    # Alternate raster-row teeth reach the chosen 0.5 mm past the x=4 cut...
+    assert abs(left_stack.layers[0].bounds[2] - 4.5) < 1e-9
+    # ...while the nominal piece bounds (and targets) stay the plain cell.
+    assert pieces[0]["layer_stack"].bounds[1][0] == 4.0
+    assert "Overlapping Rows" in status and "0.5 mm" in status
+
+
 def test_describe_split_source_warns_about_group_splits() -> None:
     from shapely.geometry import MultiPolygon, box
 

tests/test_vector_gcode.py

@@ -1683,6 +1683,154 @@ def test_split_contour_gcode_never_traces_the_cuts(tmp_path) -> None:
     assert vertical_prints == []
 
 
+def test_split_overlapping_rows_comb_within_each_layer() -> None:
+    layer = box(0.0, 0.0, 8.0, 6.0)
+    stack = _stack(layer, layer, name="comb")
+
+    left, right = split_layer_stack_grid(
+        stack, columns=2, rows=1, overlapping_rows=True, overlap=1.0, grid=1.0
+    )
+
+    # Scan frame (0,0,8,6) at 1 mm pitch: rows at y=0.5..5.5, so band k spans
+    # y in [k, k+1]. The x=4 seam combs: even bands push the boundary to 5,
+    # odd bands pull it to 3 (on layer 0). Probes are inset from the band
+    # edges so they don't graze the neighbouring tooth's boundary segment.
+    band0 = box(0.0, 0.1, 8.0, 0.9)
+    band1 = box(0.0, 1.1, 8.0, 1.9)
+    assert abs(left.layers[0].intersection(band0).bounds[2] - 5.0) < 1e-9
+    assert abs(left.layers[0].intersection(band1).bounds[2] - 3.0) < 1e-9
+    assert abs(right.layers[0].intersection(band0).bounds[0] - 5.0) < 1e-9
+    assert abs(right.layers[0].intersection(band1).bounds[0] - 3.0) < 1e-9
+    # The comb phase flips between layers so the teeth interlock in Z too.
+    assert abs(left.layers[1].intersection(band0).bounds[2] - 3.0) < 1e-9
+
+    # The pieces still tile the parent exactly: no gap, no double-print.
+    for layer_number in range(2):
+        union = left.layers[layer_number].union(right.layers[layer_number])
+        assert abs(union.area - layer.area) < 1e-6
+        doubled = left.layers[layer_number].intersection(right.layers[layer_number])
+        assert doubled.area < 1e-9
+
+    # Nominal bounds stay the un-shifted cells.
+    assert left.bounds == ((0.0, 0.0, 0.0), (4.0, 6.0, 2.0))
+    assert right.bounds == ((4.0, 0.0, 0.0), (8.0, 6.0, 2.0))
+
+
+def test_split_overlapping_rows_raster_rows_alternate_across_the_seam() -> None:
+    from vector_toolpath import _axis_raster_segments
+
+    layer = box(0.0, 0.0, 8.0, 6.0)
+    stack = _stack(layer, layer, name="combr")
+    left, right = split_layer_stack_grid(
+        stack, columns=2, rows=1, overlapping_rows=True, overlap=1.0, grid=1.0
+    )
+
+    def print_spans(piece: LayerStack) -> dict:
+        spans: dict = {}
+        segments = _axis_raster_segments(
+            piece.layers[0], piece.layers[0], 1.0, "X", scan_anchor=0.5
+        )
+        for seg in segments:
+            if seg[4] != 255:
+                continue
+            row = round(seg[1], 6)
+            lo, hi = spans.get(row, (min(seg[0], seg[2]), max(seg[0], seg[2])))
+            spans[row] = (min(lo, seg[0], seg[2]), max(hi, seg[0], seg[2]))
+        return spans
+
+    left_spans = print_spans(left)
+    right_spans = print_spans(right)
+    # Even rows: the left head prints past the seam to x=5 and the right head
+    # takes over exactly there; odd rows mirror at x=3 — the interleaved
+    # finger pattern.
+    assert left_spans[0.5] == (0.0, 5.0)
+    assert right_spans[0.5] == (5.0, 8.0)
+    assert left_spans[1.5] == (0.0, 3.0)
+    assert right_spans[1.5] == (3.0, 8.0)
+
+
+def test_split_overlapping_rows_axes_restrict_which_seams_comb() -> None:
+    layer = box(0.0, 0.0, 8.0, 8.0)
+    stack = _stack(layer, name="axes")
+
+    # X only: the vertical (column) seam combs, the horizontal seam stays a
+    # straight cut at y=4.
+    pieces = split_layer_stack_grid(
+        stack,
+        columns=2,
+        rows=2,
+        overlapping_rows=True,
+        row_overlap_axes="x",
+        overlap=1.0,
+        grid=1.0,
+    )
+    top_left = pieces[0].layers[0]  # row 1 = top strip
+    bottom_left = pieces[2].layers[0]
+    band0 = box(0.0, 0.1, 8.0, 0.9)
+    band1 = box(0.0, 1.1, 8.0, 1.9)
+    teeth_x = {
+        round(bottom_left.intersection(band0).bounds[2], 6),
+        round(bottom_left.intersection(band1).bounds[2], 6),
+    }
+    assert teeth_x == {3.0, 5.0}
+    assert abs(top_left.bounds[1] - 4.0) < 1e-9  # straight horizontal cut
+    assert abs(bottom_left.bounds[3] - 4.0) < 1e-9
+
+    # Y only: mirrored — the horizontal seam combs, the vertical cut at x=4
+    # stays straight.
+    pieces = split_layer_stack_grid(
+        stack,
+        columns=2,
+        rows=2,
+        overlapping_rows=True,
+        row_overlap_axes="y",
+        overlap=1.0,
+        grid=1.0,
+    )
+    bottom_left = pieces[2].layers[0]
+    col_band0 = box(0.1, 0.0, 0.9, 8.0)
+    col_band1 = box(1.1, 0.0, 1.9, 8.0)
+    teeth_y = {
+        round(bottom_left.intersection(col_band0).bounds[3], 6),
+        round(bottom_left.intersection(col_band1).bounds[3], 6),
+    }
+    assert teeth_y == {3.0, 5.0}
+    assert abs(bottom_left.bounds[2] - 4.0) < 1e-9  # straight vertical cut
+
+    # Pieces always tile the parent, whichever axes comb.
+    total = pieces[0].layers[0]
+    for piece in pieces[1:]:
+        total = total.union(piece.layers[0])
+    assert abs(total.area - layer.area) < 1e-6
+
+
+def test_split_overlapping_rows_and_layers_combine() -> None:
+    layer = box(0.0, 0.0, 8.0, 6.0)
+    stack = _stack(layer, layer, name="both")
+
+    left, right = split_layer_stack_grid(
+        stack,
+        columns=2,
+        rows=1,
+        overlapping_layers=True,
+        overlapping_rows=True,
+        overlap=0.5,
+        grid=1.0,
+    )
+
+    # Layer shift moves the seam to 4.5 (layer 0), the comb then swings the
+    # per-band boundary to 5.0 / 4.0 around it. Tiling stays exact.
+    band0 = box(0.0, 0.1, 8.0, 0.9)
+    band1 = box(0.0, 1.1, 8.0, 1.9)
+    assert abs(left.layers[0].intersection(band0).bounds[2] - 5.0) < 1e-9
+    assert abs(left.layers[0].intersection(band1).bounds[2] - 4.0) < 1e-9
+    for layer_number in range(2):
+        union = left.layers[layer_number].union(right.layers[layer_number])
+        assert abs(union.area - layer.area) < 1e-6
+        doubled = left.layers[layer_number].intersection(right.layers[layer_number])
+        assert doubled.area < 1e-9
+
+
 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_toolpath.py

@@ -14,7 +14,7 @@ from dataclasses import dataclass
 
 from shapely import prepare
 from shapely.affinity import rotate, translate
-from shapely.geometry import LineString, MultiLineString, MultiPolygon, Point, box
+from shapely.geometry import LineString, MultiLineString, MultiPolygon, Point, Polygon, box
 from shapely.geometry.polygon import orient
 from shapely.ops import linemerge, unary_union
 
@@ -1965,6 +1965,153 @@ def _shifted_split_edges(
     return adjusted
 
 
+def _comb_amplitude(edges: list[float], overlap: float) -> float:
+    """Row-overlap tooth depth, capped so comb boundaries can never cross.
+
+    Adjacent interior boundaries comb in opposite phases, converging by twice
+    the amplitude within a band — so with several interior boundaries the
+    teeth may reach at most half the narrowest cell. With a single interior
+    boundary (2 cells) only the outer edges bound the teeth.
+    """
+    count = len(edges) - 1
+    if count <= 1 or overlap <= 0.0:
+        return 0.0
+    min_width = min(edges[i + 1] - edges[i] for i in range(count))
+    limit = min_width * (0.999 if count == 2 else 0.4995)
+    return max(0.0, min(overlap, limit))
+
+
+def _comb_boundary(
+    edges: list[float],
+    boundary_index: int,
+    band_index: int,
+    layer_index: int,
+    amplitude: float,
+) -> float:
+    """Comb boundary position at one raster-row band.
+
+    A pure function of (boundary, band, layer), so the two cells sharing a
+    boundary always compute the same tooth positions and tile exactly. The
+    parity convention extends `_shifted_split_edges`, so combining
+    Overlapping Rows with Overlapping Layers keeps both alternations.
+    """
+    direction = 1 if (band_index + boundary_index + layer_index) % 2 == 1 else -1
+    return edges[boundary_index] + direction * amplitude
+
+
+def _comb_profile_polygon(
+    span_lo: float,
+    span_hi: float,
+    lo_for_band,
+    hi_for_band,
+    anchor: float,
+    pitch: float,
+    comb_axis: str,
+) -> Polygon:
+    """Staircase polygon: the combed extent per raster-row band.
+
+    Bands are one `pitch` tall, centred on the scanline grid
+    {anchor + k*pitch} (band cuts sit midway BETWEEN scanlines), so each
+    tooth covers exactly one raster row. `comb_axis` "X" means the combed
+    coordinate is X with bands stacked along Y; "Y" is the transpose.
+    """
+    cuts: list[float] = []
+    k = math.floor((span_lo - anchor) / pitch) - 2
+    while True:
+        cut = anchor + (k + 0.5) * pitch
+        if cut >= span_hi - EPS:
+            break
+        if cut > span_lo + EPS:
+            cuts.append(cut)
+        k += 1
+    stops = [span_lo, *cuts, span_hi]
+
+    lows: list[float] = []
+    highs: list[float] = []
+    for index in range(len(stops) - 1):
+        mid = (stops[index] + stops[index + 1]) / 2.0
+        band = math.floor((mid - anchor) / pitch + 0.5)
+        lows.append(lo_for_band(band))
+        highs.append(hi_for_band(band))
+
+    ring: list[tuple[float, float]] = []
+    for index in range(len(stops) - 1):
+        ring.append((lows[index], stops[index]))
+        ring.append((lows[index], stops[index + 1]))
+    for index in reversed(range(len(stops) - 1)):
+        ring.append((highs[index], stops[index + 1]))
+        ring.append((highs[index], stops[index]))
+    if comb_axis == "Y":
+        ring = [(stop, value) for value, stop in ring]
+    deduped = [pt for idx, pt in enumerate(ring) if idx == 0 or pt != ring[idx - 1]]
+    return Polygon(deduped)
+
+
+def _comb_cell_geometry(
+    x_edges: list[float],
+    y_edges: list[float],
+    x_cell: int,
+    y_cell: int,
+    comb_x: float,
+    comb_y: float,
+    pitch: float,
+    anchor_x: float,
+    anchor_y: float,
+    layer_index: int,
+):
+    """One split cell with Overlapping Rows: interior boundaries comb.
+
+    With teeth on both axes the cell is the intersection of the two full-
+    frame comb profiles: a point's column is decided by the x-comb at its
+    y-band and its row by the y-comb at its x-band, which assigns every
+    point to exactly one cell — the pieces still tile the parent exactly.
+    """
+    columns = len(x_edges) - 1
+    rows = len(y_edges) - 1
+
+    def x_lo(band: int) -> float:
+        if x_cell == 0 or comb_x <= 0.0:
+            return x_edges[x_cell]
+        return _comb_boundary(x_edges, x_cell, band, layer_index, comb_x)
+
+    def x_hi(band: int) -> float:
+        if x_cell + 1 == columns or comb_x <= 0.0:
+            return x_edges[x_cell + 1]
+        return _comb_boundary(x_edges, x_cell + 1, band, layer_index, comb_x)
+
+    def y_lo(band: int) -> float:
+        if y_cell == 0 or comb_y <= 0.0:
+            return y_edges[y_cell]
+        return _comb_boundary(y_edges, y_cell, band, layer_index, comb_y)
+
+    def y_hi(band: int) -> float:
+        if y_cell + 1 == rows or comb_y <= 0.0:
+            return y_edges[y_cell + 1]
+        return _comb_boundary(y_edges, y_cell + 1, band, layer_index, comb_y)
+
+    combs_x = comb_x > 0.0 and columns > 1
+    combs_y = comb_y > 0.0 and rows > 1
+    if not combs_x and not combs_y:
+        return box(
+            x_edges[x_cell], y_edges[y_cell], x_edges[x_cell + 1], y_edges[y_cell + 1]
+        )
+    if combs_x and not combs_y:
+        return _comb_profile_polygon(
+            y_edges[y_cell], y_edges[y_cell + 1], x_lo, x_hi, anchor_y, pitch, "X"
+        )
+    if combs_y and not combs_x:
+        return _comb_profile_polygon(
+            x_edges[x_cell], x_edges[x_cell + 1], y_lo, y_hi, anchor_x, pitch, "Y"
+        )
+    profile_x = _comb_profile_polygon(
+        y_edges[0], y_edges[-1], x_lo, x_hi, anchor_y, pitch, "X"
+    )
+    profile_y = _comb_profile_polygon(
+        x_edges[0], x_edges[-1], y_lo, y_hi, anchor_x, pitch, "Y"
+    )
+    return profile_x.intersection(profile_y)
+
+
 def _linework_to_paths(geometry: object) -> list[list[tuple[float, float]]]:
     """Merge linework into maximal polylines, ordered/oriented
     deterministically so shapes sharing reference motion trace them
@@ -2049,15 +2196,24 @@ def split_layer_stack_grid(
     overlap: float = 0.0,
     grid: float | None = None,
     frame: tuple[float, float, float, float] | None = None,
+    overlapping_rows: bool = False,
+    row_overlap_axes: str = "both",
 ) -> list[LayerStack]:
     """Split a sliced shape into a rows x columns grid of piece stacks.
 
     Pieces are returned row-major with row 1 the top strip (max-Y side),
     matching the legacy image-grid ordering. With `overlapping_layers`, the
     interior cut lines alternate by ±overlap between layers so neighbouring
-    pieces interlock. `grid` (the fil width) sizes the cells in whole grid
-    multiples (see `_base_split_edges`). Piece `bounds` are the nominal
-    (un-shifted) cell boxes.
+    pieces interlock. With `overlapping_rows`, each interior cut becomes a
+    comb within every layer: alternate raster-row bands (one `grid` pitch
+    each, aligned to the shared scanline grid) extend ±overlap past the cut
+    in opposite directions, so neighbouring pieces interlock like fingers —
+    this needs `grid` to place the bands. `row_overlap_axes` restricts which
+    cuts comb: "x" only the column cuts (teeth reach along X), "y" only the
+    row cuts (teeth reach along Y), "both" (default) all interior cuts.
+    `grid` (the fil width) sizes the cells in whole grid multiples (see
+    `_base_split_edges`). Piece `bounds` are the nominal (un-shifted) cell
+    boxes.
 
     `frame` overrides the XY box the cell grid is computed over. Splitting
     every member of a multi-material group with the group's combined bounds
@@ -2089,6 +2245,27 @@ def split_layer_stack_grid(
     # one-fil-width pitch instead of each piece re-centring its own lines.
     scan_frame = stack.scan_frame or (x_min, y_min, x_max, y_max)
 
+    # Overlapping Rows: comb bands ride the same scanline grid the raster
+    # uses, so each tooth covers exactly one raster row.
+    pitch = float(grid) if grid and float(grid) > 0.0 else None
+    axes = str(row_overlap_axes or "both").strip().lower()
+    comb_rows_x = (
+        bool(overlapping_rows)
+        and axes in ("both", "x")
+        and columns > 1
+        and overlap > 0.0
+        and pitch is not None
+    )
+    comb_rows_y = (
+        bool(overlapping_rows)
+        and axes in ("both", "y")
+        and rows > 1
+        and overlap > 0.0
+        and pitch is not None
+    )
+    anchor_x = _scan_anchor(scan_frame[0], scan_frame[2], pitch) if pitch else 0.0
+    anchor_y = _scan_anchor(scan_frame[1], scan_frame[3], pitch) if pitch else 0.0
+
     base_name = stack.name or "shape"
     pieces: list[LayerStack] = []
     for row_index in range(1, rows + 1):
@@ -2106,12 +2283,26 @@ def split_layer_stack_grid(
                     continue
                 x_edges = layer_x_edges[layer_number]
                 y_edges = layer_y_edges[layer_number]
-                cell = box(
-                    x_edges[x_cell],
-                    y_edges[y_cell],
-                    x_edges[x_cell + 1],
-                    y_edges[y_cell + 1],
-                )
+                if comb_rows_x or comb_rows_y:
+                    cell = _comb_cell_geometry(
+                        x_edges,
+                        y_edges,
+                        x_cell,
+                        y_cell,
+                        _comb_amplitude(x_edges, overlap) if comb_rows_x else 0.0,
+                        _comb_amplitude(y_edges, overlap) if comb_rows_y else 0.0,
+                        pitch,
+                        anchor_x,
+                        anchor_y,
+                        layer_number,
+                    )
+                else:
+                    cell = box(
+                        x_edges[x_cell],
+                        y_edges[y_cell],
+                        x_edges[x_cell + 1],
+                        y_edges[y_cell + 1],
+                    )
                 layers.append(_as_multipolygon(layer.intersection(cell)))
 
                 # Contours come from the parent's outline (or, when