Add nozzle spacing controls and visualization

README.md

@@ -50,10 +50,11 @@ Then open the local Gradio URL in your browser, upload STL files or load the bun
 - Combines generated stacks into a reference TIFF stack
 - Converts generated TIFF ZIPs into G-code files with pressure, valve, and port settings per shape
 - 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)
+- Calculates X/Y nozzle spacing from shared or separate Shape 1->2 and Shape 2->3 spacing values, then visualizes the resulting nozzle layout
 - Previews each shape's generated G-code inline (text boxes under the downloads)
 - Visualizes generated or uploaded G-code tool paths, with the source selectable from Shape 1/2/3 or an uploaded file
 - Renders the tool path as a fast line plot or an animated 3D tube plot (play/pause, speed, scrub, frame-step, nozzle marker)
-- Plots all three shapes side by side (offset in X) and animates them printing in parallel, with a server-side GIF export of that animation
+- Plots all three shapes using the configured nozzle spacing and animates them printing in parallel, with a server-side GIF export of that animation
 
 ## Behavior and Implementation Notes
 
@@ -99,7 +100,7 @@ The G-code visualization tab renders the generated Shape 1/2/3 G-code or an uplo
 
 ### Parallel Printing Visualization
 
-The fourth tab plots all three shapes' G-code at once, offset along X so they do not overlap, 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 all three 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.
 
 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

@@ -22,6 +22,7 @@ from PIL import Image, ImageDraw, ImageFont
 import trimesh
 
 from gcode_viewer import (
+    build_nozzle_spacing_figure,
     build_parallel_figure,
     build_parallel_gif,
     build_toolpath_figure,
@@ -91,20 +92,26 @@ APP_CSS = """
 }
 
 #load-sample-stls-button,
-#load-sample-stls-button button {
+#load-sample-stls-button button,
+#visualize-nozzle-spacing-button,
+#visualize-nozzle-spacing-button button {
     background: #f97316 !important;
     border-color: #ea580c !important;
     color: #ffffff !important;
 }
 
 #load-sample-stls-button:hover,
-#load-sample-stls-button button:hover {
+#load-sample-stls-button button:hover,
+#visualize-nozzle-spacing-button:hover,
+#visualize-nozzle-spacing-button button:hover {
     background: #ea580c !important;
     border-color: #c2410c !important;
 }
 
 #load-sample-stls-button:focus-visible,
-#load-sample-stls-button button:focus-visible {
+#load-sample-stls-button button:focus-visible,
+#visualize-nozzle-spacing-button:focus-visible,
+#visualize-nozzle-spacing-button button:focus-visible {
     box-shadow: 0 0 0 2px rgba(249, 115, 22, 0.35) !important;
 }
 
@@ -744,7 +751,8 @@ def _format_model_details(
     lines = [
         "### Model Details",
         f"- Source: `{source_name}`",
-        f"- Extents: `{extents[0]:.3f} x {extents[1]:.3f} x {extents[2]:.3f}`",
+        f"- Dimensions (mm): `X {extents[0]:.3f}, Y {extents[1]:.3f}, Z {extents[2]:.3f}`",
+        f"- Footprint (mm): `X {extents[0]:.3f} x Y {extents[1]:.3f}`",
     ]
 
     if scale_factors and not all(math.isclose(value, 1.0) for value in scale_factors):
@@ -1740,21 +1748,17 @@ PARALLEL_COLOR_CHOICES = [
     ("Red", "#d62728"), ("Purple", "#9467bd"), ("Pink", "#e377c2"),
     ("Teal", "#17becf"), ("Black", "#000000"),
 ]
+DEFAULT_PARALLEL_COLORS = ("#ff7f0e", "#1f77b4", "#2ca02c")
 
 
-def render_parallel(
+def _load_parallel_parts(
     path1: str | None,
     path2: str | None,
     path3: str | None,
     color1: str,
     color2: str,
     color3: str,
-    travel_opacity: float,
-    filament_width: float,
-    travel_width: float,
-    gap: float,
-    tube: bool = True,
-) -> tuple[Any, str]:
+) -> tuple[list[dict], list[str]]:
     specs = [(1, path1, color1), (2, path2, color2), (3, path3, color3)]
     parts: list[dict] = []
     messages: list[str] = []
@@ -1774,17 +1778,188 @@ def render_parallel(
         parts.append({"idx": idx, "color": color, "parsed": parsed})
         messages.append(f"Shape {idx}: {parsed['point_count']} moves, {parsed.get('layer_count', 0)} layer(s).")
 
+    return parts, messages
+
+
+def _resolve_nozzle_layout(
+    parts: list[dict],
+    same_spacing: bool | None,
+    part_gap_12_x: float | None,
+    part_gap_12_y: float | None,
+    part_gap_23_x: float | None,
+    part_gap_23_y: float | None,
+) -> tuple[dict[int, tuple[float, float]], list[dict]]:
+    offsets: dict[int, tuple[float, float]] = {}
+    spacings: list[dict] = []
+    if not parts:
+        return offsets, spacings
+
+    ordered = sorted(parts, key=lambda part: part["idx"])
+    offsets[ordered[0]["idx"]] = (0.0, 0.0)
+
+    pair_spacing = {
+        (1, 2): (float(part_gap_12_x or 0.0), float(part_gap_12_y or 0.0)),
+        (2, 3): (
+            float(part_gap_12_x or 0.0) if same_spacing else float(part_gap_23_x or 0.0),
+            float(part_gap_12_y or 0.0) if same_spacing else float(part_gap_23_y or 0.0),
+        ),
+    }
+
+    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 prev_idx == 1 and cur_idx == 3:
+            x12, y12 = pair_spacing[(1, 2)]
+            x23, y23 = pair_spacing[(2, 3)]
+            return x12 + x23, y12 + y23
+        return 0.0, 0.0
+
+    for previous, current in zip(ordered, ordered[1:]):
+        prev_idx = previous["idx"]
+        cur_idx = current["idx"]
+        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"]
+        dx = (prev_xmax + prev_offset_x + gap_x) - cur_xmin
+        dy = prev_offset_y + y_step
+        offsets[cur_idx] = (dx, dy)
+        spacings.append({
+            "from": prev_idx,
+            "to": cur_idx,
+            "dx": dx - prev_offset_x,
+            "dy": y_step,
+        })
+
+    return offsets, spacings
+
+
+def _same_spacing_from_individual(use_individual_spacing: bool | None) -> bool:
+    return not bool(use_individual_spacing)
+
+
+def update_individual_nozzle_spacing_visibility(
+    use_individual_spacing: bool | None,
+) -> dict[str, Any]:
+    return gr.update(visible=bool(use_individual_spacing))
+
+
+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"]
+        lines.append(
+            f"Shape {part['idx']}: X {xmax - xmin:.2f} mm, "
+            f"Y {ymax - ymin:.2f} mm, Z {zmax - zmin:.2f} mm."
+        )
+    return lines
+
+
+def _format_nozzle_spacing_status(
+    parts: list[dict],
+    offsets: dict[int, tuple[float, float]],
+    spacings: list[dict],
+) -> str:
+    lines = _format_shape_dimensions(parts)
+    ordered_nozzles = sorted(offsets)
+    if ordered_nozzles:
+        lines.append("**Nozzle coordinates:**")
+        for idx in ordered_nozzles:
+            x, y = offsets[idx]
+            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.")
+        return "  \n".join(lines)
+
+    lines.append("**Nozzle-to-nozzle distances:**")
+    for first_pos, first_idx in enumerate(ordered_nozzles):
+        for second_idx in ordered_nozzles[first_pos + 1:]:
+            x0, y0 = offsets[first_idx]
+            x1, y1 = offsets[second_idx]
+            dx = x1 - x0
+            dy = y1 - y0
+            distance = math.hypot(dx, dy)
+            angle = math.degrees(math.atan2(dy, dx)) if distance else 0.0
+            lines.append(
+                f"Nozzle {first_idx} -> {second_idx}: "
+                f"Delta X {dx:.2f} mm, Delta Y {dy:.2f} mm; "
+                f"distance {distance:.2f} mm at {angle:.1f} deg."
+            )
+
+    lines.append("**Adjacent spacing inputs:**")
+    for spacing in spacings:
+        lines.append(
+            f"Nozzle {spacing['from']} -> {spacing['to']}: "
+            f"X {spacing['dx']:.2f} mm, Y {spacing['dy']:.2f} mm."
+        )
+    return "  \n".join(lines)
+
+
+def render_nozzle_spacing_preview(
+    path1: str | None,
+    path2: str | None,
+    path3: str | None,
+    use_individual_spacing: bool,
+    part_gap_12_x: float,
+    part_gap_12_y: float,
+    part_gap_23_x: float,
+    part_gap_23_y: float,
+) -> tuple[Any, str]:
+    parts, _messages = _load_parallel_parts(path1, path2, path3, *DEFAULT_PARALLEL_COLORS)
+    if not parts:
+        return None, "No shape G-code available. Generate G-code first."
+    offsets, spacings = _resolve_nozzle_layout(
+        parts,
+        _same_spacing_from_individual(use_individual_spacing),
+        part_gap_12_x,
+        part_gap_12_y,
+        part_gap_23_x,
+        part_gap_23_y,
+    )
+    figure = build_nozzle_spacing_figure(parts, offsets, spacings)
+    return figure, _format_nozzle_spacing_status(parts, offsets, spacings)
+
+
+def render_parallel(
+    path1: str | None,
+    path2: str | None,
+    path3: str | None,
+    color1: str,
+    color2: str,
+    color3: str,
+    travel_opacity: float,
+    filament_width: float,
+    travel_width: float,
+    use_individual_spacing: bool,
+    part_gap_12_x: float,
+    part_gap_12_y: float,
+    part_gap_23_x: float,
+    part_gap_23_y: float,
+    tube: bool = True,
+) -> tuple[Any, str]:
+    parts, messages = _load_parallel_parts(path1, path2, path3, color1, color2, color3)
+
     if not parts:
         return None, "No shape G-code available. Generate G-code on the TIFF Slices to GCode tab first."
+    offsets, spacings = _resolve_nozzle_layout(
+        parts,
+        _same_spacing_from_individual(use_individual_spacing),
+        part_gap_12_x,
+        part_gap_12_y,
+        part_gap_23_x,
+        part_gap_23_y,
+    )
 
     figure = build_parallel_figure(
         parts,
-        gap=float(gap),
+        part_offsets=offsets,
         filament_width=float(filament_width),
         travel_width=float(travel_width),
         travel_opacity=float(travel_opacity),
         tube=tube,
     )
+    messages.append(_format_nozzle_spacing_status(parts, offsets, spacings))
     return figure, "  \n".join(messages)
 
 
@@ -1824,7 +1999,11 @@ def export_parallel_gif(
     color2: str,
     color3: str,
     travel_opacity: float,
-    gap: float,
+    use_individual_spacing: bool,
+    part_gap_12_x: float,
+    part_gap_12_y: float,
+    part_gap_23_x: float,
+    part_gap_23_y: float,
     duration: float,
     fps: float,
     elev: float,
@@ -1836,20 +2015,18 @@ def export_parallel_gif(
     CPU-only (Agg backend) — no WebGL or headless browser — so it works locally
     and on Hugging Face. Each shape grows as colored lines on a shared timeline.
     """
-    specs = [(path1, color1), (path2, color2), (path3, color3)]
-    parts: list[dict] = []
-    for idx, (path, color) in enumerate(specs, start=1):
-        if not path:
-            continue
-        try:
-            parsed = parse_gcode_path(Path(path).read_text())
-        except OSError:
-            continue
-        if parsed.get("point_count"):
-            parts.append({"idx": idx, "color": color, "parsed": parsed})
+    parts, _messages = _load_parallel_parts(path1, path2, path3, color1, color2, color3)
 
     if not parts:
         return None
+    offsets, _spacings = _resolve_nozzle_layout(
+        parts,
+        _same_spacing_from_individual(use_individual_spacing),
+        part_gap_12_x,
+        part_gap_12_y,
+        part_gap_23_x,
+        part_gap_23_y,
+    )
 
     def report(frame: int, total: int) -> None:
         progress(frame / total, desc=f"Rendering frame {frame + 1}/{total}")
@@ -1858,7 +2035,7 @@ def export_parallel_gif(
     result = build_parallel_gif(
         parts,
         out_path=out_path,
-        gap=float(gap),
+        part_offsets=offsets,
         duration=float(duration),
         fps=int(fps),
         travel_opacity=float(travel_opacity),
@@ -2104,9 +2281,9 @@ def build_demo() -> gr.Blocks:
 
             # --- Shared slicing controls ---
             with gr.Row():
-                layer_height = gr.Number(label="Layer Height", value=0.8, minimum=0.0001, step=0.01)
+                layer_height = gr.Number(label="Layer Height (mm)", value=0.8, minimum=0.0001, step=0.01)
                 pixel_size = gr.Number(
-                    label="Pixel Size/Fill Width",
+                    label="Pixel Size/Fill Width (mm)",
                     value=0.8,
                     minimum=0.0001,
                     step=0.01,
@@ -2504,6 +2681,7 @@ def build_demo() -> gr.Blocks:
                 ),
                 value=True,
             )
+
             gcode_button = gr.Button("Generate G-Code", variant="primary")
 
             with gr.Row():
@@ -2529,6 +2707,47 @@ def build_demo() -> gr.Blocks:
 
             gcode_status = gr.Markdown("")
 
+            with gr.Group():
+                gr.Markdown("### Nozzle Spacing")
+                nozzle_use_individual_spacing = gr.Checkbox(
+                    label="Use Individual Spacing",
+                    value=False,
+                )
+                with gr.Row():
+                    nozzle_part_gap_12_x = gr.Number(
+                        label="Shared / Shape 1 -> 2 X edge spacing (mm)",
+                        value=5.0,
+                        step=0.5,
+                    )
+                    nozzle_part_gap_12_y = gr.Number(
+                        label="Shared / Nozzle 1 -> 2 Y spacing (mm)",
+                        value=0.0,
+                        step=0.5,
+                    )
+                with gr.Row(visible=False) as individual_nozzle_spacing_row:
+                    nozzle_part_gap_23_x = gr.Number(
+                        label="Shape 2 -> 3 X edge spacing (mm)",
+                        value=5.0,
+                        step=0.5,
+                    )
+                    nozzle_part_gap_23_y = gr.Number(
+                        label="Nozzle 2 -> 3 Y spacing (mm)",
+                        value=0.0,
+                        step=0.5,
+                    )
+                nozzle_preview_button = gr.Button(
+                    "Visualize Nozzle Spacing",
+                    variant="secondary",
+                    elem_id="visualize-nozzle-spacing-button",
+                )
+                with gr.Row():
+                    with gr.Column(scale=3, min_width=420):
+                        nozzle_spacing_plot = gr.Plot(label="Nozzle Spacing")
+                    with gr.Column(scale=1, min_width=260):
+                        nozzle_spacing_status = gr.Markdown(
+                            "Generate G-code, then visualize nozzle spacing."
+                        )
+
             gcode_button.click(
                 fn=run_all_tiff_to_gcode,
                 inputs=[
@@ -2588,6 +2807,27 @@ def build_demo() -> gr.Blocks:
                     return [];
                 }""",
             )
+            nozzle_spacing_inputs = [
+                gcode_file_1,
+                gcode_file_2,
+                gcode_file_3,
+                nozzle_use_individual_spacing,
+                nozzle_part_gap_12_x,
+                nozzle_part_gap_12_y,
+                nozzle_part_gap_23_x,
+                nozzle_part_gap_23_y,
+            ]
+            nozzle_use_individual_spacing.change(
+                fn=update_individual_nozzle_spacing_visibility,
+                inputs=[nozzle_use_individual_spacing],
+                outputs=[individual_nozzle_spacing_row],
+                queue=False,
+            )
+            nozzle_preview_button.click(
+                fn=render_nozzle_spacing_preview,
+                inputs=nozzle_spacing_inputs,
+                outputs=[nozzle_spacing_plot, nozzle_spacing_status],
+            )
 
         with gr.Tab("G-Code Visualization"):
             gr.Markdown(
@@ -2862,10 +3102,6 @@ def build_demo() -> gr.Blocks:
                             label="Travel width (mm)", minimum=0.05, maximum=3.0,
                             value=0.2, step=0.05, min_width=150,
                         )
-                    pp_gap = gr.Slider(
-                        label="Gap between parts (mm)",
-                        minimum=0.0, maximum=50.0, value=5.0, step=0.5,
-                    )
                     parallel_status = gr.Markdown("")
 
                     with gr.Group(visible=False) as pp_export_group:
@@ -2906,7 +3142,10 @@ def build_demo() -> gr.Blocks:
             parallel_render_inputs = [
                 gcode_file_1, gcode_file_2, gcode_file_3,
                 pp_color_1, pp_color_2, pp_color_3,
-                pp_travel_opacity, pp_filament_width, pp_travel_width, pp_gap,
+                pp_travel_opacity, pp_filament_width, pp_travel_width,
+                nozzle_use_individual_spacing,
+                nozzle_part_gap_12_x, nozzle_part_gap_12_y,
+                nozzle_part_gap_23_x, nozzle_part_gap_23_y,
             ]
             parallel_outputs = [
                 parallel_plot, parallel_status, parallel_mode,
@@ -2922,13 +3161,33 @@ def build_demo() -> gr.Blocks:
                 inputs=parallel_render_inputs,
                 outputs=parallel_outputs,
             )
-            # Width and gap changes rebuild the figure in the last-used mode.
-            for _slider in (pp_filament_width, pp_travel_width, pp_gap):
+            # Width changes rebuild the figure in the last-used mode after the slider is released.
+            for _slider in (
+                pp_filament_width,
+                pp_travel_width,
+            ):
                 _slider.release(
                     fn=rerender_parallel_current_mode,
                     inputs=[parallel_mode] + parallel_render_inputs,
                     outputs=[parallel_plot, parallel_status],
                 )
+            # Number inputs do not support release() in this Gradio build.
+            nozzle_use_individual_spacing.change(
+                fn=rerender_parallel_current_mode,
+                inputs=[parallel_mode] + parallel_render_inputs,
+                outputs=[parallel_plot, parallel_status],
+            )
+            for _number in (
+                nozzle_part_gap_12_x,
+                nozzle_part_gap_12_y,
+                nozzle_part_gap_23_x,
+                nozzle_part_gap_23_y,
+            ):
+                _number.change(
+                    fn=rerender_parallel_current_mode,
+                    inputs=[parallel_mode] + parallel_render_inputs,
+                    outputs=[parallel_plot, parallel_status],
+                )
             # Color changes recolor a part's print/travel/nozzle traces client-side.
             for _picker, _idx in ((pp_color_1, 1), (pp_color_2, 2), (pp_color_3, 3)):
                 _picker.change(
@@ -2974,7 +3233,11 @@ def build_demo() -> gr.Blocks:
                 inputs=[
                     gcode_file_1, gcode_file_2, gcode_file_3,
                     pp_color_1, pp_color_2, pp_color_3,
-                    pp_gif_travel_opacity, pp_gap, pp_gif_duration, pp_gif_fps,
+                    pp_gif_travel_opacity,
+                    nozzle_use_individual_spacing,
+                    nozzle_part_gap_12_x, nozzle_part_gap_12_y,
+                    nozzle_part_gap_23_x, nozzle_part_gap_23_y,
+                    pp_gif_duration, pp_gif_fps,
                     pp_elev, pp_azim,
                 ],
                 outputs=[pp_gif_file],

gcode_viewer.py

@@ -515,14 +515,15 @@ def build_toolpath_figure(
 def build_parallel_figure(
     parts: list[dict],
     gap: float = 5.0,
+    part_offsets: dict[int, tuple[float, float]] | None = None,
     filament_width: float = 0.8,
     travel_width: float = 0.2,
     travel_opacity: float = 0.2,
     print_opacity: float = 1.0,
     tube: bool = True,
 ) -> go.Figure:
-    """Render several parsed shapes side by side, offset along X so they don't
-    overlap. `tube` True draws filament tubes with a shared-time animation
+    """Render several parsed shapes with optional explicit X/Y nozzle offsets.
+    `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
@@ -548,8 +549,12 @@ def build_parallel_figure(
 
         (pxmin, pymin, pzmin), (pxmax, pymax, pzmax) = parsed["bounds"]
         width = pxmax - pxmin
-        x_off = running_x - pxmin
-        running_x += width + gap
+        if part_offsets is None:
+            x_off = running_x - pxmin
+            y_off = 0.0
+            running_x += width + gap
+        else:
+            x_off, y_off = part_offsets.get(idx, (0.0, 0.0))
 
         if tube:
             print_tube = _build_path_tube(moves, radius=max(filament_width, 0.05) / 2.0, kind="print")
@@ -557,13 +562,16 @@ def build_parallel_figure(
             path = _path_arrays(moves)
 
             px = [v + x_off for v in print_tube["x"]]
+            py = [v + y_off for v in print_tube["y"]]
             tx = [v + x_off for v in travel_tube["x"]]
+            ty = [v + y_off for v in travel_tube["y"]]
             path_x = [v + x_off for v in path["x"]]
+            path_y = [v + y_off for v in path["y"]]
 
             if travel_tube["i"]:
                 fig.add_trace(
                     go.Mesh3d(
-                        x=tx, y=travel_tube["y"], z=travel_tube["z"],
+                        x=tx, y=ty, z=travel_tube["z"],
                         i=travel_tube["i"], j=travel_tube["j"], k=travel_tube["k"],
                         color=color, opacity=travel_opacity, name=f"Travel {idx}",
                         showlegend=False, hoverinfo="skip",
@@ -573,7 +581,7 @@ def build_parallel_figure(
             if print_tube["i"]:
                 fig.add_trace(
                     go.Mesh3d(
-                        x=px, y=print_tube["y"], z=print_tube["z"],
+                        x=px, y=py, z=print_tube["z"],
                         i=print_tube["i"], j=print_tube["j"], k=print_tube["k"],
                         color=color, opacity=print_opacity, name=f"Shape {idx}",
                         showlegend=True, hoverinfo="skip",
@@ -582,7 +590,7 @@ def build_parallel_figure(
                 )
             fig.add_trace(
                 go.Scatter3d(
-                    x=[path_x[-1]], y=[path["y"][-1]], z=[path["z"][-1]],
+                    x=[path_x[-1]], y=[path_y[-1]], z=[path["z"][-1]],
                     mode="markers", name=f"Nozzle {idx}",
                     marker=dict(size=4, color=color), showlegend=False, hoverinfo="skip",
                 )
@@ -596,13 +604,15 @@ def build_parallel_figure(
                 "nozzleName": f"Nozzle {idx}",
                 "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"],
+                "path_x": path_x, "path_y": path_y, "path_z": path["z"], "path_t": path["t"],
             })
         else:
             t_xs, t_ys, t_zs = _segments_to_xyz(parsed["travel_segments"])
             p_xs, p_ys, p_zs = _segments_to_xyz(parsed["print_segments"])
             t_xs = [v + x_off if v is not None else None for v in t_xs]
             p_xs = [v + x_off if v is not None else None for v in p_xs]
+            t_ys = [v + y_off if v is not None else None for v in t_ys]
+            p_ys = [v + y_off if v is not None else None for v in p_ys]
             if t_xs:
                 fig.add_trace(
                     go.Scatter3d(
@@ -623,7 +633,7 @@ def build_parallel_figure(
         rendered = True
         n_parts += 1
         bx0 = min(bx0, pxmin + x_off); bx1 = max(bx1, pxmax + x_off)
-        by0 = min(by0, pymin); by1 = max(by1, pymax)
+        by0 = min(by0, pymin + y_off); by1 = max(by1, pymax + y_off)
         bz0 = min(bz0, pzmin); bz1 = max(bz1, pzmax)
 
     if not rendered:
@@ -650,10 +660,90 @@ def build_parallel_figure(
     return fig
 
 
+def build_nozzle_spacing_figure(
+    parts: list[dict],
+    part_offsets: dict[int, tuple[float, float]],
+    spacings: list[dict],
+) -> go.Figure:
+    fig = go.Figure()
+    bx0 = by0 = float("inf")
+    bx1 = by1 = float("-inf")
+
+    for part in parts:
+        idx = part["idx"]
+        color = part["color"]
+        parsed = part["parsed"]
+        (pxmin, pymin, _), (pxmax, pymax, _) = parsed["bounds"]
+        x_off, y_off = 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(
+            go.Scatter(
+                x=xs,
+                y=ys,
+                mode="lines",
+                name=f"Shape {idx} bounds",
+                line=dict(color=color, width=2),
+            )
+        )
+        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}"],
+                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)
+
+    for spacing in spacings:
+        start = spacing["from"]
+        end = spacing["to"]
+        x0, y0 = part_offsets.get(start, (0.0, 0.0))
+        x1, y1 = part_offsets.get(end, (0.0, 0.0))
+        fig.add_trace(
+            go.Scatter(
+                x=[x0, x1],
+                y=[y0, y1],
+                mode="lines+markers+text",
+                name=f"Nozzle {start}->{end}",
+                line=dict(color="#444444", width=2, dash="dash"),
+                marker=dict(color="#444444", size=6),
+                text=["", f"dx {spacing['dx']:.2f}, dy {spacing['dy']:.2f}"],
+                textposition="middle right",
+            )
+        )
+
+    if bx0 == float("inf"):
+        bx0 = by0 = -1.0
+        bx1 = by1 = 1.0
+
+    pad = max(bx1 - bx0, by1 - by0, 1.0) * 0.08
+    fig.update_layout(
+        height=420,
+        uirevision="nozzle-spacing",
+        xaxis_title="X (mm)",
+        yaxis_title="Y (mm)",
+        xaxis=dict(range=[bx0 - pad, bx1 + pad], scaleanchor="y", scaleratio=1),
+        yaxis=dict(range=[by0 - pad, by1 + pad]),
+        margin=dict(l=0, r=0, t=30, b=0),
+        legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="left", x=0.0),
+        title="Nozzle spacing layout",
+    )
+    return fig
+
+
 def build_parallel_gif(
     parts: list[dict],
     out_path: str | Path,
     gap: float = 5.0,
+    part_offsets: dict[int, tuple[float, float]] | None = None,
     duration: float = 6.0,
     fps: int = 10,
     travel_opacity: float = 0.15,
@@ -689,14 +779,18 @@ def build_parallel_gif(
         if not moves:
             continue
         (pxmin, pymin, pzmin), (pxmax, pymax, pzmax) = parsed["bounds"]
-        x_off = running_x - pxmin
-        running_x += (pxmax - pxmin) + gap
+        if part_offsets is None:
+            x_off = running_x - pxmin
+            y_off = 0.0
+            running_x += (pxmax - pxmin) + gap
+        else:
+            x_off, y_off = part_offsets.get(part["idx"], (0.0, 0.0))
 
         cum = 0.0
         mlist: list[tuple] = []
         for m in moves:
-            s = (m["start"][0] + x_off, m["start"][1], m["start"][2])
-            e = (m["end"][0] + x_off, m["end"][1], m["end"][2])
+            s = (m["start"][0] + x_off, m["start"][1] + y_off, m["start"][2])
+            e = (m["end"][0] + x_off, m["end"][1] + y_off, m["end"][2])
             seg_len = math.dist(s, e)
             mlist.append((m["kind"], s, e, cum, cum + seg_len))
             cum += seg_len
@@ -707,7 +801,7 @@ def build_parallel_gif(
         })
 
         bx0 = min(bx0, pxmin + x_off); bx1 = max(bx1, pxmax + x_off)
-        by0 = min(by0, pymin); by1 = max(by1, pymax)
+        by0 = min(by0, pymin + y_off); by1 = max(by1, pymax + y_off)
         bz0 = min(bz0, pzmin); bz1 = max(bz1, pzmax)
 
     if not pdata or total_length <= 0:

tests/test_nozzle_spacing.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import numpy as np
+
+from app import (
+    _format_nozzle_spacing_status,
+    _resolve_nozzle_layout,
+)
+
+
+def _part(idx: int, bounds: tuple[tuple[float, float, float], tuple[float, float, float]]) -> dict:
+    return {
+        "idx": idx,
+        "color": "#000000",
+        "parsed": {"bounds": bounds, "moves": [{"kind": "print"}], "point_count": 1},
+    }
+
+
+def test_calculated_nozzle_layout_uses_requested_part_gap() -> None:
+    parts = [
+        _part(1, ((0.0, 0.0, 0.0), (10.0, 20.0, 1.0))),
+        _part(2, ((0.0, 0.0, 0.0), (5.0, 6.0, 1.0))),
+        _part(3, ((-2.0, -1.0, 0.0), (2.0, 3.0, 1.0))),
+    ]
+
+    offsets, spacings = _resolve_nozzle_layout(
+        parts,
+        same_spacing=False,
+        part_gap_12_x=2.5,
+        part_gap_12_y=-1.0,
+        part_gap_23_x=8.0,
+        part_gap_23_y=4.0,
+    )
+
+    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))
+    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}
+
+
+def test_calculated_nozzle_layout_allows_negative_x_overlap() -> None:
+    parts = [
+        _part(1, ((0.0, 0.0, 0.0), (10.0, 10.0, 1.0))),
+        _part(2, ((0.0, 0.0, 0.0), (10.0, 10.0, 1.0))),
+    ]
+
+    offsets, spacings = _resolve_nozzle_layout(
+        parts,
+        same_spacing=True,
+        part_gap_12_x=-2.0,
+        part_gap_12_y=3.0,
+        part_gap_23_x=0.0,
+        part_gap_23_y=0.0,
+    )
+
+    np.testing.assert_allclose(offsets[1], (0.0, 0.0))
+    np.testing.assert_allclose(offsets[2], (8.0, 3.0))
+    assert spacings == [{"from": 1, "to": 2, "dx": 8.0, "dy": 3.0}]
+
+
+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))),
+        _part(2, ((0.0, 0.0, 0.0), (4.0, 10.0, 1.0))),
+        _part(3, ((0.0, 0.0, 0.0), (6.0, 10.0, 1.0))),
+    ]
+
+    offsets, spacings = _resolve_nozzle_layout(
+        parts,
+        same_spacing=True,
+        part_gap_12_x=3.0,
+        part_gap_12_y=2.0,
+        part_gap_23_x=20.0,
+        part_gap_23_y=10.0,
+    )
+
+    np.testing.assert_allclose(offsets[1], (0.0, 0.0))
+    np.testing.assert_allclose(offsets[2], (13.0, 2.0))
+    np.testing.assert_allclose(offsets[3], (20.0, 4.0))
+    assert spacings[0] == {"from": 1, "to": 2, "dx": 13.0, "dy": 2.0}
+    assert spacings[1] == {"from": 2, "to": 3, "dx": 7.0, "dy": 2.0}
+
+
+def test_spacing_status_lists_all_nozzle_pair_distances() -> None:
+    parts = [
+        _part(1, ((0.0, 0.0, 0.0), (10.0, 10.0, 1.0))),
+        _part(2, ((0.0, 0.0, 0.0), (4.0, 10.0, 1.0))),
+        _part(3, ((0.0, 0.0, 0.0), (6.0, 10.0, 1.0))),
+    ]
+    offsets, spacings = _resolve_nozzle_layout(
+        parts,
+        same_spacing=True,
+        part_gap_12_x=3.0,
+        part_gap_12_y=2.0,
+        part_gap_23_x=20.0,
+        part_gap_23_y=10.0,
+    )
+
+    status = _format_nozzle_spacing_status(parts, offsets, spacings)
+
+    assert "Nozzle 1: X 0.00 mm, Y 0.00 mm." in status
+    assert "Nozzle 1 -> 2: Delta X 13.00 mm, Delta Y 2.00 mm" in status
+    assert "Nozzle 1 -> 3: Delta X 20.00 mm, Delta Y 4.00 mm" in status
+    assert "Nozzle 2 -> 3: Delta X 7.00 mm, Delta Y 2.00 mm" in status