Add multi-nozzle shape splitting workflow

README.md

@@ -48,8 +48,9 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 - Encodes material as black (`0`) and empty space as white (`255`) in each TIFF slice
 - Lets you step through the slice stack in the browser
 - Exports a ZIP containing the generated TIFF images
-- Combines generated stacks into a reference TIFF stack
-- Converts generated TIFF ZIPs into G-code files with pressure, valve, and port settings per shape from the Shape Settings table
+- 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
 - 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
@@ -61,7 +62,7 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 
 ### Reference TIFF Stack Alignment
 
-When you click **Generate Reference TIFF Stack**, the app combines available TIFF stacks layer-by-layer.
+When you click **Generate TIFF Stacks**, the app automatically combines available TIFF stacks layer-by-layer into the Reference TIFF Stack. The **Generate Reference TIFF Stack** button can still rebuild it manually from the current shape stacks.
 
 - If source TIFFs have different dimensions, each layer is placed on a canvas using the largest width and height.
 - Layers are centered in X and Y before merging.
@@ -69,6 +70,14 @@ When you click **Generate Reference TIFF Stack**, the app combines available TIF
 - Alignment is centered image placement, not bottom-left anchoring.
 - If image-size differences are odd, centering may produce a one-pixel shift due to integer rounding.
 
+### Single Shape Multi-Nozzle
+
+The **Single Shape Multi-Nozzle** 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.
+- 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.
+
 ### G-code XY Step Size
 
 - G-code generation uses the slicer's `Pixel Size/Fill Width` for XY step distance by passing `fil_width=pixel_size` into `generate_snake_path_gcode()`.
@@ -78,10 +87,10 @@ When you click **Generate Reference TIFF Stack**, the app combines available TIF
 - Generated G-code starts in relative coordinate mode (`G91`).
 - `G0` is travel and `G1` is print/feed.
 - The app generates print/feed moves from material pixels and travel moves between material regions.
-- Generated files include pressure preset commands and WAGO valve commands based on the selected pressure, valve, and port.
+- Generated files include pressure preset commands and WAGO valve commands based on the selected pressure, valve, and port; the nozzle number controls layout/spacing assignment.
 - Pressure increases by `0.1` psi per layer by default.
 - **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. Requires generating the Reference TIFF Stack on the first tab first; shapes are skipped with a message if it is missing.
+- **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.
 
 ### Print vs Travel Classification
@@ -102,7 +111,7 @@ The G-code visualization tab renders generated shape G-code or an uploaded `.txt
 
 ### Parallel Printing Visualization
 
-The fourth tab plots the generated shapes' G-code at once using the nozzle spacing configured on the TIFF-to-G-code tab, each in its own color. Like the visualization tab it has a fast **Line Plot** and an animated **Tube Plot**; the animation advances all parts on a shared cumulative-path-length timeline, so a shorter part finishes first.
+The fourth tab plots the generated shapes' G-code at once using the nozzle spacing configured on the TIFF-to-G-code tab, each in its own color. Shape Settings maps each STL to a nozzle number, so multiple shapes can share one nozzle offset while valves remain independent. Like the visualization tab it has a fast **Line Plot** and an animated **Tube Plot**; the animation advances all parts on a shared cumulative-path-length timeline, so a shorter part finishes first.
 
 It can also **export the animation as a GIF**, rendered server-side with Matplotlib (the `Agg` CPU backend — no WebGL, no headless browser, and no `ffmpeg`, so it works locally and on Hugging Face). The GIF is line-style with faint grey travel and white, black-outlined nozzle markers drawn on top; controls cover duration, frames per second, elevation/azimuth viewing angle, and travel opacity (0 hides travel).
 

app.py

@@ -4,6 +4,7 @@ import tempfile
 import math
 import time
 import warnings
+import zipfile
 from pathlib import Path
 from typing import Any
 
@@ -134,7 +135,7 @@ APP_CSS = """
 }
 
 #shape-settings-table table tbody tr td:last-child,
-#shape-settings-table [role="gridcell"]:nth-child(10n) {
+#shape-settings-table [role="gridcell"]:nth-child(12n) {
     color: #ffffff !important;
     cursor: pointer;
     font-size: 0 !important;
@@ -143,7 +144,7 @@ APP_CSS = """
 }
 
 #shape-settings-table table tbody tr td:last-child::after,
-#shape-settings-table [role="gridcell"]:nth-child(10n)::after {
+#shape-settings-table [role="gridcell"]:nth-child(12n)::after {
     content: "X";
     display: inline-flex;
     align-items: center;
@@ -159,9 +160,9 @@ APP_CSS = """
 }
 
 #shape-settings-table table tbody tr td:last-child input,
-#shape-settings-table [role="gridcell"]:nth-child(10n) input,
+#shape-settings-table [role="gridcell"]:nth-child(12n) input,
 #shape-settings-table table tbody tr td:last-child textarea,
-#shape-settings-table [role="gridcell"]:nth-child(10n) textarea {
+#shape-settings-table [role="gridcell"]:nth-child(12n) textarea {
     display: none !important;
 }
 
@@ -295,7 +296,7 @@ APP_HEAD = """
         });
     }
     function suppressDeleteCellEditor(event) {
-        var cell = event.target && event.target.closest ? event.target.closest('#shape-settings-table td:last-child, #shape-settings-table [role="gridcell"]:nth-child(10n)') : null;
+        var cell = event.target && event.target.closest ? event.target.closest('#shape-settings-table td:last-child, #shape-settings-table [role="gridcell"]:nth-child(12n)') : null;
         if (!cell) return;
         setTimeout(function () {
             if (document.activeElement && cell.contains(document.activeElement)) {
@@ -1377,8 +1378,23 @@ def _resolve_nozzle_layout(
     if not parts:
         return offsets, spacings
 
-    ordered = sorted(parts, key=lambda part: part["idx"])
-    offsets[ordered[0]["idx"]] = (0.0, 0.0)
+    grouped: dict[int, list[dict]] = {}
+    for part in parts:
+        grouped.setdefault(_record_nozzle_number(part, int(part.get("idx", 1) or 1)), []).append(part)
+    ordered_nozzles = sorted(grouped)
+    offsets[ordered_nozzles[0]] = (0.0, 0.0)
+
+    def nozzle_bounds(nozzle: int) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
+        mins: list[tuple[float, float, float]] = []
+        maxs: list[tuple[float, float, float]] = []
+        for part in grouped[nozzle]:
+            part_min, part_max = part["parsed"]["bounds"]
+            mins.append(part_min)
+            maxs.append(part_max)
+        return (
+            tuple(min(values) for values in zip(*mins)),
+            tuple(max(values) for values in zip(*maxs)),
+        )
 
     first_spacing = (float(part_gap_12_x or 0.0), float(part_gap_12_y or 0.0))
     raw_pairs: list[tuple[float, float]] = [
@@ -1390,37 +1406,41 @@ def _resolve_nozzle_layout(
             float(extra_pair_gaps[index] or 0.0),
             float(extra_pair_gaps[index + 1] or 0.0) if index + 1 < len(extra_pair_gaps) else 0.0,
         ))
-    max_pair_count = max((int(part.get("idx", 0)) for part in parts), default=1) - 1
+    max_pair_count = max(0, len(ordered_nozzles) - 1)
     while len(raw_pairs) < max_pair_count:
         raw_pairs.append(first_spacing)
     if same_spacing:
         raw_pairs = [first_spacing for _ in raw_pairs]
 
     pair_spacing = {
-        (index + 1, index + 2): raw_pairs[index]
-        for index in range(len(raw_pairs))
+        (ordered_nozzles[index], ordered_nozzles[index + 1]): raw_pairs[index]
+        for index in range(min(len(raw_pairs), max_pair_count))
     }
 
     def spacing_between(prev_idx: int, cur_idx: int) -> tuple[float, float]:
         if (prev_idx, cur_idx) in pair_spacing:
             return pair_spacing[(prev_idx, cur_idx)]
-        if cur_idx <= prev_idx:
+        try:
+            start_pos = ordered_nozzles.index(prev_idx)
+            end_pos = ordered_nozzles.index(cur_idx)
+        except ValueError:
+            return 0.0, 0.0
+        if end_pos <= start_pos:
             return 0.0, 0.0
         total_x = 0.0
         total_y = 0.0
-        for pair_idx in range(prev_idx, cur_idx):
-            step_x, step_y = pair_spacing.get((pair_idx, pair_idx + 1), first_spacing)
+        for pair_pos in range(start_pos, end_pos):
+            pair = (ordered_nozzles[pair_pos], ordered_nozzles[pair_pos + 1])
+            step_x, step_y = pair_spacing.get(pair, first_spacing)
             total_x += step_x
             total_y += step_y
         return total_x, total_y
 
-    for previous, current in zip(ordered, ordered[1:]):
-        prev_idx = previous["idx"]
-        cur_idx = current["idx"]
+    for prev_idx, cur_idx in zip(ordered_nozzles, ordered_nozzles[1:]):
         gap_x, y_step = spacing_between(prev_idx, cur_idx)
         prev_offset_x, prev_offset_y = offsets[prev_idx]
-        (_, _, _), (prev_xmax, _prev_ymax, _) = previous["parsed"]["bounds"]
-        (cur_xmin, _cur_ymin, _), (_, _, _) = current["parsed"]["bounds"]
+        (_, _, _), (prev_xmax, _prev_ymax, _) = nozzle_bounds(prev_idx)
+        (cur_xmin, _cur_ymin, _), (_, _, _) = nozzle_bounds(cur_idx)
         dx = (prev_xmax + prev_offset_x + gap_x) - cur_xmin
         dy = prev_offset_y + y_step
         offsets[cur_idx] = (dx, dy)
@@ -1442,8 +1462,9 @@ def _format_shape_dimensions(parts: list[dict]) -> list[str]:
     lines = ["**Shape dimensions from generated G-code:**"]
     for part in sorted(parts, key=lambda item: item["idx"]):
         (xmin, ymin, zmin), (xmax, ymax, zmax) = part["parsed"]["bounds"]
+        nozzle = _record_nozzle_number(part, int(part.get("idx", 1) or 1))
         lines.append(
-            f"Shape {part['idx']}: X {xmax - xmin:.2f} mm, "
+            f"Shape {part['idx']} (Nozzle {nozzle}): X {xmax - xmin:.2f} mm, "
             f"Y {ymax - ymin:.2f} mm, Z {zmax - zmin:.2f} mm."
         )
     return lines
@@ -1463,7 +1484,7 @@ def _format_nozzle_spacing_status(
             lines.append(f"Nozzle {idx}: X {x:.2f} mm, Y {y:.2f} mm.")
 
     if not spacings:
-        lines.append("Generate G-code for at least two shapes to calculate nozzle spacing.")
+        lines.append("Generate G-code for at least two nozzles to calculate nozzle spacing.")
         return "  \n".join(lines)
 
     lines.append("**Nozzle-to-nozzle distances:**")
@@ -1614,7 +1635,142 @@ def generate_reference_stack(
     return ref_state, slider, label, preview
 
 
-SHAPE_SETTINGS_HEADERS = ["Shape", "STL", "Target X (mm)", "Target Y (mm)", "Target Z (mm)", "Pressure (psi)", "Valve", "Port", "Color", "Delete"]
+def _zip_tiff_paths(tiff_paths: list[Path], zip_path: Path) -> None:
+    with zipfile.ZipFile(zip_path, mode="w", compression=zipfile.ZIP_DEFLATED) as archive:
+        for tiff_path in tiff_paths:
+            archive.write(tiff_path, arcname=tiff_path.name)
+
+
+def _partition_length(length: int, count: int) -> list[tuple[int, int]]:
+    base = length // count
+    remainder = length % count
+    spans: list[tuple[int, int]] = []
+    start = 0
+    for index in range(count):
+        size = base + (1 if index < remainder else 0)
+        end = start + size
+        spans.append((start, end))
+        start = end
+    return spans
+
+
+def split_tiff_stack_grid(
+    state: ViewerState,
+    base_name: str = "split_shape",
+    columns: float = 2,
+    rows: float = 1,
+    progress: gr.Progress = gr.Progress(),
+) -> list[dict[str, Any]]:
+    tiff_paths = [Path(path) for path in state.get("tiff_paths", [])]
+    if not tiff_paths:
+        raise ValueError("Generate a TIFF stack for the selected shape before splitting it.")
+
+    with Image.open(tiff_paths[0]) as first_image:
+        width, height = first_image.size
+    column_count = max(1, _coerce_int(columns, 2))
+    row_count = max(1, _coerce_int(rows, 1))
+    if column_count > width:
+        raise ValueError(f"Cannot split {width}-pixel-wide TIFF slices into {column_count} columns.")
+    if row_count > height:
+        raise ValueError(f"Cannot split {height}-pixel-tall TIFF slices into {row_count} rows.")
+
+    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)
+    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):
+            piece_dir = output_dir / f"r{row_index:02d}_c{col_index:02d}_tiff_slices"
+            piece_dir.mkdir(parents=True, exist_ok=True)
+            pieces.append({
+                "row": row_index,
+                "col": col_index,
+                "x_start": x_start,
+                "x_end": x_end,
+                "y_start": y_start,
+                "y_end": y_end,
+                "tiff_dir": piece_dir,
+                "tiff_paths": [],
+            })
+
+    for index, source_path in enumerate(tiff_paths):
+        progress(index / max(len(tiff_paths), 1), desc=f"Splitting layer {index + 1}/{len(tiff_paths)}")
+        with Image.open(source_path) as image:
+            layer = image.convert("L")
+            if layer.size != (width, height):
+                raise ValueError("All TIFF slices must have the same dimensions to split the stack.")
+
+            for piece in pieces:
+                piece_image = layer.crop((piece["x_start"], piece["y_start"], piece["x_end"], piece["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:
+        piece_width = piece["x_end"] - piece["x_start"]
+        piece_height = piece["y_end"] - piece["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 + (piece["x_start"] * pixel_size),
+            "y_min": base_y_min + ((height - piece["y_end"]) * pixel_size),
+            "image_width": piece_width,
+            "image_height": piece_height,
+            "zip_path": str(zip_path),
+        }
+        piece["state"] = piece_state
+        piece["zip_path"] = zip_path
+    return pieces
+
+
+def split_tiff_stack_left_right(
+    state: ViewerState,
+    base_name: str = "split_shape",
+    progress: gr.Progress = gr.Progress(),
+) -> tuple[ViewerState, ViewerState, Path, Path]:
+    pieces = split_tiff_stack_grid(state, base_name=base_name, columns=2, rows=1, progress=progress)
+    return pieces[0]["state"], pieces[1]["state"], pieces[0]["zip_path"], pieces[1]["zip_path"]
+
+
+SHAPE_SETTINGS_HEADERS = [
+    "Shape",
+    "STL",
+    "Target X (mm)",
+    "Target Y (mm)",
+    "Target Z (mm)",
+    "Pressure (psi)",
+    "Valve",
+    "Nozzle",
+    "Port",
+    "Color",
+    "Contour Tracing",
+    "Delete",
+]
+SHAPE_SETTINGS_DATATYPES = [
+    "number",
+    "str",
+    "number",
+    "number",
+    "number",
+    "number",
+    "number",
+    "number",
+    "number",
+    "str",
+    "bool",
+    "str",
+]
 SIMPLE_NOZZLE_SPACING_HEADERS = [
     "Spacing Mode",
     "Applies To",
@@ -1622,8 +1778,8 @@ SIMPLE_NOZZLE_SPACING_HEADERS = [
     "Y nozzle spacing (mm)",
 ]
 ADVANCED_NOZZLE_SPACING_HEADERS = [
-    "From Shape",
-    "To Shape",
+    "From Nozzle",
+    "To Nozzle",
     "X edge spacing (mm)",
     "Y nozzle spacing (mm)",
 ]
@@ -1640,6 +1796,39 @@ def _normalise_rows(table: Any) -> list[list[Any]]:
     return list(table or [])
 
 
+def _coerce_bool(value: Any, default: bool = False) -> bool:
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return default
+    if isinstance(value, (int, float)):
+        return bool(value)
+    text = str(value).strip().lower()
+    if not text:
+        return default
+    if text in {"1", "true", "yes", "y", "on", "checked"}:
+        return True
+    if text in {"0", "false", "no", "n", "off", "unchecked"}:
+        return False
+    return default
+
+
+def _coerce_int(value: Any, default: int) -> int:
+    try:
+        return int(float(value))
+    except (TypeError, ValueError):
+        try:
+            return int(float(default))
+        except (TypeError, ValueError):
+            return 0
+
+
+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)
+    return nozzle if nozzle > 0 else default
+
+
 def _file_path_value(file_value: Any) -> str | None:
     if not file_value:
         return None
@@ -1710,8 +1899,10 @@ def _records_from_files(files: Any, previous_records: list[dict] | None = None)
             "last_scaled_axis": previous.get("last_scaled_axis", "target_x"),
             "pressure": previous.get("pressure", 25.0),
             "valve": previous.get("valve", 4),
+            "nozzle": previous.get("nozzle", index),
             "port": previous.get("port", 1),
             "color": previous.get("color", _default_color(index)),
+            "contour_tracing": previous.get("contour_tracing", False),
             "tiff_state": previous.get("tiff_state", _empty_state()),
             "zip_path": previous.get("zip_path"),
             "gcode_path": previous.get("gcode_path"),
@@ -1738,8 +1929,10 @@ def _shape_settings_rows(records: list[dict]) -> list[list[Any]]:
             record.get("target_z", DEFAULT_TARGET_EXTENTS[2]),
             record.get("pressure", 25.0),
             record.get("valve", 4),
+            _record_nozzle_number(record, int(record["idx"])),
             record.get("port", 1),
             record.get("color", _default_color(record["idx"])),
+            bool(record.get("contour_tracing", False)),
             "Delete",
         ]
         for record in records
@@ -1773,20 +1966,33 @@ def _apply_shape_settings(records: list[dict], settings_table: Any) -> list[dict
                 ("target_z", 4, DEFAULT_TARGET_EXTENTS[2]),
                 ("pressure", 5, 25.0),
                 ("valve", 6, 4),
-                ("port", 7, 1),
             ):
                 try:
                     copy[key] = float(row[pos])
                 except (IndexError, TypeError, ValueError):
                     copy[key] = copy.get(key, default)
+            has_nozzle_column = len(row) >= len(SHAPE_SETTINGS_HEADERS)
+            nozzle_pos = 7 if has_nozzle_column else None
+            port_pos = 8 if has_nozzle_column else 7
+            color_pos = 9 if has_nozzle_column else 8
+            contour_pos = 10 if has_nozzle_column else 9
+            copy["valve"] = _coerce_int(copy.get("valve", 4), 4)
+            copy["nozzle"] = _coerce_int(
+                row[nozzle_pos] if nozzle_pos is not None else copy.get("nozzle", copy.get("idx", 1)),
+                _record_nozzle_number(copy),
+            )
+            copy["port"] = _coerce_int(
+                row[port_pos] if len(row) > port_pos else copy.get("port", 1),
+                _coerce_int(copy.get("port", 1), 1),
+            )
+            if copy["nozzle"] <= 0:
+                copy["nozzle"] = _record_nozzle_number(copy)
+            if len(row) > color_pos and row[color_pos]:
+                copy["color"] = str(row[color_pos])
             try:
-                copy["valve"] = int(float(copy["valve"]))
-                copy["port"] = int(float(copy["port"]))
-            except (TypeError, ValueError):
-                copy["valve"] = 4
-                copy["port"] = 1
-            if len(row) > 8 and row[8]:
-                copy["color"] = str(row[8])
+                copy["contour_tracing"] = _coerce_bool(row[contour_pos], bool(copy.get("contour_tracing", False)))
+            except IndexError:
+                copy["contour_tracing"] = bool(copy.get("contour_tracing", False))
         updated.append(copy)
     return updated
 
@@ -1823,8 +2029,23 @@ def _last_edited_target_axes(records: list[dict] | None, settings_table: Any) ->
     return edited_axes
 
 
-def _shape_spacing_label(record: dict) -> str:
-    return f"Shape {record.get('idx', '?')}: {record.get('name') or 'Unnamed'}"
+def _nozzle_spacing_label(nozzle: int, records: list[dict]) -> str:
+    shapes = [
+        f"Shape {record.get('idx', '?')}"
+        for record in records
+        if _record_nozzle_number(record, int(record.get("idx", 1) or 1)) == nozzle
+    ]
+    if shapes:
+        return f"Nozzle {nozzle}: {', '.join(shapes)}"
+    return f"Nozzle {nozzle}"
+
+
+def _ordered_nozzle_numbers(records: list[dict]) -> list[int]:
+    nozzles = {
+        _record_nozzle_number(record, int(record.get("idx", position) or position))
+        for position, record in enumerate(records, start=1)
+    }
+    return sorted(nozzles)
 
 
 def _spacing_pairs_from_table(spacing_table: Any) -> list[tuple[float, float]]:
@@ -1849,18 +2070,19 @@ def _spacing_table_update(records: list[dict], existing_table: Any | None = None
     if not use_individual_spacing:
         return gr.update(
             headers=SIMPLE_NOZZLE_SPACING_HEADERS,
-            value=[["Same spacing", "All neighboring shapes", first_pair[0], first_pair[1]]],
+            value=[["Same spacing", "All neighboring nozzles", first_pair[0], first_pair[1]]],
             row_count=(1, "fixed"),
             column_count=(len(SIMPLE_NOZZLE_SPACING_HEADERS), "fixed"),
             label="Nozzle Spacing",
         )
 
     rows: list[list[Any]] = []
-    for index, (first, second) in enumerate(zip(records, records[1:])):
+    ordered_nozzles = _ordered_nozzle_numbers(records)
+    for index, (first, second) in enumerate(zip(ordered_nozzles, ordered_nozzles[1:])):
         gap_x, gap_y = pairs[index] if index < len(pairs) else first_pair
         rows.append([
-            _shape_spacing_label(first),
-            _shape_spacing_label(second),
+            _nozzle_spacing_label(first, records),
+            _nozzle_spacing_label(second, records),
             gap_x,
             gap_y,
         ])
@@ -2085,6 +2307,21 @@ def normalize_shape_dimensions_for_mode(
     return normalized, _shape_settings_rows(normalized)
 
 
+def normalize_shape_settings_and_spacing(
+    records: list[dict] | None,
+    settings_table: Any | None,
+    scale_mode: str | None,
+    existing_spacing: Any | None,
+    use_individual_spacing: bool | None,
+) -> tuple:
+    updated_records, updated_settings = normalize_shape_dimensions_for_mode(records, settings_table, scale_mode)
+    return (
+        updated_records,
+        updated_settings,
+        _spacing_table_update(updated_records, existing_spacing, use_individual_spacing),
+    )
+
+
 def show_selected_model(
     records: list[dict] | None,
     selected: str | None,
@@ -2148,7 +2385,19 @@ def generate_dynamic_stacks(
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
     if not records:
-        return records, [], "Upload at least one STL first.", _dropdown_update(records), _reset_slider(), "No slice stack loaded yet.", None
+        return (
+            records,
+            [],
+            "Upload at least one STL first.",
+            _dropdown_update(records),
+            _reset_slider(),
+            "No slice stack loaded yet.",
+            None,
+            _empty_state(),
+            _reset_slider(),
+            "No reference stack generated yet.",
+            None,
+        )
     total = len(records)
     messages: list[str] = []
     for pos, record in enumerate(records):
@@ -2182,6 +2431,11 @@ def generate_dynamic_stacks(
             messages.append(f"Shape {record['idx']}: wrote `{stack.zip_path.name}`.")
         except Exception as exc:
             messages.append(f"Shape {record['idx']}: failed ({exc}).")
+    ref_state, ref_slider, ref_label, ref_preview = generate_dynamic_reference_stack(records, progress=progress)
+    if (ref_state or {}).get("tiff_paths"):
+        messages.append("Reference TIFF Stack: updated automatically.")
+    else:
+        messages.append("Reference TIFF Stack: skipped (no generated shape slices available).")
     first_state = records[0].get("tiff_state") or _empty_state()
     label, preview = _render_selected_slice(first_state, 0)
     slider = gr.update(
@@ -2199,6 +2453,10 @@ def generate_dynamic_stacks(
         slider,
         label,
         preview,
+        ref_state,
+        ref_slider,
+        ref_label,
+        ref_preview,
     )
 
 
@@ -2207,6 +2465,187 @@ def generate_dynamic_reference_stack(records: list[dict] | None, progress: gr.Pr
     return generate_reference_stack(*states, progress=progress)
 
 
+def _split_piece_choice(piece: dict[str, Any]) -> str:
+    return f"R{piece['row']} C{piece['col']}"
+
+
+def _split_piece_dropdown_update(pieces: list[dict[str, Any]], selected: str | None = None) -> dict[str, Any]:
+    choices = [_split_piece_choice(piece) for piece in pieces]
+    value = selected if selected in choices else (choices[0] if choices else None)
+    return gr.update(choices=choices, value=value)
+
+
+def _selected_split_piece(pieces: list[dict[str, Any]] | None, selected: str | None) -> dict[str, Any] | None:
+    if not pieces:
+        return None
+    for piece in pieces:
+        if _split_piece_choice(piece) == selected:
+            return piece
+    return pieces[0]
+
+
+def preview_selected_split_piece(pieces: list[dict[str, Any]] | None, selected: str | None) -> tuple:
+    piece = _selected_split_piece(pieces, selected)
+    if not piece:
+        return _reset_slider(), "No split stack generated yet.", None
+    state = piece.get("state") or _empty_state()
+    label, preview = _render_selected_slice(state, 0)
+    slider = gr.update(
+        minimum=0,
+        maximum=max(0, len(state.get("tiff_paths", [])) - 1),
+        value=0,
+        step=1,
+        interactive=len(state.get("tiff_paths", [])) > 1,
+    )
+    return slider, label, preview
+
+
+def jump_to_selected_split_piece(pieces: list[dict[str, Any]] | None, selected: str | None, index: float) -> tuple:
+    piece = _selected_split_piece(pieces, selected)
+    if not piece:
+        return "No split stack generated yet.", None
+    return _render_selected_slice(piece.get("state") or _empty_state(), int(index))
+
+
+def shift_selected_split_piece(pieces: list[dict[str, Any]] | None, selected: str | None, index: float, delta: int) -> tuple:
+    piece = _selected_split_piece(pieces, selected)
+    if not piece:
+        return gr.update(value=0), "No split stack generated yet.", None
+    state = piece.get("state") or _empty_state()
+    new_index, label, preview = shift_slice(state, index, delta)
+    return gr.update(value=new_index), label, preview
+
+
+def split_selected_shape_for_grid(
+    records: list[dict] | None,
+    selected: str | None,
+    settings_table: Any | None,
+    existing_spacing: Any | None,
+    use_individual_spacing: bool | None,
+    columns: float,
+    rows: float,
+    starting_nozzle: float,
+    starting_valve: float,
+    progress: gr.Progress = gr.Progress(),
+) -> tuple:
+    records = _apply_shape_settings(records or [], settings_table)
+    if not records:
+        empty = _empty_state()
+        return (
+            records,
+            _shape_settings_rows(records),
+            _spacing_table_update(records, existing_spacing, use_individual_spacing),
+            [],
+            [],
+            _gcode_dropdown_update(records),
+            _gcode_dropdown_update(records, include_upload=True),
+            _dropdown_update(records),
+            [],
+            [],
+            _split_piece_dropdown_update([]),
+            _reset_slider(),
+            "No split stack generated yet.",
+            None,
+            "Generate TIFF stacks for a shape before splitting it.",
+        )
+
+    pos = _selected_record_index(records, selected)
+    if pos < 0:
+        pos = 0
+    source = records[pos]
+    state = source.get("tiff_state") or _empty_state()
+    try:
+        pieces = split_tiff_stack_grid(
+            state,
+            base_name=str(source.get("name") or f"shape_{source.get('idx', pos + 1)}"),
+            columns=columns,
+            rows=rows,
+            progress=progress,
+        )
+    except Exception as exc:
+        empty = _empty_state()
+        return (
+            records,
+            _shape_settings_rows(records),
+            _spacing_table_update(records, existing_spacing, use_individual_spacing),
+            [record.get("zip_path") for record in records if record.get("zip_path")],
+            [record.get("gcode_path") for record in records if record.get("gcode_path")],
+            _gcode_dropdown_update(records),
+            _gcode_dropdown_update(records, include_upload=True),
+            _dropdown_update(records, selected),
+            [],
+            [],
+            _split_piece_dropdown_update([]),
+            _reset_slider(),
+            "No split stack generated yet.",
+            None,
+            f"Split failed: {exc}",
+        )
+
+    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_records: list[dict] = []
+    for index, piece in enumerate(pieces):
+        piece_state = piece["state"]
+        piece_width_mm = float(piece_state.get("image_width", 0) or 0) * float(piece_state.get("pixel_size", 0.0) or 0.0)
+        piece_height_mm = float(piece_state.get("image_height", 0) or 0) * float(piece_state.get("pixel_size", 0.0) or 0.0)
+        piece_record = dict(source)
+        piece_record.update({
+            "name": f"{base_name} - R{piece['row']}C{piece['col']}",
+            "stl_path": None,
+            "target_x": piece_width_mm or source.get("target_x", DEFAULT_TARGET_EXTENTS[0]),
+            "target_y": piece_height_mm or source.get("target_y", DEFAULT_TARGET_EXTENTS[1]),
+            "nozzle": first_nozzle + index,
+            "valve": first_valve + index,
+            "tiff_state": piece_state,
+            "zip_path": str(piece["zip_path"]),
+            "gcode_path": None,
+        })
+        split_records.append(piece_record)
+    next_records = _reindex_shape_records([*records[:pos], *split_records, *records[pos + 1:]])
+    slider, label, preview = preview_selected_split_piece(pieces, None)
+    status = (
+        f"Split Shape {source.get('idx', pos + 1)} into {len(pieces)} print-ready stacks "
+        f"({max(1, _coerce_int(columns, 2))} columns x {max(1, _coerce_int(rows, 1))} rows).  \n"
+        f"Nozzles {first_nozzle}-{first_nozzle + len(pieces) - 1}; valves {first_valve}-{first_valve + len(pieces) - 1}."
+    )
+    return (
+        next_records,
+        _shape_settings_rows(next_records),
+        _spacing_table_update(next_records, existing_spacing, use_individual_spacing),
+        [record.get("zip_path") for record in next_records if record.get("zip_path")],
+        [record.get("gcode_path") for record in next_records if record.get("gcode_path")],
+        _gcode_dropdown_update(next_records),
+        _gcode_dropdown_update(next_records, include_upload=True),
+        _dropdown_update(next_records),
+        [str(piece["zip_path"]) for piece in pieces],
+        pieces,
+        _split_piece_dropdown_update(pieces),
+        slider,
+        label,
+        preview,
+        status,
+    )
+
+
+def _contour_tracing_sources(records: list[dict]) -> list[dict]:
+    sources: list[dict] = []
+    for record in records:
+        if not record.get("contour_tracing"):
+            continue
+        state = record.get("tiff_state") or {}
+        tiff_paths = state.get("tiff_paths") or []
+        source = {
+            "owner_idx": int(record.get("idx", len(sources) + 1)),
+            "tiff_paths": list(tiff_paths),
+            "zip_path": record.get("zip_path"),
+        }
+        if source["tiff_paths"] or source["zip_path"]:
+            sources.append(source)
+    return sources
+
+
 def generate_dynamic_gcode(
     records: list[dict] | None,
     settings_table: Any,
@@ -2219,7 +2658,11 @@ def generate_dynamic_gcode(
 ) -> tuple:
     records = _apply_shape_settings(records or [], settings_table)
     motion_tiffs = (ref_state or {}).get("tiff_paths") if use_reference_motion else None
+    contour_sources = _contour_tracing_sources(records)
     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}.")
     for record in records:
         zip_path = record.get("zip_path")
         if not zip_path:
@@ -2241,6 +2684,8 @@ def generate_dynamic_gcode(
                 all_g1=bool(all_g1),
                 motion_tiffs=motion_tiffs,
                 raster_pattern=raster_pattern,
+                contour_tiff_sets=contour_sources,
+                active_contour_owner=int(record.get("idx", 0)),
             )
             record["gcode_path"] = str(gcode_path)
             messages.append(f"Shape {record['idx']}: wrote `{gcode_path.name}`.")
@@ -2285,8 +2730,9 @@ def _parts_from_records(records: list[dict] | None) -> tuple[list[dict], list[st
         if not parsed.get("point_count"):
             messages.append(f"Shape {idx}: no G0/G1 moves found.")
             continue
-        parts.append({"idx": idx, "color": record.get("color", _default_color(idx)), "parsed": parsed})
-        messages.append(f"Shape {idx}: {parsed['point_count']} moves, {parsed.get('layer_count', 0)} layer(s).")
+        nozzle = _record_nozzle_number(record, idx)
+        parts.append({"idx": idx, "nozzle": nozzle, "color": record.get("color", _default_color(idx)), "parsed": parsed})
+        messages.append(f"Shape {idx} (Nozzle {nozzle}): {parsed['point_count']} moves, {parsed.get('layer_count', 0)} layer(s).")
     return parts, messages
 
 
@@ -2480,6 +2926,7 @@ def build_dynamic_demo() -> gr.Blocks:
         shape_records = gr.State([])
         last_shape_delete_at = gr.State(0.0)
         ref_state = gr.State(_empty_state())
+        split_piece_states = gr.State([])
 
         with gr.Tab("STL to TIFF Slicer"):
             gr.Markdown(
@@ -2512,6 +2959,7 @@ def build_dynamic_demo() -> gr.Blocks:
                 value=[],
                 row_count=(0, "dynamic"),
                 column_count=(len(SHAPE_SETTINGS_HEADERS), "fixed"),
+                datatype=SHAPE_SETTINGS_DATATYPES,
                 interactive=True,
                 label="Shape Settings",
                 elem_id="shape-settings-table",
@@ -2562,15 +3010,44 @@ def build_dynamic_demo() -> gr.Blocks:
                         ref_next_button = gr.Button("Next", scale=1, min_width=90, size="sm")
                     ref_slice_slider = gr.Slider(label="Slice Index", minimum=0, maximum=0, value=0, step=1, interactive=False)
 
+        with gr.Tab("Single Shape Multi-Nozzle"):
+            gr.Markdown(
+                """
+                # Single Shape Multi-Nozzle
+                Split one generated TIFF stack into a row/column grid, then print each piece with a different nozzle.
+                """
+            )
+            with gr.Row():
+                split_source = gr.Dropdown(label="Source Shape", choices=[], value=None, allow_custom_value=False)
+                split_refresh_sources = gr.Button("Refresh Source Shapes", variant="secondary", size="sm")
+            with gr.Row():
+                split_columns = gr.Number(label="Columns (X)", value=2, minimum=1, step=1)
+                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_button = gr.Button("Split Selected Shape into Grid Pieces", variant="primary")
+            split_status = gr.Markdown("Generate a TIFF stack, then split it for multi-nozzle printing.")
+            split_downloads = gr.File(label="Download Split TIFF ZIPs", file_count="multiple", interactive=False)
+            with gr.Row():
+                with gr.Column(scale=1, min_width=260):
+                    split_piece_source = gr.Dropdown(label="Preview Generated Piece", choices=[], value=None, allow_custom_value=False)
+                    with gr.Row():
+                        split_piece_prev = gr.Button("Prev", scale=1, min_width=90, size="sm")
+                        split_piece_next = gr.Button("Next", scale=1, min_width=90, size="sm")
+                    split_piece_slider = gr.Slider(label="Piece Slice Index", minimum=0, maximum=0, value=0, step=1, interactive=False)
+                    split_piece_label = gr.Markdown("No split stack generated yet.")
+                with gr.Column(scale=2, min_width=420):
+                    split_piece_preview = gr.Image(label="Generated Piece Preview", type="pil", image_mode="RGB", height=330)
+
         with gr.Tab("TIFF Slices to GCode"):
             gr.Markdown(
                 """
                 # TIFF Slices to GCode
-                Generate G-code for every shape with a TIFF stack. Pressure, valve, port, and color come from the Shape Settings table.
+                Generate G-code for every shape with a TIFF stack. Pressure, valve, nozzle, port, and color come from the Shape Settings table.
                 """
             )
             gcode_use_ref_motion = gr.Checkbox(
-                label="Use Reference Stack for motion (all shapes share one nozzle path; each dispenses only its own geometry). Generate the Reference TIFF Stack on the first tab first.",
+                label="Use Reference Stack for motion (all shapes share one nozzle path; each dispenses only its own geometry).",
                 value=True,
             )
             gcode_all_g1 = gr.Checkbox(label="Move at one constant speed (no fast travel moves)", value=True)
@@ -2593,7 +3070,7 @@ def build_dynamic_demo() -> gr.Blocks:
                 nozzle_use_individual_spacing = gr.Checkbox(label="Advanced Settings", value=False)
                 nozzle_spacing_table = gr.Dataframe(
                     headers=NOZZLE_SPACING_HEADERS,
-                    value=[["Same spacing", "All neighboring shapes", 5.0, 0.0]],
+                    value=[["Same spacing", "All neighboring nozzles", 5.0, 0.0]],
                     row_count=(1, "fixed"),
                     column_count=(len(NOZZLE_SPACING_HEADERS), "fixed"),
                     interactive=True,
@@ -2684,20 +3161,40 @@ def build_dynamic_demo() -> gr.Blocks:
             parallel_mode = gr.State("tube")
 
         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)
-        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)
-        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])
+        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,
+        )
+        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,
+        )
+        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,
+        )
         shape_settings.select(
             fn=delete_shape_from_settings,
             inputs=[shape_records, shape_settings, nozzle_spacing_table, nozzle_use_individual_spacing, last_shape_delete_at],
             outputs=[stl_upload, *shape_sync_outputs, last_shape_delete_at],
+        ).then(
+            fn=lambda records: _dropdown_update(records),
+            inputs=[shape_records],
+            outputs=[split_source],
+            queue=False,
         )
 
         preview_inputs = [shape_records, selected_shape, shape_settings, model_opacity, scale_mode]
         shape_settings.change(
-            fn=normalize_shape_dimensions_for_mode,
-            inputs=[shape_records, shape_settings, scale_mode],
-            outputs=[shape_records, shape_settings],
+            fn=normalize_shape_settings_and_spacing,
+            inputs=[shape_records, shape_settings, scale_mode, nozzle_spacing_table, nozzle_use_individual_spacing],
+            outputs=[shape_records, shape_settings, nozzle_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])
@@ -2730,13 +3227,67 @@ def build_dynamic_demo() -> gr.Blocks:
         generate_button.click(
             fn=generate_dynamic_stacks,
             inputs=[shape_records, shape_settings, layer_height, pixel_size, scale_mode],
-            outputs=[shape_records, tiff_downloads, slicer_status, selected_shape, slice_slider, slice_label, slice_preview],
+            outputs=[
+                shape_records,
+                tiff_downloads,
+                slicer_status,
+                selected_shape,
+                slice_slider,
+                slice_label,
+                slice_preview,
+                ref_state,
+                ref_slice_slider,
+                ref_slice_label,
+                ref_slice_preview,
+            ],
+        ).then(
+            fn=lambda records: _dropdown_update(records),
+            inputs=[shape_records],
+            outputs=[split_source],
+            queue=False,
         )
         ref_generate_button.click(fn=generate_dynamic_reference_stack, inputs=[shape_records], outputs=[ref_state, ref_slice_slider, ref_slice_label, ref_slice_preview])
         ref_slice_slider.release(fn=jump_to_slice, inputs=[ref_state, ref_slice_slider], outputs=[ref_slice_label, ref_slice_preview], queue=False)
         ref_prev_button.click(fn=lambda sv, idx: shift_slice(sv, idx, -1), inputs=[ref_state, ref_slice_slider], outputs=[ref_slice_slider, ref_slice_label, ref_slice_preview], queue=False)
         ref_next_button.click(fn=lambda sv, idx: shift_slice(sv, idx, 1), inputs=[ref_state, ref_slice_slider], outputs=[ref_slice_slider, ref_slice_label, ref_slice_preview], queue=False)
 
+        split_refresh_sources.click(fn=lambda records: _dropdown_update(records), inputs=[shape_records], outputs=[split_source], queue=False)
+        split_button.click(
+            fn=split_selected_shape_for_grid,
+            inputs=[
+                shape_records,
+                split_source,
+                shape_settings,
+                nozzle_spacing_table,
+                nozzle_use_individual_spacing,
+                split_columns,
+                split_rows,
+                split_start_nozzle,
+                split_start_valve,
+            ],
+            outputs=[
+                shape_records,
+                shape_settings,
+                nozzle_spacing_table,
+                tiff_downloads,
+                gcode_downloads,
+                gcode_text_source,
+                gcode_source,
+                split_source,
+                split_downloads,
+                split_piece_states,
+                split_piece_source,
+                split_piece_slider,
+                split_piece_label,
+                split_piece_preview,
+                split_status,
+            ],
+        )
+        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)
+        split_piece_prev.click(fn=lambda pieces, selected, idx: shift_selected_split_piece(pieces, selected, idx, -1), inputs=[split_piece_states, split_piece_source, split_piece_slider], outputs=[split_piece_slider, split_piece_label, split_piece_preview], queue=False)
+        split_piece_next.click(fn=lambda pieces, selected, idx: shift_selected_split_piece(pieces, selected, idx, 1), inputs=[split_piece_states, split_piece_source, split_piece_slider], outputs=[split_piece_slider, split_piece_label, split_piece_preview], queue=False)
+
         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],

gcode_viewer.py

@@ -381,6 +381,14 @@ def _segments_to_xyz(
     return xs, ys, zs
 
 
+def _part_nozzle(part: dict) -> int:
+    try:
+        nozzle = int(float(part.get("nozzle", part.get("idx", 1))))
+    except (TypeError, ValueError):
+        nozzle = int(part.get("idx", 1) or 1)
+    return nozzle if nozzle > 0 else int(part.get("idx", 1) or 1)
+
+
 def build_toolpath_figure(
     parsed: dict,
     travel_opacity: float = 0.2,
@@ -526,9 +534,9 @@ def build_parallel_figure(
     `tube` True draws filament tubes with a shared-time animation
     timeline; False draws fast thin scatter lines (no animation).
 
-    `parts` is a list of {"idx": int, "color": str, "parsed": dict}. Each part's
-    print and travel traces (and, in tube mode, a nozzle marker) are named by idx
-    so the client-side animation/recolor can address them.
+    `parts` is a list of {"idx": int, "nozzle": int, "color": str, "parsed": dict}.
+    Each part's print and travel traces (and, in tube mode, a nozzle marker) are
+    named by idx so the client-side animation/recolor can address them.
     """
     fig = go.Figure()
     anim_parts: list[dict] = []
@@ -541,6 +549,7 @@ def build_parallel_figure(
     running_x = 0.0
     for part in parts:
         idx = part["idx"]
+        nozzle = _part_nozzle(part)
         color = part["color"]
         parsed = part["parsed"]
         moves = parsed.get("moves") or []
@@ -554,7 +563,8 @@ def build_parallel_figure(
             y_off = 0.0
             running_x += width + gap
         else:
-            x_off, y_off = part_offsets.get(idx, (0.0, 0.0))
+            x_off, y_off = part_offsets.get(nozzle, part_offsets.get(idx, (0.0, 0.0)))
+        nozzle_trace_name = f"Nozzle {nozzle} (Shape {idx})"
 
         if tube:
             print_tube = _build_path_tube(moves, radius=max(filament_width, 0.05) / 2.0, kind="print")
@@ -591,7 +601,7 @@ def build_parallel_figure(
             fig.add_trace(
                 go.Scatter3d(
                     x=[path_x[-1]], y=[path_y[-1]], z=[path["z"][-1]],
-                    mode="markers", name=f"Nozzle {idx}",
+                    mode="markers", name=nozzle_trace_name,
                     marker=dict(size=4, color=color), showlegend=False, hoverinfo="skip",
                 )
             )
@@ -601,7 +611,7 @@ def build_parallel_figure(
             anim_parts.append({
                 "printName": f"Shape {idx}",
                 "travelName": f"Travel {idx}",
-                "nozzleName": f"Nozzle {idx}",
+                "nozzleName": nozzle_trace_name,
                 "print_face_t": print_tube["face_t"],
                 "travel_face_t": travel_tube["face_t"],
                 "path_x": path_x, "path_y": path_y, "path_z": path["z"], "path_t": path["t"],
@@ -668,13 +678,16 @@ def build_nozzle_spacing_figure(
     fig = go.Figure()
     bx0 = by0 = float("inf")
     bx1 = by1 = float("-inf")
+    nozzle_colors: dict[int, str] = {}
 
     for part in parts:
         idx = part["idx"]
+        nozzle = _part_nozzle(part)
         color = part["color"]
+        nozzle_colors.setdefault(nozzle, color)
         parsed = part["parsed"]
         (pxmin, pymin, _), (pxmax, pymax, _) = parsed["bounds"]
-        x_off, y_off = part_offsets.get(idx, (0.0, 0.0))
+        x_off, y_off = part_offsets.get(nozzle, part_offsets.get(idx, (0.0, 0.0)))
         xs = [pxmin + x_off, pxmax + x_off, pxmax + x_off, pxmin + x_off, pxmin + x_off]
         ys = [pymin + y_off, pymin + y_off, pymax + y_off, pymax + y_off, pymin + y_off]
         fig.add_trace(
@@ -682,25 +695,31 @@ def build_nozzle_spacing_figure(
                 x=xs,
                 y=ys,
                 mode="lines",
-                name=f"Shape {idx} bounds",
+                name=f"Shape {idx} bounds (N{nozzle})",
                 line=dict(color=color, width=2),
             )
         )
+        bx0 = min(bx0, min(xs), x_off)
+        bx1 = max(bx1, max(xs), x_off)
+        by0 = min(by0, min(ys), y_off)
+        by1 = max(by1, max(ys), y_off)
+
+    for nozzle, (x_off, y_off) in sorted(part_offsets.items()):
         fig.add_trace(
             go.Scatter(
                 x=[x_off],
                 y=[y_off],
                 mode="markers+text",
-                name=f"Nozzle {idx}",
-                marker=dict(color=color, size=12),
-                text=[f"N{idx}"],
+                name=f"Nozzle {nozzle}",
+                marker=dict(color=nozzle_colors.get(nozzle, "#444444"), size=12),
+                text=[f"N{nozzle}"],
                 textposition="top center",
             )
         )
-        bx0 = min(bx0, min(xs), x_off)
-        bx1 = max(bx1, max(xs), x_off)
-        by0 = min(by0, min(ys), y_off)
-        by1 = max(by1, max(ys), y_off)
+        bx0 = min(bx0, x_off)
+        bx1 = max(bx1, x_off)
+        by0 = min(by0, y_off)
+        by1 = max(by1, y_off)
 
     for spacing in spacings:
         start = spacing["from"]
@@ -759,7 +778,7 @@ def build_parallel_gif(
 
     Each part's toolpath is drawn as growing colored lines (print solid, travel
     faint), three parts in parallel on a shared cumulative-length time axis.
-    `parts` is a list of {"idx": int, "color": str, "parsed": dict}.
+    `parts` is a list of {"idx": int, "nozzle": int, "color": str, "parsed": dict}.
     """
     import matplotlib
     matplotlib.use("Agg")
@@ -784,7 +803,8 @@ def build_parallel_gif(
             y_off = 0.0
             running_x += (pxmax - pxmin) + gap
         else:
-            x_off, y_off = part_offsets.get(part["idx"], (0.0, 0.0))
+            nozzle = _part_nozzle(part)
+            x_off, y_off = part_offsets.get(nozzle, part_offsets.get(part["idx"], (0.0, 0.0)))
 
         cum = 0.0
         mlist: list[tuple] = []

tests/test_app_scaling.py

@@ -2,10 +2,14 @@ from __future__ import annotations
 
 import numpy as np
 import trimesh
+from PIL import Image
 
 from app import (
     SCALE_MODE_TARGET_DIMENSIONS,
     SCALE_MODE_UNIFORM_FACTOR,
+    generate_dynamic_stacks,
+    split_tiff_stack_grid,
+    split_tiff_stack_left_right,
     _resolve_mesh_scale_factors,
     _uniform_target_extents_from_anchor,
 )
@@ -53,3 +57,84 @@ def test_uniform_target_extents_update_from_changed_side() -> None:
     )
 
     np.testing.assert_allclose(target_extents, (6.0, 12.0, 24.0))
+
+
+def test_generate_dynamic_stacks_empty_input_resets_reference_stack() -> None:
+    outputs = generate_dynamic_stacks([], [], 0.8, 0.8, SCALE_MODE_TARGET_DIMENSIONS)
+
+    assert len(outputs) == 11
+    assert outputs[0] == []
+    assert outputs[2] == "Upload at least one STL first."
+    assert outputs[7]["tiff_paths"] == []
+    assert outputs[9] == "No reference stack generated yet."
+
+
+def test_split_tiff_stack_left_right_preserves_pixels_and_metadata(tmp_path) -> None:
+    pixels = np.array(
+        [
+            [0, 255, 0, 255, 0],
+            [255, 0, 255, 0, 255],
+        ],
+        dtype=np.uint8,
+    )
+    tiff_path = tmp_path / "slice_0000.tif"
+    Image.fromarray(pixels, mode="L").save(tiff_path)
+    state = {
+        "tiff_paths": [str(tiff_path)],
+        "z_values": [1.25],
+        "pixel_size": 0.5,
+        "x_min": 10.0,
+        "y_min": -2.0,
+        "image_width": 5,
+        "image_height": 2,
+    }
+
+    left_state, right_state, left_zip, right_zip = split_tiff_stack_left_right(state, "wide-part")
+
+    assert left_zip.exists()
+    assert right_zip.exists()
+    assert left_state["image_width"] == 3
+    assert right_state["image_width"] == 2
+    assert left_state["x_min"] == 10.0
+    assert right_state["x_min"] == 11.5
+    assert left_state["z_values"] == [1.25]
+    assert right_state["z_values"] == [1.25]
+
+    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:])
+
+
+def test_split_tiff_stack_grid_preserves_pixels_and_offsets(tmp_path) -> None:
+    pixels = np.arange(20, dtype=np.uint8).reshape((4, 5))
+    tiff_path = tmp_path / "slice_0000.tif"
+    Image.fromarray(pixels, mode="L").save(tiff_path)
+    state = {
+        "tiff_paths": [str(tiff_path)],
+        "z_values": [2.0],
+        "pixel_size": 0.25,
+        "x_min": 4.0,
+        "y_min": 10.0,
+        "image_width": 5,
+        "image_height": 4,
+    }
+
+    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_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)
+
+    expected = [
+        pixels[:2, :3],
+        pixels[:2, 3:],
+        pixels[2:, :3],
+        pixels[2:, 3:],
+    ]
+    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)

tests/test_nozzle_spacing.py

@@ -5,7 +5,9 @@ import numpy as np
 from app import (
     ADVANCED_NOZZLE_SPACING_HEADERS,
     SCALE_MODE_UNIFORM_FACTOR,
+    SHAPE_SETTINGS_HEADERS,
     SIMPLE_NOZZLE_SPACING_HEADERS,
+    _apply_shape_settings,
     delete_shape_from_settings,
     _format_nozzle_spacing_status,
     _shape_settings_rows,
@@ -16,9 +18,14 @@ from app import (
 )
 
 
-def _part(idx: int, bounds: tuple[tuple[float, float, float], tuple[float, float, float]]) -> dict:
+def _part(
+    idx: int,
+    bounds: tuple[tuple[float, float, float], tuple[float, float, float]],
+    nozzle: int | None = None,
+) -> dict:
     return {
         "idx": idx,
+        "nozzle": nozzle if nozzle is not None else idx,
         "color": "#000000",
         "parsed": {"bounds": bounds, "moves": [{"kind": "print"}], "point_count": 1},
     }
@@ -42,9 +49,9 @@ def test_calculated_nozzle_layout_uses_requested_part_gap() -> None:
 
     np.testing.assert_allclose(offsets[1], (0.0, 0.0))
     np.testing.assert_allclose(offsets[2], (12.5, -1.0))
-    np.testing.assert_allclose(offsets[3], (24.5, 3.0))
+    np.testing.assert_allclose(offsets[3], (27.5, 3.0))
     assert spacings[0] == {"from": 1, "to": 2, "dx": 12.5, "dy": -1.0}
-    assert spacings[1] == {"from": 2, "to": 3, "dx": 12.0, "dy": 4.0}
+    assert spacings[1] == {"from": 2, "to": 3, "dx": 15.0, "dy": 4.0}
 
 
 def test_calculated_nozzle_layout_allows_negative_x_overlap() -> None:
@@ -67,6 +74,28 @@ def test_calculated_nozzle_layout_allows_negative_x_overlap() -> None:
     assert spacings == [{"from": 1, "to": 2, "dx": 8.0, "dy": 3.0}]
 
 
+def test_nozzle_layout_groups_shapes_that_share_a_nozzle() -> None:
+    parts = [
+        _part(1, ((0.0, 0.0, 0.0), (10.0, 10.0, 1.0)), nozzle=1),
+        _part(2, ((-1.0, -2.0, 0.0), (12.0, 4.0, 1.0)), nozzle=1),
+        _part(3, ((0.0, 0.0, 0.0), (6.0, 5.0, 1.0)), nozzle=2),
+    ]
+
+    offsets, spacings = _resolve_nozzle_layout(
+        parts,
+        same_spacing=True,
+        part_gap_12_x=5.0,
+        part_gap_12_y=1.5,
+        part_gap_23_x=0.0,
+        part_gap_23_y=0.0,
+    )
+
+    assert sorted(offsets) == [1, 2]
+    np.testing.assert_allclose(offsets[1], (0.0, 0.0))
+    np.testing.assert_allclose(offsets[2], (17.0, 1.5))
+    assert spacings == [{"from": 1, "to": 2, "dx": 17.0, "dy": 1.5}]
+
+
 def test_same_spacing_reuses_first_pair_values_for_second_pair() -> None:
     parts = [
         _part(1, ((0.0, 0.0, 0.0), (10.0, 10.0, 1.0))),
@@ -182,6 +211,40 @@ def test_keep_proportions_uses_most_recently_edited_dimension() -> None:
     assert updated_settings[0][2:5] == [25.0, 50.0, 12.5]
 
 
+def test_shape_settings_round_trip_contour_tracing_column() -> None:
+    records = [
+        {
+            "idx": 1,
+            "name": "circle",
+            "stl_path": "circle.stl",
+            "target_x": 10.0,
+            "target_y": 11.0,
+            "target_z": 12.0,
+            "pressure": 25.0,
+            "valve": 4,
+            "nozzle": 1,
+            "port": 1,
+            "color": "#111111",
+            "contour_tracing": False,
+        }
+    ]
+
+    rows = _shape_settings_rows(records)
+    assert SHAPE_SETTINGS_HEADERS[6:9] == ["Valve", "Nozzle", "Port"]
+    assert SHAPE_SETTINGS_HEADERS[-2:] == ["Contour Tracing", "Delete"]
+    assert rows[0][6:9] == [4, 1, 1]
+    assert rows[0][-2:] == [False, "Delete"]
+
+    rows[0][7] = 3
+    rows[0][8] = 2
+    rows[0][-2] = True
+    updated = _apply_shape_settings(records, rows)
+
+    assert updated[0]["nozzle"] == 3
+    assert updated[0]["port"] == 2
+    assert updated[0]["contour_tracing"] is True
+
+
 def test_simple_spacing_table_uses_one_shared_spacing_row() -> None:
     records = [
         {"idx": 1, "name": "first"},
@@ -193,11 +256,11 @@ def test_simple_spacing_table_uses_one_shared_spacing_row() -> None:
     gap12x, gap12y, gap23x, gap23y, extra = _spacing_args_from_table(update["value"], False)
 
     assert update["headers"] == SIMPLE_NOZZLE_SPACING_HEADERS
-    assert update["value"] == [["Same spacing", "All neighboring shapes", 7.0, -1.5]]
+    assert update["value"] == [["Same spacing", "All neighboring nozzles", 7.0, -1.5]]
     assert (gap12x, gap12y, gap23x, gap23y, extra) == (7.0, -1.5, 7.0, -1.5, [])
 
 
-def test_advanced_spacing_table_uses_named_shape_pairs() -> None:
+def test_advanced_spacing_table_uses_named_nozzle_pairs() -> None:
     records = [
         {"idx": 1, "name": "first"},
         {"idx": 2, "name": "second"},
@@ -212,14 +275,27 @@ def test_advanced_spacing_table_uses_named_shape_pairs() -> None:
     gap12x, gap12y, gap23x, gap23y, extra = _spacing_args_from_table(update["value"], True)
 
     assert update["headers"] == ADVANCED_NOZZLE_SPACING_HEADERS
-    assert update["value"][0][:2] == ["Shape 1: first", "Shape 2: second"]
-    assert update["value"][1][:2] == ["Shape 2: second", "Shape 3: third"]
+    assert update["value"][0][:2] == ["Nozzle 1: Shape 1", "Nozzle 2: Shape 2"]
+    assert update["value"][1][:2] == ["Nozzle 2: Shape 2", "Nozzle 3: Shape 3"]
     assert (gap12x, gap12y, gap23x, gap23y, extra) == (4.0, 0.5, 8.0, 1.0, [])
 
 
+def test_advanced_spacing_table_collapses_duplicate_nozzles() -> None:
+    records = [
+        {"idx": 1, "name": "first", "nozzle": 1},
+        {"idx": 2, "name": "second", "nozzle": 1},
+        {"idx": 3, "name": "third", "nozzle": 2},
+    ]
+
+    update = _spacing_table_update(records, [["ignored", "ignored", 9.0, 2.5]], True)
+
+    assert update["headers"] == ADVANCED_NOZZLE_SPACING_HEADERS
+    assert update["value"] == [["Nozzle 1: Shape 1, Shape 2", "Nozzle 2: Shape 3", 9.0, 2.5]]
+
+
 def test_delete_shape_reindexes_without_losing_shape_data() -> None:
     class Event:
-        index = (1, 9)
+        index = (1, len(SHAPE_SETTINGS_HEADERS) - 1)
 
     records = [
         {"idx": 1, "name": "first", "stl_path": "first.stl", "target_x": 10.0, "target_y": 11.0, "target_z": 12.0, "pressure": 25, "valve": 4, "port": 1, "color": "#111111"},
@@ -241,7 +317,7 @@ def test_delete_shape_reindexes_without_losing_shape_data() -> None:
 
 def test_delete_shape_cooldown_blocks_immediate_second_delete() -> None:
     class Event:
-        index = (1, 9)
+        index = (1, len(SHAPE_SETTINGS_HEADERS) - 1)
 
     records = [
         {"idx": 1, "name": "first", "stl_path": "first.stl", "target_x": 10.0, "target_y": 11.0, "target_z": 12.0, "pressure": 25, "valve": 4, "port": 1, "color": "#111111"},

tests/test_tiff_to_gcode.py

@@ -2,15 +2,413 @@ from __future__ import annotations
 
 import zipfile
 
+import numpy as np
 from PIL import Image
 
 from tiff_to_gcode import (
+    RASTER_PATTERN_SAME_DIRECTION,
     RASTER_PATTERN_WOODPILE,
     RASTER_PATTERN_Y_DIRECTION,
+    _build_contour_layers,
+    _trace_mask_contours,
     generate_snake_path_gcode,
 )
 
 
+def _move_signature(gcode_text: str) -> list[tuple[float | None, float | None, float | None]]:
+    signature: list[tuple[float | None, float | None, float | None]] = []
+    for line in gcode_text.splitlines():
+        if not line.startswith(("G0", "G1")):
+            continue
+        axes: dict[str, float] = {}
+        for token in line.split():
+            if token[:1] in {"X", "Y", "Z"}:
+                axes[token[0]] = float(token[1:])
+        signature.append((axes.get("X"), axes.get("Y"), axes.get("Z")))
+    return signature
+
+
+def _move_endpoints_for_color(gcode_text: str, color: int) -> list[tuple[float, float]]:
+    x = y = 0.0
+    endpoints: list[tuple[float, float]] = []
+    for line in gcode_text.splitlines():
+        if not line.startswith(("G0", "G1")):
+            continue
+        start = (x, y)
+        for token in line.split():
+            if token.startswith("X"):
+                x += float(token[1:])
+            if token.startswith("Y"):
+                y += float(token[1:])
+        if f"; Color {color}" in line:
+            endpoints.extend([start, (x, y)])
+    return endpoints
+
+
+def _moves_with_colors(gcode_text: str) -> list[dict]:
+    x = y = z = 0.0
+    moves: list[dict] = []
+    for line in gcode_text.splitlines():
+        if not line.startswith(("G0", "G1")):
+            continue
+        start = (x, y, z)
+        for token in line.split():
+            if token.startswith("X"):
+                x += float(token[1:])
+            if token.startswith("Y"):
+                y += float(token[1:])
+            if token.startswith("Z"):
+                z += float(token[1:])
+        color = None
+        if "; Color " in line:
+            color = int(line.rsplit("; Color ", 1)[1])
+        moves.append({"start": start, "end": (x, y, z), "color": color})
+    return moves
+
+
+def test_trace_mask_contours_uses_tiff_pixel_border_edges() -> None:
+    contours = _trace_mask_contours(
+        np.array(
+            [
+                [True, True],
+                [True, True],
+            ],
+            dtype=bool,
+        ),
+        pixel_size=1.0,
+    )
+
+    assert contours == [[(0.0, 0.0), (2.0, 0.0), (2.0, 2.0), (0.0, 2.0), (0.0, 0.0)]]
+
+
+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)
+    raster_image.putpixel((4, 3), 0)
+    raster_image.save(raster_tiff)
+    raster_zip = tmp_path / "raster_slices.zip"
+    with zipfile.ZipFile(raster_zip, mode="w") as archive:
+        archive.write(raster_tiff, arcname=raster_tiff.name)
+
+    contour_tiff = tmp_path / "contour_slice_0000.tif"
+    contour_image = Image.new("L", (7, 6), 255)
+    contour_image.putpixel((4, 3), 0)
+    contour_image.save(contour_tiff)
+
+    gcode_path = generate_snake_path_gcode(
+        raster_zip,
+        shape_name="aligned_contour",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        all_g1=True,
+        contour_tiff_sets=[{"owner_idx": 1, "tiff_paths": [str(contour_tiff)]}],
+        active_contour_owner=1,
+    )
+
+    points = _move_endpoints_for_color(gcode_path.read_text(), 255)
+    xs = [point[0] for point in points]
+    ys = [point[1] for point in points]
+
+    assert (min(xs), max(xs)) == (1.0, 2.0)
+    assert (min(ys), max(ys)) == (-0.5, 0.5)
+
+
+def test_contour_tracing_travels_to_nearest_border_after_infill(tmp_path) -> None:
+    tiff_path = tmp_path / "slice_0000.tif"
+    image = Image.new("L", (7, 6), 255)
+    image.putpixel((4, 3), 0)
+    image.save(tiff_path)
+    zip_path = tmp_path / "slices.zip"
+    with zipfile.ZipFile(zip_path, mode="w") as archive:
+        archive.write(tiff_path, arcname=tiff_path.name)
+
+    gcode_path = generate_snake_path_gcode(
+        zip_path,
+        shape_name="nearest_border_contour",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        all_g1=True,
+        contour_tiff_sets=[{"owner_idx": 1, "tiff_paths": [str(tiff_path)]}],
+        active_contour_owner=1,
+    )
+
+    moves = _moves_with_colors(gcode_path.read_text())
+    assert moves[1] == {
+        "start": (1.0, 0.0, 0.0),
+        "end": (2.0, 0.0, 0.0),
+        "color": 255,
+    }
+    assert moves[2]["color"] == 255
+    assert moves[2]["start"] == (2.0, 0.0, 0.0)
+
+
+def test_contour_tracing_anchors_to_expanding_raster_frame(tmp_path) -> None:
+    tiff_path = tmp_path / "slice_0000.tif"
+    image = Image.new("L", (7, 5), 255)
+    for col in [3]:
+        image.putpixel((col, 0), 0)
+    for col in range(2, 5):
+        image.putpixel((col, 1), 0)
+    for col in range(1, 6):
+        image.putpixel((col, 2), 0)
+    image.save(tiff_path)
+
+    zip_path = tmp_path / "slices.zip"
+    with zipfile.ZipFile(zip_path, mode="w") as archive:
+        archive.write(tiff_path, arcname=tiff_path.name)
+
+    gcode_path = generate_snake_path_gcode(
+        zip_path,
+        shape_name="expanding_contour",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        all_g1=True,
+        contour_tiff_sets=[{"owner_idx": 1, "tiff_paths": [str(tiff_path)]}],
+        active_contour_owner=1,
+    )
+
+    print_moves = [
+        move for move in _moves_with_colors(gcode_path.read_text()) if move["color"] == 255
+    ]
+    contour_points = [
+        point
+        for move in print_moves[3:]
+        for point in (move["start"], move["end"])
+    ]
+    xs = [point[0] for point in contour_points]
+    ys = [point[1] for point in contour_points]
+
+    assert print_moves[:3] == [
+        {"start": (1.0, 0.0, 0.0), "end": (2.0, 0.0, 0.0), "color": 255},
+        {"start": (3.0, 1.0, 0.0), "end": (0.0, 1.0, 0.0), "color": 255},
+        {"start": (-1.0, 2.0, 0.0), "end": (4.0, 2.0, 0.0), "color": 255},
+    ]
+    assert print_moves[3]["start"] == (4.0, 2.0, 0.0)
+    assert (min(xs), max(xs)) == (-1.0, 4.0)
+    assert (min(ys), max(ys)) == (-0.5, 2.5)
+
+
+def test_contour_tracing_uses_shifted_layer_raster_frame(tmp_path) -> None:
+    tiff_paths = []
+    for index, pixel in enumerate([(4, 3), (5, 4)]):
+        tiff_path = tmp_path / f"slice_{index:04d}.tif"
+        image = Image.new("L", (8, 7), 255)
+        image.putpixel(pixel, 0)
+        image.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="shifted_layer_contour",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        layer_height=1.0,
+        all_g1=True,
+        contour_tiff_sets=[{"owner_idx": 1, "tiff_paths": [str(p) for p in tiff_paths]}],
+        active_contour_owner=1,
+    )
+
+    layer_one_prints = [
+        move
+        for move in _moves_with_colors(gcode_path.read_text())
+        if move["color"] == 255
+        and move["start"][2] == 1.0
+        and move["end"][2] == 1.0
+    ]
+
+    assert layer_one_prints[0] == {
+        "start": (3.0, 1.0, 1.0),
+        "end": (2.0, 1.0, 1.0),
+        "color": 255,
+    }
+    contour_points = [
+        point
+        for move in layer_one_prints[1:]
+        for point in (move["start"], move["end"])
+    ]
+    xs = [point[0] for point in contour_points]
+    ys = [point[1] for point in contour_points]
+
+    assert layer_one_prints[1]["start"] == (2.0, 1.0, 1.0)
+    assert layer_one_prints[1]["end"] == (2.0, 0.5, 1.0)
+    assert (min(xs), max(xs)) == (2.0, 3.0)
+    assert (min(ys), max(ys)) == (0.5, 1.5)
+
+
+def test_contour_tracing_mirrors_odd_layer_y_frame(tmp_path) -> None:
+    tiff_paths = []
+    for index in range(2):
+        tiff_path = tmp_path / f"slice_{index:04d}.tif"
+        image = Image.new("L", (8, 7), 255)
+        image.putpixel((4, 3), 0)
+        image.putpixel((4, 4), 0)
+        image.putpixel((5, 4), 0)
+        image.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="odd_layer_y_contour",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        layer_height=1.0,
+        all_g1=True,
+        contour_tiff_sets=[{"owner_idx": 1, "tiff_paths": [str(p) for p in tiff_paths]}],
+        active_contour_owner=1,
+    )
+
+    layer_one_prints = [
+        move
+        for move in _moves_with_colors(gcode_path.read_text())
+        if move["color"] == 255
+        and move["start"][2] == 1.0
+        and move["end"][2] == 1.0
+    ]
+    contour_points = [
+        point
+        for move in layer_one_prints[2:]
+        for point in (move["start"], move["end"])
+    ]
+    xs = [point[0] for point in contour_points]
+    ys = [point[1] for point in contour_points]
+
+    assert layer_one_prints[:2] == [
+        {"start": (1.0, 1.0, 1.0), "end": (3.0, 1.0, 1.0), "color": 255},
+        {"start": (2.0, 0.0, 1.0), "end": (1.0, 0.0, 1.0), "color": 255},
+    ]
+    assert layer_one_prints[2]["start"] == (1.0, 0.0, 1.0)
+    assert layer_one_prints[2]["end"] == (1.0, -0.5, 1.0)
+    assert (min(xs), max(xs)) == (1.0, 3.0)
+    assert (min(ys), max(ys)) == (-0.5, 1.5)
+
+
+def test_contour_tracing_closes_loop_and_restores_raster_endpoint(tmp_path) -> None:
+    tiff_paths = []
+    for index in range(4):
+        tiff_path = tmp_path / f"slice_{index:04d}.tif"
+        image = Image.new("L", (8, 8), 255)
+        image.putpixel((4, 2), 0)
+        image.putpixel((4, 3), 0)
+        image.putpixel((5, 4), 0)
+        image.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="odd_layer_last_infill_anchor",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        layer_height=1.0,
+        all_g1=True,
+        contour_tiff_sets=[{"owner_idx": 1, "tiff_paths": [str(p) for p in tiff_paths]}],
+        active_contour_owner=1,
+    )
+
+    all_moves = _moves_with_colors(gcode_path.read_text())
+    for layer_z in (1.0, 3.0):
+        layer_moves = [
+            move
+            for move in all_moves
+            if move["start"][2] == layer_z
+            and move["end"][2] == layer_z
+        ]
+        layer_prints = [
+            move
+            for move in layer_moves
+            if move["color"] == 255
+        ]
+
+        assert layer_prints[:3] == [
+            {"start": (3.0, 2.0, layer_z), "end": (2.0, 2.0, layer_z), "color": 255},
+            {"start": (1.0, 1.0, layer_z), "end": (2.0, 1.0, layer_z), "color": 255},
+            {"start": (2.0, 0.0, layer_z), "end": (1.0, 0.0, layer_z), "color": 255},
+        ]
+        contour_start = layer_prints[2]["end"]
+        assert layer_prints[3]["start"] == contour_start
+        assert layer_prints[-1]["end"] == contour_start
+
+        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,
+            "end": (0.0, 0.0, layer_z),
+            "color": 0,
+        }
+
+
+def test_contour_tracing_follows_default_raster_layer_flip(tmp_path) -> None:
+    tiff_paths = []
+    motion_img = np.zeros((7, 8), dtype=np.uint8)
+    motion_img[3, 4] = 255
+    motion_img[4, 4] = 255
+    motion_img[4, 5] = 255
+    for index in range(2):
+        tiff_path = tmp_path / f"l_shape_{index:04d}.tif"
+        image = Image.new("L", (8, 7), 255)
+        image.putpixel((4, 3), 0)
+        image.putpixel((4, 4), 0)
+        image.putpixel((5, 4), 0)
+        image.save(tiff_path)
+        tiff_paths.append(str(tiff_path))
+
+    contour_layers = _build_contour_layers(
+        [{"owner_idx": 1, "tiff_paths": tiff_paths}],
+        [motion_img, motion_img],
+        pixel_size=1.0,
+        invert=True,
+        off_color=0,
+        work_dir=tmp_path,
+        raster_pattern=RASTER_PATTERN_SAME_DIRECTION,
+    )
+
+    assert contour_layers[0][0]["contours"][0] == [
+        (1.0, -0.5),
+        (2.0, -0.5),
+        (2.0, 0.5),
+        (3.0, 0.5),
+        (3.0, 1.5),
+        (1.0, 1.5),
+        (1.0, -0.5),
+    ]
+    assert contour_layers[1][0]["contours"][0] == [
+        (1.0, -0.5),
+        (3.0, -0.5),
+        (3.0, 0.5),
+        (2.0, 0.5),
+        (2.0, 1.5),
+        (1.0, 1.5),
+        (1.0, -0.5),
+    ]
+
+
 def test_gcode_header_writes_presets_before_initial_aux_commands(tmp_path) -> None:
     tiff_path = tmp_path / "slice_0000.tif"
     Image.new("L", (1, 1), 0).save(tiff_path)
@@ -166,3 +564,86 @@ def test_y_direction_raster_prints_each_layer_along_y_axis(tmp_path) -> None:
     assert max(x_positions) <= 3.0
     assert min(y_positions) >= 0.0
     assert max(y_positions) <= 2.0
+
+
+def test_contour_tracing_skips_inactive_nozzle_outline(tmp_path) -> None:
+    blank_tiff = tmp_path / "blank_slice_0000.tif"
+    Image.new("L", (1, 1), 255).save(blank_tiff)
+    blank_zip = tmp_path / "blank_slices.zip"
+    with zipfile.ZipFile(blank_zip, mode="w") as archive:
+        archive.write(blank_tiff, arcname=blank_tiff.name)
+
+    contour_tiff = tmp_path / "contour_slice_0000.tif"
+    Image.new("L", (1, 1), 0).save(contour_tiff)
+    contour_sources = [{"owner_idx": 1, "tiff_paths": [str(contour_tiff)]}]
+
+    active_path = generate_snake_path_gcode(
+        blank_zip,
+        shape_name="active_contour",
+        pressure=25,
+        valve=7,
+        port=3,
+        all_g1=True,
+        contour_tiff_sets=contour_sources,
+        active_contour_owner=1,
+    )
+    inactive_path = generate_snake_path_gcode(
+        blank_zip,
+        shape_name="inactive_contour",
+        pressure=25,
+        valve=7,
+        port=3,
+        all_g1=True,
+        contour_tiff_sets=contour_sources,
+        active_contour_owner=2,
+    )
+
+    active_text = active_path.read_text()
+    inactive_text = inactive_path.read_text()
+
+    assert _move_signature(active_text)
+    assert _move_signature(inactive_text) == []
+    assert any(
+        line.startswith("G1") and "; Color 255" in line
+        for line in active_text.splitlines()
+    )
+    assert not any("; Color 255" in line for line in inactive_text.splitlines())
+
+
+def test_inactive_contour_tracing_preserves_original_raster_moves(tmp_path) -> None:
+    tiff_paths = []
+    for index in range(2):
+        tiff_path = tmp_path / f"slice_{index:04d}.tif"
+        image = Image.new("L", (4, 3), 255)
+        image.putpixel((1, 1), 0)
+        image.putpixel((2, 1), 0)
+        image.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)
+
+    original_path = generate_snake_path_gcode(
+        zip_path,
+        shape_name="original_raster",
+        pressure=25,
+        valve=7,
+        port=3,
+        all_g1=True,
+    )
+    inactive_path = generate_snake_path_gcode(
+        zip_path,
+        shape_name="inactive_contour_raster",
+        pressure=25,
+        valve=7,
+        port=3,
+        all_g1=True,
+        contour_tiff_sets=[{"owner_idx": 2, "tiff_paths": [str(p) for p in tiff_paths]}],
+        active_contour_owner=1,
+    )
+
+    assert _move_signature(inactive_path.read_text()) == _move_signature(
+        original_path.read_text()
+    )

tiff_to_gcode.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import tempfile
 import zipfile
+from collections import defaultdict
 from codecs import encode
 from pathlib import Path
 from textwrap import wrap
@@ -20,7 +21,6 @@ RASTER_PATTERN_CHOICES = (
     RASTER_PATTERN_WOODPILE,
 )
 
-
 def _normalize_raster_pattern(pattern: str | None) -> str:
     if pattern == RASTER_PATTERN_WOODPILE:
         return RASTER_PATTERN_WOODPILE
@@ -197,6 +197,115 @@ def _center_on_canvas(
     return out
 
 
+def _simplify_closed_contour(
+    points: list[tuple[int, int]],
+) -> list[tuple[int, int]]:
+    if len(points) < 4:
+        return points
+    if points[0] != points[-1]:
+        points = [*points, points[0]]
+
+    ring = points[:-1]
+    simplified: list[tuple[int, int]] = []
+    for idx, point in enumerate(ring):
+        prev_point = ring[idx - 1]
+        next_point = ring[(idx + 1) % len(ring)]
+        dx1 = point[0] - prev_point[0]
+        dy1 = point[1] - prev_point[1]
+        dx2 = next_point[0] - point[0]
+        dy2 = next_point[1] - point[1]
+        if dx1 * dy2 == dy1 * dx2:
+            continue
+        simplified.append(point)
+
+    if len(simplified) < 3:
+        simplified = ring
+    simplified.append(simplified[0])
+    return simplified
+
+
+def _contour_area2(points: list[tuple[float, float]]) -> float:
+    return sum(
+        x0 * y1 - x1 * y0
+        for (x0, y0), (x1, y1) in zip(points, points[1:])
+    )
+
+
+def _contour_sort_key(points: list[tuple[float, float]]) -> tuple[float, float, float]:
+    xs = [point[0] for point in points]
+    ys = [point[1] for point in points]
+    return (-abs(_contour_area2(points)), min(ys), min(xs))
+
+
+def _trace_mask_contours(
+    mask: np.ndarray,
+    pixel_size: float,
+    x_offset_px: float = 0.0,
+    y_offset_px: float = 0.0,
+) -> list[list[tuple[float, float]]]:
+    if not np.any(mask):
+        return []
+
+    mask = mask.astype(bool)
+    segments: list[tuple[tuple[int, int], tuple[int, int]]] = []
+    height, width = mask.shape
+
+    def is_on(row: int, col: int) -> bool:
+        return 0 <= row < height and 0 <= col < width and bool(mask[row, col])
+
+    for row in range(height):
+        for col in range(width):
+            if not mask[row, col]:
+                continue
+            if not is_on(row - 1, col):
+                segments.append(((col, row), (col + 1, row)))
+            if not is_on(row, col + 1):
+                segments.append(((col + 1, row), (col + 1, row + 1)))
+            if not is_on(row + 1, col):
+                segments.append(((col + 1, row + 1), (col, row + 1)))
+            if not is_on(row, col - 1):
+                segments.append(((col, row + 1), (col, row)))
+
+    outgoing: dict[tuple[int, int], list[tuple[int, int]]] = defaultdict(list)
+    for start, end in segments:
+        outgoing[start].append(end)
+
+    contours: list[list[tuple[float, float]]] = []
+    remaining = set(segments)
+    while remaining:
+        start, end = min(remaining)
+        remaining.remove((start, end))
+        contour = [start, end]
+        current = end
+
+        while current != start:
+            next_point = next(
+                (
+                    candidate
+                    for candidate in outgoing.get(current, [])
+                    if (current, candidate) in remaining
+                ),
+                None,
+            )
+            if next_point is None:
+                break
+            remaining.remove((current, next_point))
+            current = next_point
+            contour.append(current)
+
+        if len(contour) > 3 and contour[-1] == contour[0]:
+            simplified = _simplify_closed_contour(contour)
+            contours.append(
+                [
+                    ((x + x_offset_px) * pixel_size, (y + y_offset_px) * pixel_size)
+                    for x, y in simplified
+                ]
+            )
+
+    contours.sort(key=_contour_sort_key)
+    return contours
+
+
 def _append_relative_move(
     output_list: list[dict],
     current_x: float,
@@ -217,6 +326,396 @@ def _append_relative_move(
     return target_x, target_y
 
 
+def _point_distance_sq(
+    ax: float,
+    ay: float,
+    bx: float,
+    by: float,
+) -> float:
+    return (ax - bx) ** 2 + (ay - by) ** 2
+
+
+def _closest_point_on_segment(
+    px: float,
+    py: float,
+    ax: float,
+    ay: float,
+    bx: float,
+    by: float,
+) -> tuple[float, float, float]:
+    dx = bx - ax
+    dy = by - ay
+    length_sq = dx * dx + dy * dy
+    if length_sq == 0:
+        return ax, ay, 0.0
+    t = ((px - ax) * dx + (py - ay) * dy) / length_sq
+    t = max(0.0, min(1.0, t))
+    return ax + t * dx, ay + t * dy, t
+
+
+def _rotate_closed_contour_to_nearest_border(
+    contour: list[tuple[float, float]],
+    current_x: float,
+    current_y: float,
+    approach_dx: float = 0.0,
+    approach_dy: float = 0.0,
+) -> list[tuple[float, float]]:
+    if len(contour) < 3:
+        return contour
+
+    ring = contour[:-1] if contour[0] == contour[-1] else contour
+    if len(ring) < 2:
+        return contour
+
+    best_idx = 0
+    best_t = 0.0
+    best_point = ring[0]
+    best_dist = float("inf")
+    for idx, (ax, ay) in enumerate(ring):
+        bx, by = ring[(idx + 1) % len(ring)]
+        point_x, point_y, t = _closest_point_on_segment(
+            current_x,
+            current_y,
+            ax,
+            ay,
+            bx,
+            by,
+        )
+        distance = _point_distance_sq(current_x, current_y, point_x, point_y)
+        if distance < best_dist:
+            best_dist = distance
+            best_idx = idx
+            best_t = t
+            best_point = (point_x, point_y)
+
+    eps = 1e-9
+    def choose_direction(
+        forward: list[tuple[float, float]],
+        reverse: list[tuple[float, float]],
+    ) -> list[tuple[float, float]]:
+        if (
+            len(forward) < 2
+            or len(reverse) < 2
+            or (approach_dx == 0 and approach_dy == 0)
+        ):
+            return forward
+
+        def score(candidate: list[tuple[float, float]]) -> float:
+            tx = candidate[1][0] - candidate[0][0]
+            ty = candidate[1][1] - candidate[0][1]
+            # Positive when the shape interior, opposite the approach vector,
+            # is to the left of the contour's first move.
+            return (ty * approach_dx) - (tx * approach_dy)
+
+        return reverse if score(reverse) > score(forward) else forward
+
+    if best_t <= eps:
+        forward = ring[best_idx:] + ring[:best_idx] + [ring[best_idx]]
+        reverse_ring = list(reversed(ring))
+        reverse_idx = reverse_ring.index(ring[best_idx])
+        reverse = (
+            reverse_ring[reverse_idx:]
+            + reverse_ring[:reverse_idx]
+            + [reverse_ring[reverse_idx]]
+        )
+        return choose_direction(forward, reverse)
+
+    next_idx = (best_idx + 1) % len(ring)
+    if best_t >= 1.0 - eps:
+        forward = ring[next_idx:] + ring[:next_idx] + [ring[next_idx]]
+        reverse_ring = list(reversed(ring))
+        reverse_idx = reverse_ring.index(ring[next_idx])
+        reverse = (
+            reverse_ring[reverse_idx:]
+            + reverse_ring[:reverse_idx]
+            + [reverse_ring[reverse_idx]]
+        )
+        return choose_direction(forward, reverse)
+
+    forward = [best_point]
+    for step in range(1, len(ring) + 1):
+        forward.append(ring[(best_idx + step) % len(ring)])
+    forward.append(best_point)
+
+    reverse = [best_point]
+    for step in range(0, len(ring)):
+        reverse.append(ring[(best_idx - step) % len(ring)])
+    reverse.append(best_point)
+    return choose_direction(forward, reverse)
+
+
+def _last_print_reference(output_list: list[dict]) -> tuple[float, float, float, float]:
+    x = y = 0.0
+    last_x = last_y = 0.0
+    last_dx = last_dy = 0.0
+    for move in output_list:
+        dx = float(move.get("X", 0.0))
+        dy = float(move.get("Y", 0.0))
+        x += dx
+        y += dy
+        if move.get("Color") == 255 and "Z" not in move:
+            last_x = x
+            last_y = y
+            last_dx = dx
+            last_dy = dy
+    return last_x, last_y, last_dx, last_dy
+
+
+def _rewind_trailing_travel(
+    output_list: list[dict],
+    current_x: float,
+    current_y: float,
+) -> tuple[float, float]:
+    if not output_list:
+        return current_x, current_y
+
+    last_move = output_list[-1]
+    if last_move.get("Color") != 0 or "Z" in last_move:
+        return current_x, current_y
+
+    has_layer_print = any(
+        move.get("Color") == 255 and "Z" not in move
+        for move in reversed(output_list[:-1])
+    )
+    if not has_layer_print:
+        return current_x, current_y
+
+    output_list.pop()
+    return (
+        current_x - float(last_move.get("X", 0.0)),
+        current_y - float(last_move.get("Y", 0.0)),
+    )
+
+
+def _contour_source_paths(source: dict, extract_root: Path, source_pos: int) -> list[Path]:
+    paths = source.get("tiff_paths") or source.get("paths") or []
+    if paths:
+        return sorted((Path(path) for path in paths), key=lambda path: _sort_key(path.name))
+
+    zip_path = source.get("zip_path")
+    if not zip_path:
+        return []
+    extract_dir = extract_root / f"source_{source_pos:03d}"
+    extract_dir.mkdir(parents=True, exist_ok=True)
+    return _extract_zip_tiffs(Path(zip_path), extract_dir)
+
+
+def _active_pixel_bounds(mask: np.ndarray) -> tuple[int, int, int, int] | None:
+    rows, cols = np.where(mask)
+    if len(rows) == 0:
+        return None
+    return int(rows.min()), int(rows.max()), int(cols.min()), int(cols.max())
+
+
+def _first_raster_row_start(mask: np.ndarray) -> tuple[int, int] | None:
+    rows = np.where(mask.any(axis=1))[0]
+    if len(rows) == 0:
+        return None
+    row = int(rows[0])
+    cols = np.where(mask[row])[0]
+    if len(cols) == 0:
+        return None
+    return row, int(cols[0])
+
+
+def _contour_pixel_offsets(
+    raster_pattern: str,
+    motion_mask: np.ndarray,
+    contour_mask: np.ndarray,
+) -> tuple[float, float]:
+    if raster_pattern == RASTER_PATTERN_SAME_DIRECTION:
+        first_row_start = _first_raster_row_start(motion_mask)
+        if first_row_start is None:
+            first_row_start = _first_raster_row_start(contour_mask)
+        if first_row_start is None:
+            return 0.0, 0.0
+        first_row, first_col = first_row_start
+        # The legacy X-raster infill path anchors every row to the first
+        # 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
+
+
+def _build_contour_layers(
+    contour_tiff_sets: list[dict] | None,
+    path_ref_list: list[np.ndarray],
+    pixel_size: float,
+    invert: bool,
+    off_color: int,
+    work_dir: Path,
+    raster_pattern: str,
+    layer_start_directions: list[int] | None = None,
+) -> list[list[dict]]:
+    contour_layers: list[list[dict]] = [[] for _ in path_ref_list]
+    if not contour_tiff_sets:
+        return contour_layers
+
+    extract_root = work_dir / "contour_sources"
+    for source_pos, source in enumerate(contour_tiff_sets):
+        try:
+            owner_idx = int(source.get("owner_idx", source.get("idx", source_pos + 1)))
+        except (TypeError, ValueError):
+            owner_idx = source_pos + 1
+
+        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):
+                continue
+            canvas_h, canvas_w = path_img.shape[:2]
+            contour_img = _load_grayscale(source_paths[layer_number], invert=invert)
+            if contour_img.shape[:2] != (canvas_h, canvas_w):
+                contour_img = _center_on_canvas(
+                    contour_img,
+                    canvas_h,
+                    canvas_w,
+                    fill=off_color,
+                )
+            contour_path_img = path_img
+            if raster_pattern == RASTER_PATTERN_SAME_DIRECTION and layer_number % 2 == 1:
+                contour_path_img = np.flipud(contour_path_img)
+                contour_img = np.flipud(contour_img)
+            if (
+                raster_pattern == RASTER_PATTERN_SAME_DIRECTION
+                and layer_start_directions is not None
+                and layer_number < len(layer_start_directions)
+                and layer_start_directions[layer_number] > 0
+            ):
+                contour_path_img = np.fliplr(contour_path_img)
+                contour_img = np.fliplr(contour_img)
+
+            contour_mask = contour_img > off_color
+            x_offset_px, y_offset_px = _contour_pixel_offsets(
+                raster_pattern,
+                contour_path_img > off_color,
+                contour_mask,
+            )
+            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}
+                )
+
+    return contour_layers
+
+
+def _same_direction_layer_start_directions(
+    path_ref_list: list[np.ndarray],
+    off_color: int,
+) -> list[int]:
+    directions: list[int] = []
+    direction = -1
+    for path_img in path_ref_list:
+        directions.append(direction)
+        nonblank_rows = int(np.count_nonzero((path_img > off_color).any(axis=1)))
+        if nonblank_rows % 2 == 1:
+            direction *= -1
+    return directions
+
+
+def _append_layer_contours(
+    output_list: list[dict],
+    current_x: float,
+    current_y: float,
+    contour_layers: list[list[dict]],
+    layer_number: int,
+    active_owner_idx: int | None,
+    origin_x: float = 0.0,
+    origin_y: float = 0.0,
+    x_scale: float = 1.0,
+    y_scale: float = 1.0,
+) -> tuple[float, float]:
+    if layer_number >= len(contour_layers):
+        return current_x, current_y
+
+    active_sources = [
+        source
+        for source in contour_layers[layer_number]
+        if source.get("owner_idx") == active_owner_idx
+        and any(len(contour) >= 2 for contour in source.get("contours", []))
+    ]
+    if not active_sources:
+        return current_x, current_y
+
+    current_x, current_y = _rewind_trailing_travel(
+        output_list,
+        current_x,
+        current_y,
+    )
+
+    first_start_x: float | None = None
+    first_start_y: float | None = None
+    use_infill_reference = True
+
+    for source in active_sources:
+        color = 255
+        for contour in source.get("contours", []):
+            if len(contour) < 2:
+                continue
+            contour = [
+                (origin_x + (x_scale * x), origin_y + (y_scale * y))
+                for x, y in contour
+            ]
+            if use_infill_reference:
+                nearest_x, nearest_y, approach_dx, approach_dy = _last_print_reference(
+                    output_list
+                )
+            else:
+                nearest_x, nearest_y = current_x, current_y
+                approach_dx, approach_dy = 0.0, 0.0
+            contour = _rotate_closed_contour_to_nearest_border(
+                contour,
+                nearest_x,
+                nearest_y,
+                approach_dx,
+                approach_dy,
+            )
+            if contour[0] != contour[-1]:
+                contour = [*contour, contour[0]]
+            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,
+                current_x,
+                current_y,
+                start_x,
+                start_y,
+                0,
+            )
+            for target_x, target_y in contour[1:]:
+                current_x, current_y = _append_relative_move(
+                    output_list,
+                    current_x,
+                    current_y,
+                    target_x,
+                    target_y,
+                    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
+
+
 def _woodpile_layer_segments(
     path_img: np.ndarray,
     color_img: np.ndarray,
@@ -320,10 +819,13 @@ def _build_footprint_raster_gcode_list(
     pixel_size: float,
     layer_height: float,
     raster_pattern: str,
+    contour_layers: list[list[dict]] | None = None,
+    active_contour_owner: int | None = None,
 ) -> list[dict]:
     gcode_list: list[dict] = []
     current_x = 0.0
     current_y = 0.0
+    contour_layers = contour_layers or []
 
     for layer_number, (path_img, color_img) in enumerate(zip(path_ref_list, color_ref_list)):
         raster_axis = _raster_axis_for_pattern(raster_pattern, layer_number)
@@ -331,6 +833,23 @@ def _build_footprint_raster_gcode_list(
         if not segments:
             if layer_number > 0:
                 gcode_list.append({"X": 0.0, "Y": 0.0, "Z": layer_height, "Color": 0})
+            layer_end_x, layer_end_y = current_x, current_y
+            current_x, current_y = _append_layer_contours(
+                gcode_list,
+                current_x,
+                current_y,
+                contour_layers,
+                layer_number,
+                active_contour_owner,
+            )
+            current_x, current_y = _append_relative_move(
+                gcode_list,
+                current_x,
+                current_y,
+                layer_end_x,
+                layer_end_y,
+                0,
+            )
             continue
 
         first_x, first_y = segments[0][0], segments[0][1]
@@ -372,6 +891,24 @@ def _build_footprint_raster_gcode_list(
                 color,
             )
 
+        layer_end_x, layer_end_y = current_x, current_y
+        current_x, current_y = _append_layer_contours(
+            gcode_list,
+            current_x,
+            current_y,
+            contour_layers,
+            layer_number,
+            active_contour_owner,
+        )
+        current_x, current_y = _append_relative_move(
+            gcode_list,
+            current_x,
+            current_y,
+            layer_end_x,
+            layer_end_y,
+            0,
+        )
+
     return gcode_list
 
 
@@ -388,6 +925,8 @@ def generate_snake_path_gcode(
     all_g1: bool = False,
     motion_tiffs: list[str] | None = None,
     raster_pattern: str | None = RASTER_PATTERN_SAME_DIRECTION,
+    contour_tiff_sets: list[dict] | None = None,
+    active_contour_owner: int | None = None,
 ) -> Path:
     zip_path = Path(zip_path)
     if not zip_path.exists():
@@ -435,6 +974,24 @@ def generate_snake_path_gcode(
         path_ref_list = [im.copy() for im in shape_imgs]
         color_ref_list = [im.copy() for im in shape_imgs]
 
+    layer_start_directions = None
+    if raster_pattern == RASTER_PATTERN_SAME_DIRECTION:
+        layer_start_directions = _same_direction_layer_start_directions(
+            path_ref_list,
+            off_color,
+        )
+
+    contour_layers = _build_contour_layers(
+        contour_tiff_sets,
+        path_ref_list,
+        fil_width,
+        invert,
+        off_color,
+        work_dir,
+        raster_pattern,
+        layer_start_directions,
+    )
+
     setpress_lines = [_setpress_cmd(com_port, pressure, start=True)]
     pressure_on_lines = [_toggle_cmd(com_port, start=True)]
     pressure_off_lines = [_toggle_cmd(com_port, start=False)]
@@ -446,9 +1003,13 @@ def generate_snake_path_gcode(
             fil_width,
             layer_height,
             raster_pattern,
+            contour_layers,
+            active_contour_owner,
         )
     else:
         gcode_list: list[dict] = []
+        current_x = 0.0
+        current_y = 0.0
         dist_sign_long = 1
         current_offsets_x: list[int] = []
         use_flip_y = False
@@ -504,6 +1065,8 @@ def generate_snake_path_gcode(
                 gcode_list.append(
                     {"X": shift_y, "Y": shift_x, "Z": layer_height, "Color": 0}
                 )
+                current_x += shift_y
+                current_y += shift_x
 
             for row in current_image_ref:
                 if all(p == off_color for p in row):
@@ -521,6 +1084,10 @@ def generate_snake_path_gcode(
 
             if layers == 0:
                 direction = -1
+            layer_start = len(gcode_list)
+            layer_origin_x, layer_origin_y = current_x, current_y
+            layer_x_scale = 1.0 if direction < 0 else -1.0
+            layer_y_scale = -1.0 if layers % 2 == 1 else 1.0
             direction = _gcode_layer(
                 ref_for_path,
                 current_image,
@@ -529,6 +1096,31 @@ def generate_snake_path_gcode(
                 direction,
                 layers,
             )
+            for move in gcode_list[layer_start:]:
+                current_x += float(move.get("X", 0.0))
+                current_y += float(move.get("Y", 0.0))
+
+            layer_end_x, layer_end_y = current_x, current_y
+            current_x, current_y = _append_layer_contours(
+                gcode_list,
+                current_x,
+                current_y,
+                contour_layers,
+                layers,
+                active_contour_owner,
+                layer_origin_x,
+                layer_origin_y,
+                layer_x_scale,
+                layer_y_scale,
+            )
+            current_x, current_y = _append_relative_move(
+                gcode_list,
+                current_x,
+                current_y,
+                layer_end_x,
+                layer_end_y,
+                off_color,
+            )
 
     gcode_path = work_dir / f"{shape_name}_SnakePath_gcode.txt"
     pressure_cur = float(pressure)