Add reference-stack motion option and global G-code toggles

New options on the TIFF Slices to GCode tab:
- "Use Reference Stack for motion" (default on): every shape shares one
nozzle path derived from the combined Reference TIFF Stack, while the
valve still follows each shape, so parallel heads move in lockstep and
each dispenses only its own geometry. The shape slice is centred onto
the reference canvas to align with the motion path; layers beyond a
shape's height move without dispensing. Skips with a clear message if
no Reference TIFF Stack has been generated.
- "Use G1 for all moves" promoted from three per-shape checkboxes to one
global checkbox (default on) applied to every shape.

generate_snake_path_gcode now takes separate path (motion) and color
(valve) image sources; default behavior is unchanged.

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

app.py

@@ -962,6 +962,9 @@ def run_all_tiff_to_gcode(
     pressure3: float,
     valve3: float,
     port3: float,
+    all_g1: bool = False,
+    use_reference_motion: bool = False,
+    ref_state: ViewerState | None = None,
     layer_height: float = 0.8,
     pixel_size: float = 0.8,
 ) -> tuple[str | None, str | None, str | None, str]:
@@ -971,6 +974,12 @@ def run_all_tiff_to_gcode(
         (3, zip3, pressure3, valve3, port3),
     ]
 
+    # When reference-driven motion is requested, every shape's nozzle path comes
+    # from the combined Reference TIFF Stack; the valve still follows each shape.
+    motion_tiffs: list[str] | None = None
+    if use_reference_motion:
+        motion_tiffs = (ref_state or {}).get("tiff_paths") or None
+
     outputs: list[str | None] = [None, None, None]
     messages: list[str] = []
 
@@ -979,6 +988,13 @@ def run_all_tiff_to_gcode(
             messages.append(f"Shape {idx}: skipped (no TIFF ZIP available).")
             continue
 
+        if use_reference_motion and not motion_tiffs:
+            messages.append(
+                f"Shape {idx}: skipped (Reference motion selected, but no Reference "
+                f"TIFF Stack has been generated on the first tab)."
+            )
+            continue
+
         zip_name = Path(zip_path).stem
         default_shape_name = f"shape{idx}"
         shape_name = zip_name.replace("_tiff_slices", "") or default_shape_name
@@ -992,6 +1008,8 @@ def run_all_tiff_to_gcode(
                 port=int(port),
                 layer_height=float(layer_height),
                 fil_width=float(pixel_size),
+                all_g1=bool(all_g1),
+                motion_tiffs=motion_tiffs,
             )
             outputs[idx - 1] = str(gcode_path)
             messages.append(f"Shape {idx}: wrote `{gcode_path.name}`.")
@@ -1602,6 +1620,14 @@ def build_demo() -> gr.Blocks:
                                     precision=0,
                                 )
 
+            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.",
+                value=True,
+            )
+            gcode_all_g1 = gr.Checkbox(
+                label="Use G1 for all moves (no G0 travel commands) — applies to all shapes",
+                value=True,
+            )
             gcode_button = gr.Button("Generate G-Code", variant="primary")
 
             with gr.Row():
@@ -1642,6 +1668,9 @@ def build_demo() -> gr.Blocks:
                     gcode_pressure_3,
                     gcode_valve_3,
                     gcode_port_3,
+                    gcode_all_g1,
+                    gcode_use_ref_motion,
+                    ref_state,
                     layer_height,
                     pixel_size,
                 ],

tiff_to_gcode.py

@@ -163,6 +163,22 @@ def _load_grayscale(path: Path, invert: bool) -> np.ndarray:
     return array
 
 
+def _center_on_canvas(
+    img: np.ndarray, canvas_h: int, canvas_w: int, fill: int = 0
+) -> np.ndarray:
+    """Place `img` centred on a (canvas_h, canvas_w) canvas filled with `fill`.
+
+    Mirrors the centring used to build the reference stack, so a shape's slice
+    lines up pixel-for-pixel with the reference (motion) slice of the same layer.
+    """
+    h, w = img.shape[:2]
+    out = np.full((canvas_h, canvas_w), fill, dtype=img.dtype)
+    y_off = max(0, (canvas_h - h) // 2)
+    x_off = max(0, (canvas_w - w) // 2)
+    out[y_off : y_off + h, x_off : x_off + w] = img[: canvas_h, : canvas_w]
+    return out
+
+
 def generate_snake_path_gcode(
     zip_path: str | Path,
     shape_name: str,
@@ -173,6 +189,8 @@ def generate_snake_path_gcode(
     fil_width: float = 0.8,
     invert: bool = True,
     increase_pressure_per_layer: float = 0.1,
+    all_g1: bool = False,
+    motion_tiffs: list[str] | None = None,
 ) -> Path:
     zip_path = Path(zip_path)
     if not zip_path.exists():
@@ -185,19 +203,40 @@ def generate_snake_path_gcode(
     if not tiff_files:
         raise ValueError("No TIFF files found in the ZIP archive.")
 
-    ref_list: list[np.ndarray] = []
-    img_list: list[np.ndarray] = []
-    for i, path in enumerate(tiff_files):
-        img = _load_grayscale(path, invert=invert)
-        ref_list.append(img.copy())
-        if (i + 1) % 2 == 0:
-            img = np.flipud(img)
-        img_list.append(img)
-
     off_color = 0
     com_port = f"serialPort{port}"
     color_dict: dict[int, int] = {0: 100, 255: valve}
 
+    # Two non-flipped source image lists. The "path" images drive the nozzle
+    # motion (which rows are swept, the sweep extent, the inter-layer shifts);
+    # the "color" images decide the valve state (material) at each swept pixel.
+    # Normally both are this shape's own slices. When reference motion tiffs are
+    # supplied, motion comes from the combined reference stack while the valve is
+    # still driven by this shape's slices, centred onto the reference canvas — so
+    # parallel heads share one motion path but each dispenses only its geometry.
+    shape_imgs = [_load_grayscale(p, invert=invert) for p in tiff_files]
+
+    if motion_tiffs:
+        motion_paths = sorted(
+            (Path(p) for p in motion_tiffs), key=lambda p: _sort_key(p.name)
+        )
+        path_ref_list = [_load_grayscale(p, invert=invert) for p in motion_paths]
+        if not path_ref_list:
+            raise ValueError("No reference TIFF files provided for motion.")
+        color_ref_list: list[np.ndarray] = []
+        for li, motion_img in enumerate(path_ref_list):
+            h_c, w_c = motion_img.shape[:2]
+            if li < len(shape_imgs):
+                color_ref_list.append(
+                    _center_on_canvas(shape_imgs[li], h_c, w_c, fill=off_color)
+                )
+            else:
+                # Reference is taller than this shape: move but dispense nothing.
+                color_ref_list.append(np.full((h_c, w_c), off_color, dtype=np.uint8))
+    else:
+        path_ref_list = [im.copy() for im in shape_imgs]
+        color_ref_list = [im.copy() for im in shape_imgs]
+
     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)]
@@ -208,10 +247,9 @@ def generate_snake_path_gcode(
     use_flip_y = False
     direction = -1
 
-    for layers in range(len(img_list)):
-        current_image = img_list[layers]
-        current_image_ref = ref_list[layers]
-        last_image_ref = ref_list[layers - 1] if layers > 0 else None
+    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:
@@ -265,9 +303,14 @@ def generate_snake_path_gcode(
                 dist_sign_long = -dist_sign_long
             dist_sign_long = -dist_sign_long
 
-        ref_for_path = current_image_ref.copy()
-        if (layers + 1) % 2 == 0:
-            ref_for_path = np.flipud(ref_for_path)
+        # 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
@@ -306,7 +349,9 @@ def generate_snake_path_gcode(
                         f.write(_valve_cmd(color_dict[cur_color], 1))
                         f.write(_valve_cmd(color_dict[prev_color], 0))
 
-            move_type = "G1" if cur_color != off_color else "G0"
+            # When all_g1 is set, every move is emitted as G1 regardless of
+            # valve state; the valve commands still mark print vs travel.
+            move_type = "G1" if (all_g1 or cur_color != off_color) else "G0"
             if "Z" in move:
                 line = (
                     f"{move_type} X{move['X']} Y{move['Y']} Z{move['Z']} "