Add spiral raster patterns

README.md

@@ -93,7 +93,7 @@ The **Multi-Nozzle Split** accordion on the **STL to TIFF Slicer** tab can split
 - 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. 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.
+- **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. `Rectangular Spiral raster` walks each layer from the outer layer bounds toward the center, then reverses from center to edge on the next layer. `Circle Spiral raster` uses a shrinking circular spiral from the layer bounds toward the center, then reverses outward on the next layer.
 - **Auto Align Split Parts**: in Nozzle Spacing, fills Grid Layout gaps for split-piece alignment. X-direction raster uses X `-3.2` mm and Y `-0.8` mm; Y-direction raster switches those values.
 - **Contour Tracing**: enabled per row in Shape Settings. The app uses the shape-optimized row-envelope tracer, travels from the layer raster end to the nearest contour point, prints the contour, then returns to the raster endpoint before the next layer.
 

tests/test_tiff_to_gcode.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import math
 import zipfile
 
 import numpy as np
@@ -7,11 +8,17 @@ from PIL import Image
 
 from tiff_to_gcode import (
     CONTOUR_MODE_ROW_ENVELOPE,
+    RASTER_PATTERN_CIRCLE_SPIRAL,
+    RASTER_PATTERN_RECTANGULAR_SPIRAL,
     RASTER_PATTERN_SAME_DIRECTION,
     RASTER_PATTERN_WOODPILE,
     RASTER_PATTERN_Y_DIRECTION,
     _build_contour_layers,
     _append_layer_contours,
+    _circle_spiral_layer_segments,
+    _circle_spiral_points,
+    _rectangular_spiral_layer_segments,
+    _rectangular_spiral_positions,
     _trace_mask_contours,
     _trace_row_envelope_contours,
     generate_snake_path_gcode,
@@ -722,6 +729,141 @@ def test_woodpile_raster_switches_print_axis_between_layers(tmp_path) -> None:
     assert actual_restart_distance < old_restart_distance
 
 
+def test_rectangular_spiral_positions_walk_edge_to_center() -> None:
+    assert _rectangular_spiral_positions(0, 2, 0, 3) == [
+        (0, 0),
+        (0, 1),
+        (0, 2),
+        (0, 3),
+        (1, 3),
+        (2, 3),
+        (2, 2),
+        (2, 1),
+        (2, 0),
+        (1, 0),
+        (1, 1),
+        (1, 2),
+    ]
+
+
+def test_rectangular_spiral_segments_can_reverse_center_to_edge() -> None:
+    path_img = np.full((3, 3), 255, dtype=np.uint8)
+    color_img = np.full((3, 3), 255, dtype=np.uint8)
+
+    inward = _rectangular_spiral_layer_segments(path_img, color_img, 1.0)
+    outward = _rectangular_spiral_layer_segments(
+        path_img,
+        color_img,
+        1.0,
+        reverse=True,
+    )
+
+    assert inward[0] == (0.0, 0.5, 2.5, 0.5, 255)
+    assert inward[-1] == (0.5, 1.5, 2.0, 1.5, 255)
+    assert outward[0][:2] == inward[-1][2:4]
+    assert outward[-1][2:4] == inward[0][:2]
+
+
+def test_rectangular_spiral_raster_reverses_between_layers(tmp_path) -> None:
+    tiff_paths = []
+    for index in range(2):
+        tiff_path = tmp_path / f"slice_{index:04d}.tif"
+        Image.new("L", (3, 3), 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="rectangular_spiral",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        layer_height=1.0,
+        raster_pattern=RASTER_PATTERN_RECTANGULAR_SPIRAL,
+    )
+
+    moves = _moves_with_colors(gcode_path.read_text())
+    first_layer_change = next(
+        move for move in moves if move["end"][2] > move["start"][2]
+    )
+
+    assert first_layer_change["start"][:2] == first_layer_change["end"][:2]
+    end_x, end_y, end_z = moves[-1]["end"]
+    assert abs(end_x) < 1e-9
+    assert abs(end_y) < 1e-9
+    assert end_z == 1.0
+
+
+def test_circle_spiral_points_decrease_radius_to_center() -> None:
+    points = _circle_spiral_points(2.0, 3.0, outer_radius=4.0, pitch=1.0)
+    radii = [math.hypot(x - 2.0, y - 3.0) for x, y in points]
+
+    assert radii[0] == 4.0
+    assert radii[-1] == 0.0
+    assert all(
+        current <= previous + 1e-9
+        for previous, current in zip(radii, radii[1:])
+    )
+
+
+def test_circle_spiral_segments_can_reverse_center_to_edge() -> None:
+    path_img = np.full((5, 5), 255, dtype=np.uint8)
+    color_img = np.full((5, 5), 255, dtype=np.uint8)
+
+    inward = _circle_spiral_layer_segments(path_img, color_img, 1.0)
+    outward = _circle_spiral_layer_segments(
+        path_img,
+        color_img,
+        1.0,
+        reverse=True,
+    )
+
+    assert inward
+    assert outward
+    assert outward[0][:2] == inward[-1][2:4]
+    assert outward[-1][2:4] == inward[0][:2]
+
+
+def test_circle_spiral_raster_reverses_between_layers(tmp_path) -> None:
+    tiff_paths = []
+    for index in range(2):
+        tiff_path = tmp_path / f"slice_{index:04d}.tif"
+        Image.new("L", (5, 5), 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="circle_spiral",
+        pressure=25,
+        valve=7,
+        port=3,
+        fil_width=1.0,
+        layer_height=1.0,
+        raster_pattern=RASTER_PATTERN_CIRCLE_SPIRAL,
+    )
+
+    moves = _moves_with_colors(gcode_path.read_text())
+    first_layer_change = next(
+        move for move in moves if move["end"][2] > move["start"][2]
+    )
+
+    assert first_layer_change["start"][:2] == first_layer_change["end"][:2]
+    end_x, end_y, end_z = moves[-1]["end"]
+    assert abs(end_x) < 1e-9
+    assert abs(end_y) < 1e-9
+    assert end_z == 1.0
+
+
 def test_y_direction_raster_prints_each_layer_along_y_axis(tmp_path) -> None:
     tiff_paths = []
     for index in range(2):

tiff_to_gcode.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import math
 import os
 import tempfile
 import zipfile
@@ -15,10 +16,14 @@ from PIL import Image
 RASTER_PATTERN_SAME_DIRECTION = "X-direction raster"
 RASTER_PATTERN_Y_DIRECTION = "Y-direction raster"
 RASTER_PATTERN_WOODPILE = "Woodpile raster"
+RASTER_PATTERN_RECTANGULAR_SPIRAL = "Rectangular Spiral raster"
+RASTER_PATTERN_CIRCLE_SPIRAL = "Circle Spiral raster"
 RASTER_PATTERN_CHOICES = (
     RASTER_PATTERN_SAME_DIRECTION,
     RASTER_PATTERN_Y_DIRECTION,
     RASTER_PATTERN_WOODPILE,
+    RASTER_PATTERN_RECTANGULAR_SPIRAL,
+    RASTER_PATTERN_CIRCLE_SPIRAL,
 )
 CONTOUR_MODE_EXACT = "Exact pixel border"
 CONTOUR_MODE_ROW_ENVELOPE = "Shape-optimized row envelope"
@@ -28,6 +33,10 @@ CONTOUR_MODE_CHOICES = (
 )
 
 def _normalize_raster_pattern(pattern: str | None) -> str:
+    if pattern == RASTER_PATTERN_CIRCLE_SPIRAL:
+        return RASTER_PATTERN_CIRCLE_SPIRAL
+    if pattern == RASTER_PATTERN_RECTANGULAR_SPIRAL:
+        return RASTER_PATTERN_RECTANGULAR_SPIRAL
     if pattern == RASTER_PATTERN_WOODPILE:
         return RASTER_PATTERN_WOODPILE
     if pattern == RASTER_PATTERN_Y_DIRECTION:
@@ -996,6 +1005,250 @@ def _oriented_woodpile_layer_segments(
     )
 
 
+def _rectangular_spiral_positions(
+    top: int,
+    bottom: int,
+    left: int,
+    right: int,
+) -> list[tuple[int, int]]:
+    positions: list[tuple[int, int]] = []
+    while top <= bottom and left <= right:
+        for col in range(left, right + 1):
+            positions.append((top, col))
+        top += 1
+
+        for row in range(top, bottom + 1):
+            positions.append((row, right))
+        right -= 1
+
+        if top <= bottom:
+            for col in range(right, left - 1, -1):
+                positions.append((bottom, col))
+            bottom -= 1
+
+        if left <= right:
+            for row in range(bottom, top - 1, -1):
+                positions.append((row, left))
+            left += 1
+
+    return positions
+
+
+def _append_colored_segment(
+    segments: list[tuple[float, float, float, float, int]],
+    start_x: float,
+    start_y: float,
+    end_x: float,
+    end_y: float,
+    color: int,
+) -> None:
+    if start_x == end_x and start_y == end_y:
+        return
+
+    if segments:
+        prev_start_x, prev_start_y, prev_end_x, prev_end_y, prev_color = segments[-1]
+        if (
+            prev_color == color
+            and prev_end_x == start_x
+            and prev_end_y == start_y
+        ):
+            prev_dx = prev_end_x - prev_start_x
+            prev_dy = prev_end_y - prev_start_y
+            next_dx = end_x - start_x
+            next_dy = end_y - start_y
+            if abs((prev_dx * next_dy) - (prev_dy * next_dx)) < 1e-9:
+                segments[-1] = (
+                    prev_start_x,
+                    prev_start_y,
+                    end_x,
+                    end_y,
+                    color,
+                )
+                return
+
+    segments.append((start_x, start_y, end_x, end_y, color))
+
+
+def _rectangular_spiral_layer_segments(
+    path_img: np.ndarray,
+    color_img: np.ndarray,
+    pixel_size: float,
+    reverse: bool = False,
+) -> list[tuple[float, float, float, float, int]]:
+    bounds = _active_pixel_bounds(path_img > 0)
+    if bounds is None:
+        return []
+
+    top, bottom, left, right = bounds
+    positions = _rectangular_spiral_positions(top, bottom, left, right)
+    if reverse:
+        positions.reverse()
+    if not positions:
+        return []
+
+    def center(row: int, col: int) -> tuple[float, float]:
+        return (float(col) + 0.5) * pixel_size, (float(row) + 0.5) * pixel_size
+
+    def pixel_color(row: int, col: int) -> int:
+        return int(color_img[row, col])
+
+    segments: list[tuple[float, float, float, float, int]] = []
+    if len(positions) == 1:
+        row, col = positions[0]
+        y = (float(row) + 0.5) * pixel_size
+        _append_colored_segment(
+            segments,
+            float(col) * pixel_size,
+            y,
+            (float(col) + 1.0) * pixel_size,
+            y,
+            pixel_color(row, col),
+        )
+        return segments
+
+    centers = [center(row, col) for row, col in positions]
+    first_dx = centers[1][0] - centers[0][0]
+    first_dy = centers[1][1] - centers[0][1]
+    last_dx = centers[-1][0] - centers[-2][0]
+    last_dy = centers[-1][1] - centers[-2][1]
+
+    start_x = centers[0][0] - (first_dx * 0.5)
+    start_y = centers[0][1] - (first_dy * 0.5)
+    first_row, first_col = positions[0]
+    _append_colored_segment(
+        segments,
+        start_x,
+        start_y,
+        centers[0][0],
+        centers[0][1],
+        pixel_color(first_row, first_col),
+    )
+
+    for idx, ((row, col), (next_row, next_col)) in enumerate(
+        zip(positions, positions[1:])
+    ):
+        start_center_x, start_center_y = centers[idx]
+        end_center_x, end_center_y = centers[idx + 1]
+        mid_x = (start_center_x + end_center_x) / 2.0
+        mid_y = (start_center_y + end_center_y) / 2.0
+        _append_colored_segment(
+            segments,
+            start_center_x,
+            start_center_y,
+            mid_x,
+            mid_y,
+            pixel_color(row, col),
+        )
+        _append_colored_segment(
+            segments,
+            mid_x,
+            mid_y,
+            end_center_x,
+            end_center_y,
+            pixel_color(next_row, next_col),
+        )
+
+    last_row, last_col = positions[-1]
+    end_x = centers[-1][0] + (last_dx * 0.5)
+    end_y = centers[-1][1] + (last_dy * 0.5)
+    _append_colored_segment(
+        segments,
+        centers[-1][0],
+        centers[-1][1],
+        end_x,
+        end_y,
+        pixel_color(last_row, last_col),
+    )
+    return segments
+
+
+def _circle_spiral_points(
+    center_x: float,
+    center_y: float,
+    outer_radius: float,
+    pitch: float,
+) -> list[tuple[float, float]]:
+    if outer_radius <= 0.0:
+        return [(center_x, center_y)]
+
+    pitch = max(float(pitch), 1e-9)
+    sample_spacing = pitch
+    theta_max = (outer_radius / pitch) * 2.0 * math.pi
+    theta = 0.0
+    points = [(center_x + outer_radius, center_y)]
+
+    while theta < theta_max:
+        radius = max(outer_radius - (pitch * theta / (2.0 * math.pi)), 0.0)
+        d_theta = min(math.pi / 10.0, sample_spacing / max(radius, pitch))
+        theta = min(theta + d_theta, theta_max)
+        radius = max(outer_radius - (pitch * theta / (2.0 * math.pi)), 0.0)
+        points.append(
+            (
+                center_x + (radius * math.cos(theta)),
+                center_y + (radius * math.sin(theta)),
+            )
+        )
+
+    if points[-1] != (center_x, center_y):
+        points.append((center_x, center_y))
+    return points
+
+
+def _circle_spiral_layer_segments(
+    path_img: np.ndarray,
+    color_img: np.ndarray,
+    pixel_size: float,
+    reverse: bool = False,
+) -> list[tuple[float, float, float, float, int]]:
+    bounds = _active_pixel_bounds(path_img > 0)
+    if bounds is None:
+        return []
+
+    top, bottom, left, right = bounds
+    left_x = float(left) * pixel_size
+    right_x = float(right + 1) * pixel_size
+    top_y = float(top) * pixel_size
+    bottom_y = float(bottom + 1) * pixel_size
+    center_x = (left_x + right_x) / 2.0
+    center_y = (top_y + bottom_y) / 2.0
+    outer_radius = max(
+        math.hypot(corner_x - center_x, corner_y - center_y)
+        for corner_x, corner_y in (
+            (left_x, top_y),
+            (right_x, top_y),
+            (right_x, bottom_y),
+            (left_x, bottom_y),
+        )
+    )
+
+    points = _circle_spiral_points(center_x, center_y, outer_radius, pixel_size)
+    if reverse:
+        points.reverse()
+
+    height, width = color_img.shape[:2]
+
+    def point_color(x: float, y: float) -> int:
+        col = int(math.floor(x / pixel_size))
+        row = int(math.floor(y / pixel_size))
+        if row < 0 or row >= height or col < 0 or col >= width:
+            return 0
+        return int(color_img[row, col])
+
+    segments: list[tuple[float, float, float, float, int]] = []
+    for (start_x, start_y), (end_x, end_y) in zip(points, points[1:]):
+        mid_x = (start_x + end_x) / 2.0
+        mid_y = (start_y + end_y) / 2.0
+        _append_colored_segment(
+            segments,
+            start_x,
+            start_y,
+            end_x,
+            end_y,
+            point_color(mid_x, mid_y),
+        )
+    return segments
+
+
 def _build_footprint_raster_gcode_list(
     path_ref_list: list[np.ndarray],
     color_ref_list: list[np.ndarray],
@@ -1012,16 +1265,31 @@ def _build_footprint_raster_gcode_list(
     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)
-        segments = _oriented_woodpile_layer_segments(
-            path_img,
-            color_img,
-            pixel_size,
-            raster_axis,
-            current_x,
-            current_y,
-            prefer_default=not raster_origin_initialized,
-        )
+        if raster_pattern == RASTER_PATTERN_CIRCLE_SPIRAL:
+            segments = _circle_spiral_layer_segments(
+                path_img,
+                color_img,
+                pixel_size,
+                reverse=layer_number % 2 == 1,
+            )
+        elif raster_pattern == RASTER_PATTERN_RECTANGULAR_SPIRAL:
+            segments = _rectangular_spiral_layer_segments(
+                path_img,
+                color_img,
+                pixel_size,
+                reverse=layer_number % 2 == 1,
+            )
+        else:
+            raster_axis = _raster_axis_for_pattern(raster_pattern, layer_number)
+            segments = _oriented_woodpile_layer_segments(
+                path_img,
+                color_img,
+                pixel_size,
+                raster_axis,
+                current_x,
+                current_y,
+                prefer_default=not raster_origin_initialized,
+            )
         if not segments:
             if layer_number > 0:
                 gcode_list.append({"X": 0.0, "Y": 0.0, "Z": layer_height, "Color": 0})
@@ -1206,7 +1474,12 @@ def generate_snake_path_gcode(
     pressure_on_lines = [_toggle_cmd(com_port, start=True)]
     pressure_off_lines = [_toggle_cmd(com_port, start=False)]
 
-    if raster_pattern in (RASTER_PATTERN_Y_DIRECTION, RASTER_PATTERN_WOODPILE):
+    if raster_pattern in (
+        RASTER_PATTERN_Y_DIRECTION,
+        RASTER_PATTERN_WOODPILE,
+        RASTER_PATTERN_RECTANGULAR_SPIRAL,
+        RASTER_PATTERN_CIRCLE_SPIRAL,
+    ):
         gcode_list = _build_footprint_raster_gcode_list(
             path_ref_list,
             color_ref_list,