Add 3D G-code tool-path viewer and wire layer_height through gcode pipeline

- New gcode_viewer.py module: parses G91 relative G-code, accumulates
positions, and renders an interactive Plotly 3D scatter plot with
distinct print vs travel traces
- G-Code Visualization tab: radio toggle to use Shape 1 output or
upload a custom file, renders tool path on button click
- Layer height from slicer tab now flows into G-code Z moves
- Default layer height and pixel size set to 0.8
- Add plotly dependency

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

app.py

@@ -6,6 +6,7 @@ from typing import Any
 import gradio as gr
 from PIL import Image
 
+from gcode_viewer import build_toolpath_figure, parse_gcode_path
 from stl_slicer import SliceStack, load_mesh, slice_stl_to_tiffs
 from tiff_to_gcode import generate_snake_path_gcode
 
@@ -324,6 +325,50 @@ def run_all_tiff_to_gcode(
     return outputs[0], outputs[1], outputs[2], "\n".join(messages)
 
 
+GCODE_SOURCE_SHAPE1 = "Use Shape 1 G-Code"
+GCODE_SOURCE_UPLOAD = "Upload G-Code file"
+
+
+def toggle_gcode_source(source: str) -> dict[str, Any]:
+    return gr.update(visible=(source == GCODE_SOURCE_UPLOAD))
+
+
+def render_toolpath(
+    source: str,
+    uploaded_path: str | None,
+    shape1_path: str | None,
+) -> tuple[Any, str]:
+    if source == GCODE_SOURCE_UPLOAD:
+        path = uploaded_path
+        if not path:
+            return None, "No G-code file uploaded yet."
+    else:
+        path = shape1_path
+        if not path:
+            return None, "No Shape 1 G-code available yet. Generate it on the TIFF Slices to GCode tab first."
+
+    try:
+        text = Path(path).read_text()
+    except OSError as exc:
+        return None, f"Failed to read G-code file: {exc}"
+
+    parsed = parse_gcode_path(text)
+    if parsed["point_count"] == 0:
+        return None, "No G0/G1 movement lines found in the file."
+
+    figure = build_toolpath_figure(parsed)
+    (x_min, y_min, z_min), (x_max, y_max, z_max) = parsed["bounds"]
+    summary = (
+        f"**{parsed['point_count']} moves parsed** — "
+        f"{len(parsed['print_segments'])} print segment(s), "
+        f"{len(parsed['travel_segments'])} travel segment(s).  \n"
+        f"Bounds: X ∈ [{x_min:.2f}, {x_max:.2f}], "
+        f"Y ∈ [{y_min:.2f}, {y_max:.2f}], "
+        f"Z ∈ [{z_min:.2f}, {z_max:.2f}] mm."
+    )
+    return figure, summary
+
+
 def shift_slice(state: ViewerState, index: float, delta: int) -> tuple[int, str, Image.Image | None]:
     tiff_paths = state.get("tiff_paths", [])
     if not tiff_paths:
@@ -607,6 +652,37 @@ def build_demo() -> gr.Blocks:
                 outputs=[gcode_file_1, gcode_file_2, gcode_file_3, gcode_status],
             )
 
+        with gr.Tab("G-Code Visualization"):
+            gr.Markdown(
+                "### 3D Tool-Path Viewer\n"
+                "Choose a G-code source, then click **Render Tool Path** to visualize the nozzle path."
+            )
+            with gr.Row():
+                gcode_source = gr.Radio(
+                    choices=[GCODE_SOURCE_SHAPE1, GCODE_SOURCE_UPLOAD],
+                    value=GCODE_SOURCE_SHAPE1,
+                    label="G-Code source",
+                )
+                gcode_upload = gr.File(
+                    label="Upload G-Code",
+                    file_types=[".txt", ".gcode", ".nc"],
+                    visible=False,
+                )
+            render_button = gr.Button("Render Tool Path", variant="primary")
+            toolpath_plot = gr.Plot(label="Tool Path")
+            toolpath_status = gr.Markdown("")
+
+            gcode_source.change(
+                fn=toggle_gcode_source,
+                inputs=[gcode_source],
+                outputs=[gcode_upload],
+            )
+            render_button.click(
+                fn=render_toolpath,
+                inputs=[gcode_source, gcode_upload, gcode_file_1],
+                outputs=[toolpath_plot, toolpath_status],
+            )
+
     return demo
 
 

gcode_viewer.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+import plotly.graph_objects as go
+
+
+_MOVE_RE = re.compile(
+    r"^\s*(G0|G1)\s+X(-?\d+(?:\.\d+)?)\s+Y(-?\d+(?:\.\d+)?)"
+    r"(?:\s+Z(-?\d+(?:\.\d+)?))?",
+    re.IGNORECASE,
+)
+
+
+def parse_gcode_path(gcode_text: str) -> dict:
+    relative = True
+    x = y = z = 0.0
+
+    print_segments: list[list[tuple[float, float, float]]] = []
+    travel_segments: list[list[tuple[float, float, float]]] = []
+    current_kind: str | None = None
+    current_segment: list[tuple[float, float, float]] = []
+
+    all_x: list[float] = []
+    all_y: list[float] = []
+    all_z: list[float] = []
+
+    def flush_segment() -> None:
+        nonlocal current_segment, current_kind
+        if current_segment and current_kind is not None:
+            target = print_segments if current_kind == "print" else travel_segments
+            target.append(current_segment)
+        current_segment = []
+        current_kind = None
+
+    for raw_line in gcode_text.splitlines():
+        line = raw_line.strip()
+        if not line:
+            flush_segment()
+            continue
+
+        upper = line.upper()
+        if upper.startswith("G90"):
+            relative = False
+            continue
+        if upper.startswith("G91"):
+            relative = True
+            continue
+
+        match = _MOVE_RE.match(line)
+        if not match:
+            flush_segment()
+            continue
+
+        gcmd = match.group(1).upper()
+        dx = float(match.group(2))
+        dy = float(match.group(3))
+        dz_match = match.group(4)
+        dz = float(dz_match) if dz_match is not None else 0.0
+
+        prev_pos = (x, y, z)
+
+        if relative:
+            x += dx
+            y += dy
+            z += dz
+        else:
+            x, y = dx, dy
+            if dz_match is not None:
+                z = dz
+
+        kind = "travel" if gcmd == "G1" else "print"
+
+        if kind != current_kind:
+            flush_segment()
+            current_kind = kind
+            current_segment = [prev_pos]
+
+        current_segment.append((x, y, z))
+        all_x.append(x)
+        all_y.append(y)
+        all_z.append(z)
+
+    flush_segment()
+
+    if all_x:
+        bounds = (
+            (min(all_x), min(all_y), min(all_z)),
+            (max(all_x), max(all_y), max(all_z)),
+        )
+    else:
+        bounds = ((0.0, 0.0, 0.0), (0.0, 0.0, 0.0))
+
+    return {
+        "print_segments": print_segments,
+        "travel_segments": travel_segments,
+        "bounds": bounds,
+        "point_count": len(all_x),
+    }
+
+
+def _segments_to_xyz(
+    segments: list[list[tuple[float, float, float]]],
+) -> tuple[list[float | None], list[float | None], list[float | None]]:
+    xs: list[float | None] = []
+    ys: list[float | None] = []
+    zs: list[float | None] = []
+    for segment in segments:
+        for px, py, pz in segment:
+            xs.append(px)
+            ys.append(py)
+            zs.append(pz)
+        xs.append(None)
+        ys.append(None)
+        zs.append(None)
+    return xs, ys, zs
+
+
+def build_toolpath_figure(parsed: dict) -> go.Figure:
+    print_xs, print_ys, print_zs = _segments_to_xyz(parsed["print_segments"])
+    travel_xs, travel_ys, travel_zs = _segments_to_xyz(parsed["travel_segments"])
+
+    fig = go.Figure()
+
+    if travel_xs:
+        fig.add_trace(
+            go.Scatter3d(
+                x=travel_xs,
+                y=travel_ys,
+                z=travel_zs,
+                mode="lines",
+                name="Travel (G0)",
+                line=dict(color="rgba(150,150,150,0.55)", width=2, dash="dot"),
+                hoverinfo="skip",
+            )
+        )
+
+    if print_xs:
+        fig.add_trace(
+            go.Scatter3d(
+                x=print_xs,
+                y=print_ys,
+                z=print_zs,
+                mode="lines",
+                name="Print (G1)",
+                line=dict(color="#1f77b4", width=4),
+                hovertemplate="X=%{x:.2f}<br>Y=%{y:.2f}<br>Z=%{z:.2f}<extra></extra>",
+            )
+        )
+
+    (x_min, y_min, z_min), (x_max, y_max, z_max) = parsed["bounds"]
+    fig.update_layout(
+        scene=dict(
+            xaxis_title="X (mm)",
+            yaxis_title="Y (mm)",
+            zaxis_title="Z (mm)",
+            aspectmode="data",
+        ),
+        margin=dict(l=0, r=0, t=30, b=0),
+        legend=dict(orientation="h", yanchor="bottom", y=1.0, xanchor="left", x=0.0),
+        title=(
+            f"Tool path — {len(parsed['print_segments'])} print / "
+            f"{len(parsed['travel_segments'])} travel segments   "
+            f"X[{x_min:.1f},{x_max:.1f}]  Y[{y_min:.1f},{y_max:.1f}]  "
+            f"Z[{z_min:.1f},{z_max:.1f}]"
+        ),
+    )
+    return fig
+
+
+def render_gcode_file(path: str | Path) -> tuple[go.Figure, dict]:
+    text = Path(path).read_text()
+    parsed = parse_gcode_path(text)
+    return build_toolpath_figure(parsed), parsed

pyproject.toml

@@ -9,6 +9,7 @@ dependencies = [
     "networkx>=3.4.2",
     "numpy>=2.2.0",
     "pillow>=11.1.0",
+    "plotly>=6.7.0",
     "scipy>=1.15.2",
     "shapely>=2.0.7",
     "trimesh>=4.6.5",

uv.lock

@@ -523,6 +523,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
 ]
 
+[[package]]
+name = "narwhals"
+version = "2.19.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4e/1a/bd3317c0bdbcd9ffb710ddf5250b32898f8f2c240be99494fe137feb77a7/narwhals-2.19.0.tar.gz", hash = "sha256:14fd7040b5ff211d415a82e4827b9d04c354e213e72a6d0730205ffd72e3b7ff", size = 623698, upload-time = "2026-04-06T15:50:58.786Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/37/72/e61e3091e0e00fae9d3a8ef85ece9d2cd4b5966058e1f2901ce42679eebf/narwhals-2.19.0-py3-none-any.whl", hash = "sha256:1f8dfa4a33a6dbff878c3e9be4c3b455dfcaf2a9322f1357db00e4e92e95b84b", size = 446991, upload-time = "2026-04-06T15:50:57.046Z" },
+]
+
 [[package]]
 name = "networkx"
 version = "3.6.1"
@@ -835,6 +844,19 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f2/26/c56ce33ca856e358d27fda9676c055395abddb82c35ac0f593877ed4562e/pillow-12.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:cb9bb857b2d057c6dfc72ac5f3b44836924ba15721882ef103cecb40d002d80e", size = 7029880, upload-time = "2026-02-11T04:23:04.783Z" },
 ]
 
+[[package]]
+name = "plotly"
+version = "6.7.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "narwhals" },
+    { name = "packaging" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3a/7f/0f100df1172aadf88a929a9dbb902656b0880ba4b960fe5224867159d8f4/plotly-6.7.0.tar.gz", hash = "sha256:45eea0ff27e2a23ccd62776f77eb43aa1ca03df4192b76036e380bb479b892c6", size = 6911286, upload-time = "2026-04-09T20:36:45.738Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/ad/cba91b3bcf04073e4d1655a5c1710ef3f457f56f7d1b79dcc3d72f4dd912/plotly-6.7.0-py3-none-any.whl", hash = "sha256:ac8aca1c25c663a59b5b9140a549264a5badde2e057d79b8c772ae2920e32ff0", size = 9898444, upload-time = "2026-04-09T20:36:39.812Z" },
+]
+
 [[package]]
 name = "pluggy"
 version = "1.6.0"
@@ -1279,6 +1301,7 @@ dependencies = [
     { name = "networkx" },
     { name = "numpy" },
     { name = "pillow" },
+    { name = "plotly" },
     { name = "scipy" },
     { name = "shapely" },
     { name = "trimesh" },
@@ -1295,6 +1318,7 @@ requires-dist = [
     { name = "networkx", specifier = ">=3.4.2" },
     { name = "numpy", specifier = ">=2.2.0" },
     { name = "pillow", specifier = ">=11.1.0" },
+    { name = "plotly", specifier = ">=6.7.0" },
     { name = "scipy", specifier = ">=1.15.2" },
     { name = "shapely", specifier = ">=2.0.7" },
     { name = "trimesh", specifier = ">=4.6.5" },