Add Gradio STL slicer app

.gitignore

@@ -0,0 +1,3 @@
+.venv/
+__pycache__/
+.pytest_cache/

README.md

@@ -0,0 +1,26 @@
+# STL to TIFF Gradio App
+
+This project provides a Gradio app that takes an uploaded STL file, slices it along the Z axis, saves each slice as a TIFF image, and lets you browse the stack inside the UI.
+
+## Run
+
+```powershell
+uv sync --all-groups
+uv run python app.py
+```
+
+Then open the local Gradio URL in your browser, upload an STL file, and generate the TIFF stack.
+
+## What the app does
+
+- Uploads a single `.stl` file
+- Lets you choose layer height and XY pixel size
+- Produces one `.tif` image per slice
+- Lets you step through the slice stack in the browser
+- Exports a ZIP containing the generated TIFF images
+
+## Test
+
+```powershell
+uv run pytest
+```

app.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import gradio as gr
+from PIL import Image
+
+from stl_slicer import SliceStack, slice_stl_to_tiffs
+
+
+ViewerState = dict[str, Any]
+
+
+def _read_slice_preview(path: str) -> Image.Image:
+    with Image.open(path) as image:
+        return image.copy()
+
+
+def _empty_state() -> ViewerState:
+    return {"tiff_paths": [], "z_values": []}
+
+
+def _stack_to_state(stack: SliceStack) -> ViewerState:
+    return {
+        "tiff_paths": [str(path) for path in stack.tiff_paths],
+        "z_values": stack.z_values,
+    }
+
+
+def _format_summary(stack: SliceStack, source_name: str) -> str:
+    (x_min, y_min, z_min), (x_max, y_max, z_max) = stack.bounds
+    return "\n".join(
+        [
+            "### Slice Stack Ready",
+            f"- Source: `{source_name}`",
+            f"- TIFF count: `{len(stack.tiff_paths)}`",
+            f"- Image size: `{stack.image_size[0]} x {stack.image_size[1]}` pixels",
+            f"- Layer height: `{stack.layer_height}`",
+            f"- Pixel size: `{stack.pixel_size}`",
+            f"- Bounds: `x={x_min:.3f}..{x_max:.3f}`, `y={y_min:.3f}..{y_max:.3f}`, `z={z_min:.3f}..{z_max:.3f}`",
+        ]
+    )
+
+
+def _slice_label(state: ViewerState, index: int) -> str:
+    path = Path(state["tiff_paths"][index]).name
+    z_value = state["z_values"][index]
+    total = len(state["tiff_paths"])
+    return f"Slice {index + 1} / {total} | z = {z_value:.4f} | {path}"
+
+
+def _render_selected_slice(state: ViewerState, index: int) -> tuple[str, Image.Image | None, str | None]:
+    tiff_paths = state.get("tiff_paths", [])
+    if not tiff_paths:
+        return "No slice stack loaded yet.", None, None
+
+    bounded_index = max(0, min(int(index), len(tiff_paths) - 1))
+    selected_path = tiff_paths[bounded_index]
+    return (
+        _slice_label(state, bounded_index),
+        _read_slice_preview(selected_path),
+        selected_path,
+    )
+
+
+def generate_stack(
+    stl_file: str | None,
+    layer_height: float,
+    pixel_size: float,
+    progress: gr.Progress = gr.Progress(),
+):
+    if not stl_file:
+        raise gr.Error("Upload an STL file before generating slices.")
+
+    def report_progress(current: int, total: int) -> None:
+        progress(current / total, desc=f"Rendering slice {current} of {total}")
+
+    stack = slice_stl_to_tiffs(
+        stl_file,
+        layer_height=layer_height,
+        pixel_size=pixel_size,
+        progress_callback=report_progress,
+    )
+
+    state = _stack_to_state(stack)
+    label, preview, selected_path = _render_selected_slice(state, 0)
+    slider_update = gr.update(
+        minimum=0,
+        maximum=max(0, len(stack.tiff_paths) - 1),
+        value=0,
+        step=1,
+        interactive=len(stack.tiff_paths) > 1,
+    )
+
+    return (
+        _format_summary(stack, Path(stl_file).name),
+        state,
+        slider_update,
+        label,
+        preview,
+        str(stack.zip_path),
+        selected_path,
+    )
+
+
+def jump_to_slice(state: ViewerState, index: float) -> tuple[str, Image.Image | None, str | None]:
+    return _render_selected_slice(state, int(index))
+
+
+def shift_slice(state: ViewerState, index: float, delta: int) -> tuple[int, str, Image.Image | None, str | None]:
+    tiff_paths = state.get("tiff_paths", [])
+    if not tiff_paths:
+        return 0, "No slice stack loaded yet.", None, None
+
+    new_index = max(0, min(int(index) + delta, len(tiff_paths) - 1))
+    label, preview, selected_path = _render_selected_slice(state, new_index)
+    return new_index, label, preview, selected_path
+
+
+def build_demo() -> gr.Blocks:
+    with gr.Blocks(title="STL TIFF Slicer") as demo:
+        gr.Markdown(
+            """
+            # STL to TIFF Slicer
+            Upload an STL, choose a layer height and XY pixel size, and generate a TIFF stack.
+            Use the slider or the previous and next buttons to browse through the resulting slices.
+            """
+        )
+
+        state = gr.State(_empty_state())
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                stl_file = gr.File(
+                    label="STL File",
+                    file_types=[".stl"],
+                    type="filepath",
+                )
+                layer_height = gr.Number(
+                    label="Layer Height",
+                    value=0.1,
+                    minimum=0.0001,
+                    step=0.01,
+                )
+                pixel_size = gr.Number(
+                    label="Pixel Size",
+                    value=0.05,
+                    minimum=0.0001,
+                    step=0.01,
+                )
+                generate_button = gr.Button("Generate TIFF Stack", variant="primary")
+                download_zip = gr.File(label="Download All TIFFs (ZIP)")
+                current_tiff = gr.File(label="Current TIFF Slice")
+
+            with gr.Column(scale=2):
+                summary = gr.Markdown("Upload an STL file to begin.")
+                slice_label = gr.Markdown("No slice stack loaded yet.")
+                slice_preview = gr.Image(
+                    label="Slice Preview",
+                    type="pil",
+                    image_mode="L",
+                    height=520,
+                )
+                with gr.Row():
+                    prev_button = gr.Button("Previous Slice")
+                    next_button = gr.Button("Next Slice")
+                slice_slider = gr.Slider(
+                    label="Slice Index",
+                    minimum=0,
+                    maximum=0,
+                    value=0,
+                    step=1,
+                    interactive=False,
+                )
+
+        generate_button.click(
+            fn=generate_stack,
+            inputs=[stl_file, layer_height, pixel_size],
+            outputs=[
+                summary,
+                state,
+                slice_slider,
+                slice_label,
+                slice_preview,
+                download_zip,
+                current_tiff,
+            ],
+        )
+
+        slice_slider.release(
+            fn=jump_to_slice,
+            inputs=[state, slice_slider],
+            outputs=[slice_label, slice_preview, current_tiff],
+            queue=False,
+        )
+
+        prev_button.click(
+            fn=lambda state_value, index: shift_slice(state_value, index, -1),
+            inputs=[state, slice_slider],
+            outputs=[slice_slider, slice_label, slice_preview, current_tiff],
+            queue=False,
+        )
+
+        next_button.click(
+            fn=lambda state_value, index: shift_slice(state_value, index, 1),
+            inputs=[state, slice_slider],
+            outputs=[slice_slider, slice_label, slice_preview, current_tiff],
+            queue=False,
+        )
+
+    return demo
+
+
+def main() -> None:
+    demo = build_demo()
+    demo.launch()
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "stl-to-gcode"
+version = "0.1.0"
+description = "Gradio app for slicing STL files into TIFF image stacks."
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "gradio>=5.23.0",
+    "networkx>=3.4.2",
+    "numpy>=2.2.0",
+    "pillow>=11.1.0",
+    "scipy>=1.15.2",
+    "shapely>=2.0.7",
+    "trimesh>=4.6.5",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.5",
+]
+
+[tool.uv]
+package = false

stl_slicer.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import math
+import tempfile
+import uuid
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable
+
+import numpy as np
+from PIL import Image, ImageDraw
+from shapely.geometry import GeometryCollection, MultiPolygon, Polygon
+import trimesh
+
+
+ProgressCallback = Callable[[int, int], None] | None
+
+
+@dataclass(slots=True)
+class SliceStack:
+    output_dir: Path
+    zip_path: Path
+    tiff_paths: list[Path]
+    z_values: list[float]
+    image_size: tuple[int, int]
+    bounds: tuple[tuple[float, float, float], tuple[float, float, float]]
+    layer_height: float
+    pixel_size: float
+
+
+def load_mesh(stl_path: str | Path) -> trimesh.Trimesh:
+    loaded = trimesh.load(stl_path, force="scene")
+    if isinstance(loaded, trimesh.Scene):
+        if not loaded.geometry:
+            raise ValueError("The STL file does not contain any mesh geometry.")
+        mesh = trimesh.util.concatenate(tuple(loaded.geometry.values()))
+    else:
+        mesh = loaded
+
+    if not isinstance(mesh, trimesh.Trimesh) or mesh.is_empty:
+        raise ValueError("Unable to load a valid mesh from the STL file.")
+
+    return mesh
+
+
+def calculate_z_levels(z_min: float, z_max: float, layer_height: float) -> list[float]:
+    if layer_height <= 0:
+        raise ValueError("Layer height must be greater than zero.")
+
+    thickness = z_max - z_min
+    if thickness <= 0:
+        return [z_min]
+
+    layer_count = max(1, math.ceil(thickness / layer_height))
+    top_guard = math.nextafter(z_max, z_min)
+
+    return [
+        min(z_min + ((index + 0.5) * layer_height), top_guard)
+        for index in range(layer_count)
+    ]
+
+
+def _to_pixel_ring(
+    coords: np.ndarray,
+    x_min: float,
+    y_min: float,
+    pixel_size: float,
+    image_height: int,
+) -> list[tuple[int, int]]:
+    pixels: list[tuple[int, int]] = []
+    for x_value, y_value in coords:
+        x_pixel = int(round((float(x_value) - x_min) / pixel_size))
+        y_pixel = int(round((float(y_value) - y_min) / pixel_size))
+        pixels.append((x_pixel, image_height - 1 - y_pixel))
+    return pixels
+
+
+def _ring_to_world_xy(ring_coords: object, to_3d: np.ndarray) -> np.ndarray:
+    planar = np.asarray(ring_coords, dtype=float)
+    if planar.ndim != 2 or planar.shape[1] < 2:
+        raise ValueError("Encountered an invalid polygon ring while slicing.")
+
+    planar_3d = np.column_stack([planar[:, 0], planar[:, 1], np.zeros(len(planar))])
+    world = trimesh.transform_points(planar_3d, to_3d)
+    return world[:, :2]
+
+
+def _compose_even_odd_polygons(polygons: list[Polygon]) -> list[Polygon]:
+    geometry: Polygon | MultiPolygon | GeometryCollection | None = None
+    for polygon in polygons:
+        geometry = polygon if geometry is None else geometry.symmetric_difference(polygon)
+
+    if geometry is None or geometry.is_empty:
+        return []
+
+    if isinstance(geometry, Polygon):
+        return [geometry]
+
+    if isinstance(geometry, MultiPolygon):
+        return list(geometry.geoms)
+
+    if isinstance(geometry, GeometryCollection):
+        return [geom for geom in geometry.geoms if isinstance(geom, Polygon) and not geom.is_empty]
+
+    return []
+
+
+def _extract_world_polygons(section: trimesh.path.Path3D) -> list[tuple[np.ndarray, list[np.ndarray]]]:
+    if hasattr(section, "to_2D"):
+        planar, to_3d = section.to_2D()
+    else:
+        planar, to_3d = section.to_planar()
+
+    composed_polygons = _compose_even_odd_polygons(list(planar.polygons_closed))
+    polygons: list[tuple[np.ndarray, list[np.ndarray]]] = []
+    for polygon in composed_polygons:
+        exterior = _ring_to_world_xy(polygon.exterior.coords, to_3d)
+        holes = [_ring_to_world_xy(interior.coords, to_3d) for interior in polygon.interiors]
+        polygons.append((exterior, holes))
+
+    return polygons
+
+
+def _render_slice(
+    section: trimesh.path.Path3D | None,
+    x_min: float,
+    y_min: float,
+    image_size: tuple[int, int],
+    pixel_size: float,
+) -> Image.Image:
+    image = Image.new("L", image_size, 0)
+
+    if section is None:
+        return image
+
+    polygons = _extract_world_polygons(section)
+    if not polygons:
+        return image
+
+    draw = ImageDraw.Draw(image)
+    for exterior, holes in polygons:
+        draw.polygon(
+            _to_pixel_ring(exterior, x_min, y_min, pixel_size, image.height),
+            fill=255,
+        )
+        for hole in holes:
+            draw.polygon(
+                _to_pixel_ring(hole, x_min, y_min, pixel_size, image.height),
+                fill=0,
+            )
+
+    return image
+
+
+def _make_output_paths(stl_path: Path, output_root: str | Path | None) -> tuple[Path, Path]:
+    root = Path(output_root) if output_root else Path(tempfile.mkdtemp(prefix="stl_slices_"))
+    stem = stl_path.stem or "mesh"
+    job_dir = root / f"{stem}_{uuid.uuid4().hex[:8]}"
+    slices_dir = job_dir / "tiff_slices"
+    slices_dir.mkdir(parents=True, exist_ok=True)
+    zip_path = job_dir / f"{stem}_tiff_slices.zip"
+    return slices_dir, zip_path
+
+
+def _zip_tiffs(tiff_paths: list[Path], zip_path: Path) -> None:
+    with zipfile.ZipFile(zip_path, mode="w", compression=zipfile.ZIP_DEFLATED) as archive:
+        for tiff_path in tiff_paths:
+            archive.write(tiff_path, arcname=tiff_path.name)
+
+
+def slice_stl_to_tiffs(
+    stl_path: str | Path,
+    layer_height: float,
+    pixel_size: float,
+    output_root: str | Path | None = None,
+    progress_callback: ProgressCallback = None,
+) -> SliceStack:
+    if pixel_size <= 0:
+        raise ValueError("Pixel size must be greater than zero.")
+
+    stl_path = Path(stl_path)
+    mesh = load_mesh(stl_path)
+    bounds = mesh.bounds
+    (x_min, y_min, z_min), (x_max, y_max, z_max) = bounds
+
+    z_values = calculate_z_levels(float(z_min), float(z_max), layer_height)
+    width = max(1, math.ceil((float(x_max) - float(x_min)) / pixel_size) + 1)
+    height = max(1, math.ceil((float(y_max) - float(y_min)) / pixel_size) + 1)
+    image_size = (width, height)
+
+    output_dir, zip_path = _make_output_paths(stl_path, output_root)
+    tiff_paths: list[Path] = []
+
+    for index, z_value in enumerate(z_values):
+        section = mesh.section(
+            plane_origin=np.array([0.0, 0.0, z_value], dtype=float),
+            plane_normal=np.array([0.0, 0.0, 1.0], dtype=float),
+        )
+        image = _render_slice(section, float(x_min), float(y_min), image_size, pixel_size)
+        tiff_path = output_dir / f"slice_{index:04d}.tif"
+        image.save(tiff_path, compression="tiff_deflate")
+        tiff_paths.append(tiff_path)
+
+        if progress_callback is not None:
+            progress_callback(index + 1, len(z_values))
+
+    _zip_tiffs(tiff_paths, zip_path)
+
+    return SliceStack(
+        output_dir=output_dir,
+        zip_path=zip_path,
+        tiff_paths=tiff_paths,
+        z_values=z_values,
+        image_size=image_size,
+        bounds=(
+            (float(x_min), float(y_min), float(z_min)),
+            (float(x_max), float(y_max), float(z_max)),
+        ),
+        layer_height=layer_height,
+        pixel_size=pixel_size,
+    )

tests/conftest.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))

tests/test_stl_slicer.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import numpy as np
+from PIL import Image
+from shapely.geometry import Polygon
+import trimesh
+
+from stl_slicer import _compose_even_odd_polygons, calculate_z_levels, slice_stl_to_tiffs
+
+
+def test_calculate_z_levels_creates_single_layer_for_thin_mesh() -> None:
+    z_values = calculate_z_levels(0.0, 0.01, 0.1)
+
+    assert len(z_values) == 1
+    assert 0.0 <= z_values[0] < 0.01
+
+
+def test_slice_stl_to_tiffs_creates_non_empty_tiffs(tmp_path) -> None:
+    mesh = trimesh.creation.box(extents=(2.0, 2.0, 2.0))
+    stl_path = tmp_path / "cube.stl"
+    mesh.export(stl_path)
+
+    stack = slice_stl_to_tiffs(
+        stl_path,
+        layer_height=0.5,
+        pixel_size=0.25,
+        output_root=tmp_path / "generated",
+    )
+
+    assert len(stack.tiff_paths) == 4
+    assert stack.zip_path.exists()
+    assert all(path.exists() for path in stack.tiff_paths)
+
+    with Image.open(stack.tiff_paths[0]) as first_image:
+        pixels = np.array(first_image)
+
+    assert pixels.max() == 255
+    assert pixels.sum() > 0
+
+
+def test_compose_even_odd_polygons_preserves_holes() -> None:
+    outer = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)])
+    inner = Polygon([(3, 3), (7, 3), (7, 7), (3, 7)])
+
+    composed = _compose_even_odd_polygons([outer, inner])
+
+    assert len(composed) == 1
+    assert composed[0].area == outer.area - inner.area
+    assert len(composed[0].interiors) == 1