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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: 3d-base
-Version: 0.3.0
+Version: 0.3.2
 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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "3d-base"
-version = "0.3.0"
+version = "0.3.2"
 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"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: 3d-base
-Version: 0.3.0
+Version: 0.3.2
 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

{3d_base-0.3.0 → 3d_base-0.3.2}/src/base3d/mesh.py

@@ -188,15 +188,22 @@ def as_written(mesh: trimesh.Trimesh, file_type: str = "stl", loose_mm3: float =
             "touches": touches, "loose_mm3": float(loose)}
 
 
-def solid_from_skin(mesh: trimesh.Trimesh, centre, reach: float, lean: float = 0.3) -> trimesh.Trimesh:
+def solid_from_skin(mesh: trimesh.Trimesh, centre, lean: float = 0.3, keep=None) -> 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.
+    The inner surface is the largest connected region, by area, of faces that point toward `centre`
+    (the cosine of the angle between the face normal and the direction to `centre` is above `lean`)
+    and are seen from it: a ray from `centre` to the face's middle meets that face first. A face
+    behind a wall (the top of a brim, as seen through the shell) is kept whichever way it faces.
+    Removing the inner surface 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.
+
+    `keep` names faces that stay whatever they face, as a boolean mask over the faces: a part the
+    centre sees through the opening, such as the underside of a cap's bill, which faces the centre
+    from outside the shell and would otherwise be taken for inner surface and have the air under it
+    fanned solid.
 
     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
@@ -210,49 +217,149 @@ def solid_from_skin(mesh: trimesh.Trimesh, centre, reach: float, lean: float = 0
     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)
+    cand = np.einsum("ij,ij->i", n, to_c) > lean
+    if keep is not None:
+        cand &= ~np.asarray(keep, bool)
+    if not cand.any():
+        raise ValueError("no face points toward the centre")
+    which = np.flatnonzero(cand)
+    cand[which[~_seen_from(mesh, centre, which)]] = False
     if not cand.any():
-        raise ValueError("no face points toward the centre within reach")
+        raise ValueError("no face that points toward the centre is seen from it")
     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]
+    # the inner surface is the largest connected region of candidates by area: the one nearest the
+    # centre can be a stray pair of faces (a cap's two faces inside its button), and which faces go
+    # must not depend on where the part happens to lie
+    area = np.asarray(mesh.area_faces, float)
+    by_region = np.bincount(label[cand], weights=area[cand], minlength=int(label.max()) + 1)
+    inner = cand & (label == int(np.argmax(by_region)))
+    # what stays is the one connected skin round the inner surface; an island of faces inside it that
+    # the centre cannot see (the side of a groove hidden by its lip) would be fanned into a sealed
+    # pocket, so it goes with the inner surface
+    kept = ~inner
+    both = kept[adj[:, 0]] & kept[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)
+    by_region = np.bincount(label[kept], weights=area[kept], minlength=int(label.max()) + 1)
+    kept &= label == int(np.argmax(by_region))
+    faces = np.asarray(mesh.faces)[kept]
     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]
+    # the skin's boundary edges, each in the winding of the face it belongs to, so the fan triangle
+    # across it runs the edge the other way and is wound with the skin. Chaining the edges into loops
+    # after sorting them lost that direction, and a fan that is not flat then faced the wrong way.
+    directed = np.asarray(skin.edges)
+    _u, inverse, count = np.unique(np.sort(directed, axis=1), axis=0, return_inverse=True, return_counts=True)
+    boundary = directed[count[np.asarray(inverse).reshape(-1)] == 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)
+    fan = np.c_[boundary[:, 1], boundary[:, 0], np.full(len(boundary), apex)]
+    solid = trimesh.Trimesh(V, np.vstack([faces, fan.reshape(-1, 3)]), process=False)
     solid.merge_vertices()
-    if not solid.is_watertight:
+    if not solid.is_watertight or not solid.is_winding_consistent:
         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
+def _seen_from(mesh: trimesh.Trimesh, centre, which, cells: int = 64, batch: int = 4_000_000):
+    """Which of the faces `which` a ray from `centre` to their middles meets first.
+
+    Every ray starts at the one point, so the triangles are binned by their direction from it on a
+    cube map (six faces of `cells` by `cells`), and each ray is tested only against the triangles in
+    its own cell, `batch` ray-triangle pairs at a time. Cast through the mesh's own tree instead,
+    each ray was tested against every triangle whose box it crossed, thousands for a ray from the
+    middle of a shell, and a shell of 70k faces took minutes and more than 8 GB.
+    """
+    centre = np.asarray(centre, float)
+    V = np.asarray(mesh.vertices, float) - centre
+    F = np.asarray(mesh.faces)
+    which = np.asarray(which, int)
+    tri = V[F]                                                        # (n, 3, 3)
+    face_of, u_of, v_of = _cube_cells(tri.reshape(-1, 3), cells)     # per vertex of each triangle
+    face_of, u_of, v_of = (a.reshape(-1, 3) for a in (face_of, u_of, v_of))
+    # a triangle whose three vertices lie on one cube face projects onto that face as the triangle
+    # of their projections, inside the box of their cells; one across an edge of the cube is put
+    # on each face a vertex of it lies on, in a box widened by its own angular size in cells
+    same = (face_of[:, 0] == face_of[:, 1]) & (face_of[:, 0] == face_of[:, 2])
+    entries = []
+    lo_u, hi_u = u_of.min(axis=1), u_of.max(axis=1)
+    lo_v, hi_v = v_of.min(axis=1), v_of.max(axis=1)
+    entries.append(_box_entries(np.flatnonzero(same), face_of[same, 0], lo_u[same], hi_u[same], lo_v[same], hi_v[same], cells))
+    across = np.flatnonzero(~same)
+    if len(across):
+        d = tri[across] / np.maximum(np.linalg.norm(tri[across], axis=2), 1e-12)[:, :, None]
+        cos = np.minimum.reduce([np.einsum("ij,ij->i", d[:, a], d[:, b]) for a, b in ((0, 1), (1, 2), (0, 2))])
+        margin = np.ceil(np.arccos(np.clip(cos, -1, 1)) / (2.0 / cells / 3.0)).astype(int) + 1
+        for k in range(3):
+            entries.append(_box_entries(across, face_of[across, k], u_of[across, k] - margin, u_of[across, k] + margin,
+                                        v_of[across, k] - margin, v_of[across, k] + margin, cells))
+    cell_tri = np.unique(np.vstack(entries), axis=0)                 # (cell, triangle), sorted by cell
+    starts = np.searchsorted(cell_tri[:, 0], np.arange(6 * cells * cells + 1))
+    # the rays: one per face in `which`, to its middle, against the triangles of its cell
+    mid = tri[which].mean(axis=1)
+    dist = np.linalg.norm(mid, axis=1)
+    rf, ru, rv = _cube_cells(mid, cells)
+    rcell = (rf * cells + ru) * cells + rv
+    counts = starts[rcell + 1] - starts[rcell]
+    pair_ray = np.repeat(np.arange(len(which)), counts)
+    offsets = np.repeat(starts[rcell] - np.cumsum(counts) + counts, counts)
+    pair_tri = cell_tri[np.arange(len(pair_ray)) + offsets, 1]
+    own = pair_tri == which[pair_ray]
+    hidden = np.zeros(len(which), bool)
+    for i in range(0, len(pair_ray), batch):
+        r, t_idx = pair_ray[i:i + batch], pair_tri[i:i + batch]
+        t = _ray_t(mid[r] / dist[r][:, None], tri[t_idx])
+        before = (t < dist[r] - 1e-7) & ~own[i:i + batch]
+        hidden[np.unique(r[before])] = True
+    return ~hidden
+
+
+def _cube_cells(d, cells):
+    """The cube-map cell of each direction `d`: the face (0..5, the dominant axis and its sign) and
+    the cell along the other two axes (0..cells-1)."""
+    d = np.asarray(d, float)
+    a = np.abs(d)
+    ax = np.argmax(a, axis=1)
+    idx = np.arange(len(d))
+    m = np.maximum(a[idx, ax], 1e-12)
+    face = ax * 2 + (d[idx, ax] < 0)
+    other = np.array([[1, 2], [0, 2], [0, 1]])[ax]
+    u = np.clip(((d[idx, other[:, 0]] / m + 1.0) / 2.0 * cells).astype(int), 0, cells - 1)
+    v = np.clip(((d[idx, other[:, 1]] / m + 1.0) / 2.0 * cells).astype(int), 0, cells - 1)
+    return face, u, v
+
+
+def _box_entries(tri_idx, face, lo_u, hi_u, lo_v, hi_v, cells):
+    """(cell, triangle) rows for every cell of each triangle's box on its cube face."""
+    lo_u, hi_u = np.clip(lo_u, 0, cells - 1), np.clip(hi_u, 0, cells - 1)
+    lo_v, hi_v = np.clip(lo_v, 0, cells - 1), np.clip(hi_v, 0, cells - 1)
+    nu, nv = hi_u - lo_u + 1, hi_v - lo_v + 1
+    n = nu * nv
+    rep = np.repeat(np.arange(len(tri_idx)), n)
+    k = np.arange(len(rep)) - np.repeat(np.cumsum(n) - n, n)
+    uu = lo_u[rep] + k // nv[rep]
+    vv = lo_v[rep] + k % nv[rep]
+    cell = (face[rep] * cells + uu) * cells + vv
+    return np.c_[cell, tri_idx[rep]]
+
+
+def _ray_t(d, tri):
+    """Where rays from the origin along `d` (m, 3) meet the triangles `tri` (m, 3, 3), as the
+    distance along each ray, infinite where a ray misses its triangle (Moller-Trumbore)."""
+    e1 = tri[:, 1] - tri[:, 0]
+    e2 = tri[:, 2] - tri[:, 0]
+    p = np.cross(d, e2)
+    det = np.einsum("ij,ij->i", e1, p)
+    ok = np.abs(det) > 1e-12
+    inv = np.where(ok, 1.0 / np.where(ok, det, 1.0), 0.0)
+    s = -tri[:, 0]
+    u = np.einsum("ij,ij->i", s, p) * inv
+    q = np.cross(s, e1)
+    v = np.einsum("ij,ij->i", d, q) * inv
+    t = np.einsum("ij,ij->i", e2, q) * inv
+    hit = ok & (u >= -1e-9) & (v >= -1e-9) & (u + v <= 1.0 + 1e-9) & (t > 1e-9)
+    return np.where(hit, t, np.inf)

{3d_base-0.3.0 → 3d_base-0.3.2}/src/base3d/skill/SKILL.md

@@ -265,6 +265,11 @@ for s in spots:
   part.stl`) draws three cuts through its centre coloured by wall thickness, with the cut face in
   blue. A ridge, a dip in a floor or a gap that is not where you thought shows there in a minute,
   where a function written against the wrong shape costs a rebuild per guess.
+- Nothing prints at one line. When a part's thickness runs from plenty at one place down to one
+  line at another (the sides of a shell where it sits closest to what it covers, the tips of a
+  clamp cut by parallel planes), the thin end is the design error. Change it, by growing the part
+  until its thinnest wall reaches the bar or by cutting the feature so it ends square, and do not
+  offer "leave it as one line" as a choice. A one-line wall is brittle, whatever the slicer draws.
 - Before thickening anything, find out which side can grow. A shell that sits on another part (a cap
   on a head) can only grow outward where there is no gap under it, and growing outward changes the
   look. Measure the gap first.
@@ -328,9 +333,13 @@ fixed each.
 - A fill sampled by rays from a centre also reaches surfaces it was not meant for (the underside of
   a brim far out from the centre). Limit how far it may reach.
 - Better than any fill: a hollow part that is to sit on another does not need a fill at all.
-  `mesh.solid_from_skin(mesh, centre, reach)` removes the inner surface and closes the skin, so the
+  `mesh.solid_from_skin(mesh, centre)` removes the inner surface and closes the skin, so the
   cavity cut for the part it sits on is the only inside it has, and there is no surface for air to
-  lie against. Three fills on one cap each left tunnels; the skin made solid left none.
+  lie against. Three fills on one cap each left tunnels; the skin made solid left none. The inner
+  surface is what a ray from the centre meets first: do not cut it off at a distance from the
+  centre, because the part beyond the cut stays, with the shell's own thin wall, under a floor
+  fanned above it (a cap's sides round the ears read 0.46 mm that way). Name with `keep` the faces
+  the centre sees through the opening (a bill's underside), or the air under them is fanned solid.
 
 ## trimesh calls that cost a build each to learn
 

{3d_base-0.3.0 → 3d_base-0.3.2}/tests/test_mesh.py

@@ -147,7 +147,115 @@ def test_a_hollow_dome_becomes_a_solid_one_from_its_skin():
     if dome.volume < 0:
         dome.invert()
     assert dome.is_watertight
-    solid = solid_from_skin(dome, centre=(0, 0, 0), reach=9.5)
+    solid = solid_from_skin(dome, centre=(0, 0, 0))
     assert solid.is_watertight and solid.euler_number == 2
     assert abs(solid.volume - 2.0 / 3.0 * np.pi * 1000) < 0.03 * 2094   # a solid half ball
     assert abs(solid.bounds[1][2] - 10.0) < 1e-6                        # the outside is kept
+
+
+def _bell_profiles():
+    """A bell: 1 mm thick at the top, flaring to a 0.4 mm wall at the rim, open at the bottom, with
+    its inner surface at the flare further from the centre than at the top, as a cap's is round the
+    ears. (outer from the top down to the rim, inner from the rim back up to the top), in (r, z)."""
+    t = np.linspace(0, np.pi / 2, 48)
+    flare = np.sin(t) ** 4
+    outer = np.c_[(10 + 3.0 * flare) * np.sin(t), (10 + 3.0 * flare) * np.cos(t)]
+    inner = np.c_[(9 + 3.6 * flare) * np.sin(t), (9 + 3.6 * flare) * np.cos(t)][::-1]
+    return outer, inner
+
+
+def _revolved(profile, sections=96):
+    part = trimesh.creation.revolve(profile, sections=sections)
+    if part.volume < 0:
+        part.invert()
+    assert part.is_watertight
+    return part
+
+
+def test_the_whole_inner_surface_goes_where_it_flares_out_and_the_thin_wall_with_it():
+    from base3d.mesh import solid_from_skin
+    from base3d.thickness import thin_spots
+    outer, inner = _bell_profiles()
+    bell = _revolved(np.vstack([outer, inner, outer[:1]]))
+    solid = solid_from_skin(bell, centre=(0, 0, 0))
+    assert solid.is_watertight and solid.is_winding_consistent and solid.euler_number == 2
+    thin = [s for s in thin_spots(solid, 0.8) if s["points"] >= 8]
+    assert thin == [], "the 0.4 mm wall at the flare is still there"
+    full = _revolved(np.vstack([outer, [[0.0, 0.0]], outer[:1]]))      # a solid bell
+    assert abs(solid.volume - full.volume) < 0.03 * full.volume
+
+
+def test_a_face_behind_a_wall_is_not_part_of_the_inner_surface():
+    from base3d.mesh import solid_from_skin
+    from base3d.thickness import thin_spots
+    # a dome shell with a brim: seen from a centre 5 mm up, the brim's top faces the centre, but the
+    # dome's wall stands between
+    t = np.linspace(0, np.pi / 2, 24)
+    outer = np.c_[10 * np.sin(t), 10 * np.cos(t)]                    # top to the rim at (10, 0)
+    brim = np.array([[16.0, 0.0], [16.0, -1.0], [9.0, -1.0]])      # out along the rim, under, back in
+    inner = np.c_[9 * np.sin(t), 9 * np.cos(t)][::-1]               # rim back up to the top
+    dome = _revolved(np.vstack([outer, brim, inner, outer[:1]]), sections=64)
+    solid = solid_from_skin(dome, centre=(0, 0, 5))
+    assert solid.is_watertight and solid.is_winding_consistent and solid.euler_number == 2
+    assert [s for s in thin_spots(solid, 0.8) if s["points"] >= 8] == []
+    assert abs(solid.bounds[1][0] - 16.0) < 1e-6                     # the brim is still there
+    # the same solid drawn as one profile: the dome, the brim, and the fan from the brim's inner
+    # edge under the rim up to the centre (the brim's inner side faces the centre and is seen)
+    want = _revolved(np.vstack([outer, brim, [[0.0, 5.0]], outer[:1]]), sections=64)
+    assert abs(solid.volume - want.volume) < 0.03 * want.volume
+
+
+def test_a_fan_that_is_not_flat_is_wound_with_the_skin():
+    from base3d.mesh import solid_from_skin
+    # a dome shell made solid about a centre above its rim: the fan is a cone, and the solid's volume
+    # is the half ball less that cone only when the cone faces the right way
+    t = np.linspace(0, np.pi / 2, 24)
+    outer = np.c_[10 * np.sin(t), 10 * np.cos(t)]
+    inner = np.c_[9 * np.sin(t), 9 * np.cos(t)][::-1]
+    dome = _revolved(np.vstack([outer, inner, outer[:1]]), sections=64)
+    solid = solid_from_skin(dome, centre=(0, 0, 4))
+    assert solid.is_winding_consistent
+    want = 2.0 / 3.0 * np.pi * 1000 - np.pi * 81 * 4 / 3.0
+    assert abs(solid.volume - want) < 0.03 * want
+
+
+def test_what_the_centre_sees_matches_a_ray_cast_through_the_tree():
+    from base3d.mesh import _seen_from
+    t = np.linspace(0, np.pi / 2, 24)
+    outer = np.c_[10 * np.sin(t), 10 * np.cos(t)]
+    brim = np.array([[16.0, 0.0], [16.0, -1.0], [9.0, -1.0]])
+    inner = np.c_[9 * np.sin(t), 9 * np.cos(t)][::-1]
+    dome = _revolved(np.vstack([outer, brim, inner, outer[:1]]), sections=64)
+    dome.apply_transform(trimesh.transformations.rotation_matrix(0.7, [1, 2, 3]))   # off the axes
+    centre = dome.centroid + [0.3, -0.2, 2.0]
+    which = np.arange(len(dome.faces))
+    c = dome.triangles_center
+    d = c - centre
+    d /= np.linalg.norm(d, axis=1)[:, None]
+    first = np.asarray(dome.ray.intersects_first(np.repeat(centre[None, :], len(which), axis=0), d))
+    want = first == which
+    got = _seen_from(dome, centre, which)
+    assert (got == want).all(), f"{int((got != want).sum())} faces differ of {len(which)}"
+    assert 0 < got.sum() < len(which)
+
+
+def test_a_bill_seen_through_the_opening_is_kept_when_named():
+    from base3d.mesh import solid_from_skin
+    # a dome with a flat bill out to 20 mm, made solid about a centre 8 mm below the rim: the bill's
+    # underside faces that centre and is seen from it through the opening, so without being told the
+    # fill takes it for inner surface and fans the air under the bill solid
+    t = np.linspace(0, np.pi / 2, 24)
+    outer = np.c_[10 * np.sin(t), 10 * np.cos(t)]
+    bill = np.array([[20.0, 0.0], [20.0, -1.0], [9.0, -1.0]])
+    inner = np.c_[9 * np.sin(t), 9 * np.cos(t)][::-1]
+    dome = _revolved(np.vstack([outer, bill, inner, outer[:1]]), sections=64)
+    under = np.array([[15.0, 0.0, -2.0]])
+    c, n = dome.triangles_center, dome.face_normals
+    underside = (np.abs(c[:, 2] + 1.0) < 1e-6) & (np.linalg.norm(c[:, :2], axis=1) > 9.5) & (n[:, 2] < -0.9)
+    assert underside.sum() > 0
+    blind = solid_from_skin(dome, centre=(0, 0, -8))
+    assert blind.contains(under)[0], "the air under the bill was not filled, so the test proves nothing"
+    told = solid_from_skin(dome, centre=(0, 0, -8), keep=underside)
+    assert told.is_watertight and told.is_winding_consistent and told.euler_number == 2
+    assert not told.contains(under)[0]
+    assert abs(told.bounds[1][0] - 20.0) < 1e-6