Add lead-in and advanced split alignment controls

README.md

@@ -52,6 +52,7 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 - Automatically combines generated stacks into a reference TIFF stack when TIFF stacks are generated
 - Splits one generated TIFF stack into an editable row/column grid for multi-nozzle printing of one large shape
 - Converts generated TIFF ZIPs into G-code files with pressure, valve, nozzle, and port settings per shape from the Shape Settings table
+- Appends a shape-optimized outer contour after each enabled shape layer by tracing that layer's active row envelope
 - Offers G-code generation options for raster pattern, **Use G1 for all moves** (no rapid travel command), and **Use Reference Stack for motion** (all shapes share one nozzle path; each dispenses only its own geometry)
 - Calculates X/Y nozzle spacing from an editable adjacent-pair spacing table, then visualizes the resulting nozzle layout
 - Previews selected generated G-code inline
@@ -75,7 +76,7 @@ When you click **Generate TIFF Stacks**, the app automatically combines availabl
 
 The **Multi-Nozzle Split** accordion on the **STL to TIFF Slicer** tab can split one generated shape stack into a grid of print-ready stacks. Choose a source shape that already has TIFF slices, set the number of columns and rows, choose the starting nozzle and valve numbers, then click **Split Selected Shape into Grid Pieces**.
 
-- Each slice is split into columns along X and rows along Y; leftover pixels are assigned to earlier columns/rows so no pixels are dropped.
+- Each slice is padded with white pixels as needed, then split into equal-width columns and equal-height rows so every generated piece in the grid has a matching TIFF canvas.
 - 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 the existing **TIFF Slices to GCode** tab can generate separate G-code for each piece.
 
@@ -93,6 +94,8 @@ The **Multi-Nozzle Split** accordion on the **STL to TIFF Slicer** tab can split
 - **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 Reference Stack for motion**: when enabled, every shape's snake-path *motion* is taken from the combined Reference TIFF Stack while each shape's *valve/dispensing* comes from its own slices — so parallel print heads share one synchronized nozzle path and each deposits only its own geometry. The reference stack is generated automatically with TIFF stacks; shapes are skipped with a message if it is missing.
 - **Raster Pattern**: `X-direction raster` keeps the existing X-direction back-and-forth raster on every layer. `Y-direction raster` rasters every layer in Y. `Woodpile raster` alternates the raster axis by layer, switching between X-direction and Y-direction sweeps.
+- **Auto Align Split Parts**: in Nozzle Spacing, fills Grid Layout gaps for split-piece alignment. X-direction raster uses X `-3.2` mm and Y `-0.8` mm; Y-direction raster switches those values.
+- **Contour Tracing**: enabled per row in Shape Settings. The app uses the shape-optimized row-envelope tracer, travels from the layer raster end to the nearest contour point, prints the contour, then returns to the raster endpoint before the next layer.
 
 ### Print vs Travel Classification
 

app.py

@@ -38,8 +38,10 @@ from stl_slicer import (
     slice_stl_to_tiffs,
 )
 from tiff_to_gcode import (
-RASTER_PATTERN_CHOICES,
+    CONTOUR_MODE_ROW_ENVELOPE,
+    RASTER_PATTERN_CHOICES,
     RASTER_PATTERN_SAME_DIRECTION,
+    RASTER_PATTERN_Y_DIRECTION,
     generate_snake_path_gcode,
 )
 
@@ -67,6 +69,8 @@ NOZZLE_LAYOUT_PRESETS = [
     "2 x 5",
     "5 x 2",
 ]
+AUTO_ALIGN_X_RASTER_OFFSETS = (-3.2, -0.8)
+AUTO_ALIGN_Y_RASTER_OFFSETS = (-0.8, -3.2)
 APP_CSS = """
 .gradio-container {
     font-size: 90%;
@@ -149,10 +153,15 @@ APP_CSS = """
 }
 
 #nozzle-spacing-table table tbody tr td:nth-child(-n+2),
+#nozzle-grid-spacing-table table tbody tr td:nth-child(-n+2),
 #nozzle-spacing-table table thead th,
+#nozzle-grid-spacing-table table thead th,
 #nozzle-spacing-table [role="columnheader"],
+#nozzle-grid-spacing-table [role="columnheader"],
 #nozzle-spacing-table [role="gridcell"]:nth-child(4n + 1),
-#nozzle-spacing-table [role="gridcell"]:nth-child(4n + 2) {
+#nozzle-spacing-table [role="gridcell"]:nth-child(4n + 2),
+#nozzle-grid-spacing-table [role="gridcell"]:nth-child(4n + 1),
+#nozzle-grid-spacing-table [role="gridcell"]:nth-child(4n + 2) {
     background: rgba(243, 244, 246, 0.82) !important;
     color: var(--body-text-color-subdued) !important;
     pointer-events: none;
@@ -1499,12 +1508,22 @@ def _nozzle_group_bounds(grouped: dict[int, list[dict]], nozzle: int) -> tuple[t
     )
 
 
+def _grid_default_gap_for_pair(pair_index: int, column_count: int, x_gap: float, y_gap: float) -> tuple[float, float]:
+    current_col = pair_index % column_count
+    next_col = (pair_index + 1) % column_count
+    if next_col > current_col:
+        return x_gap, 0.0
+    return 0.0, y_gap
+
+
 def _resolve_nozzle_grid_layout(
     parts: list[dict],
     columns: Any,
     rows: Any,
     column_spacing: Any,
     row_spacing: Any,
+    use_individual_spacing: bool | None = False,
+    spacing_table: Any | None = None,
 ) -> tuple[dict[int, tuple[float, float]], list[dict]]:
     offsets: dict[int, tuple[float, float]] = {}
     spacings: list[dict] = []
@@ -1516,14 +1535,8 @@ def _resolve_nozzle_grid_layout(
     column_count = max(1, _coerce_int(columns, 1))
     requested_rows = max(1, _coerce_int(rows, 1))
     row_count = max(requested_rows, math.ceil(len(ordered_nozzles) / column_count))
-    try:
-        x_gap = float(column_spacing)
-    except (TypeError, ValueError):
-        x_gap = 0.0
-    try:
-        y_gap = float(row_spacing)
-    except (TypeError, ValueError):
-        y_gap = 0.0
+    x_gap = _coerce_float(column_spacing, 0.0)
+    y_gap = _coerce_float(row_spacing, 0.0)
 
     placements = {
         nozzle: (index % column_count, index // column_count)
@@ -1539,6 +1552,53 @@ def _resolve_nozzle_grid_layout(
         column_widths[column] = max(column_widths[column], xmax - xmin)
         row_heights[row] = max(row_heights[row], ymax - ymin)
 
+    if use_individual_spacing:
+        gap_pairs = _spacing_pairs_from_table(spacing_table)
+
+        def pair_gap(pair_index: int) -> tuple[float, float]:
+            if pair_index < len(gap_pairs):
+                return gap_pairs[pair_index]
+            return _grid_default_gap_for_pair(pair_index, column_count, x_gap, y_gap)
+
+        row_start_x = 0.0
+        row_min_y = 0.0
+        for row in range(row_count):
+            row_start_index = row * column_count
+            row_nozzles = ordered_nozzles[row_start_index:row_start_index + column_count]
+            if not row_nozzles:
+                break
+            for col, nozzle in enumerate(row_nozzles):
+                (xmin, ymin, _), _ = bounds_by_nozzle[nozzle]
+                if col == 0:
+                    target_x = row_start_x
+                    target_y = row_min_y
+                else:
+                    prev = row_nozzles[col - 1]
+                    gap_x, gap_y = pair_gap(row_start_index + col - 1)
+                    prev_offset_x, _prev_offset_y = offsets[prev]
+                    (_, _, _), (prev_xmax, _prev_ymax, _) = bounds_by_nozzle[prev]
+                    target_x = prev_offset_x + prev_xmax + gap_x
+                    target_y = row_min_y + gap_y
+                offsets[nozzle] = (target_x - xmin, target_y - ymin)
+
+            row_bottom = max(offsets[nozzle][1] + bounds_by_nozzle[nozzle][1][1] for nozzle in row_nozzles)
+            next_row_start_index = row_start_index + len(row_nozzles)
+            if next_row_start_index < len(ordered_nozzles):
+                row_shift_x, row_gap = pair_gap(next_row_start_index - 1)
+                row_start_x += row_shift_x
+                row_min_y = row_bottom + row_gap
+
+        for first, second in zip(ordered_nozzles, ordered_nozzles[1:]):
+            first_x, first_y = offsets[first]
+            second_x, second_y = offsets[second]
+            spacings.append({
+                "from": first,
+                "to": second,
+                "dx": second_x - first_x,
+                "dy": second_y - first_y,
+            })
+        return offsets, spacings
+
     column_positions: list[float] = []
     x_pos = 0.0
     for width in column_widths:
@@ -1574,11 +1634,21 @@ def _resolve_layout_from_spacing_controls(
     rows: Any,
     column_spacing: Any,
     row_spacing: Any,
+    use_grid_individual_spacing: bool | None,
+    grid_spacing_table: Any,
     use_individual_spacing: bool,
     spacing_table: Any,
 ) -> tuple[dict[int, tuple[float, float]], list[dict]]:
     if layout_mode != NOZZLE_LAYOUT_PAIR_TABLE:
-        return _resolve_nozzle_grid_layout(parts, columns, rows, column_spacing, row_spacing)
+        return _resolve_nozzle_grid_layout(
+            parts,
+            columns,
+            rows,
+            column_spacing,
+            row_spacing,
+            use_grid_individual_spacing,
+            grid_spacing_table,
+        )
     gap12x, gap12y, gap23x, gap23y, extra = _spacing_args_from_table(spacing_table, use_individual_spacing)
     return _resolve_nozzle_layout(
         parts,
@@ -1791,6 +1861,25 @@ def _partition_length(length: int, count: int) -> list[tuple[int, int]]:
     return spans
 
 
+def _padded_grid_axis(length: int, count: int) -> dict[str, Any]:
+    cell_size = max(1, math.ceil(length / count))
+    padded_length = cell_size * count
+    total_pad = padded_length - length
+    leading_pad = total_pad // 2
+    trailing_pad = total_pad - leading_pad
+    spans = [
+        (index * cell_size, (index + 1) * cell_size)
+        for index in range(count)
+    ]
+    return {
+        "cell_size": cell_size,
+        "padded_length": padded_length,
+        "leading_pad": leading_pad,
+        "trailing_pad": trailing_pad,
+        "spans": spans,
+    }
+
+
 def _layer_split_spans(length: int, count: int, layer_index: int, overlap_pixels: int) -> list[tuple[int, int]]:
     base_spans = _partition_length(length, count)
     if overlap_pixels <= 0 or count <= 1:
@@ -1806,14 +1895,6 @@ def _layer_split_spans(length: int, count: int, layer_index: int, overlap_pixels
     return [(adjusted[index], adjusted[index + 1]) for index in range(count)]
 
 
-def _overlap_canvas_span(start: int, end: int, length: int, position: int, count: int, overlap_pixels: int) -> tuple[int, int]:
-    if overlap_pixels <= 0:
-        return start, end
-    canvas_start = max(0, start - overlap_pixels) if position > 1 else start
-    canvas_end = min(length, end + overlap_pixels) if position < count else end
-    return canvas_start, canvas_end
-
-
 def split_tiff_stack_grid(
     state: ViewerState,
     base_name: str = "split_shape",
@@ -1837,9 +1918,24 @@ def split_tiff_stack_grid(
 
     safe_name = "".join(ch if ch.isalnum() or ch in {"-", "_"} else "_" for ch in base_name).strip("_") or "split_shape"
     output_dir = Path(tempfile.mkdtemp(prefix=f"{safe_name}_split_"))
-    x_spans = _partition_length(width, column_count)
-    y_spans = _partition_length(height, row_count)
+    x_axis = _padded_grid_axis(width, column_count)
+    y_axis = _padded_grid_axis(height, row_count)
+    x_spans = x_axis["spans"]
+    y_spans = y_axis["spans"]
     overlap_pixels = 1 if overlapping_layers else 0
+    overlap_x = overlap_pixels if column_count > 1 else 0
+    overlap_y = overlap_pixels if row_count > 1 else 0
+    padded_width = int(x_axis["padded_length"])
+    padded_height = int(y_axis["padded_length"])
+    working_width = padded_width + (2 * overlap_x)
+    working_height = padded_height + (2 * overlap_y)
+    source_x = int(x_axis["leading_pad"]) + overlap_x
+    source_y = int(y_axis["leading_pad"]) + overlap_y
+    working_x_min = base_x_min = float(state.get("x_min", 0.0) or 0.0)
+    working_y_min = base_y_min = float(state.get("y_min", 0.0) or 0.0)
+    pixel_size = float(state.get("pixel_size", 0.0) or 0.0)
+    working_x_min = base_x_min - (source_x * pixel_size)
+    working_y_min = base_y_min - ((int(y_axis["trailing_pad"]) + overlap_y) * pixel_size)
     pieces: list[dict[str, Any]] = []
     for row_index, (y_start, y_end) in enumerate(y_spans, start=1):
         for col_index, (x_start, x_end) in enumerate(x_spans, start=1):
@@ -1863,53 +1959,82 @@ def split_tiff_stack_grid(
             if layer.size != (width, height):
                 raise ValueError("All TIFF slices must have the same dimensions to split the stack.")
 
-            layer_x_spans = _layer_split_spans(width, column_count, index, overlap_pixels)
-            layer_y_spans = _layer_split_spans(height, row_count, index, overlap_pixels)
-            for piece in pieces:
-                canvas_x_start, canvas_x_end = _overlap_canvas_span(
-                    piece["x_start"], piece["x_end"], width, piece["col"], column_count, overlap_pixels
+            padded_layer = Image.new("L", (working_width, working_height), 255)
+            padded_layer.paste(layer, (source_x, source_y))
+            layer_x_spans = [
+                (x_start + overlap_x, x_end + overlap_x)
+                for x_start, x_end in _layer_split_spans(
+                    padded_width,
+                    column_count,
+                    index,
+                    overlap_x,
                 )
-                canvas_y_start, canvas_y_end = _overlap_canvas_span(
-                    piece["y_start"], piece["y_end"], height, piece["row"], row_count, overlap_pixels
+            ]
+            layer_y_spans = [
+                (y_start + overlap_y, y_end + overlap_y)
+                for y_start, y_end in _layer_split_spans(
+                    padded_height,
+                    row_count,
+                    index,
+                    overlap_y,
                 )
+            ]
+            for piece in pieces:
+                canvas_x_start = piece["x_start"]
+                canvas_x_end = piece["x_end"]
+                canvas_y_start = piece["y_start"]
+                canvas_y_end = piece["y_end"]
+                if overlapping_layers:
+                    canvas_x_start -= overlap_x
+                    canvas_x_end += overlap_x
+                    canvas_y_start -= overlap_y
+                    canvas_y_end += overlap_y
+                canvas_x_start += overlap_x
+                canvas_x_end += overlap_x
+                canvas_y_start += overlap_y
+                canvas_y_end += overlap_y
                 x_start, x_end = layer_x_spans[piece["col"] - 1]
                 y_start, y_end = layer_y_spans[piece["row"] - 1]
                 if overlapping_layers:
                     piece_image = Image.new("L", (canvas_x_end - canvas_x_start, canvas_y_end - canvas_y_start), 255)
                     piece_image.paste(
-                        layer.crop((x_start, y_start, x_end, y_end)),
+                        padded_layer.crop((x_start, y_start, x_end, y_end)),
                         (x_start - canvas_x_start, y_start - canvas_y_start),
                     )
                 else:
-                    piece_image = layer.crop((x_start, y_start, x_end, y_end))
+                    piece_image = padded_layer.crop((x_start, y_start, x_end, y_end))
                 piece_path = piece["tiff_dir"] / f"slice_{index:04d}.tif"
                 piece_image.save(piece_path, compression="tiff_deflate")
                 piece["tiff_paths"].append(piece_path)
 
-    pixel_size = float(state.get("pixel_size", 0.0) or 0.0)
     z_values = list(state.get("z_values", []))
     if len(z_values) < len(tiff_paths):
         z_values.extend([0.0] * (len(tiff_paths) - len(z_values)))
 
-    base_x_min = float(state.get("x_min", 0.0) or 0.0)
-    base_y_min = float(state.get("y_min", 0.0) or 0.0)
     for piece in pieces:
-        canvas_x_start, canvas_x_end = _overlap_canvas_span(
-            piece["x_start"], piece["x_end"], width, piece["col"], column_count, overlap_pixels
-        )
-        canvas_y_start, canvas_y_end = _overlap_canvas_span(
-            piece["y_start"], piece["y_end"], height, piece["row"], row_count, overlap_pixels
-        )
-        piece_width = canvas_x_end - canvas_x_start if overlapping_layers else piece["x_end"] - piece["x_start"]
-        piece_height = canvas_y_end - canvas_y_start if overlapping_layers else piece["y_end"] - piece["y_start"]
+        canvas_x_start = piece["x_start"]
+        canvas_x_end = piece["x_end"]
+        canvas_y_start = piece["y_start"]
+        canvas_y_end = piece["y_end"]
+        if overlapping_layers:
+            canvas_x_start -= overlap_x
+            canvas_x_end += overlap_x
+            canvas_y_start -= overlap_y
+            canvas_y_end += overlap_y
+        canvas_x_start += overlap_x
+        canvas_x_end += overlap_x
+        canvas_y_start += overlap_y
+        canvas_y_end += overlap_y
+        piece_width = canvas_x_end - canvas_x_start
+        piece_height = canvas_y_end - canvas_y_start
         zip_path = output_dir / f"{safe_name}_r{piece['row']:02d}_c{piece['col']:02d}_tiff_slices.zip"
         _zip_tiff_paths(piece["tiff_paths"], zip_path)
         piece_state: ViewerState = {
             "tiff_paths": [str(path) for path in piece["tiff_paths"]],
             "z_values": z_values[: len(piece["tiff_paths"])],
             "pixel_size": pixel_size,
-            "x_min": base_x_min + ((canvas_x_start if overlapping_layers else piece["x_start"]) * pixel_size),
-            "y_min": base_y_min + ((height - (canvas_y_end if overlapping_layers else piece["y_end"])) * pixel_size),
+            "x_min": working_x_min + (canvas_x_start * pixel_size),
+            "y_min": working_y_min + ((working_height - canvas_y_end) * pixel_size),
             "image_width": piece_width,
             "image_height": piece_height,
             "zip_path": str(zip_path),
@@ -2009,6 +2134,13 @@ def _coerce_int(value: Any, default: int) -> int:
             return 0
 
 
+def _coerce_float(value: Any, default: float) -> float:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return float(default)
+
+
 def _record_nozzle_number(record: dict, fallback: int | None = None) -> int:
     default = fallback if fallback is not None else int(record.get("idx", 1) or 1)
     nozzle = _coerce_int(record.get("nozzle", default), default)
@@ -2300,29 +2432,20 @@ def _grid_spacing_rows(
     rows: Any,
     column_spacing: Any,
     row_spacing: Any,
+    existing_table: Any | None = None,
 ) -> tuple[list[list[Any]], int, int]:
     ordered_nozzles = _ordered_nozzle_numbers(records)
     column_count = max(1, _coerce_int(columns, 2))
-    row_count = max(1, _coerce_int(rows, 1))
-    try:
-        x_spacing = float(column_spacing)
-    except (TypeError, ValueError):
-        x_spacing = 5.0
-    try:
-        y_spacing = float(row_spacing)
-    except (TypeError, ValueError):
-        y_spacing = 5.0
+    requested_rows = max(1, _coerce_int(rows, 1))
+    row_count = max(requested_rows, math.ceil(len(ordered_nozzles) / column_count) if ordered_nozzles else requested_rows)
+    x_spacing = _coerce_float(column_spacing, 5.0)
+    y_spacing = _coerce_float(row_spacing, 5.0)
+    existing_pairs = _spacing_pairs_from_table(existing_table)
 
     spacing_rows: list[list[Any]] = []
     for index, (first, second) in enumerate(zip(ordered_nozzles, ordered_nozzles[1:])):
-        current_col = index % column_count
-        next_col = (index + 1) % column_count
-        if next_col > current_col:
-            gap_x = x_spacing
-            gap_y = 0.0
-        else:
-            gap_x = -x_spacing * (column_count - 1)
-            gap_y = y_spacing
+        default_gap_x, default_gap_y = _grid_default_gap_for_pair(index, column_count, x_spacing, y_spacing)
+        gap_x, gap_y = existing_pairs[index] if index < len(existing_pairs) else (default_gap_x, default_gap_y)
         spacing_rows.append([
             _nozzle_spacing_label(first, records),
             _nozzle_spacing_label(second, records),
@@ -2332,6 +2455,85 @@ def _grid_spacing_rows(
     return spacing_rows, column_count, row_count
 
 
+def _grid_spacing_table_update(
+    records: list[dict] | None,
+    columns: Any,
+    rows: Any,
+    column_spacing: Any,
+    row_spacing: Any,
+    existing_table: Any | None = None,
+    use_individual_grid_spacing: bool | None = False,
+) -> dict[str, Any]:
+    spacing_rows, _column_count, _row_count = _grid_spacing_rows(
+        records or [],
+        columns,
+        rows,
+        column_spacing,
+        row_spacing,
+        existing_table if use_individual_grid_spacing else None,
+    )
+    return gr.update(
+        headers=ADVANCED_NOZZLE_SPACING_HEADERS,
+        value=spacing_rows,
+        row_count=(len(spacing_rows), "fixed"),
+        column_count=(len(ADVANCED_NOZZLE_SPACING_HEADERS), "fixed"),
+        label="Advanced Grid Spacing",
+        visible=bool(use_individual_grid_spacing),
+    )
+
+
+def _records_by_nozzle(records: list[dict]) -> dict[int, list[dict]]:
+    grouped: dict[int, list[dict]] = {}
+    for index, record in enumerate(records, start=1):
+        grouped.setdefault(_record_nozzle_number(record, int(record.get("idx", index) or index)), []).append(record)
+    return grouped
+
+
+def _split_pair_was_created_together(records_by_nozzle: dict[int, list[dict]], first: int, second: int) -> bool:
+    for first_record in records_by_nozzle.get(first, []):
+        first_group = first_record.get("split_group_id")
+        if not first_group:
+            continue
+        first_index = _coerce_int(first_record.get("split_index"), -1)
+        if first_index < 0:
+            continue
+        for second_record in records_by_nozzle.get(second, []):
+            if second_record.get("split_group_id") != first_group:
+                continue
+            if _coerce_int(second_record.get("split_index"), -1) == first_index + 1:
+                return True
+    return False
+
+
+def _auto_align_grid_spacing_rows(
+    records: list[dict],
+    columns: Any,
+    rows: Any,
+    column_spacing: Any,
+    row_spacing: Any,
+    raster_pattern: str | None,
+) -> tuple[list[list[Any]], int, int, int]:
+    spacing_rows, column_count, row_count = _grid_spacing_rows(
+        records,
+        columns,
+        rows,
+        column_spacing,
+        row_spacing,
+    )
+    auto_x_gap, auto_y_gap = _auto_align_split_offsets(raster_pattern)
+    records_by_nozzle = _records_by_nozzle(records)
+    ordered_nozzles = _ordered_nozzle_numbers(records)
+    aligned_count = 0
+    for index, (first, second) in enumerate(zip(ordered_nozzles, ordered_nozzles[1:])):
+        if not _split_pair_was_created_together(records_by_nozzle, first, second):
+            continue
+        gap_x, gap_y = _grid_default_gap_for_pair(index, column_count, auto_x_gap, auto_y_gap)
+        spacing_rows[index][2] = gap_x
+        spacing_rows[index][3] = gap_y
+        aligned_count += 1
+    return spacing_rows, column_count, row_count, aligned_count
+
+
 def apply_nozzle_grid_spacing(
     records: list[dict] | None,
     columns: Any,
@@ -2359,6 +2561,64 @@ def apply_nozzle_grid_spacing(
     )
 
 
+def _auto_align_split_offsets(raster_pattern: str | None) -> tuple[float, float]:
+    if raster_pattern == RASTER_PATTERN_Y_DIRECTION:
+        return AUTO_ALIGN_Y_RASTER_OFFSETS
+    return AUTO_ALIGN_X_RASTER_OFFSETS
+
+
+def auto_align_split_parts_for_raster(
+    records: list[dict] | None,
+    columns: Any,
+    rows: Any,
+    column_spacing: Any,
+    row_spacing: Any,
+    raster_pattern: str | None,
+) -> tuple:
+    x_gap, y_gap = _auto_align_split_offsets(raster_pattern)
+    raster_label = raster_pattern or RASTER_PATTERN_SAME_DIRECTION
+    spacing_rows, column_count, row_count, aligned_count = _auto_align_grid_spacing_rows(
+        records or [],
+        columns,
+        rows,
+        column_spacing,
+        row_spacing,
+        raster_pattern,
+    )
+    if aligned_count <= 0:
+        return (
+            gr.update(value=NOZZLE_LAYOUT_GRID),
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            "No split-sibling nozzle connections found. Auto align was not applied.",
+        )
+
+    return (
+        gr.update(value=NOZZLE_LAYOUT_GRID),
+        gr.update(visible=True),
+        gr.update(visible=False),
+        gr.update(),
+        gr.update(),
+        gr.update(value=True),
+        gr.update(
+            headers=ADVANCED_NOZZLE_SPACING_HEADERS,
+            value=spacing_rows,
+            row_count=(len(spacing_rows), "fixed"),
+            column_count=(len(ADVANCED_NOZZLE_SPACING_HEADERS), "fixed"),
+            label="Advanced Grid Spacing",
+            visible=True,
+        ),
+        (
+            f"Auto aligned {aligned_count} split nozzle connection(s) for {raster_label} "
+            f"in a {column_count} x {row_count} grid: Column Gap X {x_gap:.2f} mm, Row Gap Y {y_gap:.2f} mm."
+        ),
+    )
+
+
 def update_nozzle_grid_preset(
     preset: str | None,
     records: list[dict] | None,
@@ -2880,6 +3140,9 @@ def split_selected_shape_for_grid(
     base_name = str(source.get("name") or f"Shape {source.get('idx', pos + 1)}")
     first_nozzle = max(1, _coerce_int(starting_nozzle, 1))
     first_valve = max(1, _coerce_int(starting_valve, _coerce_int(source.get("valve", 4), 4)))
+    split_column_count = max(1, _coerce_int(columns, 2))
+    split_row_count = max(1, _coerce_int(rows, 1))
+    split_group_id = f"split-{int(time.time() * 1_000_000)}-{source.get('idx', pos + 1)}"
     split_records: list[dict] = []
     for index, piece in enumerate(pieces):
         piece_state = piece["state"]
@@ -2893,6 +3156,12 @@ def split_selected_shape_for_grid(
             "target_y": piece_height_mm or source.get("target_y", DEFAULT_TARGET_EXTENTS[1]),
             "nozzle": first_nozzle + index,
             "valve": first_valve + index,
+            "split_group_id": split_group_id,
+            "split_index": index,
+            "split_row": int(piece["row"]),
+            "split_col": int(piece["col"]),
+            "split_rows": split_row_count,
+            "split_columns": split_column_count,
             "tiff_state": piece_state,
             "zip_path": str(piece["zip_path"]),
             "gcode_path": None,
@@ -2935,6 +3204,7 @@ def _contour_tracing_sources(records: list[dict]) -> list[dict]:
         tiff_paths = state.get("tiff_paths") or []
         source = {
             "owner_idx": int(record.get("idx", len(sources) + 1)),
+            "contour_mode": CONTOUR_MODE_ROW_ENVELOPE,
             "tiff_paths": list(tiff_paths),
             "zip_path": record.get("zip_path"),
         }
@@ -2949,6 +3219,10 @@ def generate_dynamic_gcode(
     all_g1: bool,
     use_reference_motion: bool,
     raster_pattern: str | None,
+    lead_in_enabled: bool,
+    lead_in_length: float,
+    lead_in_clearance: float,
+    lead_in_lines: float,
     ref_state: ViewerState | None,
     layer_height: float,
     pixel_size: float,
@@ -2959,7 +3233,7 @@ def generate_dynamic_gcode(
     messages: list[str] = []
     if contour_sources:
         enabled = ", ".join(f"Shape {source['owner_idx']}" for source in contour_sources)
-        messages.append(f"Contour tracing enabled for {enabled}.")
+        messages.append(f"Shape-optimized contour tracing enabled for {enabled}.")
     for record in records:
         zip_path = record.get("zip_path")
         if not zip_path:
@@ -2983,6 +3257,10 @@ def generate_dynamic_gcode(
                 raster_pattern=raster_pattern,
                 contour_tiff_sets=contour_sources,
                 active_contour_owner=int(record.get("idx", 0)),
+                lead_in_enabled=bool(lead_in_enabled),
+                lead_in_length=float(lead_in_length),
+                lead_in_clearance=float(lead_in_clearance),
+                lead_in_lines=max(1, _coerce_int(lead_in_lines, 3)),
             )
             record["gcode_path"] = str(gcode_path)
             messages.append(f"Shape {record['idx']}: wrote `{gcode_path.name}`.")
@@ -3052,6 +3330,8 @@ def render_dynamic_nozzle_spacing(
     rows: Any,
     column_spacing: Any,
     row_spacing: Any,
+    use_grid_individual_spacing: bool,
+    grid_spacing_table: Any,
     use_individual_spacing: bool,
     spacing_table: Any,
 ) -> tuple[Any, str]:
@@ -3065,6 +3345,8 @@ def render_dynamic_nozzle_spacing(
         rows,
         column_spacing,
         row_spacing,
+        use_grid_individual_spacing,
+        grid_spacing_table,
         use_individual_spacing,
         spacing_table,
     )
@@ -3142,6 +3424,8 @@ def render_dynamic_parallel(
     rows: Any,
     column_spacing: Any,
     row_spacing: Any,
+    use_grid_individual_spacing: bool,
+    grid_spacing_table: Any,
     use_individual_spacing: bool,
     spacing_table: Any,
     tube: bool = True,
@@ -3157,6 +3441,8 @@ def render_dynamic_parallel(
         rows,
         column_spacing,
         row_spacing,
+        use_grid_individual_spacing,
+        grid_spacing_table,
         use_individual_spacing,
         spacing_table,
     )
@@ -3197,6 +3483,8 @@ def export_dynamic_parallel_gif(
     rows: Any,
     column_spacing: Any,
     row_spacing: Any,
+    use_grid_individual_spacing: bool,
+    grid_spacing_table: Any,
     use_individual_spacing: bool,
     spacing_table: Any,
     duration: float,
@@ -3216,6 +3504,8 @@ def export_dynamic_parallel_gif(
         rows,
         column_spacing,
         row_spacing,
+        use_grid_individual_spacing,
+        grid_spacing_table,
         use_individual_spacing,
         spacing_table,
     )
@@ -3369,6 +3659,11 @@ def build_dynamic_demo() -> gr.Blocks:
                 value=RASTER_PATTERN_SAME_DIRECTION,
                 allow_custom_value=False,
             )
+            gcode_lead_in_enabled = gr.Checkbox(label="Lead In", value=False)
+            with gr.Row():
+                gcode_lead_in_length = gr.Number(label="Lead In Length (mm)", value=5.0, minimum=0.1, step=0.1)
+                gcode_lead_in_clearance = gr.Number(label="Lead In Clearance (mm)", value=5.0, minimum=0.0, step=0.1)
+                gcode_lead_in_lines = gr.Number(label="Lead In Raster Lines", value=3, minimum=1, step=1)
             gcode_button = gr.Button("Generate G-Code", variant="primary")
             gcode_downloads = gr.File(label="Download G-Code Files", file_count="multiple", interactive=False, elem_classes=["gcode-download"])
             gcode_status = gr.Markdown("")
@@ -3395,6 +3690,19 @@ def build_dynamic_demo() -> gr.Blocks:
                         nozzle_grid_rows = gr.Number(label="Grid Rows", value=2, minimum=1, step=1)
                         nozzle_grid_column_spacing = gr.Number(label="Column Gap (X, mm)", value=0.0, step=0.1)
                         nozzle_grid_row_spacing = gr.Number(label="Row Gap (Y, mm)", value=0.0, step=0.1)
+                    with gr.Row():
+                        auto_align_split_parts_button = gr.Button("Auto Align Split Parts", variant="secondary", size="sm")
+                        nozzle_grid_use_individual_spacing = gr.Checkbox(label="Use Different Grid Connection Gaps", value=False)
+                    nozzle_grid_spacing_table = gr.Dataframe(
+                        headers=ADVANCED_NOZZLE_SPACING_HEADERS,
+                        value=[],
+                        row_count=(0, "fixed"),
+                        column_count=(len(ADVANCED_NOZZLE_SPACING_HEADERS), "fixed"),
+                        interactive=True,
+                        label="Advanced Grid Spacing",
+                        visible=False,
+                        elem_id="nozzle-grid-spacing-table",
+                    )
                 with gr.Group(visible=False) as nozzle_custom_group:
                     nozzle_use_individual_spacing = gr.Checkbox(label="Use Different Values for Each Nozzle Connection", value=False)
                     nozzle_spacing_table = gr.Dataframe(
@@ -3489,24 +3797,49 @@ def build_dynamic_demo() -> gr.Blocks:
 
             parallel_mode = gr.State("tube")
 
+        grid_spacing_refresh_inputs = [
+            shape_records,
+            nozzle_grid_columns,
+            nozzle_grid_rows,
+            nozzle_grid_column_spacing,
+            nozzle_grid_row_spacing,
+            nozzle_grid_spacing_table,
+            nozzle_grid_use_individual_spacing,
+        ]
+
         shape_sync_outputs = [shape_records, shape_settings, nozzle_spacing_table, selected_shape, gcode_text_source, gcode_source, tiff_downloads, gcode_downloads]
         stl_upload.change(fn=sync_uploaded_shapes, inputs=[stl_upload, shape_records, shape_settings, nozzle_spacing_table, nozzle_use_individual_spacing], outputs=shape_sync_outputs).then(
             fn=lambda records: _dropdown_update(records),
             inputs=[shape_records],
             outputs=[split_source],
             queue=False,
+        ).then(
+            fn=_grid_spacing_table_update,
+            inputs=grid_spacing_refresh_inputs,
+            outputs=[nozzle_grid_spacing_table],
+            queue=False,
         )
         sync_uploads_button.click(fn=sync_uploaded_shapes, inputs=[stl_upload, shape_records, shape_settings, nozzle_spacing_table, nozzle_use_individual_spacing], outputs=shape_sync_outputs).then(
             fn=lambda records: _dropdown_update(records),
             inputs=[shape_records],
             outputs=[split_source],
             queue=False,
+        ).then(
+            fn=_grid_spacing_table_update,
+            inputs=grid_spacing_refresh_inputs,
+            outputs=[nozzle_grid_spacing_table],
+            queue=False,
         )
         load_samples_button.click(fn=load_sample_shapes, inputs=[stl_upload, shape_records, shape_settings, nozzle_spacing_table, nozzle_use_individual_spacing], outputs=[stl_upload, *shape_sync_outputs]).then(
             fn=lambda records: _dropdown_update(records),
             inputs=[shape_records],
             outputs=[split_source],
             queue=False,
+        ).then(
+            fn=_grid_spacing_table_update,
+            inputs=grid_spacing_refresh_inputs,
+            outputs=[nozzle_grid_spacing_table],
+            queue=False,
         )
         shape_settings.select(
             fn=delete_shape_from_settings,
@@ -3517,6 +3850,11 @@ def build_dynamic_demo() -> gr.Blocks:
             inputs=[shape_records],
             outputs=[split_source],
             queue=False,
+        ).then(
+            fn=_grid_spacing_table_update,
+            inputs=grid_spacing_refresh_inputs,
+            outputs=[nozzle_grid_spacing_table],
+            queue=False,
         )
 
         preview_inputs = [shape_records, selected_shape, shape_settings, model_opacity, scale_mode]
@@ -3525,6 +3863,11 @@ def build_dynamic_demo() -> gr.Blocks:
             inputs=[shape_records, shape_settings, scale_mode, nozzle_spacing_table, nozzle_use_individual_spacing],
             outputs=[shape_records, shape_settings, nozzle_spacing_table],
             queue=False,
+        ).then(
+            fn=_grid_spacing_table_update,
+            inputs=grid_spacing_refresh_inputs,
+            outputs=[nozzle_grid_spacing_table],
+            queue=False,
         )
         selected_shape.change(fn=show_selected_model, inputs=preview_inputs, outputs=[model_viewer, model_details, slice_slider, slice_label, slice_preview])
         refresh_preview_button.click(fn=show_selected_model, inputs=preview_inputs, outputs=[model_viewer, model_details, slice_slider, slice_label, slice_preview])
@@ -3616,6 +3959,11 @@ def build_dynamic_demo() -> gr.Blocks:
             fn=generate_dynamic_reference_stack,
             inputs=[shape_records],
             outputs=[ref_state, ref_slice_slider, ref_slice_label, ref_slice_preview],
+        ).then(
+            fn=_grid_spacing_table_update,
+            inputs=grid_spacing_refresh_inputs,
+            outputs=[nozzle_grid_spacing_table],
+            queue=False,
         )
         split_piece_source.change(fn=preview_selected_split_piece, inputs=[split_piece_states, split_piece_source], outputs=[split_piece_slider, split_piece_label, split_piece_preview], queue=False)
         split_piece_slider.release(fn=jump_to_selected_split_piece, inputs=[split_piece_states, split_piece_source, split_piece_slider], outputs=[split_piece_label, split_piece_preview], queue=False)
@@ -3624,7 +3972,20 @@ def build_dynamic_demo() -> gr.Blocks:
 
         gcode_button.click(
             fn=generate_dynamic_gcode,
-            inputs=[shape_records, shape_settings, gcode_all_g1, gcode_use_ref_motion, gcode_raster_pattern, ref_state, layer_height, pixel_size],
+            inputs=[
+                shape_records,
+                shape_settings,
+                gcode_all_g1,
+                gcode_use_ref_motion,
+                gcode_raster_pattern,
+                gcode_lead_in_enabled,
+                gcode_lead_in_length,
+                gcode_lead_in_clearance,
+                gcode_lead_in_lines,
+                ref_state,
+                layer_height,
+                pixel_size,
+            ],
             outputs=[shape_records, gcode_downloads, gcode_status, gcode_text_source, gcode_source],
         )
         gcode_text_source.change(fn=load_selected_gcode_text, inputs=[shape_records, gcode_text_source], outputs=[gcode_text])
@@ -3635,12 +3996,52 @@ def build_dynamic_demo() -> gr.Blocks:
             outputs=[nozzle_grid_group, nozzle_custom_group],
             queue=False,
         )
+        auto_align_split_parts_button.click(
+            fn=auto_align_split_parts_for_raster,
+            inputs=[
+                shape_records,
+                nozzle_grid_columns,
+                nozzle_grid_rows,
+                nozzle_grid_column_spacing,
+                nozzle_grid_row_spacing,
+                gcode_raster_pattern,
+            ],
+            outputs=[
+                nozzle_layout_mode,
+                nozzle_grid_group,
+                nozzle_custom_group,
+                nozzle_grid_column_spacing,
+                nozzle_grid_row_spacing,
+                nozzle_grid_use_individual_spacing,
+                nozzle_grid_spacing_table,
+                nozzle_spacing_status,
+            ],
+            queue=False,
+        )
         nozzle_grid_preset.change(
             fn=update_nozzle_grid_preset,
             inputs=[nozzle_grid_preset, shape_records, nozzle_grid_columns, nozzle_grid_rows],
             outputs=[nozzle_grid_columns, nozzle_grid_rows],
             queue=False,
+        ).then(
+            fn=_grid_spacing_table_update,
+            inputs=grid_spacing_refresh_inputs,
+            outputs=[nozzle_grid_spacing_table],
+            queue=False,
         )
+        for grid_spacing_control in (
+            nozzle_grid_columns,
+            nozzle_grid_rows,
+            nozzle_grid_column_spacing,
+            nozzle_grid_row_spacing,
+            nozzle_grid_use_individual_spacing,
+        ):
+            grid_spacing_control.change(
+                fn=_grid_spacing_table_update,
+                inputs=grid_spacing_refresh_inputs,
+                outputs=[nozzle_grid_spacing_table],
+                queue=False,
+            )
         nozzle_use_individual_spacing.change(fn=update_nozzle_spacing_table_mode, inputs=[shape_records, nozzle_spacing_table, nozzle_use_individual_spacing], outputs=[nozzle_spacing_table], queue=False)
         nozzle_preview_button.click(
             fn=render_dynamic_nozzle_spacing,
@@ -3651,6 +4052,8 @@ def build_dynamic_demo() -> gr.Blocks:
                 nozzle_grid_rows,
                 nozzle_grid_column_spacing,
                 nozzle_grid_row_spacing,
+                nozzle_grid_use_individual_spacing,
+                nozzle_grid_spacing_table,
                 nozzle_use_individual_spacing,
                 nozzle_spacing_table,
             ],
@@ -3704,6 +4107,8 @@ def build_dynamic_demo() -> gr.Blocks:
             nozzle_grid_rows,
             nozzle_grid_column_spacing,
             nozzle_grid_row_spacing,
+            nozzle_grid_use_individual_spacing,
+            nozzle_grid_spacing_table,
             nozzle_use_individual_spacing,
             nozzle_spacing_table,
         ]
@@ -3723,6 +4128,8 @@ def build_dynamic_demo() -> gr.Blocks:
                 nozzle_grid_rows,
                 nozzle_grid_column_spacing,
                 nozzle_grid_row_spacing,
+                nozzle_grid_use_individual_spacing,
+                nozzle_grid_spacing_table,
                 nozzle_use_individual_spacing,
                 nozzle_spacing_table,
                 pp_gif_duration,

tests/test_app_scaling.py

@@ -94,7 +94,7 @@ def test_split_tiff_stack_left_right_preserves_pixels_and_metadata(tmp_path) ->
     assert left_zip.exists()
     assert right_zip.exists()
     assert left_state["image_width"] == 3
-    assert right_state["image_width"] == 2
+    assert right_state["image_width"] == 3
     assert left_state["x_min"] == 10.0
     assert right_state["x_min"] == 11.5
     assert left_state["z_values"] == [1.25]
@@ -103,7 +103,9 @@ def test_split_tiff_stack_left_right_preserves_pixels_and_metadata(tmp_path) ->
     with Image.open(left_state["tiff_paths"][0]) as left_image:
         np.testing.assert_array_equal(np.asarray(left_image), pixels[:, :3])
     with Image.open(right_state["tiff_paths"][0]) as right_image:
-        np.testing.assert_array_equal(np.asarray(right_image), pixels[:, 3:])
+        expected = np.full((2, 3), 255, dtype=np.uint8)
+        expected[:, :2] = pixels[:, 3:]
+        np.testing.assert_array_equal(np.asarray(right_image), expected)
 
 
 def test_split_tiff_stack_grid_preserves_pixels_and_offsets(tmp_path) -> None:
@@ -123,17 +125,55 @@ def test_split_tiff_stack_grid_preserves_pixels_and_offsets(tmp_path) -> None:
     pieces = split_tiff_stack_grid(state, "grid-part", columns=2, rows=2)
 
     assert [(piece["row"], piece["col"]) for piece in pieces] == [(1, 1), (1, 2), (2, 1), (2, 2)]
-    assert [piece["state"]["image_width"] for piece in pieces] == [3, 2, 3, 2]
+    assert [piece["state"]["image_width"] for piece in pieces] == [3, 3, 3, 3]
     assert [piece["state"]["image_height"] for piece in pieces] == [2, 2, 2, 2]
     assert [piece["state"]["x_min"] for piece in pieces] == [4.0, 4.75, 4.0, 4.75]
     assert [piece["state"]["y_min"] for piece in pieces] == [10.5, 10.5, 10.0, 10.0]
     assert all(piece["zip_path"].exists() for piece in pieces)
 
+    right_top = np.full((2, 3), 255, dtype=np.uint8)
+    right_top[:, :2] = pixels[:2, 3:]
+    right_bottom = np.full((2, 3), 255, dtype=np.uint8)
+    right_bottom[:, :2] = pixels[2:, 3:]
     expected = [
         pixels[:2, :3],
-        pixels[:2, 3:],
+        right_top,
         pixels[2:, :3],
-        pixels[2:, 3:],
+        right_bottom,
+    ]
+    for piece, expected_pixels in zip(pieces, expected):
+        with Image.open(piece["state"]["tiff_paths"][0]) as image:
+            np.testing.assert_array_equal(np.asarray(image), expected_pixels)
+
+
+def test_split_tiff_stack_grid_pads_more_than_three_columns_to_equal_widths(tmp_path) -> None:
+    pixels = np.arange(20, dtype=np.uint8).reshape((2, 10))
+    tiff_path = tmp_path / "slice_0000.tif"
+    Image.fromarray(pixels, mode="L").save(tiff_path)
+    state = {
+        "tiff_paths": [str(tiff_path)],
+        "z_values": [0.0],
+        "pixel_size": 1.0,
+        "x_min": 100.0,
+        "y_min": 0.0,
+        "image_width": 10,
+        "image_height": 2,
+    }
+
+    pieces = split_tiff_stack_grid(state, "four-way", columns=4, rows=1)
+
+    assert [piece["state"]["image_width"] for piece in pieces] == [3, 3, 3, 3]
+    assert [piece["state"]["x_min"] for piece in pieces] == [99.0, 102.0, 105.0, 108.0]
+
+    first_expected = np.full((2, 3), 255, dtype=np.uint8)
+    first_expected[:, 1:] = pixels[:, :2]
+    last_expected = np.full((2, 3), 255, dtype=np.uint8)
+    last_expected[:, :2] = pixels[:, 8:]
+    expected = [
+        first_expected,
+        pixels[:, 2:5],
+        pixels[:, 5:8],
+        last_expected,
     ]
     for piece, expected_pixels in zip(pieces, expected):
         with Image.open(piece["state"]["tiff_paths"][0]) as image:
@@ -159,21 +199,23 @@ def test_split_tiff_stack_grid_overlapping_layers_keep_small_alignment_margin(tm
 
     left, right = split_tiff_stack_grid(state, "overlap-part", columns=2, rows=1, overlapping_layers=True)
 
-    assert left["state"]["image_width"] == 4
-    assert right["state"]["image_width"] == 4
-    assert left["state"]["x_min"] == 10.0
+    assert left["state"]["image_width"] == 5
+    assert right["state"]["image_width"] == 5
+    assert left["state"]["x_min"] == 9.5
     assert right["state"]["x_min"] == 11.0
     with Image.open(left["state"]["tiff_paths"][0]) as left_layer0:
-        expected = np.zeros((2, 4), dtype=np.uint8)
+        expected = np.full((2, 5), 255, dtype=np.uint8)
+        expected[:, 1:] = 0
         np.testing.assert_array_equal(np.asarray(left_layer0), expected)
     with Image.open(right["state"]["tiff_paths"][0]) as right_layer0:
-        expected = np.full((2, 4), 255, dtype=np.uint8)
-        expected[:, 2:] = 0
+        expected = np.full((2, 5), 255, dtype=np.uint8)
+        expected[:, 2:4] = 0
         np.testing.assert_array_equal(np.asarray(right_layer0), expected)
     with Image.open(left["state"]["tiff_paths"][1]) as left_layer1:
-        expected = np.full((2, 4), 255, dtype=np.uint8)
-        expected[:, :2] = 0
+        expected = np.full((2, 5), 255, dtype=np.uint8)
+        expected[:, 1:3] = 0
         np.testing.assert_array_equal(np.asarray(left_layer1), expected)
     with Image.open(right["state"]["tiff_paths"][1]) as right_layer1:
-        expected = np.zeros((2, 4), dtype=np.uint8)
+        expected = np.full((2, 5), 255, dtype=np.uint8)
+        expected[:, :4] = 0
         np.testing.assert_array_equal(np.asarray(right_layer1), expected)

tests/test_nozzle_spacing.py

@@ -7,7 +7,10 @@ from app import (
     SCALE_MODE_UNIFORM_FACTOR,
     SHAPE_SETTINGS_HEADERS,
     SIMPLE_NOZZLE_SPACING_HEADERS,
+    _auto_align_split_offsets,
+    _auto_align_grid_spacing_rows,
     _apply_shape_settings,
+    _contour_tracing_sources,
     delete_shape_from_settings,
     _format_nozzle_spacing_status,
     _grid_spacing_rows,
@@ -19,6 +22,11 @@ from app import (
     _resolve_nozzle_grid_layout,
     _resolve_nozzle_layout,
 )
+from tiff_to_gcode import (
+    CONTOUR_MODE_ROW_ENVELOPE,
+    RASTER_PATTERN_SAME_DIRECTION,
+    RASTER_PATTERN_Y_DIRECTION,
+)
 
 
 def _part(
@@ -248,6 +256,27 @@ def test_shape_settings_round_trip_contour_tracing_column() -> None:
     assert updated[0]["contour_tracing"] is True
 
 
+def test_contour_tracing_sources_request_shape_optimized_mode() -> None:
+    sources = _contour_tracing_sources(
+        [
+            {
+                "idx": 2,
+                "contour_tracing": True,
+                "tiff_state": {"tiff_paths": ["slice_0000.tif"]},
+            }
+        ]
+    )
+
+    assert sources == [
+        {
+            "owner_idx": 2,
+            "contour_mode": CONTOUR_MODE_ROW_ENVELOPE,
+            "tiff_paths": ["slice_0000.tif"],
+            "zip_path": None,
+        }
+    ]
+
+
 def test_repeated_sample_path_gets_next_unused_nozzle() -> None:
     records = _records_from_files(
         ["sample.stl", "sample.stl"],
@@ -316,6 +345,78 @@ def test_advanced_spacing_table_collapses_duplicate_nozzles() -> None:
     assert update["value"] == [["Nozzle 1: Shape 1, Shape 2", "Nozzle 2: Shape 3", 9.0, 2.5]]
 
 
+def test_auto_align_split_offsets_follow_raster_axis() -> None:
+    assert _auto_align_split_offsets(RASTER_PATTERN_SAME_DIRECTION) == (-3.2, -0.8)
+    assert _auto_align_split_offsets(RASTER_PATTERN_Y_DIRECTION) == (-0.8, -3.2)
+
+
+def test_auto_align_grid_spacing_only_targets_split_siblings() -> None:
+    records = [
+        {"idx": 1, "name": "first", "nozzle": 1, "split_group_id": "split-a", "split_index": 0},
+        {"idx": 2, "name": "second", "nozzle": 2, "split_group_id": "split-a", "split_index": 1},
+        {"idx": 3, "name": "third", "nozzle": 3},
+        {"idx": 4, "name": "fourth", "nozzle": 4, "split_group_id": "split-a", "split_index": 2},
+    ]
+
+    rows, column_count, row_count, aligned_count = _auto_align_grid_spacing_rows(
+        records,
+        columns=2,
+        rows=2,
+        column_spacing=10.0,
+        row_spacing=3.0,
+        raster_pattern=RASTER_PATTERN_SAME_DIRECTION,
+    )
+
+    assert column_count == 2
+    assert row_count == 2
+    assert aligned_count == 1
+    assert rows == [
+        ["Nozzle 1: Shape 1", "Nozzle 2: Shape 2", -3.2, 0.0],
+        ["Nozzle 2: Shape 2", "Nozzle 3: Shape 3", 0.0, 3.0],
+        ["Nozzle 3: Shape 3", "Nozzle 4: Shape 4", 10.0, 0.0],
+    ]
+
+
+def test_auto_align_grid_spacing_handles_split_row_transition() -> None:
+    records = [
+        {"idx": 1, "name": "first", "nozzle": 1, "split_group_id": "split-a", "split_index": 0},
+        {"idx": 2, "name": "second", "nozzle": 2, "split_group_id": "split-a", "split_index": 1},
+        {"idx": 3, "name": "third", "nozzle": 3, "split_group_id": "split-a", "split_index": 2},
+    ]
+
+    rows, _column_count, _row_count, aligned_count = _auto_align_grid_spacing_rows(
+        records,
+        columns=2,
+        rows=2,
+        column_spacing=10.0,
+        row_spacing=3.0,
+        raster_pattern=RASTER_PATTERN_SAME_DIRECTION,
+    )
+
+    assert aligned_count == 2
+    assert rows[0] == ["Nozzle 1: Shape 1", "Nozzle 2: Shape 2", -3.2, 0.0]
+    assert rows[1] == ["Nozzle 2: Shape 2", "Nozzle 3: Shape 3", 0.0, -0.8]
+
+
+def test_auto_align_grid_spacing_skips_unsplit_records() -> None:
+    records = [
+        {"idx": 1, "name": "first", "nozzle": 1},
+        {"idx": 2, "name": "second", "nozzle": 2},
+    ]
+
+    rows, _column_count, _row_count, aligned_count = _auto_align_grid_spacing_rows(
+        records,
+        columns=2,
+        rows=1,
+        column_spacing=10.0,
+        row_spacing=3.0,
+        raster_pattern=RASTER_PATTERN_SAME_DIRECTION,
+    )
+
+    assert aligned_count == 0
+    assert rows == [["Nozzle 1: Shape 1", "Nozzle 2: Shape 2", 10.0, 0.0]]
+
+
 def test_grid_spacing_rows_follow_row_major_pattern() -> None:
     records = [
         {"idx": 1, "name": "first", "nozzle": 1},
@@ -330,7 +431,34 @@ def test_grid_spacing_rows_follow_row_major_pattern() -> None:
     assert row_count == 2
     assert rows == [
         ["Nozzle 1: Shape 1", "Nozzle 2: Shape 2", 10.0, 0.0],
-        ["Nozzle 2: Shape 2", "Nozzle 3: Shape 3", -10.0, 3.0],
+        ["Nozzle 2: Shape 2", "Nozzle 3: Shape 3", 0.0, 3.0],
+        ["Nozzle 3: Shape 3", "Nozzle 4: Shape 4", 10.0, 0.0],
+    ]
+
+
+def test_grid_spacing_rows_preserve_existing_advanced_values() -> None:
+    records = [
+        {"idx": 1, "name": "first", "nozzle": 1},
+        {"idx": 2, "name": "second", "nozzle": 2},
+        {"idx": 3, "name": "third", "nozzle": 3},
+        {"idx": 4, "name": "fourth", "nozzle": 4},
+    ]
+
+    rows, _column_count, _row_count = _grid_spacing_rows(
+        records,
+        columns=2,
+        rows=2,
+        column_spacing=10.0,
+        row_spacing=3.0,
+        existing_table=[
+            ["Nozzle 1", "Nozzle 2", 1.5, 0.25],
+            ["Nozzle 2", "Nozzle 3", 2.0, 4.5],
+        ],
+    )
+
+    assert rows == [
+        ["Nozzle 1: Shape 1", "Nozzle 2: Shape 2", 1.5, 0.25],
+        ["Nozzle 2: Shape 2", "Nozzle 3: Shape 3", 2.0, 4.5],
         ["Nozzle 3: Shape 3", "Nozzle 4: Shape 4", 10.0, 0.0],
     ]
 
@@ -356,6 +484,39 @@ def test_nozzle_grid_layout_places_nozzles_by_rows_and_columns() -> None:
     ]
 
 
+def test_advanced_nozzle_grid_layout_uses_per_connection_gaps() -> None:
+    parts = [
+        _part(1, ((0.0, 0.0, 0.0), (10.0, 20.0, 1.0))),
+        _part(2, ((0.0, 0.0, 0.0), (10.0, 20.0, 1.0))),
+        _part(3, ((0.0, 0.0, 0.0), (10.0, 20.0, 1.0))),
+        _part(4, ((0.0, 0.0, 0.0), (10.0, 20.0, 1.0))),
+    ]
+
+    offsets, spacings = _resolve_nozzle_grid_layout(
+        parts,
+        columns=2,
+        rows=2,
+        column_spacing=2.0,
+        row_spacing=3.0,
+        use_individual_spacing=True,
+        spacing_table=[
+            ["Nozzle 1", "Nozzle 2", 2.0, 0.0],
+            ["Nozzle 2", "Nozzle 3", 4.0, 3.0],
+            ["Nozzle 3", "Nozzle 4", 6.0, 0.0],
+        ],
+    )
+
+    np.testing.assert_allclose(offsets[1], (0.0, 0.0))
+    np.testing.assert_allclose(offsets[2], (12.0, 0.0))
+    np.testing.assert_allclose(offsets[3], (4.0, 23.0))
+    np.testing.assert_allclose(offsets[4], (20.0, 23.0))
+    assert spacings == [
+        {"from": 1, "to": 2, "dx": 12.0, "dy": 0.0},
+        {"from": 2, "to": 3, "dx": -8.0, "dy": 23.0},
+        {"from": 3, "to": 4, "dx": 16.0, "dy": 0.0},
+    ]
+
+
 def test_delete_shape_reindexes_without_losing_shape_data() -> None:
     class Event:
         index = (1, len(SHAPE_SETTINGS_HEADERS) - 1)

tests/test_tiff_to_gcode.py

@@ -6,11 +6,14 @@ import numpy as np
 from PIL import Image
 
 from tiff_to_gcode import (
+    CONTOUR_MODE_ROW_ENVELOPE,
     RASTER_PATTERN_SAME_DIRECTION,
     RASTER_PATTERN_WOODPILE,
     RASTER_PATTERN_Y_DIRECTION,
     _build_contour_layers,
+    _append_layer_contours,
     _trace_mask_contours,
+    _trace_row_envelope_contours,
     generate_snake_path_gcode,
 )
 
@@ -81,6 +84,76 @@ def test_trace_mask_contours_uses_tiff_pixel_border_edges() -> None:
     assert contours == [[(0.0, 0.0), (2.0, 0.0), (2.0, 2.0), (0.0, 2.0), (0.0, 0.0)]]
 
 
+def test_trace_row_envelope_contours_follows_left_right_row_extents() -> None:
+    contours = _trace_row_envelope_contours(
+        np.array(
+            [
+                [False, True, False],
+                [True, True, True],
+            ],
+            dtype=bool,
+        ),
+        pixel_size=1.0,
+    )
+
+    assert contours == [
+        [
+            (0.0, 0.0),
+            (-1.0, 1.0),
+            (-1.0, 1.5),
+            (0.0, 1.5),
+            (1.0, 1.5),
+            (2.0, 1.5),
+            (2.0, 1.0),
+            (1.0, 0.0),
+            (1.0, -0.5),
+            (0.0, -0.5),
+        ]
+    ]
+
+
+def test_build_contour_layers_can_use_shape_optimized_row_envelope(tmp_path) -> None:
+    contour_img = np.array(
+        [
+            [0, 255, 0],
+            [255, 255, 255],
+        ],
+        dtype=np.uint8,
+    )
+    contour_tiff = tmp_path / "contour_slice_0000.tif"
+    Image.fromarray(contour_img).save(contour_tiff)
+
+    contour_layers = _build_contour_layers(
+        [
+            {
+                "owner_idx": 1,
+                "contour_mode": CONTOUR_MODE_ROW_ENVELOPE,
+                "tiff_paths": [str(contour_tiff)],
+            }
+        ],
+        [contour_img],
+        pixel_size=1.0,
+        invert=False,
+        off_color=0,
+        work_dir=tmp_path,
+        raster_pattern=RASTER_PATTERN_SAME_DIRECTION,
+    )
+
+    assert contour_layers[0][0]["contour_mode"] == CONTOUR_MODE_ROW_ENVELOPE
+    assert contour_layers[0][0]["contours"][0] == [
+        (1.0, 0.0),
+        (0.0, 1.0),
+        (0.0, 1.5),
+        (1.0, 1.5),
+        (2.0, 1.5),
+        (3.0, 1.5),
+        (3.0, 1.0),
+        (2.0, 0.0),
+        (2.0, -0.5),
+        (1.0, -0.5),
+    ]
+
+
 def test_contour_tracing_aligns_default_raster_border_pixel_frame(tmp_path) -> None:
     raster_tiff = tmp_path / "raster_slice_0000.tif"
     raster_image = Image.new("L", (7, 6), 255)
@@ -352,18 +425,47 @@ def test_contour_tracing_closes_loop_and_restores_raster_endpoint(tmp_path) -> N
         ]
         contour_start = layer_prints[2]["end"]
         assert layer_prints[3]["start"] == contour_start
-        assert layer_prints[-1]["end"] == contour_start
+        last_contour_start = layer_prints[-1]["end"]
 
         last_print_index = max(
             idx for idx, move in enumerate(layer_moves) if move["color"] == 255
         )
         assert layer_moves[last_print_index + 1] == {
-            "start": contour_start,
+            "start": last_contour_start,
             "end": (0.0, 0.0, layer_z),
             "color": 0,
         }
 
 
+def test_contour_tracing_keeps_hollow_rings_separate() -> None:
+    output = [{"X": 0.0, "Y": 0.0, "Color": 255}]
+    contour_layers = [
+        [
+            {
+                "owner_idx": 1,
+                "contours": [
+                    [(0.0, 0.0), (4.0, 0.0), (4.0, 4.0), (0.0, 4.0), (0.0, 0.0)],
+                    [(1.0, 1.0), (2.0, 1.0), (2.0, 2.0), (1.0, 2.0), (1.0, 1.0)],
+                ],
+            }
+        ]
+    ]
+
+    current_x, current_y = _append_layer_contours(
+        output,
+        0.0,
+        0.0,
+        contour_layers,
+        layer_number=0,
+        active_owner_idx=1,
+    )
+
+    contour_print_moves = [move for move in output[1:] if move["Color"] == 255]
+
+    assert len(contour_print_moves) == 8
+    assert (current_x, current_y) == (1.0, 1.0)
+
+
 def test_contour_tracing_follows_default_raster_layer_flip(tmp_path) -> None:
     tiff_paths = []
     motion_img = np.zeros((7, 8), dtype=np.uint8)
@@ -432,10 +534,55 @@ def test_gcode_header_writes_presets_before_initial_aux_commands(tmp_path) -> No
     ]
 
     assert lines[0] == "G91"
-    assert lines[1].startswith("{preset}serialPort3.write(")
+    assert lines[1] == "{aux_command}WAGO_ValveCommands(7, 0)"
     assert lines[2].startswith("{preset}serialPort3.write(")
-    assert lines[3].startswith("{aux_command}WAGO_ValveCommands(")
+    assert lines[3].startswith("{preset}serialPort3.write(")
     assert lines[4].startswith("{aux_command}WAGO_ValveCommands(")
+    assert lines[5].startswith("{aux_command}WAGO_ValveCommands(")
+
+
+def test_gcode_lead_in_runs_once_before_first_layer(tmp_path) -> None:
+    tiff_paths = []
+    for index in range(2):
+        tiff_path = tmp_path / f"slice_{index:04d}.tif"
+        Image.new("L", (1, 1), 0).save(tiff_path)
+        tiff_paths.append(tiff_path)
+
+    zip_path = tmp_path / "slices.zip"
+    with zipfile.ZipFile(zip_path, mode="w") as archive:
+        for tiff_path in tiff_paths:
+            archive.write(tiff_path, arcname=tiff_path.name)
+
+    gcode_path = generate_snake_path_gcode(
+        zip_path,
+        shape_name="lead_in",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=0.5,
+        layer_height=1.0,
+        lead_in_enabled=True,
+        lead_in_length=3.0,
+        lead_in_clearance=4.0,
+        lead_in_lines=3,
+    )
+
+    moves = _moves_with_colors(gcode_path.read_text())
+
+    assert moves[:7] == [
+        {"start": (0.0, 0.0, 0.0), "end": (-7.0, 0.0, 0.0), "color": 0},
+        {"start": (-7.0, 0.0, 0.0), "end": (-4.0, 0.0, 0.0), "color": 255},
+        {"start": (-4.0, 0.0, 0.0), "end": (-4.0, 0.5, 0.0), "color": 0},
+        {"start": (-4.0, 0.5, 0.0), "end": (-7.0, 0.5, 0.0), "color": 255},
+        {"start": (-7.0, 0.5, 0.0), "end": (-7.0, 1.0, 0.0), "color": 0},
+        {"start": (-7.0, 1.0, 0.0), "end": (-4.0, 1.0, 0.0), "color": 255},
+        {"start": (-4.0, 1.0, 0.0), "end": (0.0, 0.0, 0.0), "color": 0},
+    ]
+    assert all(move["end"][2] == 0.0 for move in moves[:7])
+
+    first_z_index = next(index for index, move in enumerate(moves) if move["end"][2] > 0.0)
+    assert first_z_index > 7
+    assert not any(move["start"][0] < -3.0 or move["end"][0] < -3.0 for move in moves[first_z_index:])
 
 
 def test_gcode_uses_g1_for_print_and_g0_for_travel(tmp_path) -> None:

tiff_to_gcode.py

@@ -20,6 +20,12 @@ RASTER_PATTERN_CHOICES = (
     RASTER_PATTERN_Y_DIRECTION,
     RASTER_PATTERN_WOODPILE,
 )
+CONTOUR_MODE_EXACT = "Exact pixel border"
+CONTOUR_MODE_ROW_ENVELOPE = "Shape-optimized row envelope"
+CONTOUR_MODE_CHOICES = (
+    CONTOUR_MODE_EXACT,
+    CONTOUR_MODE_ROW_ENVELOPE,
+)
 
 def _normalize_raster_pattern(pattern: str | None) -> str:
     if pattern == RASTER_PATTERN_WOODPILE:
@@ -29,6 +35,12 @@ def _normalize_raster_pattern(pattern: str | None) -> str:
     return RASTER_PATTERN_SAME_DIRECTION
 
 
+def _normalize_contour_mode(mode: str | None) -> str:
+    if mode == CONTOUR_MODE_ROW_ENVELOPE:
+        return CONTOUR_MODE_ROW_ENVELOPE
+    return CONTOUR_MODE_EXACT
+
+
 def _setpress(pressure: float) -> str:
     pressure_str = str(int(pressure * 10)).zfill(4)
     command_bytes = bytes("08PS  " + pressure_str, "utf-8")
@@ -160,6 +172,47 @@ def _sort_key(filename: str) -> int:
     return int(digits) if digits else 2**31
 
 
+def _lead_in_moves(
+    enabled: bool,
+    length: float,
+    clearance: float,
+    line_count: int,
+    line_spacing: float,
+    print_color: int,
+    off_color: int,
+) -> list[dict]:
+    if not enabled:
+        return []
+    lead_length = max(0.0, float(length))
+    if lead_length <= 0.0:
+        return []
+    lead_clearance = max(0.0, float(clearance))
+    pass_count = max(1, int(line_count))
+    spacing = max(0.0, float(line_spacing))
+
+    moves: list[dict] = []
+    current_x = 0.0
+    current_y = 0.0
+
+    def append_move(dx: float, dy: float, color: int) -> None:
+        nonlocal current_x, current_y
+        if dx == 0.0 and dy == 0.0:
+            return
+        moves.append({"X": dx, "Y": dy, "Color": color})
+        current_x += dx
+        current_y += dy
+
+    append_move(-(lead_clearance + lead_length), 0.0, off_color)
+    direction = 1.0
+    for pass_index in range(pass_count):
+        append_move(direction * lead_length, 0.0, print_color)
+        direction *= -1.0
+        if pass_index < pass_count - 1:
+            append_move(0.0, spacing, off_color)
+    append_move(-current_x, -current_y, off_color)
+    return moves
+
+
 def _extract_zip_tiffs(zip_path: Path, dest: Path) -> list[Path]:
     with zipfile.ZipFile(zip_path) as archive:
         archive.extractall(dest)
@@ -306,6 +359,51 @@ def _trace_mask_contours(
     return contours
 
 
+def _trace_row_envelope_contours(
+    mask: np.ndarray,
+    pixel_size: float,
+    x_offset_px: float = 0.0,
+    y_offset_px: float = 0.0,
+) -> list[list[tuple[float, float]]]:
+    """Trace one outside contour using each active row's left/right extent."""
+    if not np.any(mask):
+        return []
+
+    mask = mask.astype(bool)
+    first = np.where(mask.any(axis=1), mask.argmax(axis=1), -1)
+    last = np.where(
+        mask.any(axis=1),
+        mask.shape[1] - 1 - np.fliplr(mask).argmax(axis=1),
+        -1,
+    )
+    rows = np.where(first != -1)[0]
+    if len(rows) == 0:
+        return []
+
+    points: list[tuple[float, float]] = []
+
+    for row in rows:
+        points.append((float(first[row] - 1), float(row)))
+
+    bottom = int(rows[-1])
+    for col in range(int(first[bottom]) - 1, int(last[bottom]) + 1):
+        points.append((float(col), float(bottom) + 0.5))
+
+    for row in rows[::-1]:
+        points.append((float(last[row]), float(row)))
+
+    top = int(rows[0])
+    for col in range(int(last[top]), int(first[top]) - 2, -1):
+        points.append((float(col), float(top) - 0.5))
+
+    return [
+        [
+            ((x + x_offset_px) * pixel_size, (y + y_offset_px) * pixel_size)
+            for x, y in points
+        ]
+    ]
+
+
 def _append_relative_move(
     output_list: list[dict],
     current_x: float,
@@ -522,6 +620,7 @@ def _contour_pixel_offsets(
     raster_pattern: str,
     motion_mask: np.ndarray,
     contour_mask: np.ndarray,
+    contour_mode: str = CONTOUR_MODE_EXACT,
 ) -> tuple[float, float]:
     if raster_pattern == RASTER_PATTERN_SAME_DIRECTION:
         first_row_start = _first_raster_row_start(motion_mask)
@@ -534,8 +633,14 @@ def _contour_pixel_offsets(
         # rastered row's starting pixel. Wider lower rows can extend left of
         # that point, so using the layer-wide min column shifts pyramid-like
         # contours away from the infill.
-        return 1.0 - first_col, -0.5 - first_row
-    return 0.0, 0.0
+        x_offset, y_offset = 1.0 - first_col, -0.5 - first_row
+    else:
+        x_offset, y_offset = 0.0, 0.0
+
+    if contour_mode == CONTOUR_MODE_ROW_ENVELOPE:
+        x_offset += 1.0
+        y_offset += 0.5
+    return x_offset, y_offset
 
 
 def _build_contour_layers(
@@ -559,6 +664,9 @@ def _build_contour_layers(
         except (TypeError, ValueError):
             owner_idx = source_pos + 1
 
+        contour_mode = _normalize_contour_mode(
+            source.get("contour_mode") or source.get("mode")
+        )
         source_paths = _contour_source_paths(source, extract_root, source_pos)
         for layer_number, path_img in enumerate(path_ref_list):
             if layer_number >= len(source_paths):
@@ -590,16 +698,29 @@ def _build_contour_layers(
                 raster_pattern,
                 contour_path_img > off_color,
                 contour_mask,
+                contour_mode,
             )
-            contours = _trace_mask_contours(
-                contour_mask,
-                pixel_size,
-                x_offset_px=x_offset_px,
-                y_offset_px=y_offset_px,
-            )
+            if contour_mode == CONTOUR_MODE_ROW_ENVELOPE:
+                contours = _trace_row_envelope_contours(
+                    contour_mask,
+                    pixel_size,
+                    x_offset_px=x_offset_px,
+                    y_offset_px=y_offset_px,
+                )
+            else:
+                contours = _trace_mask_contours(
+                    contour_mask,
+                    pixel_size,
+                    x_offset_px=x_offset_px,
+                    y_offset_px=y_offset_px,
+                )
             if contours:
                 contour_layers[layer_number].append(
-                    {"owner_idx": owner_idx, "contours": contours}
+                    {
+                        "owner_idx": owner_idx,
+                        "contour_mode": contour_mode,
+                        "contours": contours,
+                    }
                 )
 
     return contour_layers
@@ -649,8 +770,6 @@ def _append_layer_contours(
         current_y,
     )
 
-    first_start_x: float | None = None
-    first_start_y: float | None = None
     use_infill_reference = True
 
     for source in active_sources:
@@ -679,8 +798,6 @@ def _append_layer_contours(
             if contour[0] != contour[-1]:
                 contour = [*contour, contour[0]]
             start_x, start_y = contour[0]
-            if first_start_x is None:
-                first_start_x, first_start_y = start_x, start_y
             use_infill_reference = False
             current_x, current_y = _append_relative_move(
                 output_list,
@@ -700,19 +817,6 @@ def _append_layer_contours(
                     color,
                 )
 
-    if first_start_x is not None and (
-        abs(current_x - first_start_x) > 1e-9
-        or abs(current_y - (first_start_y or 0.0)) > 1e-9
-    ):
-        current_x, current_y = _append_relative_move(
-            output_list,
-            current_x,
-            current_y,
-            first_start_x,
-            first_start_y,
-            255,
-        )
-
     return current_x, current_y
 
 
@@ -951,6 +1055,10 @@ def generate_snake_path_gcode(
     raster_pattern: str | None = RASTER_PATTERN_SAME_DIRECTION,
     contour_tiff_sets: list[dict] | None = None,
     active_contour_owner: int | None = None,
+    lead_in_enabled: bool = False,
+    lead_in_length: float = 5.0,
+    lead_in_clearance: float = 5.0,
+    lead_in_lines: int = 3,
 ) -> Path:
     zip_path = Path(zip_path)
     if not zip_path.exists():
@@ -1146,11 +1254,24 @@ def generate_snake_path_gcode(
                 off_color,
             )
 
+    lead_in = _lead_in_moves(
+        lead_in_enabled,
+        lead_in_length,
+        lead_in_clearance,
+        lead_in_lines,
+        fil_width,
+        255,
+        off_color,
+    )
+    if lead_in:
+        gcode_list = [*lead_in, *gcode_list]
+
     gcode_path = work_dir / f"{shape_name}_SnakePath_gcode.txt"
     pressure_cur = float(pressure)
 
     with open(gcode_path, "w") as f:
         f.write("G91\n")
+        f.write(_valve_cmd(valve, 0))
         for line in setpress_lines:
             f.write(f"{line}\n")
         for line in pressure_on_lines: