3d-base 0.2.0__tar.gz → 0.3.0__tar.gz

{3d_base-0.2.0/src/3d_base.egg-info → 3d_base-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: 3d-base
-Version: 0.2.0
+Version: 0.3.0
 Summary: Headless pictures of 3D meshes with correct occlusion and smooth shading, and a health check for exported STL files
 Author: Konstantinos Georgiou
 License-Expression: MIT
@@ -14,16 +14,27 @@ License-File: LICENSE
 Requires-Dist: numpy>=1.22
 Requires-Dist: trimesh>=3.20
 Requires-Dist: scipy>=1.8
+Requires-Dist: rtree>=1.0
+Provides-Extra: captions
+Requires-Dist: pillow>=10.1; extra == "captions"
+Provides-Extra: sections
+Requires-Dist: shapely>=2.0; extra == "sections"
+Requires-Dist: mapbox-earcut>=1.0; extra == "sections"
+Requires-Dist: networkx>=3.0; extra == "sections"
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pillow>=10.1; extra == "test"
+Requires-Dist: shapely>=2.0; extra == "test"
+Requires-Dist: mapbox-earcut>=1.0; extra == "test"
+Requires-Dist: networkx>=3.0; extra == "test"
 Dynamic: license-file
 
+![3d-base](docs/images/banner.png)
+
 # 3d-base
 
 3d-base draws pictures of 3D meshes from Python with no display, no OpenGL and no browser. It needs numpy, trimesh and scipy. I use it to check models for 3D printing from a script, and to give an AI assistant pictures it can judge a design from.
 
-![Three views of a box, a ball and a rod that pass through each other](docs/example.png)
-
 It also loads exported STL files and reports what is really wrong with them, after removing the zero-area triangles that CAD exporters write.
 
 ## Install

{3d_base-0.2.0 → 3d_base-0.3.0}/README.md

@@ -1,9 +1,9 @@
+![3d-base](docs/images/banner.png)
+
 # 3d-base
 
 3d-base draws pictures of 3D meshes from Python with no display, no OpenGL and no browser. It needs numpy, trimesh and scipy. I use it to check models for 3D printing from a script, and to give an AI assistant pictures it can judge a design from.
 
-![Three views of a box, a ball and a rod that pass through each other](docs/example.png)
-
 It also loads exported STL files and reports what is really wrong with them, after removing the zero-area triangles that CAD exporters write.
 
 ## Install

{3d_base-0.2.0 → 3d_base-0.3.0}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "3d-base"
-version = "0.2.0"
+version = "0.3.0"
 description = "Headless pictures of 3D meshes with correct occlusion and smooth shading, and a health check for exported STL files"
 readme = "README.md"
 requires-python = ">=3.9"
 license = "MIT"
 authors = [{ name = "Konstantinos Georgiou" }]
-dependencies = ["numpy>=1.22", "trimesh>=3.20", "scipy>=1.8"]
+dependencies = ["numpy>=1.22", "trimesh>=3.20", "scipy>=1.8", "rtree>=1.0"]
 keywords = ["3d", "mesh", "stl", "render", "headless", "trimesh", "3d-printing", "cad"]
 classifiers = ["Programming Language :: Python :: 3", "Topic :: Multimedia :: Graphics :: 3D Rendering"]
 
@@ -21,7 +21,9 @@ Homepage = "https://github.com/drkostas/3d-base"
 3d-base = "base3d.cli:main"
 
 [project.optional-dependencies]
-test = ["pytest>=8"]
+captions = ["pillow>=10.1"]
+sections = ["shapely>=2.0", "mapbox-earcut>=1.0", "networkx>=3.0"]
+test = ["pytest>=8", "pillow>=10.1", "shapely>=2.0", "mapbox-earcut>=1.0", "networkx>=3.0"]
 
 [tool.setuptools.packages.find]
 where = ["src"]

{3d_base-0.2.0 → 3d_base-0.3.0/src/3d_base.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: 3d-base
-Version: 0.2.0
+Version: 0.3.0
 Summary: Headless pictures of 3D meshes with correct occlusion and smooth shading, and a health check for exported STL files
 Author: Konstantinos Georgiou
 License-Expression: MIT
@@ -14,16 +14,27 @@ License-File: LICENSE
 Requires-Dist: numpy>=1.22
 Requires-Dist: trimesh>=3.20
 Requires-Dist: scipy>=1.8
+Requires-Dist: rtree>=1.0
+Provides-Extra: captions
+Requires-Dist: pillow>=10.1; extra == "captions"
+Provides-Extra: sections
+Requires-Dist: shapely>=2.0; extra == "sections"
+Requires-Dist: mapbox-earcut>=1.0; extra == "sections"
+Requires-Dist: networkx>=3.0; extra == "sections"
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pillow>=10.1; extra == "test"
+Requires-Dist: shapely>=2.0; extra == "test"
+Requires-Dist: mapbox-earcut>=1.0; extra == "test"
+Requires-Dist: networkx>=3.0; extra == "test"
 Dynamic: license-file
 
+![3d-base](docs/images/banner.png)
+
 # 3d-base
 
 3d-base draws pictures of 3D meshes from Python with no display, no OpenGL and no browser. It needs numpy, trimesh and scipy. I use it to check models for 3D printing from a script, and to give an AI assistant pictures it can judge a design from.
 
-![Three views of a box, a ball and a rod that pass through each other](docs/example.png)
-
 It also loads exported STL files and reports what is really wrong with them, after removing the zero-area triangles that CAD exporters write.
 
 ## Install

{3d_base-0.2.0 → 3d_base-0.3.0}/src/3d_base.egg-info/SOURCES.txt

@@ -11,6 +11,8 @@ src/base3d/__init__.py
 src/base3d/cli.py
 src/base3d/mesh.py
 src/base3d/show.py
+src/base3d/thickness.py
 src/base3d/skill/SKILL.md
 tests/test_mesh.py
-tests/test_show.py
+tests/test_show.py
+tests/test_thickness.py

3d_base-0.3.0/src/3d_base.egg-info/requires.txt

@@ -0,0 +1,19 @@
+numpy>=1.22
+trimesh>=3.20
+scipy>=1.8
+rtree>=1.0
+
+[captions]
+pillow>=10.1
+
+[sections]
+shapely>=2.0
+mapbox-earcut>=1.0
+networkx>=3.0
+
+[test]
+pytest>=8
+pillow>=10.1
+shapely>=2.0
+mapbox-earcut>=1.0
+networkx>=3.0

{3d_base-0.2.0 → 3d_base-0.3.0}/src/base3d/cli.py

@@ -31,6 +31,22 @@ def main(argv=None) -> int:
     c = sub.add_parser("check", help="faces, bodies, closed cavities and volume, after dropping slivers")
     c.add_argument("mesh")
 
+    t = sub.add_parser("thickness", help="the thinnest walls, and every place thinner than a bar")
+    t.add_argument("mesh")
+    t.add_argument("--bar", type=float, default=0.8, help="the thinnest wall that prints, in mm (default 0.8)")
+    t.add_argument("-n", type=int, default=4000, help="sample points on the surface (default 4000)")
+    t.add_argument("--printed", action="store_true",
+                   help="judge each wall as the part lies, +z up: two lines across a layer, two layers through a flat plate")
+
+    so = sub.add_parser("sound", help="whether a part is sound to print, and every reason it is not")
+    so.add_argument("mesh")
+    so.add_argument("--bar", type=float, default=0.8, help="the thinnest wall that prints, in mm (default 0.8)")
+
+    sc = sub.add_parser("sections", help="the part cut in half three ways, coloured by wall thickness")
+    sc.add_argument("mesh")
+    sc.add_argument("-o", "--out", default="sections.png")
+    sc.add_argument("--bar", type=float, default=0.8, help="the thinnest wall that prints, in mm (default 0.8)")
+
     a = p.parse_args(argv)
     if a.cmd == "skill":
         dest = Path(a.dir).expanduser() / "3d-base"
@@ -42,6 +58,27 @@ def main(argv=None) -> int:
         rep = report(a.mesh)
         print(json.dumps(rep, indent=1))
         return 1 if rep["voids"] else 0
+    if a.cmd == "sections":
+        from .show import sections
+        m, _ = load_clean(a.mesh)
+        save_png(sections(m, bar_mm=a.bar), a.out)
+        print(a.out)
+        return 0
+    if a.cmd == "sound":
+        from .mesh import sound
+        m, _ = load_clean(a.mesh)
+        rep = sound(m, bar_mm=a.bar)
+        print(json.dumps(rep, indent=1))
+        return 1 if rep["faults"] else 0
+    if a.cmd == "thickness":
+        from .thickness import print_thin_spots, thin_spots, wall_thickness
+        m, _ = load_clean(a.mesh)
+        _pts, _nrm, mm = wall_thickness(m, n=a.n)
+        finite = [float(x) for x in mm if x != float("inf")]
+        spots = print_thin_spots(m, line_mm=a.bar, n=a.n) if a.printed else thin_spots(m, a.bar, n=a.n)
+        print(json.dumps({"thinnest_mm": min(finite) if finite else None, "bar_mm": a.bar,
+                          "thin_spots": spots}, indent=1))
+        return 1 if spots else 0
     m, _ = load_clean(a.mesh)
     w, h = (int(x) for x in a.size.lower().split("x"))
     if a.view == "sheet":

3d_base-0.3.0/src/base3d/mesh.py

@@ -0,0 +1,258 @@
+"""Load an exported STL and tell real defects from tessellation noise.
+
+OpenCascade (and CAD tools built on it, such as build123d and CadQuery) writes zero-area triangles at
+every sphere pole when it exports STL. They make a correct solid report `is_watertight=False` with
+two or three extra bodies, so a plain `Sphere(20)` already looks broken. The slivers are an
+artefact of the tessellation and it is correct to drop them.
+
+Dropping them is also what makes the body count useful. Once the slivers are gone, a second body is
+real. A shell with negative volume is a sealed cavity (a socket that never reached the surface, for
+example), and that is a design defect worth catching before printing.
+"""
+from __future__ import annotations
+
+import numpy as np
+import trimesh
+
+SLIVER_AREA = 1e-9
+
+# Any fixed value. What matters is that it does not change between runs.
+SAMPLE_SEED = 11
+
+
+def clean(mesh: trimesh.Trimesh, sliver_area: float = SLIVER_AREA) -> trimesh.Trimesh:
+    """Drop zero-area faces and merge the vertices they leave behind. Changes the mesh in place."""
+    areas = mesh.area_faces
+    if (areas <= sliver_area).any():
+        mesh.update_faces(areas > sliver_area)
+        mesh.remove_unreferenced_vertices()
+        mesh.merge_vertices()
+    return mesh
+
+
+def load_clean(path):
+    """Load a mesh file, drop tessellation slivers, and return (mesh, bodies).
+
+    `bodies` is the list of connected pieces. After cleaning, more than one means more than one
+    real piece.
+    """
+    m = trimesh.load(str(path))
+    if isinstance(m, trimesh.Scene):  # a GLB or OBJ with several parts
+        m = m.to_geometry() if hasattr(m, "to_geometry") else m.dump(concatenate=True)
+    clean(m)
+    bodies = m.split(only_watertight=False)
+    return m, bodies
+
+
+def voids(bodies):
+    """Pieces with negative volume, which are closed cavities inside another piece."""
+    return [b for b in bodies if b.volume < 0]
+
+
+def surface_points(mesh, n=4000, seed=SAMPLE_SEED):
+    """Points on the surface of a mesh, the same points on every run.
+
+    An unseeded sample makes a design change between two builds of the same input whenever the
+    points decide something (where a support or a contact goes, for example).
+    """
+    rng = np.random.default_rng(seed)
+    try:
+        return mesh.sample(n, seed=rng)
+    except TypeError:
+        # Older trimesh has no seed argument. Sampling without one would break the promise above,
+        # so sample here: pick faces by area, then a uniform point inside each.
+        return _seeded_sample(mesh, n, rng)
+
+
+def _seeded_sample(mesh, n, rng):
+    cum = np.cumsum(np.asarray(mesh.area_faces, float))
+    face = np.searchsorted(cum, rng.random(n) * cum[-1])
+    tri = np.asarray(mesh.triangles, float)[face]
+    r = rng.random((n, 2))
+    over = r.sum(axis=1) > 1
+    r[over] = 1 - r[over]                       # fold the square onto the triangle
+    return tri[:, 0] + r[:, :1] * (tri[:, 1] - tri[:, 0]) + r[:, 1:] * (tri[:, 2] - tri[:, 0])
+
+
+def report(path) -> dict:
+    """A short health report for a mesh file."""
+    m, bodies = load_clean(path)
+    return {
+        "faces": int(len(m.faces)),
+        "bodies": len(bodies),
+        "voids": len(voids(bodies)),
+        "watertight": bool(m.is_watertight),
+        "volume": float(m.volume) if m.is_watertight else None,
+        "extents": [float(x) for x in m.extents],
+    }
+
+
+def _pieces(mesh, inverse=None, count=None):
+    """The pieces of `mesh` joined face to face (across edges shared by exactly two faces), largest
+    first. Counted here rather than by `split`, which fills holes first and needs networkx."""
+    from scipy.sparse import coo_matrix
+    from scipy.sparse.csgraph import connected_components
+    if inverse is None:
+        edges = np.sort(np.asarray(mesh.edges), axis=1)
+        _u, inverse, count = np.unique(edges, axis=0, return_inverse=True, return_counts=True)
+        inverse = np.asarray(inverse).ravel()
+    face = np.asarray(mesh.edges_face)
+    order = np.argsort(inverse, kind="stable")
+    inv, fac = inverse[order], face[order]
+    same = (inv[1:] == inv[:-1]) & (count[inv[1:]] == 2)
+    n = len(mesh.faces)
+    adj = coo_matrix((np.ones(int(same.sum())), (fac[:-1][same], fac[1:][same])), shape=(n, n))
+    k, label = connected_components(adj, directed=False)
+    pieces = [trimesh.Trimesh(mesh.vertices, mesh.faces[label == i], process=False) for i in range(k)]
+    pieces.sort(key=lambda q: -abs(float(q.volume)))
+    return pieces
+
+
+def sound(mesh: trimesh.Trimesh, bar_mm: float = 0.8, n: int = 4000, size_mm: float = 3.0,
+          loose_mm3: float = 0.5) -> dict:
+    """One call for whether a part is sound to print, and every reason it is not.
+
+    `faults` lists, in plain words, each of: not closed; more than one piece of real volume; a
+    sealed void (a closed piece of negative volume inside); the file reading back with a hole or a
+    loose piece (`as_written`); and a wall thinner than `bar_mm` over more than `size_mm`, by its
+    middle reading (`thickness.thin_spots`). An empty list is sound. The other keys carry the
+    readings behind them, so a geometry function can end with `assert not sound(m)["faults"]`.
+    """
+    from .thickness import thin_spots
+    faults = []
+    pieces = _pieces(mesh)
+    vols = [float(q.volume) for q in pieces]
+    bodies = sum(1 for v in vols if v > loose_mm3)
+    voids = sum(1 for v in vols if v < -loose_mm3)
+    closed = bool(mesh.is_watertight)
+    if not closed:
+        faults.append("not closed")
+    if bodies > 1:
+        faults.append(f"{bodies} pieces of real volume")
+    if voids:
+        faults.append(f"{voids} sealed void(s)")
+    written = as_written(mesh, loose_mm3=loose_mm3)
+    if not written["ok"]:
+        faults.append(f"reads back from a file with {written['holes']} holed edge(s) and "
+                      f"{written['loose_mm3']:.2f} mm3 loose")
+    thin = [t for t in thin_spots(mesh, bar_mm, n=n) if t["size_mm"] >= size_mm]
+    thinnest = min((t["typical_mm"] for t in thin), default=None)
+    if thin:
+        worst = min(thin, key=lambda t: t["typical_mm"])
+        faults.append(f"a wall {worst['typical_mm']:.2f} mm thick over {worst['size_mm']:.1f} mm "
+                      f"(needs {bar_mm})")
+    return {"faults": faults, "closed": closed, "bodies": bodies, "voids": voids,
+            "as_written": written, "thinnest_wall_mm": thinnest}
+
+
+def as_written(mesh: trimesh.Trimesh, file_type: str = "stl", loose_mm3: float = 0.5) -> dict:
+    """The mesh as a slicer will read it: written to `file_type`, read back, and counted.
+
+    A boolean engine can leave two vertices a hundred millionth of a millimetre apart, kept separate
+    only by their index, so a mesh can be one closed body in memory. An STL stores 32-bit coordinates
+    and has no indices, and a reader joins vertices by position, so those pairs weld together. Read
+    back, the mesh can have holes, extra pieces, or edges shared by four faces.
+
+    Returns `bodies` (the pieces joined face to face; two closed sheets that only touch along an
+    edge are two pieces), `holes` (edges with an odd number of faces, where a slicer has to guess),
+    `touches` (edges with four faces, two closed sheets touching, which still slice as they are),
+    `loose_mm3` (the volume of every piece outside the largest one; a piece whose centre is inside
+    it overlaps it, and a slicer prints overlapping shells as one solid) and `ok`, which is no hole
+    and nothing loose beyond `loose_mm3`: a boolean's slivers pass, a real second piece does not.
+    """
+    import io
+    buf = io.BytesIO()
+    mesh.export(buf, file_type=file_type)
+    buf.seek(0)
+    back = trimesh.load(buf, file_type=file_type, force="mesh")
+    edges = np.sort(np.asarray(back.edges), axis=1)
+    _uniq, inverse, count = np.unique(edges, axis=0, return_inverse=True, return_counts=True)
+    inverse = np.asarray(inverse).ravel()
+    holes = int((count % 2 == 1).sum())
+    touches = int(((count > 2) & (count % 2 == 0)).sum())
+    pieces = _pieces(back, inverse, count)
+    bodies = len(pieces)
+    loose = 0.0
+    for q in pieces[1:]:
+        # a closed piece whose centre lies inside the largest piece overlaps it, and a slicer
+        # prints overlapping shells as one solid; a piece outside the largest one is loose
+        inside = False
+        if holes == 0:
+            try:
+                inside = bool(pieces[0].contains([np.asarray(q.centroid, float)])[0])
+            except Exception:
+                inside = False
+        if not inside:
+            loose += abs(float(q.volume))
+    return {"ok": holes == 0 and loose <= loose_mm3, "bodies": int(bodies), "holes": holes,
+            "touches": touches, "loose_mm3": float(loose)}
+
+
+def solid_from_skin(mesh: trimesh.Trimesh, centre, reach: float, lean: float = 0.3) -> trimesh.Trimesh:
+    """A hollow part made solid from its outer skin, by removing its inner surface.
+
+    The inner surface is taken as the one connected region of faces that point toward `centre`
+    (the cosine of the angle between the face normal and the direction to `centre` is above
+    `lean`), lie within `reach` of it, and are joined to the face nearest to it. Removing them leaves
+    the skin open along one or more loops (the inner edge of a rim, the root of a brim), and each
+    loop is closed with a fan of triangles to `centre`. The result has the same outside and no inside,
+    so a cavity cut into it afterwards (a bore for a part it sits on) is the only inside it has.
+
+    This exists because filling a hollow part by uniting a fill with it leaves air wherever the fill
+    meets the inner surface at a grazing angle, which a slicer prints as tunnels. With no inner
+    surface there is nothing for air to lie against. Raises ValueError when the skin cannot be closed.
+    """
+    import scipy.sparse as sp
+    from scipy.sparse.csgraph import connected_components
+    centre = np.asarray(centre, float)
+    c = np.asarray(mesh.triangles_center, float)
+    n = np.asarray(mesh.face_normals, float)
+    to_c = centre - c
+    dist = np.linalg.norm(to_c, axis=1)
+    to_c = to_c / np.maximum(dist, 1e-12)[:, None]
+    cand = (dist < float(reach)) & (np.einsum("ij,ij->i", n, to_c) > lean)
+    if not cand.any():
+        raise ValueError("no face points toward the centre within reach")
+    adj = np.asarray(mesh.face_adjacency)
+    both = cand[adj[:, 0]] & cand[adj[:, 1]]
+    graph = sp.coo_matrix((np.ones(int(both.sum())), (adj[both, 0], adj[both, 1])), shape=(len(c), len(c)))
+    _k, label = connected_components(graph, directed=False)
+    seed = int(np.argmin(np.where(cand, dist, np.inf)))
+    inner = cand & (label == label[seed])
+    faces = np.asarray(mesh.faces)[~inner]
+    skin = trimesh.Trimesh(np.asarray(mesh.vertices, float), faces, process=False)
+    edges = np.sort(np.asarray(skin.edges), axis=1)
+    uniq, count = np.unique(edges, axis=0, return_counts=True)
+    rim = uniq[count == 1]
+    V = np.vstack([skin.vertices, centre[None, :]])
+    apex = len(V) - 1
+    fan = [[a, b, apex] for loop in _loops(rim) for a, b in zip(loop, loop[1:] + loop[:1])]
+    solid = trimesh.Trimesh(V, np.vstack([faces, np.asarray(fan, int).reshape(-1, 3)]), process=False)
+    solid.merge_vertices()
+    if not solid.is_watertight:
+        raise ValueError("the skin could not be closed")
+    if solid.volume < 0:
+        solid.invert()
+    return solid
+
+
+def _loops(edges):
+    """Closed loops in a set of boundary edges, as vertex lists."""
+    nxt = {}
+    for a, b in np.asarray(edges).tolist():
+        nxt.setdefault(a, []).append(b)
+        nxt.setdefault(b, []).append(a)
+    seen, loops = set(), []
+    for start in nxt:
+        if start in seen:
+            continue
+        loop, prev, cur = [start], None, start
+        while True:
+            seen.add(cur)
+            after = [v for v in nxt[cur] if v != prev and v not in seen]
+            if not after:
+                break
+            prev, cur = cur, after[0]
+            loop.append(cur)
+        loops.append(loop)
+    return loops

{3d_base-0.2.0 → 3d_base-0.3.0}/src/base3d/show.py

@@ -292,3 +292,143 @@ def save_png(img, path):
 
 # The name used before this was a package.
 _corner_normals = corner_normals
+
+
+def caption(text, width, size=28, floor=12, pad=14, gap=6, bg=(20, 20, 20), fg=(226, 232, 238),
+            font=None):
+    """A caption drawn into an image `width` wide, as an RGB array to stack with pictures.
+
+    The words are wrapped into lines that fit the width at `size`, so a long caption makes the band
+    taller instead of the type smaller, and every caption on a sheet reads at one size. Only a
+    single word wider than the band shrinks the type, down to `floor`, and a word that does not fit
+    even then raises, because a caption that is written and not visible is the same fault as a
+    number printed to a log. `font` is a path to a TrueType file; without one, Pillow's own face is
+    used. Needs Pillow (`pip install '3d-base[captions]'`).
+    """
+    try:
+        from PIL import Image, ImageDraw, ImageFont
+    except ImportError as e:
+        raise ImportError("caption needs Pillow: pip install '3d-base[captions]'") from e
+    words = text.split()
+    if not words:
+        raise ValueError("an empty caption")
+
+    def face(pt):
+        if font:
+            try:
+                return ImageFont.truetype(font, pt)
+            except OSError:
+                pass
+        try:
+            return ImageFont.load_default(size=pt)
+        except TypeError:                       # an older Pillow, one size only
+            return ImageFont.load_default()
+
+    probe = ImageDraw.Draw(Image.new("RGB", (8, 8)))
+    room = width - 2 * pad
+    pt = size
+    while True:
+        f = face(pt)
+        widest = max(probe.textlength(w, font=f) for w in words)
+        if widest <= room or pt <= floor:
+            break
+        pt -= 1
+    if widest > room:
+        raise ValueError(f"a word of {text!r} does not fit {width} px even at {floor} pt")
+    lines, line = [], ""
+    for w in words:
+        trial = (line + " " + w).strip()
+        if probe.textlength(trial, font=f) <= room:
+            line = trial
+        else:
+            lines.append(line)
+            line = w
+    lines.append(line)
+    try:
+        ascent, descent = f.getmetrics()
+    except Exception:
+        ascent, descent = pt, pt // 4
+    line_h = ascent + descent + gap
+    height = pad + len(lines) * line_h - gap
+    im = Image.new("RGB", (width, height), tuple(bg))
+    draw = ImageDraw.Draw(im)
+    y = pad // 2
+    for ln in lines:
+        draw.text((pad, y), ln, font=f, fill=tuple(fg))
+        y += line_h
+    out = np.asarray(im)
+    if int(out.max()) <= max(bg) + 10:
+        raise ValueError(f"the caption drew no pixels: {text!r}")
+    return out
+
+
+CUT = (0.20, 0.55, 0.62)
+THIN, SHORT, THICK = (0.86, 0.22, 0.20), (0.95, 0.60, 0.18), (0.80, 0.80, 0.77)
+
+
+def sections(mesh, axes=None, bar_mm=0.8, one_line_mm=0.45, n=6000, size=(420, 420), bg=(0.09, 0.10, 0.11)):
+    """The part cut in half three ways, each half coloured by its wall thickness, as one image.
+
+    Look at this before changing a part's geometry. The cuts are through the part's centre, across
+    each of `axes` (by default the part's own principal directions, from surface points). The
+    face of each cut is CUT blue, the walls are THIN red under `one_line_mm`, SHORT orange under
+    `bar_mm` and THICK grey from there, read with `thickness.wall_thickness`. The camera looks
+    straight at each cut face. Needs shapely and mapbox-earcut (`pip install '3d-base[sections]'`).
+    """
+    try:
+        import networkx  # noqa: F401  (trimesh assembles the cut's polygons with it)
+        import shapely  # noqa: F401  (and caps and triangulates with shapely and earcut or triangle)
+    except ImportError as e:
+        raise ImportError("sections needs shapely, networkx and a triangulator: pip install '3d-base[sections]'") from e
+    from scipy.spatial import cKDTree
+    from .mesh import surface_points
+    from .thickness import face_thickness, wall_thickness
+    pts, _nrm, mm = wall_thickness(mesh, n=n)
+    ft = face_thickness(mesh, pts, mm)
+    cols = np.where(ft[:, None] < one_line_mm, THIN, np.where(ft[:, None] < bar_mm, SHORT, THICK))
+    P = np.asarray(surface_points(mesh, 6000), float)
+    c = P.mean(axis=0)
+    if axes is None:
+        axes = np.linalg.svd(P - c, full_matrices=False)[2]
+    axes = [np.asarray(a, float) / max(float(np.linalg.norm(a)), 1e-12) for a in axes]
+    r = float(np.linalg.norm(mesh.extents)) * 1.15
+    tiles = []
+    for a in axes:
+        half = trimesh.intersections.slice_mesh_plane(mesh, a, c, cap=False)
+        if half is None or not len(half.faces):
+            continue
+        fc = cols[cKDTree(mesh.triangles_center).query(half.triangles_center)[1]]
+        face_v, face_f = cut_face(mesh, a, c)
+        if len(face_f):
+            n0 = len(half.vertices)
+            half = trimesh.Trimesh(np.vstack([half.vertices, face_v]), np.vstack([half.faces, face_f + n0]),
+                                   process=False)
+            fc = np.vstack([fc, np.tile(CUT, (len(face_f), 1))])
+        up = (0.0, 0.0, 1.0) if abs(float(a[2])) < 0.9 else (0.0, 1.0, 0.0)
+        tiles.append(render(half, c - a * r, c, size=size, fov=34, up=up, face_colors=fc, bg=bg))
+    return tile(tiles, cols=len(tiles), gap=8, bg=20)
+
+
+def cut_face(mesh, normal, origin, min_area=0.5):
+    """The face of a cut through `mesh` at the plane, as (vertices, faces) in 3D: every polygon of the
+    cut's outline with its holes, triangulated, polygons under `min_area` left out.
+
+    trimesh's own capping of a cut (`slice_mesh_plane(cap=True)`) comes back open when the outline
+    carries a zero-area loop, which a mesh with grazing seams can, and the picture then shows a cut
+    through a hollow part as a solid disc. Drawn from the outline's full polygons, a hole stays a hole.
+    """
+    sec = mesh.section(plane_origin=origin, plane_normal=normal)
+    if sec is None:
+        return np.zeros((0, 3)), np.zeros((0, 3), int)
+    planar, back = sec.to_planar()
+    V, F = [], []
+    for poly in planar.polygons_full:
+        if poly.area < min_area:
+            continue
+        v2, f = trimesh.creation.triangulate_polygon(poly)
+        v3 = trimesh.transform_points(np.c_[v2, np.zeros(len(v2))], back)
+        F.append(np.asarray(f, int) + sum(len(x) for x in V))
+        V.append(v3)
+    if not V:
+        return np.zeros((0, 3)), np.zeros((0, 3), int)
+    return np.vstack(V), np.vstack(F)