pycodecad 1.0.0__py3-none-any.whl

pycodecad/embed.py

@@ -0,0 +1,16 @@
+"""pycodecad's parts as Dear ImGui components for your own app (experimental in 1.0: the names may
+change in a minor version). See docs/embedding.md.
+
+    window = create_window("My app")
+    part = Workspace("part.py")      # code + parameters + 3D view, like the pycodecad window
+    viewer = Viewer()                # only a 3D view
+    while window.frame(keep_open=part.dirty()):
+        imgui.begin("Part"); part.draw(); part.close_prompt(window); imgui.end()
+        imgui.begin("Preview"); viewer.draw(part.shown); imgui.end()
+    window.close()
+"""
+from .viewer import Viewer
+from .window import Window, create_window
+from .workspace import Workspace
+
+__all__ = ["Viewer", "Window", "Workspace", "create_window"]

pycodecad/examples/assembly.py

@@ -0,0 +1,7 @@
+"""The gearbox of gearbox.py: parts from parts.py composed with normal imports."""
+from pycodecad import show
+
+from gearbox import gearbox
+
+for name, parts, color in gearbox():
+    show(parts, name=name, color=color)

pycodecad/examples/assets/logo.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="20mm" height="20mm" viewBox="0 0 20 20"><path d="M0 0 H20 V5 H5 V20 H0 Z"/></svg>

pycodecad/examples/assets/pyramid.stl

@@ -0,0 +1,44 @@
+solid pyramid
+facet normal 0 0 -1
+ outer loop
+  vertex 30 -10 0
+  vertex 50 10 0
+  vertex 50 -10 0
+ endloop
+endfacet
+facet normal 0 0 -1
+ outer loop
+  vertex 30 -10 0
+  vertex 30 10 0
+  vertex 50 10 0
+ endloop
+endfacet
+facet normal 0 -0.83205 0.5547
+ outer loop
+  vertex 30 -10 0
+  vertex 50 -10 0
+  vertex 40 0 15
+ endloop
+endfacet
+facet normal 0.83205 -0 0.5547
+ outer loop
+  vertex 50 -10 0
+  vertex 50 10 0
+  vertex 40 0 15
+ endloop
+endfacet
+facet normal 0 0.83205 0.5547
+ outer loop
+  vertex 50 10 0
+  vertex 30 10 0
+  vertex 40 0 15
+ endloop
+endfacet
+facet normal -0.83205 0 0.5547
+ outer loop
+  vertex 30 10 0
+  vertex 30 -10 0
+  vertex 40 0 15
+ endloop
+endfacet
+endsolid pyramid

pycodecad/examples/embedded_app.py

@@ -0,0 +1,77 @@
+"""An order desk built on pycodecad's ImGui components (pycodecad.embed, experimental in 1.0): pick an
+order and the tray of tray.py is rebuilt to its measures; export it for the printer.
+
+    python examples/embedded_app.py             # the app
+    python examples/embedded_app.py shot.png    # hidden: save a picture after the first run, then quit
+
+tray.py opens read only (a template): the orders never change it. Exports are written next
+to it, one file per order (order_1041.stl ...).
+"""
+import sys
+from pathlib import Path
+
+from slimgui import imgui
+
+import pycodecad.embed as p3
+
+ORDERS = (  # number, customer, width, depth, height (mm), rounded corners
+    ("1041", "Cafe Norte: cutlery", 120.0, 80.0, 30.0, True),
+    ("1042", "Workshop: screws", 60.0, 40.0, 20.0, False),
+    ("1043", "Studio: pencils", 180.0, 50.0, 25.0, True),
+    ("1044", "Kitchen: spices", 150.0, 150.0, 60.0, True),
+)
+FIRST_USE = imgui.Cond.FIRST_USE_EVER
+
+
+def place(title: str, x: float, y: float, width: float, height: float) -> None:
+    imgui.set_next_window_pos((x, y), FIRST_USE)
+    imgui.set_next_window_size((width, height), FIRST_USE)
+    imgui.begin(title)
+
+
+def main(screenshot: str | None = None) -> None:
+    window = p3.create_window("Tray orders", size=(1400, 860), visible=screenshot is None)
+    part = p3.Workspace(Path(__file__).with_name("tray.py"), read_only=True, run=False)
+    part.show_files = False  # only the template, not the other files of its folder
+    preview = p3.Viewer()  # the same tray from the front, with a camera of its own
+    preview.look_from((0.0, -1.0, 0.0))
+    chosen = None
+    while window.frame(keep_open=part.dirty()):
+        place("Template", 350, 10, 1040, 840)  # first: draw() updates it, what follows sees this frame's state
+        part.draw()
+        part.close_prompt(window)
+        imgui.end()
+
+        place("Orders", 10, 10, 330, 400)
+        for index, (number, customer, width, depth, height, rounded) in enumerate(ORDERS):
+            if imgui.selectable(f"{number}  {customer}", chosen == index)[0] or (screenshot and chosen is None):
+                chosen = index
+                part.values.update({"tray.width": width, "tray.depth": depth, "tray.height": height,
+                                    "tray.rounded": rounded})
+                part.run()  # explicit, as always
+        if chosen is not None:
+            number, _, width, depth, height, _ = ORDERS[chosen]
+            imgui.separator()
+            imgui.text(f"Order {number}: {width:g} x {depth:g} x {height:g} mm")
+            imgui.begin_disabled(part.running() or part.error is not None)
+            if imgui.button("Export STL"):
+                part.export("stl", target=f"order_{number}.stl")
+            imgui.same_line()
+            if imgui.button("Export 3MF (Bambu)"):
+                part.export("3mf", "bambu", target=f"order_{number}.3mf")
+            imgui.end_disabled()
+        imgui.text_wrapped("Running..." if part.running() else part.error or part.message)
+        imgui.end()
+
+        place("Preview", 10, 420, 330, 430)
+        preview.draw(part.shown)
+        imgui.end()
+
+        if screenshot and part.ran() and not part.running():
+            window.screenshot(screenshot)
+            window.request_close()
+    window.close()
+
+
+if __name__ == "__main__":
+    main(*sys.argv[1:2])

pycodecad/examples/gear.py

@@ -0,0 +1,6 @@
+"""One loose part made to measure: expose() gives the window a slider per parameter of gear()."""
+from pycodecad import expose, show
+
+from parts import gear
+
+show(expose(gear), name="gear", color="#F4B02A")

pycodecad/examples/gearbox.py

@@ -0,0 +1,30 @@
+"""The parts composed into a gearbox: two meshing gears on shafts, on a plate held by brackets.
+Each part is built once here; gearbox() only places them, so an animation of it is cheap."""
+from build123d import Pos, Rot
+from build123d.topology import Shape
+
+from parts import bracket, gear, pitch_radius, plate, shaft
+
+SMALL, LARGE, MODULE = 12, 24, 2.0
+BACKLASH = 0.3
+DISTANCE = pitch_radius(SMALL, MODULE) + pitch_radius(LARGE, MODULE) + BACKLASH
+AXES = [(-DISTANCE / 2, 0.0), (DISTANCE / 2, 0.0)]
+PLATE = 5.0
+
+PINION, WHEEL = gear(SMALL, MODULE), gear(LARGE, MODULE)
+SHAFT, BRACKET = shaft(6.0, 30.0), bracket(40.0, 4.0)
+WIDTH = DISTANCE + 80
+BASE = plate(WIDTH, 70, PLATE, AXES)
+
+
+def gearbox(angle: float = 0.0) -> list[tuple[str, Shape | list[Shape], str]]:
+    """(name, parts, color) with the pinion turned by angle degrees (the wheel follows)."""
+    (x0, y0), (x1, y1) = AXES
+    half_tooth = 180 / LARGE
+    return [
+        ("plate", BASE, "#9AA3AB"),
+        ("shaft", [Pos(x, y, PLATE) * SHAFT for x, y in AXES], "#D0D4D8"),
+        ("pinion", Pos(x0, y0, PLATE + 12) * Rot(0, 0, angle) * PINION, "#F4B02A"),
+        ("wheel", Pos(x1, y1, PLATE + 12) * Rot(0, 0, half_tooth - angle * SMALL / LARGE) * WHEEL, "#6947AE"),
+        ("bracket", [Pos(-WIDTH / 2, 0, 0) * Rot(0, 0, 180) * BRACKET, Pos(WIDTH / 2, 0, 0) * BRACKET], "#48B5A4"),
+    ]

pycodecad/examples/gears_turning.py

@@ -0,0 +1,11 @@
+"""An animation with frame(): the gearbox turning. The parts are built once (in gearbox.py) and
+only placed in each frame, so 90 frames cost little more than one."""
+from pycodecad import clear, frame, show
+
+from gearbox import gearbox
+
+for step in range(90):
+    clear()
+    for name, parts, color in gearbox(angle=360 * step / 90):
+        show(parts, name=name, color=color)
+    frame()

pycodecad/examples/import_files.py

@@ -0,0 +1,13 @@
+"""Extruded SVG next to a reference STL. The paths start from this file's folder, so the script
+also works with plain `python examples/import_files.py` from any directory."""
+from pathlib import Path
+
+from build123d import extrude, import_svg
+from pycodecad import import_mesh, show
+
+assets = Path(__file__).parent / "assets"
+height = 3.0
+
+logo = extrude(import_svg(assets / "logo.svg"), amount=height)  # pyright: ignore[reportArgumentType]
+show(logo, name="logo", color="gold")
+show(import_mesh(assets / "pyramid.stl"), name="reference", color="blue")

pycodecad/examples/parts.py

@@ -0,0 +1,46 @@
+"""The loose parts: one function per part, no show(). The other scripts compose them."""
+from math import cos, pi, sin
+from typing import Annotated
+
+from build123d import Align, Box, Cylinder, Polygon, Pos, extrude
+from build123d.topology import Shape
+from pytypehint import Label, Max, Min, Slider
+
+BOTTOM = (Align.CENTER, Align.CENTER, Align.MIN)
+
+
+def pitch_radius(teeth: int, module: float) -> float:
+    return module * teeth / 2
+
+
+def gear(teeth: Annotated[int, Min(8), Max(60), Slider(), Label("Teeth")] = 20,
+         module: Annotated[float, Min(0.5), Max(4.0), Slider(), Label("Module")] = 2.0,
+         thickness: Annotated[float, Min(2.0), Max(30.0), Slider(), Label("Thickness")] = 8.0,
+         bore: Annotated[float, Min(2.0), Max(20.0), Label("Bore")] = 6.0) -> Shape:
+    """Spur gear with straight flanks and a hub, centred on the origin, standing on z=0."""
+    root, tip = pitch_radius(teeth, module) - 1.25 * module, pitch_radius(teeth, module) + module
+    outline = [(r * cos(a), r * sin(a))
+               for i in range(teeth)
+               for r, a in ((root, (2 * i - 0.62) * pi / teeth), (tip, (2 * i - 0.3) * pi / teeth),
+                            (tip, (2 * i + 0.3) * pi / teeth), (root, (2 * i + 0.62) * pi / teeth))]
+    body = extrude(Polygon(*outline, align=None), thickness)
+    body += Pos(0, 0, thickness) * Cylinder(bore, thickness / 2, align=BOTTOM)
+    return body - Cylinder(bore / 2, thickness * 4)
+
+
+def shaft(diameter: float = 6.0, length: float = 30.0) -> Shape:
+    return Cylinder(diameter / 2, length, align=BOTTOM)
+
+
+def plate(width: float, depth: float, thickness: float, holes: list[tuple[float, float]]) -> Shape:
+    body = Box(width, depth, thickness, align=BOTTOM)
+    for x, y in holes:
+        body -= Pos(x, y, 0) * Cylinder(3.2, thickness, align=BOTTOM)
+    return body
+
+
+def bracket(length: float = 40.0, thickness: float = 4.0) -> Shape:
+    """L bracket with a mounting hole, its corner on the origin."""
+    base = Pos(length / 2, 0, thickness / 2) * Box(length, 20, thickness)
+    wall = Pos(thickness / 2, 0, 12) * Box(thickness, 20, 24)
+    return base + wall - Pos(length * 0.6, 0, thickness / 2) * Cylinder(3, thickness)

pycodecad/examples/tray.py

@@ -0,0 +1,28 @@
+"""Open tray made to measure: expose() gives the window a control per parameter (units: mm).
+
+Change the values in the window and press Run (Ctrl+R); outside the window the defaults are used,
+or `--set` on the command line: pycodecad export tray.py tray.stl --set width=120
+"""
+from typing import Annotated
+
+from build123d import Axis, Box, Pos, fillet
+from pytypehint import Description, Label, Max, Min, Slider
+from pycodecad import expose, show
+
+
+def tray(width: Annotated[float, Min(20.0), Max(200.0), Slider(), Label("Width")] = 80.0,
+         depth: Annotated[float, Min(20.0), Max(200.0), Slider(), Label("Depth")] = 60.0,
+         height: Annotated[float, Min(5.0), Max(100.0), Slider(), Label("Height")] = 25.0,
+         wall: Annotated[float, Min(0.8), Max(5.0), Label("Wall"),
+                         Description("Also the thickness of the floor")] = 2.0,
+         rounded: Annotated[bool, Label("Rounded corners")] = True):
+    """A box without lid: the outside measures width x depth x height, the floor is one wall thick."""
+    outside = Pos(0, 0, height / 2) * Box(width, depth, height)
+    inside = Pos(0, 0, wall + height / 2) * Box(width - 2 * wall, depth - 2 * wall, height)
+    if rounded:
+        outside = fillet(outside.edges().filter_by(Axis.Z), radius=min(width, depth) / 8)
+        inside = fillet(inside.edges().filter_by(Axis.Z), radius=max(min(width, depth) / 8 - wall, 0.5))
+    return outside - inside
+
+
+show(expose(tray), name="tray", color="#4C9BE8")

pycodecad/files.py

@@ -0,0 +1,262 @@
+"""CAD files: export the shown objects (STL, 3MF generic or Bambu Studio, STEP, BREP, GLB) and
+read triangle meshes (STL, 3MF).
+
+Exports run where the script ran, so they write the real build123d shapes, not preview triangles.
+"""
+from __future__ import annotations
+
+import json
+import re
+import struct
+import xml.etree.ElementTree as ET
+from io import BytesIO
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+from xml.sax.saxutils import quoteattr
+from zipfile import ZIP_DEFLATED, ZipFile
+
+import numpy as np
+
+from .cad import Mesh, Shown, copy_shape, hex_color
+
+if TYPE_CHECKING:
+    from build123d.topology import Shape
+
+FORMATS = ("stl", "3mf", "step", "brep", "glb")
+PROFILES = ("generic", "bambu")
+CORE = "http://schemas.microsoft.com/3dmanufacturing/core/2015/02"
+MATERIAL = "http://schemas.microsoft.com/3dmanufacturing/material/2015/02"
+CONTENT_TYPES = "http://schemas.openxmlformats.org/package/2006/content-types"
+
+
+def export(shown: list[Shown], path: str | Path, profile: str = "generic") -> Path:
+    """Write the objects to `path`; the format comes from its extension."""
+    path = Path(path)
+    kind = path.suffix.lower().lstrip(".")
+    if kind not in FORMATS:
+        raise ValueError(f"Unknown export format {path.suffix!r}: use one of {', '.join(FORMATS)}")
+    if profile not in PROFILES:
+        raise ValueError(f"Unknown 3MF profile {profile!r}: use generic or bambu")
+    if not shown:
+        raise ValueError("Nothing to export: the script shows no objects")
+    if kind == "glb":
+        path.write_bytes(encode_glb(shown))
+    elif any(isinstance(obj.source, Mesh) for obj in shown):
+        _export_meshes(shown, path, kind)
+    else:
+        _export_shapes(shown, path, kind)
+    if kind == "3mf" and profile == "bambu":
+        adapt_bambu(path)
+    return path
+
+
+def _export_meshes(shown: list[Shown], path: Path, kind: str) -> None:
+    """A scene with imported meshes: write triangles (STL/3MF only)."""
+    if kind in ("step", "brep"):
+        raise ValueError(f"{kind.upper()} cannot hold triangle meshes: export STL, 3MF or GLB, "
+                         "or use import_mesh(path, solid=True) for small closed meshes")
+    if kind == "stl":
+        write_stl([obj.world() for obj in shown], path)
+    else:
+        write_3mf(shown, path)
+
+
+def _export_shapes(shown: list[Shown], path: Path, kind: str) -> None:
+    import build123d as b
+
+    if kind == "3mf":
+        mesher = b.Mesher()
+        mesher.add_shape([_labeled(obj) for obj in shown])  # one named, colored 3MF object each
+        mesher.write(str(path))
+        return
+    # Independent wrappers keep the source shapes unparented without copying their geometry.
+    sources = [_shape(obj) for obj in shown]
+    shape = sources[0] if len(sources) == 1 else b.Compound(children=[copy_shape(s) for s in sources])
+    writer = {"stl": b.export_stl, "step": b.export_step, "brep": b.export_brep}[kind]
+    if not writer(shape, str(path)):
+        raise RuntimeError(f"Could not write {path}")
+
+
+def _shape(obj: Shown) -> Shape:
+    # Without meshes in the scene every source is the shape that show() received.
+    assert obj.source is not None and not isinstance(obj.source, Mesh)
+    return obj.source
+
+
+def _labeled(obj: Shown) -> Shape:
+    import build123d as b
+
+    # A childless Compound stays one mesh; Mesher would split a compound with children.
+    source = _shape(obj)
+    shape = b.Compound(source.wrapped) if isinstance(source, b.Compound) else copy_shape(source)
+    shape.label = obj.name
+    shape.color = b.Color(*obj.color)
+    return shape
+
+
+# --- triangle meshes -------------------------------------------------------------------------
+
+STL_TRIANGLE = np.dtype([("normal", "<f4", (3,)), ("points", "<f4", (3, 3)), ("attribute", "<u2")])
+
+
+def read_triangles(path) -> np.ndarray:
+    """Vertices of an STL (binary or ASCII) or 3MF file, 3 rows per triangle, in millimetres."""
+    path = Path(path)
+    if path.suffix.lower() == ".stl":
+        data = path.read_bytes()
+        if len(data) >= 84 and len(data) == 84 + struct.unpack_from("<I", data, 80)[0] * 50:
+            return np.frombuffer(data, dtype=STL_TRIANGLE, offset=84)["points"].reshape(-1, 3).copy()
+        vertices = re.findall(rb"\bvertex\s+(\S+\s+\S+\s+\S+)", data)
+        if not data.lstrip().lower().startswith(b"solid") or not vertices or len(vertices) % 3:
+            raise ValueError(f"{path}: not a binary or ASCII STL file")
+        return np.array(b" ".join(vertices).split(), dtype=np.float32).reshape(-1, 3)
+    if path.suffix.lower() != ".3mf":
+        raise ValueError(f"{path}: meshes must be STL or 3MF files")
+    from build123d import Mesher
+
+    reader = Mesher()
+    assert reader.model is not None  # Mesher() always creates its lib3mf model
+    reader.model.QueryReader("3mf").ReadFromFile(str(path))
+    model = reader.model.MergeToModel()  # resolves components and their transforms
+    meshes, points = model.GetMeshObjects(), []
+    while meshes.MoveNext():
+        mesh = meshes.GetCurrentMeshObject()
+        vertices = np.array([vertex.Coordinates[:] for vertex in mesh.GetVertices()], dtype=np.float32)
+        triangles = np.array([triangle.Indices[:] for triangle in mesh.GetTriangleIndices()], dtype=np.int64)
+        if triangles.size:
+            points.append(vertices[triangles].reshape(-1, 3))
+    unit = (0.001, 1.0, 10.0, 25.4, 304.8, 1000.0)[model.GetUnit()]  # lib3mf units, in mm
+    return np.concatenate(points) * unit if points else np.empty((0, 3), dtype=np.float32)
+
+
+def write_stl(meshes: list[Mesh], path) -> None:
+    triangles = np.zeros(sum(len(mesh.positions) // 3 for mesh in meshes), dtype=STL_TRIANGLE)
+    triangles["points"] = np.concatenate([mesh.positions for mesh in meshes]).reshape(-1, 3, 3)
+    triangles["normal"] = np.concatenate([mesh.normals[::3] for mesh in meshes])
+    Path(path).write_bytes(b"pycodecad".ljust(80, b"\0") + struct.pack("<I", len(triangles)) + triangles.tobytes())
+
+
+def write_3mf(shown: list[Shown], path) -> None:
+    """A plain 3MF of triangle meshes: one named, colored object per shown object."""
+    with ZipFile(path, "w", ZIP_DEFLATED, compresslevel=1) as archive:
+        archive.writestr("[Content_Types].xml", f'<Types xmlns="{CONTENT_TYPES}"><Default Extension="rels" '
+                         'ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default '
+                         'Extension="model" ContentType="application/vnd.ms-package.3dmanufacturing-3dmodel+xml"/></Types>')
+        archive.writestr("_rels/.rels", '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/'
+                         'relationships"><Relationship Id="rel0" Target="/3D/3dmodel.model" Type="http://schemas.'
+                         'microsoft.com/3dmanufacturing/2013/01/3dmodel"/></Relationships>')
+        with archive.open("3D/3dmodel.model", "w") as model:
+            def write(text: str) -> None:
+                model.write(text.encode())
+
+            def write_rows(template: str, rows: np.ndarray) -> None:
+                for start in range(0, len(rows), 8192):  # format in blocks: fast for big meshes
+                    block = rows[start:start + 8192]
+                    write((template * len(block)) % tuple(block.ravel().tolist()))
+
+            write(f'<model xmlns="{CORE}" unit="millimeter"><resources><basematerials id="1">')
+            for obj in shown:
+                write(f'<base name={quoteattr(obj.name)} displaycolor="{hex_color(obj.color)}FF"/>')
+            write("</basematerials>")
+            for index, obj in enumerate(shown):
+                vertices, triangles = np.unique(obj.world().positions, axis=0, return_inverse=True)
+                triangles = triangles.reshape(-1, 3)
+                # 3MF forbids triangles that repeat a vertex; STL files often have such degenerate ones.
+                triangles = triangles[(triangles[:, 0] != triangles[:, 1]) & (triangles[:, 1] != triangles[:, 2])
+                                      & (triangles[:, 0] != triangles[:, 2])]
+                write(f'<object id="{index + 2}" type="model" name={quoteattr(obj.name)} pid="1" pindex="{index}">'
+                      "<mesh><vertices>")
+                write_rows('<vertex x="%.9g" y="%.9g" z="%.9g"/>', vertices)
+                write("</vertices><triangles>")
+                write_rows('<triangle v1="%d" v2="%d" v3="%d"/>', triangles)
+                write("</triangles></mesh></object>")
+            write("</resources><build>" + "".join(f'<item objectid="{i + 2}"/>' for i in range(len(shown))) + "</build></model>")
+
+
+# --- Bambu Studio 3MF ----------------------------------------------------------------------
+
+def adapt_bambu(path: Path) -> None:
+    """Rewrite colors and object names the way Bambu Studio reads them. Geometry only: no printer
+    or filament presets are embedded."""
+    with ZipFile(path) as archive:
+        entries = {name: archive.read(name) for name in archive.namelist()}
+    ET.register_namespace("", CORE)
+    ET.register_namespace("m", MATERIAL)
+    ET.register_namespace("p", "http://schemas.microsoft.com/3dmanufacturing/production/2015/06")
+    model = ET.fromstring(entries["3D/3dmodel.model"])
+    for materials in model.findall("{*}resources/{*}basematerials"):
+        materials.tag = f"{{{MATERIAL}}}colorgroup"
+        for color in materials:
+            value = color.attrib["displaycolor"]
+            color.tag = f"{{{MATERIAL}}}color"
+            color.attrib.clear()
+            color.set("color", value)
+    config = ET.Element("config")
+    for obj in model.findall("{*}resources/{*}object"):
+        if "name" in obj.attrib:
+            item = ET.SubElement(config, "object", id=obj.attrib["id"])
+            ET.SubElement(item, "metadata", key="name", value=obj.attrib["name"])
+    application = ET.Element(f"{{{CORE}}}metadata", name="Application")
+    application.text = "pycodecad"
+    model.insert(0, application)
+    ET.register_namespace("ct", CONTENT_TYPES)
+    types = ET.fromstring(entries["[Content_Types].xml"])
+    ET.SubElement(types, f"{{{CONTENT_TYPES}}}Default", Extension="config", ContentType="application/xml")
+    entries["3D/3dmodel.model"] = ET.tostring(model, encoding="utf-8", xml_declaration=True)
+    entries["Metadata/model_settings.config"] = ET.tostring(config, encoding="utf-8", xml_declaration=True)
+    entries["[Content_Types].xml"] = ET.tostring(types, encoding="utf-8", xml_declaration=True)
+    output = BytesIO()
+    with ZipFile(output, "w", ZIP_DEFLATED) as archive:
+        for name, data in entries.items():
+            archive.writestr(name, data)
+    path.write_bytes(output.getvalue())
+
+
+# --- GLB (glTF 2.0 binary) -----------------------------------------------------------------
+
+def encode_glb(shown: list[Shown]) -> bytes:
+    """The preview triangles and edges, converted from millimetres/Z-up to glTF metres/Y-up."""
+    doc: dict[str, Any] = dict(asset=dict(version="2.0", generator="pycodecad"), scene=0, scenes=[dict(nodes=[])],
+               nodes=[], meshes=[], materials=[], accessors=[], bufferViews=[], buffers=[])
+    binary = bytearray()
+
+    def accessor(values: np.ndarray, normal: bool = False) -> int:
+        data = np.asarray(values, dtype="<f4")[:, [0, 2, 1]].copy()
+        data[:, 2] *= -1
+        if not normal:
+            data *= 0.001
+        doc["bufferViews"].append(dict(buffer=0, byteOffset=len(binary), byteLength=data.nbytes, target=34962))
+        binary.extend(data.tobytes())
+        result = dict(bufferView=len(doc["bufferViews"]) - 1, componentType=5126, count=len(data), type="VEC3")
+        if not normal:
+            result.update(min=data.min(axis=0).tolist(), max=data.max(axis=0).tolist())
+        doc["accessors"].append(result)
+        return len(doc["accessors"]) - 1
+
+    def linear(c: float) -> float:
+        return c / 12.92 if c <= 0.04045 else ((c + 0.055) / 1.055) ** 2.4
+
+    for obj in shown:
+        material = len(doc["materials"])
+        doc["materials"].append(dict(name=obj.name, doubleSided=True, pbrMetallicRoughness=dict(
+            baseColorFactor=[*map(linear, obj.color), 1], metallicFactor=0, roughnessFactor=0.6)))
+        primitives = []
+        mesh = obj.world()
+        if len(mesh.positions):
+            attributes = dict(POSITION=accessor(mesh.positions), NORMAL=accessor(mesh.normals, True))
+            primitives.append(dict(attributes=attributes, mode=4, material=material))
+        if len(mesh.edges):
+            primitives.append(dict(attributes=dict(POSITION=accessor(mesh.edges)), mode=1, material=material))
+        if primitives:
+            doc["meshes"].append(dict(name=obj.name, primitives=primitives))
+            doc["nodes"].append(dict(name=obj.name, mesh=len(doc["meshes"]) - 1))
+            doc["scenes"][0]["nodes"].append(len(doc["nodes"]) - 1)
+    if not binary:
+        raise ValueError("Nothing to export: the objects have no geometry")
+    doc["buffers"].append(dict(byteLength=len(binary)))
+    payload = json.dumps(doc, separators=(",", ":")).encode()
+    payload += b" " * (-len(payload) % 4)
+    binary.extend(b"\0" * (-len(binary) % 4))
+    return (struct.pack("<III", 0x46546C67, 2, 28 + len(payload) + len(binary))
+            + struct.pack("<I4s", len(payload), b"JSON") + payload
+            + struct.pack("<I4s", len(binary), b"BIN\0") + bytes(binary))

pycodecad/icons/LICENSE

@@ -0,0 +1,43 @@
+ISC License
+
+Copyright (c) 2026 Lucide Icons and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+---
+
+The following Lucide icons are derived from the Feather project:
+
+airplay, alert-circle, alert-octagon, alert-triangle, aperture, arrow-down-circle, arrow-down-left, arrow-down-right, arrow-down, arrow-left-circle, arrow-left, arrow-right-circle, arrow-right, arrow-up-circle, arrow-up-left, arrow-up-right, arrow-up, at-sign, calendar, cast, check, chevron-down, chevron-left, chevron-right, chevron-up, chevrons-down, chevrons-left, chevrons-right, chevrons-up, circle, clipboard, clock, code, columns, command, compass, corner-down-left, corner-down-right, corner-left-down, corner-left-up, corner-right-down, corner-right-up, corner-up-left, corner-up-right, crosshair, database, divide-circle, divide-square, dollar-sign, download, external-link, feather, frown, hash, headphones, help-circle, info, italic, key, layout, life-buoy, link-2, link, loader, lock, log-in, log-out, maximize, meh, minimize, minimize-2, minus-circle, minus-square, minus, monitor, moon, more-horizontal, more-vertical, move, music, navigation-2, navigation, octagon, pause-circle, percent, plus-circle, plus-square, plus, power, radio, rss, search, server, share, shopping-bag, sidebar, smartphone, smile, square, table-2, tablet, target, terminal, trash-2, trash, triangle, tv, type, upload, x-circle, x-octagon, x-square, x, zoom-in, zoom-out
+
+The MIT License (MIT) (for the icons listed above)
+
+Copyright (c) 2013-present Cole Bemis
+
+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.

pycodecad/icons/__init__.py

@@ -0,0 +1,31 @@
+"""Button icons: the Lucide icon font (https://lucide.dev, ISC license, see LICENSE here), merged into
+the ImGui font so an icon is just a character in a label: imgui.button(icon("play"))."""
+from __future__ import annotations
+
+from importlib import resources
+
+# Lucide 1.48.0 codepoints of the icons the window uses (the font has them all; only these are named).
+CODEPOINTS = {
+    "play": 0xE13C,
+    "pause": 0xE12E,
+    "square": 0xE167,
+    "save": 0xE14D,
+    "file-plus-2": 0xE0CA,
+    "sparkles": 0xE412,
+    "copy": 0xE09E,
+    "clipboard-paste": 0xE3E8,
+    "download": 0xE0B2,
+    "refresh-cw": 0xE145,
+    "scan": 0xE257,
+    "settings-2": 0xE245,
+    "rotate-ccw": 0xE148,
+}
+
+
+def icon(name: str) -> str:
+    """The character that draws the icon (a KeyError names an icon missing from CODEPOINTS)."""
+    return chr(CODEPOINTS[name])
+
+
+def font_data() -> bytes:
+    return resources.files(__name__).joinpath("lucide.ttf").read_bytes()