Add woodpile raster pattern

README.md

@@ -50,7 +50,7 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 - 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
-- Offers two G-code generation options: **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)
+- 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
 - Visualizes generated or uploaded G-code tool paths, with the source selectable from any active generated shape or an uploaded file
@@ -82,6 +82,7 @@ When you click **Generate Reference TIFF Stack**, the app combines available TIF
 - 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.
+- **Raster Pattern**: `Same-direction raster` keeps the existing back-and-forth raster direction on every layer. `Woodpile raster` alternates the raster axis by layer, switching between X-direction and Y-direction sweeps.
 
 ### Print vs Travel Classification
 

app.py

@@ -36,7 +36,11 @@ from stl_slicer import (
     scale_mesh,
     slice_stl_to_tiffs,
 )
-from tiff_to_gcode import generate_snake_path_gcode
+from tiff_to_gcode import (
+    RASTER_PATTERN_CHOICES,
+    RASTER_PATTERN_SAME_DIRECTION,
+    generate_snake_path_gcode,
+)
 
 
 ViewerState = dict[str, Any]
@@ -2208,6 +2212,7 @@ def generate_dynamic_gcode(
     settings_table: Any,
     all_g1: bool,
     use_reference_motion: bool,
+    raster_pattern: str | None,
     ref_state: ViewerState | None,
     layer_height: float,
     pixel_size: float,
@@ -2235,6 +2240,7 @@ def generate_dynamic_gcode(
                 fil_width=float(pixel_size),
                 all_g1=bool(all_g1),
                 motion_tiffs=motion_tiffs,
+                raster_pattern=raster_pattern,
             )
             record["gcode_path"] = str(gcode_path)
             messages.append(f"Shape {record['idx']}: wrote `{gcode_path.name}`.")
@@ -2568,6 +2574,12 @@ def build_dynamic_demo() -> gr.Blocks:
                 value=True,
             )
             gcode_all_g1 = gr.Checkbox(label="Move at one constant speed (no fast travel moves)", value=True)
+            gcode_raster_pattern = gr.Dropdown(
+                label="Raster Pattern",
+                choices=list(RASTER_PATTERN_CHOICES),
+                value=RASTER_PATTERN_SAME_DIRECTION,
+                allow_custom_value=False,
+            )
             gcode_button = gr.Button("Generate G-Code", variant="primary")
             gcode_downloads = gr.File(label="Download G-Code Files", file_count="multiple", interactive=False, elem_classes=["gcode-download"])
             gcode_status = gr.Markdown("")
@@ -2727,7 +2739,7 @@ def build_dynamic_demo() -> gr.Blocks:
 
         gcode_button.click(
             fn=generate_dynamic_gcode,
-            inputs=[shape_records, shape_settings, gcode_all_g1, gcode_use_ref_motion, ref_state, layer_height, pixel_size],
+            inputs=[shape_records, shape_settings, gcode_all_g1, gcode_use_ref_motion, gcode_raster_pattern, ref_state, layer_height, pixel_size],
             outputs=[shape_records, gcode_downloads, gcode_status, gcode_text_source, gcode_source],
         )
         gcode_text_source.change(fn=load_selected_gcode_text, inputs=[shape_records, gcode_text_source], outputs=[gcode_text])

tests/test_tiff_to_gcode.py

@@ -4,7 +4,7 @@ import zipfile
 
 from PIL import Image
 
-from tiff_to_gcode import generate_snake_path_gcode
+from tiff_to_gcode import RASTER_PATTERN_WOODPILE, generate_snake_path_gcode
 
 
 def test_gcode_header_writes_presets_before_initial_aux_commands(tmp_path) -> None:
@@ -61,3 +61,53 @@ def test_gcode_uses_g1_for_print_and_g0_for_travel(tmp_path) -> None:
     assert any(line.startswith("G1") and "; Color 255" in line for line in move_lines)
     assert all(not line.startswith("G0") for line in move_lines if "; Color 255" in line)
     assert all(not line.startswith("G1") for line in move_lines if "; Color 0" in line)
+
+
+def test_woodpile_raster_switches_print_axis_between_layers(tmp_path) -> None:
+    tiff_paths = []
+    for index in range(4):
+        tiff_path = tmp_path / f"slice_{index:04d}.tif"
+        Image.new("L", (3, 2), 0).save(tiff_path)
+        tiff_paths.append(tiff_path)
+
+    zip_path = tmp_path / "slices.zip"
+    with zipfile.ZipFile(zip_path, mode="w") as archive:
+        for tiff_path in tiff_paths:
+            archive.write(tiff_path, arcname=tiff_path.name)
+
+    gcode_path = generate_snake_path_gcode(
+        zip_path,
+        shape_name="woodpile",
+        pressure=25,
+        valve=7,
+        port=3,
+        raster_pattern=RASTER_PATTERN_WOODPILE,
+    )
+
+    move_lines = [
+        line.strip()
+        for line in gcode_path.read_text().splitlines()
+        if line.startswith(("G0", "G1"))
+    ]
+    z_move_index = next(i for i, line in enumerate(move_lines) if " Z" in line)
+    first_layer_prints = [line for line in move_lines[:z_move_index] if line.startswith("G1") and "; Color 255" in line]
+    second_layer_prints = [line for line in move_lines[z_move_index + 1 :] if line.startswith("G1") and "; Color 255" in line]
+
+    assert any("X" in line and "Y0" in line for line in first_layer_prints)
+    assert any("X0" in line and "Y" in line for line in second_layer_prints)
+
+    x = y = 0.0
+    x_positions = [x]
+    y_positions = [y]
+    for line in move_lines:
+        for token in line.split():
+            if token.startswith("X"):
+                x += float(token[1:])
+            if token.startswith("Y"):
+                y += float(token[1:])
+        x_positions.append(x)
+        y_positions.append(y)
+    assert min(x_positions) >= 0.0
+    assert max(x_positions) <= 3.0
+    assert min(y_positions) >= 0.0
+    assert max(y_positions) <= 2.0

tiff_to_gcode.py

@@ -11,6 +11,17 @@ import numpy as np
 from PIL import Image
 
 
+RASTER_PATTERN_SAME_DIRECTION = "Same-direction raster"
+RASTER_PATTERN_WOODPILE = "Woodpile raster"
+RASTER_PATTERN_CHOICES = (RASTER_PATTERN_SAME_DIRECTION, RASTER_PATTERN_WOODPILE)
+
+
+def _normalize_raster_pattern(pattern: str | None) -> str:
+    if pattern == RASTER_PATTERN_WOODPILE:
+        return RASTER_PATTERN_WOODPILE
+    return RASTER_PATTERN_SAME_DIRECTION
+
+
 def _setpress(pressure: float) -> str:
     pressure_str = str(int(pressure * 10)).zfill(4)
     command_bytes = bytes("08PS  " + pressure_str, "utf-8")
@@ -179,6 +190,175 @@ def _center_on_canvas(
     return out
 
 
+def _append_relative_move(
+    output_list: list[dict],
+    current_x: float,
+    current_y: float,
+    target_x: float,
+    target_y: float,
+    color: int,
+    z_step: float | None = None,
+) -> tuple[float, float]:
+    dx = target_x - current_x
+    dy = target_y - current_y
+    if dx == 0 and dy == 0 and z_step is None:
+        return current_x, current_y
+    move = {"X": dx, "Y": dy, "Color": color}
+    if z_step is not None:
+        move["Z"] = z_step
+    output_list.append(move)
+    return target_x, target_y
+
+
+def _woodpile_layer_segments(
+    path_img: np.ndarray,
+    color_img: np.ndarray,
+    pixel_size: float,
+    raster_axis: str,
+) -> list[tuple[float, float, float, float, int]]:
+    mask = path_img > 0
+    segments: list[tuple[float, float, float, float, int]] = []
+
+    if raster_axis == "Y":
+        first_nonblank = np.where(mask.any(axis=0), mask.argmax(axis=0), -1)
+        last_nonblank = np.where(
+            mask.any(axis=0),
+            mask.shape[0] - 1 - np.flipud(mask).argmax(axis=0),
+            -1,
+        )
+        for col_number, col in enumerate(np.where(first_nonblank != -1)[0]):
+            f_idx, l_idx = int(first_nonblank[col]), int(last_nonblank[col])
+            if f_idx == -1:
+                continue
+            forward = col_number % 2 == 0
+            row_values = list(range(f_idx, l_idx + 1)) if forward else list(range(l_idx, f_idx - 1, -1))
+            run_start = row_values[0]
+            prev_row = row_values[0]
+            prev_color = int(color_img[prev_row, col])
+            x = (int(col) + 0.5) * pixel_size
+            for row in row_values[1:]:
+                this_color = int(color_img[row, col])
+                if this_color == prev_color:
+                    prev_row = row
+                    continue
+                if forward:
+                    start_y = run_start * pixel_size
+                    end_y = (prev_row + 1) * pixel_size
+                else:
+                    start_y = (run_start + 1) * pixel_size
+                    end_y = prev_row * pixel_size
+                segments.append((x, start_y, x, end_y, prev_color))
+                run_start = prev_row = row
+                prev_color = this_color
+            if forward:
+                start_y = run_start * pixel_size
+                end_y = (prev_row + 1) * pixel_size
+            else:
+                start_y = (run_start + 1) * pixel_size
+                end_y = prev_row * pixel_size
+            segments.append((x, start_y, x, end_y, prev_color))
+        return segments
+
+    first_nonblank = np.where(mask.any(axis=1), mask.argmax(axis=1), -1)
+    last_nonblank = np.where(
+        mask.any(axis=1),
+        mask.shape[1] - 1 - np.fliplr(mask).argmax(axis=1),
+        -1,
+    )
+    for row_number, row in enumerate(np.where(first_nonblank != -1)[0]):
+        f_idx, l_idx = int(first_nonblank[row]), int(last_nonblank[row])
+        if f_idx == -1:
+            continue
+        forward = row_number % 2 == 0
+        col_values = list(range(f_idx, l_idx + 1)) if forward else list(range(l_idx, f_idx - 1, -1))
+        run_start = col_values[0]
+        prev_col = col_values[0]
+        prev_color = int(color_img[row, prev_col])
+        y = (int(row) + 0.5) * pixel_size
+        for col in col_values[1:]:
+            this_color = int(color_img[row, col])
+            if this_color == prev_color:
+                prev_col = col
+                continue
+            if forward:
+                start_x = run_start * pixel_size
+                end_x = (prev_col + 1) * pixel_size
+            else:
+                start_x = (run_start + 1) * pixel_size
+                end_x = prev_col * pixel_size
+            segments.append((start_x, y, end_x, y, prev_color))
+            run_start = prev_col = col
+            prev_color = this_color
+        if forward:
+            start_x = run_start * pixel_size
+            end_x = (prev_col + 1) * pixel_size
+        else:
+            start_x = (run_start + 1) * pixel_size
+            end_x = prev_col * pixel_size
+        segments.append((start_x, y, end_x, y, prev_color))
+    return segments
+
+
+def _build_woodpile_gcode_list(
+    path_ref_list: list[np.ndarray],
+    color_ref_list: list[np.ndarray],
+    pixel_size: float,
+    layer_height: float,
+) -> list[dict]:
+    gcode_list: list[dict] = []
+    current_x = 0.0
+    current_y = 0.0
+
+    for layer_number, (path_img, color_img) in enumerate(zip(path_ref_list, color_ref_list)):
+        raster_axis = "X" if layer_number % 2 == 0 else "Y"
+        segments = _woodpile_layer_segments(path_img, color_img, pixel_size, raster_axis)
+        if not segments:
+            if layer_number > 0:
+                gcode_list.append({"X": 0.0, "Y": 0.0, "Z": layer_height, "Color": 0})
+            continue
+
+        first_x, first_y = segments[0][0], segments[0][1]
+        if layer_number > 0:
+            current_x, current_y = _append_relative_move(
+                gcode_list,
+                current_x,
+                current_y,
+                first_x,
+                first_y,
+                0,
+                z_step=layer_height,
+            )
+        else:
+            current_x, current_y = _append_relative_move(
+                gcode_list,
+                current_x,
+                current_y,
+                first_x,
+                first_y,
+                0,
+            )
+
+        for start_x, start_y, end_x, end_y, color in segments:
+            current_x, current_y = _append_relative_move(
+                gcode_list,
+                current_x,
+                current_y,
+                start_x,
+                start_y,
+                0,
+            )
+            current_x, current_y = _append_relative_move(
+                gcode_list,
+                current_x,
+                current_y,
+                end_x,
+                end_y,
+                color,
+            )
+
+    return gcode_list
+
+
 def generate_snake_path_gcode(
     zip_path: str | Path,
     shape_name: str,
@@ -191,10 +371,12 @@ def generate_snake_path_gcode(
     increase_pressure_per_layer: float = 0.1,
     all_g1: bool = False,
     motion_tiffs: list[str] | None = None,
+    raster_pattern: str | None = RASTER_PATTERN_SAME_DIRECTION,
 ) -> Path:
     zip_path = Path(zip_path)
     if not zip_path.exists():
         raise FileNotFoundError(f"ZIP file not found: {zip_path}")
+    raster_pattern = _normalize_raster_pattern(raster_pattern)
 
     work_dir = Path(tempfile.mkdtemp(prefix="tiff_gcode_"))
     extract_dir = work_dir / "tiffs"
@@ -241,87 +423,95 @@ def generate_snake_path_gcode(
     pressure_on_lines = [_toggle_cmd(com_port, start=True)]
     pressure_off_lines = [_toggle_cmd(com_port, start=False)]
 
-    gcode_list: list[dict] = []
-    dist_sign_long = 1
-    current_offsets_x: list[int] = []
-    use_flip_y = False
-    direction = -1
-
-    for layers in range(len(path_ref_list)):
-        current_image_ref = path_ref_list[layers]
-        last_image_ref = path_ref_list[layers - 1] if layers > 0 else None
-        y_ref = current_image_ref.shape[0]
-
-        def find_first_valid_y(row: np.ndarray | None, flip: bool = False) -> int | None:
-            if row is None:
+    if raster_pattern == RASTER_PATTERN_WOODPILE:
+        gcode_list = _build_woodpile_gcode_list(
+            path_ref_list,
+            color_ref_list,
+            fil_width,
+            layer_height,
+        )
+    else:
+        gcode_list: list[dict] = []
+        dist_sign_long = 1
+        current_offsets_x: list[int] = []
+        use_flip_y = False
+        direction = -1
+
+        for layers in range(len(path_ref_list)):
+            current_image_ref = path_ref_list[layers]
+            last_image_ref = path_ref_list[layers - 1] if layers > 0 else None
+            y_ref = current_image_ref.shape[0]
+
+            def find_first_valid_y(row: np.ndarray | None, flip: bool = False) -> int | None:
+                if row is None:
+                    return None
+                row_data = np.flip(row) if flip else row
+                for j, pixel in enumerate(row_data):
+                    if np.any(pixel) != off_color:
+                        return y_ref - 1 - j if flip else j
                 return None
-            row_data = np.flip(row) if flip else row
-            for j, pixel in enumerate(row_data):
-                if np.any(pixel) != off_color:
-                    return y_ref - 1 - j if flip else j
-            return None
-
-        last_x = last_y = None
-        if current_offsets_x:
-            use_flip_x = layers % 2 == 1
-            last_x = current_offsets_x[-1] if use_flip_x else current_offsets_x[0]
-            last_row = (
-                last_image_ref[last_x] if last_image_ref is not None else None
-            )
-            last_y = find_first_valid_y(last_row, flip=use_flip_y)
-            current_offsets_x.clear()
-
-        current_offsets_x = [
-            i for i, row in enumerate(current_image_ref) if np.any(row) != off_color
-        ]
-
-        first_x = first_y = None
-        if current_offsets_x:
-            use_flip_x = layers % 2 == 1
-            first_x = current_offsets_x[-1] if use_flip_x else current_offsets_x[0]
-            first_row = current_image_ref[first_x]
-            first_y = find_first_valid_y(first_row, flip=use_flip_y)
-
-        if None in (last_x, last_y, first_x, first_y):
-            shift_x = shift_y = 0
-        else:
-            shift_x = (first_x - last_x) * fil_width
-            shift_y = (first_y - last_y) * fil_width * dist_sign_long
-            if use_flip_y:
-                shift_y = -shift_y
 
-        if len(current_offsets_x) % 2 == 1:
-            use_flip_y = not use_flip_y
+            last_x = last_y = None
+            if current_offsets_x:
+                use_flip_x = layers % 2 == 1
+                last_x = current_offsets_x[-1] if use_flip_x else current_offsets_x[0]
+                last_row = (
+                    last_image_ref[last_x] if last_image_ref is not None else None
+                )
+                last_y = find_first_valid_y(last_row, flip=use_flip_y)
+                current_offsets_x.clear()
+
+            current_offsets_x = [
+                i for i, row in enumerate(current_image_ref) if np.any(row) != off_color
+            ]
+
+            first_x = first_y = None
+            if current_offsets_x:
+                use_flip_x = layers % 2 == 1
+                first_x = current_offsets_x[-1] if use_flip_x else current_offsets_x[0]
+                first_row = current_image_ref[first_x]
+                first_y = find_first_valid_y(first_row, flip=use_flip_y)
+
+            if None in (last_x, last_y, first_x, first_y):
+                shift_x = shift_y = 0
+            else:
+                shift_x = (first_x - last_x) * fil_width
+                shift_y = (first_y - last_y) * fil_width * dist_sign_long
+                if use_flip_y:
+                    shift_y = -shift_y
 
-        if layers > 0:
-            gcode_list.append(
-                {"X": shift_y, "Y": shift_x, "Z": layer_height, "Color": 0}
-            )
+            if len(current_offsets_x) % 2 == 1:
+                use_flip_y = not use_flip_y
+
+            if layers > 0:
+                gcode_list.append(
+                    {"X": shift_y, "Y": shift_x, "Z": layer_height, "Color": 0}
+                )
 
-        for row in current_image_ref:
-            if all(p == off_color for p in row):
+            for row in current_image_ref:
+                if all(p == off_color for p in row):
+                    dist_sign_long = -dist_sign_long
                 dist_sign_long = -dist_sign_long
-            dist_sign_long = -dist_sign_long
 
-        # Flip path and color together on even layers so they stay aligned.
-        even_layer = (layers + 1) % 2 == 0
-        ref_for_path = (
-            np.flipud(current_image_ref) if even_layer else current_image_ref.copy()
-        )
-        current_image = (
-            np.flipud(color_ref_list[layers]) if even_layer else color_ref_list[layers]
-        )
+            # Flip path and color together on even layers so they stay aligned.
+            even_layer = (layers + 1) % 2 == 0
+            ref_for_path = (
+                np.flipud(current_image_ref) if even_layer else current_image_ref.copy()
+            )
+            current_image = (
+                np.flipud(color_ref_list[layers]) if even_layer else color_ref_list[layers]
+            )
 
-        if layers == 0:
-            direction = -1
-        direction = _gcode_layer(
-            ref_for_path,
-            current_image,
-            gcode_list,
-            fil_width,
-            direction,
-            layers,
-        )
+            if layers == 0:
+                direction = -1
+            direction = _gcode_layer(
+                ref_for_path,
+                current_image,
+                gcode_list,
+                fil_width,
+                direction,
+                layers,
+            )
 
     gcode_path = work_dir / f"{shape_name}_SnakePath_gcode.txt"
     pressure_cur = float(pressure)