solidsmith 0.2.0__py3-none-any.whl

solidsmith/__init__.py

@@ -0,0 +1,47 @@
+"""solidsmith — forge watertight, print-ready 3D parts from Python.
+
+The missing glue between trimesh and your printer: booleans that don't fall
+over, 3MF export that keeps its colors, a printability report, and quick
+multi-view renders to iterate against.
+"""
+
+from solidsmith import printers, sdf, workflow
+from solidsmith.export import write_3mf, write_stl
+from solidsmith.ops import (
+    clean,
+    concat,
+    difference,
+    hex_prism,
+    intersection,
+    rounded_prism,
+    union,
+)
+from solidsmith.part import Part
+from solidsmith.printers import Printer
+from solidsmith.preview import DEFAULT_VIEWS, render_views
+from solidsmith.report import DEFAULT_BED, PrintReport, check
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "DEFAULT_BED",
+    "DEFAULT_VIEWS",
+    "Part",
+    "PrintReport",
+    "Printer",
+    "printers",
+    "check",
+    "clean",
+    "concat",
+    "difference",
+    "hex_prism",
+    "intersection",
+    "render_views",
+    "rounded_prism",
+    "sdf",
+    "union",
+    "workflow",
+    "write_3mf",
+    "write_stl",
+    "__version__",
+]

solidsmith/export.py

@@ -0,0 +1,92 @@
+"""Export meshes to print-ready files.
+
+STL is the easy half. 3MF is the interesting one: trimesh writes valid 3MF
+geometry but silently drops color, so every body opens gray in the slicer.
+`write_3mf` post-processes the archive it writes — injecting a real
+``<basematerials>`` resource and tagging each body with a material index —
+so a multi-color model opens with its filament assignments already in place.
+"""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+import zipfile
+from pathlib import Path
+
+import trimesh
+
+from solidsmith.ops import concat
+from solidsmith.part import Part, as_parts
+
+_CORE_NS = "http://schemas.microsoft.com/3dmanufacturing/core/2015/02"
+_MODEL_ENTRY = "3D/3dmodel.model"
+
+
+def write_stl(parts, path) -> Path:
+    """Write one binary STL. Multiple parts are concatenated (STL has no color)."""
+    path = Path(path)
+    parts = as_parts(parts)
+    mesh = parts[0].mesh if len(parts) == 1 else concat(*(p.mesh for p in parts))
+    mesh.export(path)
+    return path
+
+
+def write_3mf(parts, path) -> Path:
+    """Write a single 3MF containing every part as a separately colored body."""
+    path = Path(path)
+    parts = as_parts(parts)
+
+    scene = trimesh.Scene()
+    for i, part in enumerate(parts):
+        # zero-padded prefix pins a stable object order in the archive
+        scene.add_geometry(part.mesh, geom_name=f"{i:03d}_{part.name}")
+    scene.export(path)
+
+    _inject_materials(path, parts)
+    return path
+
+
+def _inject_materials(path: Path, parts: "list[Part]") -> None:
+    """Rewrite the 3MF's model XML with basematerials + per-object material refs."""
+    with zipfile.ZipFile(path, "r") as zf:
+        entries = {info.filename: zf.read(info.filename) for info in zf.infolist()}
+    if _MODEL_ENTRY not in entries:
+        raise ValueError(f"{path} has no {_MODEL_ENTRY}; not a 3MF written by trimesh?")
+
+    ET.register_namespace("", _CORE_NS)
+    root = ET.fromstring(entries[_MODEL_ENTRY])
+    ns = {"m": _CORE_NS}
+    resources = root.find("m:resources", ns)
+    if resources is None:
+        raise ValueError("3MF model has no <resources> element")
+
+    objects = [
+        obj for obj in resources.findall("m:object", ns)
+        if obj.find("m:mesh", ns) is not None
+    ]
+    if len(objects) != len(parts):
+        raise ValueError(
+            f"expected {len(parts)} mesh objects in the 3MF, found {len(objects)}"
+        )
+
+    used_ids = [int(obj.get("id")) for obj in resources.findall("m:object", ns)]
+    material_id = str(max(used_ids) + 1)
+
+    materials = ET.Element(f"{{{_CORE_NS}}}basematerials", {"id": material_id})
+    for part in parts:
+        r, g, b = (int(c) for c in part.color)
+        ET.SubElement(
+            materials,
+            f"{{{_CORE_NS}}}base",
+            {"name": part.name, "displaycolor": f"#{r:02X}{g:02X}{b:02X}"},
+        )
+    resources.insert(0, materials)
+
+    for index, obj in enumerate(objects):
+        obj.set("pid", material_id)
+        obj.set("pindex", str(index))
+
+    entries[_MODEL_ENTRY] = ET.tostring(root, encoding="UTF-8", xml_declaration=True)
+    with zipfile.ZipFile(path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for name, data in entries.items():
+            zf.writestr(name, data)

solidsmith/ops.py

@@ -0,0 +1,96 @@
+"""Boolean modeling that stays watertight.
+
+trimesh's default boolean backend rejects meshes that are fine in practice;
+the manifold engine is far more robust but still rewards mesh hygiene on the
+way in and out. These wrappers bake both in, so `difference(a, b)` is a thing
+you can stop thinking about.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import trimesh
+
+
+def clean(mesh: trimesh.Trimesh) -> trimesh.Trimesh:
+    """Scrub a mesh in place: weld vertices, drop degenerate faces, fix winding.
+
+    Marching-cubes and heavily boolean'd meshes accumulate slivers that make
+    later booleans fail; running this between operations keeps them reliable.
+    """
+    mesh.merge_vertices()
+    mesh.update_faces(mesh.nondegenerate_faces())
+    mesh.remove_unreferenced_vertices()
+    mesh.fix_normals()
+    return mesh
+
+
+def _boolean(kind: str, meshes: "list[trimesh.Trimesh]") -> trimesh.Trimesh:
+    prepared = [clean(m.copy()) for m in meshes]
+    result = getattr(trimesh.boolean, kind)(prepared, engine="manifold")
+    return clean(result)
+
+
+def union(*meshes: trimesh.Trimesh) -> trimesh.Trimesh:
+    """Fuse meshes into one solid."""
+    if len(meshes) == 1:
+        return clean(meshes[0].copy())
+    return _boolean("union", list(meshes))
+
+
+def difference(base: trimesh.Trimesh, *cutters: trimesh.Trimesh) -> trimesh.Trimesh:
+    """Subtract every cutter from base."""
+    if not cutters:
+        return clean(base.copy())
+    return _boolean("difference", [base, *cutters])
+
+
+def intersection(*meshes: trimesh.Trimesh) -> trimesh.Trimesh:
+    """Keep only the volume common to all meshes."""
+    return _boolean("intersection", list(meshes))
+
+
+def concat(*meshes: trimesh.Trimesh) -> trimesh.Trimesh:
+    """Append meshes without any boolean (touching bodies that print as one)."""
+    return trimesh.util.concatenate(list(meshes))
+
+
+def rounded_prism(
+    extents,
+    radius: float,
+    sections: int = 64,
+) -> trimesh.Trimesh:
+    """Rectangular prism with rounded vertical corners, sitting on z=0.
+
+    extents is (x, y, z) in mm; radius rounds the four vertical edges. Built
+    from boxes plus corner cylinders so it needs no 2D triangulation deps,
+    and clamps the radius rather than erroring when it exceeds the footprint.
+    """
+    x, y, z = (float(v) for v in extents)
+    if min(x, y, z) <= 0:
+        raise ValueError(f"extents must be positive, got {extents}")
+    radius = max(0.0, min(float(radius), x / 2 - 1e-3, y / 2 - 1e-3))
+
+    if radius < 1e-6:
+        prism = trimesh.creation.box((x, y, z))
+    else:
+        core_x = trimesh.creation.box((x, y - 2 * radius, z))
+        core_y = trimesh.creation.box((x - 2 * radius, y, z))
+        corners = []
+        for sx in (-1.0, 1.0):
+            for sy in (-1.0, 1.0):
+                cyl = trimesh.creation.cylinder(radius=radius, height=z, sections=sections)
+                cyl.apply_translation((sx * (x / 2 - radius), sy * (y / 2 - radius), 0))
+                corners.append(cyl)
+        prism = union(core_x, core_y, *corners)
+
+    prism.apply_translation((0, 0, z / 2))
+    return prism
+
+
+def hex_prism(circumradius: float, height: float, point_up: bool = True) -> trimesh.Trimesh:
+    """Hexagonal prism along z, centered at the origin (honeycomb building block)."""
+    hexagon = trimesh.creation.cylinder(radius=circumradius, height=height, sections=6)
+    if point_up:
+        hexagon.apply_transform(trimesh.transformations.rotation_matrix(np.pi / 6, (0, 0, 1)))
+    return hexagon

solidsmith/part.py

@@ -0,0 +1,41 @@
+"""A mesh plus how it should appear when exported or rendered."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Tuple
+
+import trimesh
+
+
+@dataclass
+class Part:
+    """One printable body: a mesh, a display color, and a name.
+
+    Color is sRGB 0-255. A multi-color model is just a list of Parts (one
+    per filament); exported together they become a single 3MF that opens in
+    the slicer with every body already assigned its color.
+    """
+
+    mesh: trimesh.Trimesh
+    color: Tuple[int, int, int] = (140, 140, 145)
+    name: str = "part"
+
+
+def as_parts(obj) -> "list[Part]":
+    """Normalize a Part, a mesh, or a sequence of either into a list of Parts."""
+    if isinstance(obj, Part):
+        return [obj]
+    if isinstance(obj, trimesh.Trimesh):
+        return [Part(obj)]
+    parts = []
+    for i, item in enumerate(obj):
+        if isinstance(item, Part):
+            parts.append(item)
+        elif isinstance(item, trimesh.Trimesh):
+            parts.append(Part(item, name=f"part_{i}"))
+        else:
+            raise TypeError(f"expected Part or Trimesh, got {type(item).__name__}")
+    if not parts:
+        raise ValueError("no parts given")
+    return parts

solidsmith/preview.py

@@ -0,0 +1,91 @@
+"""Multi-view PNG renders with no GUI, GPU, or external renderer.
+
+matplotlib's 3D toolkit is slow for interaction but fine for stills: flat
+Lambert shading, three or four named camera angles, one image. The point is
+a feedback loop measured in seconds — iterate on the cheap render and only
+slice when the shape is right.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from solidsmith.part import as_parts
+
+#: name -> (elevation, azimuth) in degrees
+DEFAULT_VIEWS = {
+    "front": (8, -90),
+    "iso": (26, -52),
+    "side": (8, 0),
+    "top": (74, -90),
+}
+
+_LIGHT = np.array([0.35, -0.45, 0.82])
+_LIGHT = _LIGHT / np.linalg.norm(_LIGHT)
+
+
+def render_views(parts, path, views=None, dpi: int = 140, background: str = "white"):
+    """Render every part into one PNG with a subplot per camera angle.
+
+    ``parts`` may be a mesh, a Part, or a sequence of either; ``views`` maps
+    view names to (elevation, azimuth) tuples and defaults to DEFAULT_VIEWS.
+    Returns the path it wrote.
+    """
+    import matplotlib
+
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    from mpl_toolkits.mplot3d.art3d import Poly3DCollection
+
+    parts = as_parts(parts)
+    views = dict(views) if views else dict(DEFAULT_VIEWS)
+
+    spans_all = np.concatenate([p.mesh.bounds for p in parts], axis=0)
+    max_edge = 0.04 * float(np.ptp(spans_all, axis=0).max())
+
+    # one combined triangle soup so depth sorting works across parts;
+    # long edges get subdivided first because the painter's algorithm
+    # mis-sorts large triangles and streaks flat faces
+    triangles, colors = [], []
+    for part in parts:
+        mesh = part.mesh
+        if max_edge > 0 and len(mesh.faces):
+            mesh = mesh.subdivide_to_size(max_edge, max_iter=12)
+        normals = np.nan_to_num(np.asarray(mesh.face_normals, dtype=np.float64))
+        # multiply-and-sum rather than matmul: Accelerate BLAS on macOS emits
+        # spurious floating-point warnings for tiny matmuls
+        lambert = np.clip(np.sum(normals * _LIGHT, axis=1), 0.0, 1.0)
+        # shade in linear light, then back to sRGB, so colors stay saturated
+        base = (np.array(part.color, dtype=np.float64) / 255.0) ** 2.2
+        lit = base[None, :] * (0.35 + 0.65 * lambert)[:, None]
+        triangles.append(mesh.triangles)
+        colors.append(np.clip(lit, 0.0, 1.0) ** (1 / 2.2))
+    triangles = np.concatenate(triangles)
+    colors = np.concatenate(colors)
+
+    bounds_min = triangles.reshape(-1, 3).min(axis=0)
+    bounds_max = triangles.reshape(-1, 3).max(axis=0)
+    spans = np.maximum(bounds_max - bounds_min, 1e-6)
+    pad = 0.04 * spans.max()
+
+    n = len(views)
+    fig = plt.figure(figsize=(3.7 * n, 4.1), facecolor=background)
+    for i, (name, (elev, azim)) in enumerate(views.items(), start=1):
+        ax = fig.add_subplot(1, n, i, projection="3d", facecolor=background)
+        # edges painted like their faces hide antialiasing seams between triangles
+        collection = Poly3DCollection(
+            triangles, facecolors=colors, edgecolors=colors, linewidths=0.3
+        )
+        ax.add_collection3d(collection)
+        ax.set_xlim(bounds_min[0] - pad, bounds_max[0] + pad)
+        ax.set_ylim(bounds_min[1] - pad, bounds_max[1] + pad)
+        ax.set_zlim(bounds_min[2] - pad, bounds_max[2] + pad)
+        ax.set_box_aspect(spans + 2 * pad)
+        ax.view_init(elev=elev, azim=azim)
+        ax.set_axis_off()
+        ax.set_title(name, fontsize=10, color="#666666", pad=2)
+
+    fig.subplots_adjust(left=0.01, right=0.99, top=0.94, bottom=0.02, wspace=0.02)
+    fig.savefig(path, dpi=dpi, facecolor=background)
+    plt.close(fig)
+    return path

solidsmith/printers.py

@@ -0,0 +1,50 @@
+"""Named printers, so checks judge against a real machine instead of a magic bed."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Tuple
+
+
+@dataclass(frozen=True)
+class Printer:
+    """One machine's limits as seen by the printability checks.
+
+    ``bed`` is the usable build volume in mm. ``nozzle`` is the installed
+    nozzle diameter in mm; walls thinner than one extrusion of it cannot
+    be printed and future checks use it as the floor for feature size.
+    """
+
+    name: str
+    bed: Tuple[float, float, float]
+    nozzle: float = 0.4
+
+
+BAMBU_X1C = Printer("Bambu X1C / P1S", (256.0, 256.0, 256.0))
+BAMBU_P2S = Printer("Bambu P2S", (256.0, 256.0, 256.0))
+BAMBU_A1 = Printer("Bambu A1", (256.0, 256.0, 256.0))
+BAMBU_A1_MINI = Printer("Bambu A1 mini", (180.0, 180.0, 180.0))
+PRUSA_MK4 = Printer("Prusa MK4", (250.0, 210.0, 220.0))
+ENDER_3 = Printer("Creality Ender 3", (220.0, 220.0, 250.0))
+
+#: What `check` assumes when no printer is named.
+DEFAULT_PRINTER = BAMBU_X1C
+
+PRINTERS = {
+    "bambu_x1c": BAMBU_X1C,
+    "bambu_p1s": BAMBU_X1C,
+    "bambu_p2s": BAMBU_P2S,
+    "bambu_a1": BAMBU_A1,
+    "bambu_a1_mini": BAMBU_A1_MINI,
+    "prusa_mk4": PRUSA_MK4,
+    "ender_3": ENDER_3,
+}
+
+
+def printer(name: str) -> Printer:
+    """Look up a built-in profile by slug, e.g. ``printer("bambu_a1_mini")``."""
+    try:
+        return PRINTERS[name]
+    except KeyError:
+        known = ", ".join(sorted(PRINTERS))
+        raise KeyError(f"unknown printer {name!r}; built-ins: {known}") from None

solidsmith/report.py

@@ -0,0 +1,151 @@
+"""Answer "will this print?" before wasting filament on finding out."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Tuple
+
+import numpy as np
+import trimesh.proximity
+
+from solidsmith.part import as_parts
+from solidsmith.printers import DEFAULT_PRINTER, Printer
+from solidsmith.printers import printer as _lookup_printer
+
+#: Build volume of `printers.DEFAULT_PRINTER`, mm. Kept for back-compat;
+#: prefer `check(parts, printer=...)` over passing a bare bed.
+DEFAULT_BED = DEFAULT_PRINTER.bed
+
+_PLATE_TOLERANCE = 0.5  # mm; how far off z=0 still counts as "on the plate"
+_DEBRIS_VOLUME = 1.0  # mm³; a disconnected body smaller than this is boolean debris
+_WALL_SAMPLES = 512  # thickness rays per part; enough to catch any thin panel
+
+
+def _min_wall(mesh) -> float:
+    """Thinnest spot found by shooting rays inward from sampled faces, mm."""
+    faces = len(mesh.faces)
+    if faces <= _WALL_SAMPLES:
+        idx = np.arange(faces)
+    else:
+        idx = np.random.default_rng(0).choice(faces, _WALL_SAMPLES, replace=False)
+    thickness = trimesh.proximity.thickness(
+        mesh, mesh.triangles_center[idx], normals=mesh.face_normals[idx], method="ray"
+    )
+    thickness = thickness[np.isfinite(thickness)]
+    return float(thickness.min()) if len(thickness) else float("inf")
+
+
+@dataclass
+class PrintReport:
+    """What the mesh looks like from a printer's point of view."""
+
+    watertight: bool
+    bodies: int
+    extents: Tuple[float, float, float]
+    volume_cm3: float
+    triangles: int
+    fits_bed: bool
+    bed: Tuple[float, float, float]
+    printer: str
+    on_plate: bool
+    warnings: List[str] = field(default_factory=list)
+
+    def summary(self) -> str:
+        def mark(ok: bool) -> str:
+            return "✔" if ok else "✖"
+
+        x, y, z = self.extents
+        bx, by, bz = self.bed
+        body_note = "1 body" if self.bodies == 1 else f"{self.bodies} bodies"
+        lines = [
+            f"{mark(self.watertight)} watertight ({body_note})",
+            f"{mark(self.fits_bed)} {x:.1f} × {y:.1f} × {z:.1f} mm "
+            f"on a {bx:.0f} × {by:.0f} × {bz:.0f} bed ({self.printer})",
+            f"{mark(self.on_plate)} first layer on the plate (z=0)",
+            f"  {self.volume_cm3:.1f} cm³ · {self.triangles:,} triangles",
+        ]
+        lines.extend(f"⚠ {w}" for w in self.warnings)
+        return "\n".join(lines)
+
+    def __str__(self) -> str:
+        return self.summary()
+
+
+def check(parts, bed=None, printer=None) -> PrintReport:
+    """Inspect a mesh (or Parts) and report printability basics.
+
+    ``printer`` is a `printers.Printer` or a built-in slug like
+    ``"bambu_a1_mini"``; it defaults to `printers.DEFAULT_PRINTER`. ``bed``
+    remains as a shorthand for "custom machine, just this build volume" —
+    pass one or the other, not both.
+
+    Watertightness is judged per body — touching multi-color bodies are each
+    expected to be a closed solid on their own, even though their union is
+    what gets printed.
+    """
+    if printer is not None and bed is not None:
+        raise ValueError("pass bed= or printer=, not both")
+    if isinstance(printer, str):
+        printer = _lookup_printer(printer)
+    if printer is None:
+        printer = DEFAULT_PRINTER if bed is None else Printer("custom bed", tuple(bed))
+    bed = printer.bed
+
+    parts = as_parts(parts)
+    meshes = [p.mesh for p in parts]
+
+    watertight = all(m.is_watertight for m in meshes)
+    volume = sum(float(m.volume) for m in meshes if m.is_watertight)
+    triangles = int(sum(len(m.faces) for m in meshes))
+
+    lows = np.min([m.bounds[0] for m in meshes], axis=0)
+    highs = np.max([m.bounds[1] for m in meshes], axis=0)
+    extents = tuple(float(v) for v in (highs - lows))
+    fits = all(e <= b + 1e-6 for e, b in zip(extents, bed))
+
+    z_low = float(lows[2])
+    on_plate = abs(z_low) <= _PLATE_TOLERANCE
+
+    warnings = []
+    if not watertight:
+        leaky = [p.name for p in parts if not p.mesh.is_watertight]
+        warnings.append(
+            "not watertight: " + ", ".join(leaky) + " — run ops.clean() or check booleans"
+        )
+    if not fits:
+        warnings.append("model exceeds the bed; scale it down or split the print")
+    if z_low > _PLATE_TOLERANCE:
+        warnings.append(f"model floats {z_low:.1f} mm above the plate")
+    if z_low < -_PLATE_TOLERANCE:
+        warnings.append(f"model extends {-z_low:.1f} mm below the plate")
+
+    for p in parts:
+        if not p.mesh.is_watertight:
+            continue  # geometry is unreliable; the watertight warning covers it
+        thin = _min_wall(p.mesh)
+        if thin < printer.nozzle:
+            warnings.append(
+                f"'{p.name}' has walls down to {thin:.2f} mm — too thin for "
+                f"the {printer.nozzle:.2f} mm nozzle"
+            )
+        bodies = p.mesh.split(only_watertight=False)
+        specks = sum(1 for b in bodies if abs(float(b.volume)) < _DEBRIS_VOLUME)
+        if len(bodies) > 1 and specks:
+            plural = "bodies" if specks != 1 else "body"
+            warnings.append(
+                f"'{p.name}' has {specks} stray {plural} under "
+                f"{_DEBRIS_VOLUME:.0f} mm³ — boolean debris? try clean()"
+            )
+
+    return PrintReport(
+        watertight=watertight,
+        bodies=len(parts),
+        extents=extents,
+        volume_cm3=volume / 1000.0,
+        triangles=triangles,
+        fits_bed=fits,
+        bed=tuple(float(b) for b in bed),
+        printer=printer.name,
+        on_plate=on_plate,
+        warnings=warnings,
+    )

solidsmith/sdf.py

@@ -0,0 +1,193 @@
+"""Sculpt organic shapes as blended signed distance fields.
+
+Booleans give you crisp mechanical edges; SDFs give you clay. Describe a
+shape as distance functions over space, blend them with smooth minimums so
+joints read as fillets instead of seams, then pull a watertight mesh out
+with marching cubes and Taubin smoothing.
+
+A field is any callable mapping an (N, 3) array of points to (N,) signed
+distances, negative inside. Compose them functionally:
+
+    body = sdf.smooth_union(12, sdf.sphere((0, 0, 30), 25),
+                                sdf.ellipsoid((0, 18, 22), (20, 26, 16)))
+    solid = sdf.intersect(body, sdf.plane())        # flat print base at z=0
+    mesh = sdf.mesh(solid, bounds=((-30, -30, 0), (30, 50, 50)), pitch=0.5)
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import trimesh
+
+from solidsmith.ops import clean
+
+# ------------------------------------------------------------------ primitives
+
+
+def sphere(center, radius: float):
+    center = np.asarray(center, dtype=np.float64)
+
+    def field(p):
+        return np.linalg.norm(p - center, axis=-1) - radius
+
+    return field
+
+
+def ellipsoid(center, radii):
+    """Inigo Quilez's ellipsoid distance bound — exact enough for blending."""
+    center = np.asarray(center, dtype=np.float64)
+    radii = np.asarray(radii, dtype=np.float64)
+
+    def field(p):
+        q = (p - center) / radii
+        k0 = np.linalg.norm(q, axis=-1)
+        k1 = np.linalg.norm(q / radii, axis=-1)
+        return np.where(k1 > 0, k0 * (k0 - 1.0) / np.maximum(k1, 1e-12), -radii.min())
+
+    return field
+
+
+def capsule(a, b, radius_a: float, radius_b: "float | None" = None):
+    """Line-segment capsule from a to b; give two radii for a taper."""
+    a = np.asarray(a, dtype=np.float64)
+    b = np.asarray(b, dtype=np.float64)
+    r2 = radius_a if radius_b is None else radius_b
+
+    def field(p):
+        pa = p - a
+        ba = b - a
+        h = np.clip((pa @ ba) / (ba @ ba), 0.0, 1.0)
+        radius = radius_a + (r2 - radius_a) * h
+        return np.linalg.norm(pa - h[..., None] * ba, axis=-1) - radius
+
+    return field
+
+
+def rounded_box(center, extents, radius: float):
+    center = np.asarray(center, dtype=np.float64)
+    half = np.asarray(extents, dtype=np.float64) / 2.0 - radius
+
+    def field(p):
+        q = np.abs(p - center) - half
+        outside = np.linalg.norm(np.maximum(q, 0.0), axis=-1)
+        inside = np.minimum(q.max(axis=-1), 0.0)
+        return outside + inside - radius
+
+    return field
+
+
+def plane(normal=(0, 0, 1), point=(0, 0, 0)):
+    """Half-space keeping everything on the side the normal points toward."""
+    normal = np.asarray(normal, dtype=np.float64)
+    normal = normal / np.linalg.norm(normal)
+    point = np.asarray(point, dtype=np.float64)
+
+    def field(p):
+        return -((p - point) @ normal)
+
+    return field
+
+
+def vertical_cylinder(center_xy, radius: float):
+    """Infinite cylinder along z — cap it by intersecting with planes."""
+    center = np.asarray(center_xy, dtype=np.float64)
+
+    def field(p):
+        return np.linalg.norm(p[..., :2] - center, axis=-1) - radius
+
+    return field
+
+
+# ----------------------------------------------------------------- combinators
+
+
+def _smin(a, b, k: float):
+    h = np.clip(0.5 + 0.5 * (b - a) / k, 0.0, 1.0)
+    return b + (a - b) * h - k * h * (1.0 - h)
+
+
+def union(*fields):
+    return lambda p: np.minimum.reduce([f(p) for f in fields])
+
+
+def intersect(*fields):
+    return lambda p: np.maximum.reduce([f(p) for f in fields])
+
+
+def subtract(base, *cutters):
+    cut = union(*cutters)
+    return lambda p: np.maximum(base(p), -cut(p))
+
+
+def smooth_union(k: float, *fields):
+    """Union with radius-k fillets where surfaces meet (the clay look)."""
+
+    def field(p):
+        values = [f(p) for f in fields]
+        out = values[0]
+        for v in values[1:]:
+            out = _smin(out, v, k)
+        return out
+
+    return field
+
+
+def smooth_subtract(k: float, base, *cutters):
+    """Subtract with a radius-k fillet along the cut."""
+    cut = union(*cutters)
+    return lambda p: -_smin(-base(p), cut(p), k)
+
+
+def offset(base, distance: float):
+    """Positive distance inflates the solid; negative erodes it."""
+    return lambda p: base(p) - distance
+
+
+def shell(base, thickness: float):
+    """Hollow a solid into a wall of the given thickness."""
+    return lambda p: np.abs(base(p)) - thickness / 2.0
+
+
+# ---------------------------------------------------------------- meshing
+
+
+def mesh(
+    field,
+    bounds,
+    pitch: float = 0.8,
+    smooth_iterations: int = 10,
+) -> trimesh.Trimesh:
+    """Sample the field on a grid and extract a watertight surface.
+
+    bounds is ((x0, y0, z0), (x1, y1, z1)) in mm and should enclose the
+    solid with a little margin; pitch is the grid spacing (smaller = finer,
+    cost grows with the cube). Taubin smoothing removes the marching-cubes
+    staircase without shrinking the shape.
+    """
+    from skimage import measure
+
+    lo = np.asarray(bounds[0], dtype=np.float64)
+    hi = np.asarray(bounds[1], dtype=np.float64)
+    if np.any(hi <= lo):
+        raise ValueError(f"bad bounds {bounds}")
+
+    steps = np.maximum(np.ceil((hi - lo) / pitch).astype(int) + 1, 2)
+    axes = [np.linspace(lo[i], hi[i], steps[i]) for i in range(3)]
+    grid = np.stack(np.meshgrid(*axes, indexing="ij"), axis=-1)
+    volume = field(grid.reshape(-1, 3)).reshape(grid.shape[:3])
+
+    if volume.min() > 0 or volume.max() < 0:
+        raise ValueError(
+            "field never crosses zero inside bounds — nothing to mesh "
+            f"(min {volume.min():.2f}, max {volume.max():.2f})"
+        )
+
+    spacing = tuple((hi[i] - lo[i]) / (steps[i] - 1) for i in range(3))
+    vertices, faces, _, _ = measure.marching_cubes(volume, level=0.0, spacing=spacing)
+    result = trimesh.Trimesh(vertices=vertices + lo, faces=faces)
+
+    clean(result)
+    if smooth_iterations > 0:
+        trimesh.smoothing.filter_taubin(result, lamb=0.5, nu=-0.53, iterations=smooth_iterations)
+        clean(result)
+    return result

solidsmith/workflow.py

@@ -0,0 +1,88 @@
+"""The preview/final iteration loop, packaged.
+
+Scripted models converge on the same habit: every run is either a *preview*
+(coarse, fast, renders a PNG to look at) or a *final* (fine, slow, writes
+the files you slice), and every preview is archived — script included — so
+the look of each iteration and the code that produced it stay side by side.
+`main` turns a build function into that CLI:
+
+    from solidsmith import workflow
+
+    def build(fast: bool):
+        ...
+        return parts            # a mesh, a Part, or a list of them
+
+    if __name__ == "__main__":
+        workflow.main(build, name="widget")
+
+    $ python widget.py preview    # out/widget_preview.* + previews/ archive
+    $ python widget.py final      # out/widget_final.stl / .3mf
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import shutil
+import sys
+from pathlib import Path
+
+from solidsmith.export import write_3mf, write_stl
+from solidsmith.part import as_parts
+from solidsmith.preview import render_views
+from solidsmith.report import check
+
+
+def next_version(previews: Path, name: str) -> int:
+    """First unused vN in the archive directory for this model name."""
+    pattern = re.compile(rf"^{re.escape(name)}_v(\d+)$")
+    taken = [
+        int(match.group(1))
+        for entry in previews.glob(f"{name}_v*")
+        if (match := pattern.match(entry.stem))
+    ]
+    return max(taken, default=0) + 1
+
+
+def archive(files, script, previews: Path, name: str) -> int:
+    """Copy this iteration's outputs plus its script into previews/ as vN."""
+    previews.mkdir(parents=True, exist_ok=True)
+    version = next_version(previews, name)
+    for source in [*files, script]:
+        source = Path(source)
+        if source.exists():
+            shutil.copy2(source, previews / f"{name}_v{version}{source.suffix}")
+    return version
+
+
+def main(build, name: str, out="out", previews="previews", views=None, printer=None) -> None:
+    """Run a build function as a preview/final CLI (see module docstring).
+
+    ``build(fast: bool)`` should return a mesh, a Part, or a list of Parts —
+    coarse when fast is True, print-quality when False. ``printer`` is passed
+    through to `check` — a `printers.Printer` or slug like ``"bambu_p2s"``.
+    """
+    parser = argparse.ArgumentParser(description=f"Build {name}")
+    parser.add_argument(
+        "mode", choices=("preview", "final"), nargs="?", default="preview",
+        help="preview: coarse + PNG + archive (default); final: print files",
+    )
+    args = parser.parse_args()
+
+    parts = as_parts(build(args.mode == "preview"))
+    print(check(parts, printer=printer), "\n")
+
+    out_dir = Path(out)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    stem = f"{name}_{args.mode}"
+    written = [
+        write_stl(parts, out_dir / f"{stem}.stl"),
+        write_3mf(parts, out_dir / f"{stem}.3mf"),
+        render_views(parts, out_dir / f"{stem}.png", views=views),
+    ]
+    for path in written:
+        print("wrote", path)
+
+    if args.mode == "preview":
+        version = archive(written, Path(sys.argv[0]), Path(previews), name)
+        print(f"archived iteration v{version} -> {previews}/")

solidsmith-0.2.0.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: solidsmith
+Version: 0.2.0
+Summary: Forge watertight, print-ready 3D parts from Python: robust booleans, colored 3MF export, and multi-view previews.
+Author: Scott Shamansky
+License: MIT
+Project-URL: Homepage, https://github.com/scottshamansky/solidsmith
+Project-URL: Issues, https://github.com/scottshamansky/solidsmith/issues
+Keywords: 3d-printing,parametric,stl,3mf,trimesh,cad,maker
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Manufacturing
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Graphics :: 3D Modeling
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: trimesh>=4.10
+Requires-Dist: manifold3d>=2.5
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: networkx>=2.8
+Requires-Dist: lxml>=4.9
+Requires-Dist: scikit-image>=0.22
+Requires-Dist: rtree>=1.0
+Dynamic: license-file
+
+# solidsmith
+
+[![CI](https://github.com/scottshamansky/solidsmith/actions/workflows/ci.yml/badge.svg)](https://github.com/scottshamansky/solidsmith/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+![Python 3.9+](https://img.shields.io/badge/python-3.9%2B-blue)
+
+**Forge watertight, print-ready 3D parts from Python.**
+
+solidsmith is the missing glue between [trimesh](https://trimesh.org) and your
+printer: booleans that don't fall over, 3MF export that keeps its colors, a
+printability report, and quick multi-view renders to iterate against — the
+scaffolding every scripted-CAD project ends up reinventing, packaged once.
+
+![parametric honeycomb bin rendered from three angles](docs/images/honeycomb_bin.png)
+
+## Why script your models?
+
+Parametric code beats mouse-driven CAD when you make things repeatedly:
+
+- **Every dimension is a variable.** Resize a bin, thicken a wall, or regenerate
+  a whole family of sizes by editing constants, not dragging faces.
+- **Geometry you authored is geometry you own.** Marketplaces increasingly
+  require sellers of printed goods to use their own original designs. A model
+  built from your own code is original by construction, and generic patterns
+  (honeycombs, gears, chamfers) stay free for everyone.
+- **Designs diff, review, and version like any other code.**
+
+## What trimesh leaves to you (and solidsmith does)
+
+| Pain | What solidsmith does |
+| --- | --- |
+| Booleans fail on real-world meshes | `union` / `difference` / `intersection` run the robust manifold engine with mesh hygiene (`clean`) before and after |
+| 3MF export silently drops color | `write_3mf` injects real `<basematerials>` and tags each body, so multi-color models open in the slicer with filaments already assigned |
+| "Will it print?" found out the hard way | `check` reports watertightness per body, bed fit, plate contact, walls too thin for the nozzle, and stray debris bodies — against a named printer profile (`printer="bambu_a1_mini"`) or your own `Printer` |
+| Seeing your part means opening a slicer | `render_views` renders shaded PNGs from named camera angles in about a second, no GUI or GPU |
+
+## Quickstart
+
+```python
+from solidsmith import Part, check, difference, rounded_prism, render_views, write_3mf
+
+shell = rounded_prism((80, 50, 30), radius=8)
+cavity = rounded_prism((74, 44, 30), radius=5)
+cavity.apply_translation((0, 0, 3))
+tray = difference(shell, cavity)
+
+print(check(tray))                     # watertight? fits the bed? on the plate?
+write_3mf(Part(tray, color=(226, 122, 40), name="tray"), "tray.3mf")
+render_views(tray, "tray.png")         # shaded views, one PNG
+```
+
+```
+✔ watertight (1 body)
+✔ 80.0 × 50.0 × 30.0 mm on a 256 × 256 × 256 bed (Bambu X1C / P1S)
+✔ first layer on the plate (z=0)
+  31.0 cm³ · 564 triangles
+```
+
+Multi-color is just more `Part`s — one per filament — exported together:
+
+```python
+write_3mf([Part(body, (30, 120, 220), "body"),
+           Part(cap,  (240, 200, 40), "cap")], "model.3mf")
+```
+
+## Examples
+
+| Model | Run it |
+| --- | --- |
+| Honeycomb storage bin — vented walls, supports-free label tab, every dimension a parameter | `python examples/honeycomb_bin.py` |
+| Pebble planter — SDF-sculpted organic form, hollow with a drainage hole, split into two filament colors | `python examples/pebble_planter.py` |
+| Hex bit organizer — 16 slide-fit sockets for 1/4" bits, built on `workflow.main` with preview/final modes | `python examples/bit_organizer.py preview` |
+| Two-tone phone stand — angled boolean cuts, a charging-cable channel, one AMS color swap, checked against a named printer profile | `python examples/phone_stand.py preview` |
+
+![two-color SDF pebble planter](docs/images/pebble_planter.png)
+
+Each example writes STL + colored 3MF + a rendered preview into `out/` and
+prints its printability report. Add `--fast` while you iterate.
+
+## Install
+
+```bash
+git clone https://github.com/scottshamansky/solidsmith
+cd solidsmith
+pip install -e .
+```
+
+Requires Python 3.9+. Dimensions are millimeters throughout; the default bed
+is a 256 mm cube (Bambu P1/P2/X1 class) and every check takes your own `bed=`.
+
+## Sculpting (SDF)
+
+Alongside the hard-edged boolean toolkit, `solidsmith.sdf` models organic
+shapes as blended signed distance fields — functional primitives, smooth
+unions that read as clay fillets, `offset`/`shell` for hollowing, and
+marching-cubes meshing with Taubin smoothing:
+
+```python
+from solidsmith import sdf
+
+body = sdf.smooth_union(12, sdf.sphere((0, 0, 30), 25),
+                            sdf.ellipsoid((0, 18, 22), (20, 26, 16)))
+solid = sdf.intersect(body, sdf.plane())          # flat print base at z=0
+mesh = sdf.mesh(solid, bounds=((-30, -30, 0), (30, 50, 50)), pitch=0.5)
+```
+
+## The iteration loop
+
+`workflow.main` wraps the loop every scripted model settles into: `preview`
+builds coarse and renders a PNG in seconds; `final` cuts the print-quality
+files; and every preview is archived to `previews/` — script included — so
+each iteration's look and the code that produced it stay side by side.
+
+```python
+from solidsmith import workflow
+
+def build(fast: bool):
+    ...
+    return parts        # a mesh, a Part, or a list of them
+
+if __name__ == "__main__":
+    workflow.main(build, name="widget")
+```
+
+`python widget.py preview`, tweak, repeat — `python widget.py final` once
+the design is locked.
+
+## Roadmap
+
+- More examples and an overhang/support-need check
+- PyPI release
+
+## License
+
+[MIT](LICENSE)

solidsmith-0.2.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+solidsmith/__init__.py,sha256=kIRv9W-A4YoyT058BcWH9BKzfhz2-C9-kjZFf7LfHvk,1058
+solidsmith/export.py,sha256=L8sCwp0pCkx5m-r0GI0dQIt_jG_dNb7eKlIajNGZ-GM,3232
+solidsmith/ops.py,sha256=YNM3FKXrNX9HJ7gBTxOTM2YODOSnEswJ59SD0zqU8Zc,3492
+solidsmith/part.py,sha256=i3gNhXSr6wSoeUBDLOgp1v5lx0giBKmb1iK3T1-C0zk,1218
+solidsmith/preview.py,sha256=aCr0GXjGMuoNr0NGiiehbmbAUykO-OsKgWlWQLCjTRg,3644
+solidsmith/printers.py,sha256=wzFWS9pnf6zNRm-1OhJgvcJoZSxPm6VnHySMtGCw_hA,1540
+solidsmith/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+solidsmith/report.py,sha256=VxL0D7rWQ6J7nJZ9qEEs9z_1GBjxE10r4DtfA257A_g,5598
+solidsmith/sdf.py,sha256=z2BCj72nV21jUJVEsUyTcmJZbfmolFYHB8BfF_fEsb0,6023
+solidsmith/workflow.py,sha256=mslQCYIGLmxpu-OPYA_NN9kdibLMLw3Smn2t67vIPqE,3157
+solidsmith-0.2.0.dist-info/licenses/LICENSE,sha256=Pi_9yYlugE6MxpMtueVWCRMYJd3KV8AQA6YVfWE0AII,1072
+solidsmith-0.2.0.dist-info/METADATA,sha256=qPLAss-qYRPVWLS4P0h8Ma2Pj_-v-BaCladKd-r6flQ,6603
+solidsmith-0.2.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+solidsmith-0.2.0.dist-info/top_level.txt,sha256=hQBsQuh6VQCwkTyNEaDFTcsreGCqXGSXFCv5BqPTHww,11
+solidsmith-0.2.0.dist-info/RECORD,,

solidsmith-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

solidsmith-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Scott Shamansky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

solidsmith-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+solidsmith