forgekernel 0.9.0__tar.gz → 0.9.1__tar.gz

{forgekernel-0.9.0/src/forgekernel.egg-info → forgekernel-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgekernel
-Version: 0.9.0
+Version: 0.9.1
 Summary: Exact-arithmetic B-rep CAD kernel
 Author-email: Dan Willis <danielcwillis@gmail.com>
 Maintainer-email: Dan Willis <danielcwillis@gmail.com>

{forgekernel-0.9.0 → forgekernel-0.9.1}/src/forgekernel/__init__.py

@@ -4,4 +4,4 @@ Exact rational arithmetic for every topological decision; approximation
 only with tracked error bounds. See README for the three-oracle chain.
 """
 
-__version__ = "0.9.0"
+__version__ = "0.9.1"

forgekernel-0.9.1/src/forgekernel/mesh2d.py

@@ -0,0 +1,365 @@
+"""2D polygon triangulation with holes, for display meshes.
+
+Tessellation is a bounded-error *view* of the exact solid (ADR-0019: meshing is
+a display property, floats are legal). ``triangulate(outer, holes)`` returns a
+shared vertex list plus triangle indices, used to cap a drilled solid's top and
+bottom faces around its bores.
+
+This is a faithful port of the mapbox/earcut ear-clipping algorithm (ISC) — a
+robust linked-list ear clipper with hole elimination. A hand-rolled version
+tore on multi-hole inputs (bolt patterns) because two holes bridging to the same
+outer vertex need distinct linked-list nodes and angular ordering; earcut gets
+that right. The O(n²) ear scan (no z-order hash) is ample for a face's facet
+count.
+"""
+
+from __future__ import annotations
+
+Pt = tuple[float, float]
+
+
+class _Node:
+    __slots__ = ("i", "x", "y", "prev", "next", "steiner")
+
+    def __init__(self, i: int, x: float, y: float) -> None:
+        self.i = i
+        self.x = x
+        self.y = y
+        self.prev = None
+        self.next = None
+        self.steiner = False
+
+
+def triangulate(outer: list[Pt], holes: list[list[Pt]] = ()) -> tuple[list[Pt], list[tuple[int, int, int]]]:
+    """Triangulate ``outer`` minus ``holes``; returns ``(points, triangles)``
+    with triangle indices into points."""
+    pts: list[Pt] = list(outer)
+    hole_indices = []
+    for h in holes:
+        hole_indices.append(len(pts))
+        pts.extend(h)
+
+    flat = [c for p in pts for c in p]
+    tris: list[int] = []
+    outer_node = _linked_list(flat, 0, len(outer) * 2, 2, True)
+    if outer_node is None or outer_node.next is outer_node.prev:
+        return pts, []
+    if hole_indices:
+        outer_node = _eliminate_holes(flat, hole_indices, outer_node, 2)
+    _earcut_linked(outer_node, tris, 2)
+    return pts, [(tris[i], tris[i + 1], tris[i + 2]) for i in range(0, len(tris), 3)]
+
+
+def _linked_list(data, start, end, dim, clockwise):
+    last = None
+    if clockwise == (_signed_area(data, start, end, dim) > 0):
+        for i in range(start, end, dim):
+            last = _insert_node(i // dim, data[i], data[i + 1], last)
+    else:
+        for i in range(end - dim, start - 1, -dim):
+            last = _insert_node(i // dim, data[i], data[i + 1], last)
+    if last is not None and _equals(last, last.next):
+        _remove_node(last)
+        last = last.next
+    return last
+
+
+def _filter_points(start, end=None):
+    if start is None:
+        return start
+    if end is None:
+        end = start
+    p = start
+    again = True
+    while again or p is not end:
+        again = False
+        if not p.steiner and (_equals(p, p.next) or _area(p.prev, p, p.next) == 0):
+            _remove_node(p)
+            p = end = p.prev
+            if p is p.next:
+                break
+            again = True
+        else:
+            p = p.next
+    return end
+
+
+def _earcut_linked(ear, triangles, dim, pass_=0):
+    if ear is None:
+        return
+    ear = _filter_points(ear)
+    stop = ear
+    while ear.prev is not ear.next:
+        prev, nxt = ear.prev, ear.next
+        if _is_ear(ear):
+            triangles.append(prev.i)
+            triangles.append(ear.i)
+            triangles.append(nxt.i)
+            _remove_node(ear)
+            ear = nxt.next
+            stop = nxt.next
+            continue
+        ear = nxt
+        if ear is stop:
+            if pass_ == 0:
+                _earcut_linked(_filter_points(ear), triangles, dim, 1)
+            elif pass_ == 1:
+                ear = _cure_local_intersections(_filter_points(ear), triangles)
+                _earcut_linked(ear, triangles, dim, 2)
+            elif pass_ == 2:
+                _split_earcut(ear, triangles, dim)
+            return
+
+
+def _is_ear(ear):
+    a, b, c = ear.prev, ear, ear.next
+    if _area(a, b, c) >= 0:
+        return False                        # reflex
+    p = c.next
+    while p is not a:
+        if (_point_in_triangle(a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y)
+                and _area(p.prev, p, p.next) >= 0):
+            return False
+        p = p.next
+    return True
+
+
+def _cure_local_intersections(start, triangles):
+    p = start
+    while True:
+        a, b = p.prev, p.next.next
+        if (not _equals(a, b) and _intersects(a, p, p.next, b)
+                and _locally_inside(a, b) and _locally_inside(b, a)):
+            triangles.append(a.i)
+            triangles.append(p.i)
+            triangles.append(b.i)
+            _remove_node(p)
+            _remove_node(p.next)
+            p = start = b
+        p = p.next
+        if p is start:
+            break
+    return _filter_points(p)
+
+
+def _split_earcut(start, triangles, dim):
+    a = start
+    while True:
+        b = a.next.next
+        while b is not a.prev:
+            if a.i != b.i and _is_valid_diagonal(a, b):
+                c = _split_polygon(a, b)
+                a = _filter_points(a, a.next)
+                c = _filter_points(c, c.next)
+                _earcut_linked(a, triangles, dim, 0)
+                _earcut_linked(c, triangles, dim, 0)
+                return
+            b = b.next
+        a = a.next
+        if a is start:
+            break
+
+
+def _eliminate_holes(data, hole_indices, outer_node, dim):
+    queue = []
+    for i, start in enumerate(hole_indices):
+        end = hole_indices[i + 1] * dim if i + 1 < len(hole_indices) else len(data)
+        lst = _linked_list(data, start * dim, end, dim, False)
+        if lst is lst.next:
+            lst.steiner = True
+        queue.append(_left_most(lst))
+    queue.sort(key=lambda n: n.x)
+    for hole in queue:
+        outer_node = _eliminate_hole(hole, outer_node)
+    return outer_node
+
+
+def _eliminate_hole(hole, outer_node):
+    bridge = _find_hole_bridge(hole, outer_node)
+    if bridge is None:
+        return outer_node
+    bridge_reverse = _split_polygon(bridge, hole)
+    _filter_points(bridge_reverse, bridge_reverse.next)
+    return _filter_points(bridge, bridge.next)
+
+
+def _find_hole_bridge(hole, outer_node):
+    p = outer_node
+    hx, hy = hole.x, hole.y
+    qx = -float("inf")
+    m = None
+    # find the outer edge to the left of the hole point that the +x ray hits
+    while True:
+        if hy <= p.y and hy >= p.next.y and p.next.y != p.y:
+            x = p.x + (hy - p.y) / (p.next.y - p.y) * (p.next.x - p.x)
+            if hx >= x > qx:
+                qx = x
+                m = p if p.x < p.next.x else p.next
+                if x == hx:
+                    return m
+        p = p.next
+        if p is outer_node:
+            break
+    if m is None:
+        return None
+    # the bridge must not cross the polygon: pick the reflex vertex of minimum
+    # angle (or minimum x) inside the triangle (hole, (qx,hy), m)
+    stop = m
+    mx, my = m.x, m.y
+    tan_min = float("inf")
+    p = m
+    while True:
+        cond = hx > mx if hy < my else hx < mx
+        if (min(hx, qx) <= p.x <= max(hx, qx) and hx != p.x
+                and _point_in_triangle(hx if hy < my else qx, hy,
+                                       mx, my,
+                                       qx if hy < my else hx, hy,
+                                       p.x, p.y)):
+            tan = abs(hy - p.y) / (hx - p.x) if hx != p.x else float("inf")
+            if _locally_inside(p, hole) and (tan < tan_min or (
+                    tan == tan_min and (p.x > m.x or (p.x == m.x and _sector_contains(m, p))))):
+                m = p
+                tan_min = tan
+        p = p.next
+        if p is stop:
+            break
+    return m
+
+
+def _sector_contains(m, p):
+    return _area(m.prev, m, p.prev) < 0 and _area(p.next, m, m.next) < 0
+
+
+def _split_polygon(a, b):
+    a2 = _Node(a.i, a.x, a.y)
+    b2 = _Node(b.i, b.x, b.y)
+    an, bp = a.next, b.prev
+    a.next = b
+    b.prev = a
+    a2.next = an
+    an.prev = a2
+    b2.next = a2
+    a2.prev = b2
+    bp.next = b2
+    b2.prev = bp
+    return b2
+
+
+def _insert_node(i, x, y, last):
+    p = _Node(i, x, y)
+    if last is None:
+        p.prev = p
+        p.next = p
+    else:
+        p.next = last.next
+        p.prev = last
+        last.next.prev = p
+        last.next = p
+    return p
+
+
+def _remove_node(p):
+    p.next.prev = p.prev
+    p.prev.next = p.next
+
+
+def _left_most(start):
+    p = start
+    leftmost = start
+    p = p.next
+    while p is not start:
+        if p.x < leftmost.x or (p.x == leftmost.x and p.y < leftmost.y):
+            leftmost = p
+        p = p.next
+    return leftmost
+
+
+def _signed_area(data, start, end, dim):
+    s = 0.0
+    j = end - dim
+    for i in range(start, end, dim):
+        s += (data[j] - data[i]) * (data[i + 1] + data[j + 1])
+        j = i
+    return s
+
+
+def _area(p, q, r):
+    return (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y)
+
+
+def _equals(p1, p2):
+    return p1.x == p2.x and p1.y == p2.y
+
+
+def _sign(n):
+    return (n > 0) - (n < 0)
+
+
+def _on_segment(p, q, r):
+    return (min(p.x, r.x) <= q.x <= max(p.x, r.x)
+            and min(p.y, r.y) <= q.y <= max(p.y, r.y))
+
+
+def _intersects(p1, q1, p2, q2):
+    o1 = _sign(_area(p1, q1, p2))
+    o2 = _sign(_area(p1, q1, q2))
+    o3 = _sign(_area(p2, q2, p1))
+    o4 = _sign(_area(p2, q2, q1))
+    if o1 != o2 and o3 != o4:
+        return True
+    if o1 == 0 and _on_segment(p1, p2, q1):
+        return True
+    if o2 == 0 and _on_segment(p1, q2, q1):
+        return True
+    if o3 == 0 and _on_segment(p2, p1, q2):
+        return True
+    if o4 == 0 and _on_segment(p2, q1, q2):
+        return True
+    return False
+
+
+def _intersects_polygon(a, b):
+    p = a
+    while True:
+        if (p.i != a.i and p.next.i != a.i and p.i != b.i and p.next.i != b.i
+                and _intersects(p, p.next, a, b)):
+            return True
+        p = p.next
+        if p is a:
+            break
+    return False
+
+
+def _locally_inside(a, b):
+    if _area(a.prev, a, a.next) < 0:
+        return _area(a, b, a.next) >= 0 and _area(a, a.prev, b) >= 0
+    return _area(a, b, a.prev) < 0 or _area(a, a.next, b) < 0
+
+
+def _middle_inside(a, b):
+    p = a
+    inside = False
+    px, py = (a.x + b.x) / 2, (a.y + b.y) / 2
+    while True:
+        if ((p.y > py) != (p.next.y > py) and p.next.y != p.y
+                and px < (p.next.x - p.x) * (py - p.y) / (p.next.y - p.y) + p.x):
+            inside = not inside
+        p = p.next
+        if p is a:
+            break
+    return inside
+
+
+def _is_valid_diagonal(a, b):
+    return (a.next.i != b.i and a.prev.i != b.i
+            and not _intersects_polygon(a, b)
+            and ((_locally_inside(a, b) and _locally_inside(b, a) and _middle_inside(a, b)
+                  and (_area(a.prev, a, b.prev) != 0 or _area(a, b.prev, b) != 0))
+                 or (_equals(a, b) and _area(a.prev, a, a.next) > 0
+                     and _area(b.prev, b, b.next) > 0)))
+
+
+def _point_in_triangle(ax, ay, bx, by, cx, cy, px, py):
+    return ((cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0
+            and (ax - px) * (by - py) - (bx - px) * (ay - py) >= 0
+            and (bx - px) * (cy - py) - (cx - px) * (by - py) >= 0)

{forgekernel-0.9.0 → forgekernel-0.9.1}/src/forgekernel/quadric.py

@@ -83,6 +83,15 @@ class Cyl:
         return ((self.cx - self.r, self.cy - self.r, self.z0),
                 (self.cx + self.r, self.cy + self.r, self.z1))
 
+    def tessellate(self, deflection: float = 0.2) -> dict:
+        """Display mesh (walls + both caps) via the surface-of-revolution
+        lathe — floats are legal for a bounded-error view (ADR-0019)."""
+        from forgekernel.tess import lathe
+
+        r, z0, z1 = float(self.r), float(self.z0), float(self.z1)
+        profile = [(0.0, z0), (r, z0), (r, z1), (0.0, z1)]
+        return lathe(profile, deflection, float(self.cx), float(self.cy))
+
 
 def _dist2_point_seg(px, py, ax, ay, bx, by) -> Fraction:
     """Exact squared distance from point to segment (all rational)."""
@@ -197,6 +206,176 @@ class DrilledSolid:
                  "axis_origin": [float(c.cx), float(c.cy), float(c.z0)]}
                 for c in self.bores]
 
+    def tessellate(self, deflection: float = 0.2) -> dict:
+        """A watertight display mesh: the base's faces (top/bottom capped
+        around the bores), the bore walls (stepped for coaxial counterbores),
+        the counterbore shoulder rings, and any blind-hole end caps. Floats are
+        legal here — this approximates the exact solid to ``deflection`` chord
+        error (ADR-0019: meshing is a display property)."""
+        import math
+
+        from forgekernel.mesh2d import triangulate
+
+        verts: list[list[float]] = []
+        tris: list[list[int]] = []
+        index: dict = {}
+
+        def V(p) -> int:
+            k = (round(p[0], 9), round(p[1], 9), round(p[2], 9))
+            if k not in index:
+                index[k] = len(verts)
+                verts.append([float(p[0]), float(p[1]), float(p[2])])
+            return index[k]
+
+        def tri(a, b, c, outward) -> None:
+            ia, ib, ic = V(a), V(b), V(c)
+            if ia == ib or ib == ic or ia == ic:
+                return
+            n = ((b[1] - a[1]) * (c[2] - a[2]) - (b[2] - a[2]) * (c[1] - a[1]),
+                 (b[2] - a[2]) * (c[0] - a[0]) - (b[0] - a[0]) * (c[2] - a[2]),
+                 (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]))
+            if n[0] * outward[0] + n[1] * outward[1] + n[2] * outward[2] < 0:
+                ib, ic = ic, ib
+            tris.append([ia, ib, ic])
+
+        def _segs(r):
+            return (max(24, int(math.ceil(math.pi / math.acos(max(-1.0, 1.0 - deflection / r)))))
+                    if r > deflection else 24)
+
+        def circle(cx, cy, r, n):
+            return [(cx + r * math.cos(2 * math.pi * k / n),
+                     cy + r * math.sin(2 * math.pi * k / n)) for k in range(n)]
+
+        (_, _, bz0), (_, _, bz1) = self.base.bbox()
+        zmin, zmax = float(bz0), float(bz1)
+
+        # coaxial bore groups -> z-bands with the outermost radius per band
+        from collections import defaultdict
+        groups: dict = defaultdict(list)
+        for c in self.bores:
+            groups[(float(c.cx), float(c.cy))].append(c)
+        axis_bands = {}
+        for axis, cyls in groups.items():
+            zs = sorted({z for c in cyls for z in (float(c.z0), float(c.z1))})
+            bands = []
+            for za, zb in zip(zs, zs[1:]):
+                zmid = (za + zb) / 2
+                rs = [float(c.r) for c in cyls
+                      if float(c.z0) - 1e-9 <= zmid <= float(c.z1) + 1e-9]
+                if rs:
+                    bands.append((za, zb, max(rs)))
+            if bands:
+                axis_bands[axis] = bands
+        # ONE segment count per coaxial axis (from its widest radius) so every
+        # ring on that axis — cap hole, wall, shoulder, blind cap — shares
+        # vertices and the seams stay watertight (no T-junctions across bands).
+        axis_segs = {axis: _segs(max(r for _, _, r in bands))
+                     for axis, bands in axis_bands.items()}
+
+        def _in_loop(pt, loop) -> bool:
+            x, y = pt
+            inside = False
+            n = len(loop)
+            for i in range(n):
+                (x1, y1), (x2, y2) = loop[i], loop[(i + 1) % n]
+                if (y1 > y) != (y2 > y):
+                    xc = x1 + (y - y1) / (y2 - y1) * (x2 - x1)
+                    if x < xc:
+                        inside = not inside
+            return inside
+
+        # -- base faces: z-caps get holes, lateral faces are hole-free ---------
+        zcaps: dict = defaultdict(list)
+        for p in self.base.polys:
+            nrm = p.plane.n
+            nx, ny, nz = float(nrm[0]), float(nrm[1]), float(nrm[2])
+            if nx == 0 and ny == 0:
+                z = float(p.verts[0][2])
+                zcaps[(round(z, 9), 1 if nz > 0 else -1)].append(
+                    [(float(v[0]), float(v[1])) for v in p.verts])
+            else:
+                vs = [(float(v[0]), float(v[1]), float(v[2])) for v in p.verts]
+                for i in range(1, len(vs) - 1):
+                    tri(vs[0], vs[i], vs[i + 1], (nx, ny, nz))
+
+        def _cap_loops(polys_xy):
+            def key(p):
+                return (round(p[0], 9), round(p[1], 9))
+            present, coords = set(), {}
+            for poly in polys_xy:
+                m = len(poly)
+                for i in range(m):
+                    a, b = poly[i], poly[(i + 1) % m]
+                    coords[key(a)] = a
+                    coords[key(b)] = b
+                    present.add((key(a), key(b)))
+            nxt = {a: b for (a, b) in present if (b, a) not in present}
+            loops, used = [], set()
+            for start in list(nxt):
+                if start in used:
+                    continue
+                loop, cur = [], start
+                while cur in nxt and cur not in used:
+                    used.add(cur)
+                    loop.append(coords[cur])
+                    cur = nxt[cur]
+                if len(loop) >= 3:
+                    loops.append(loop)
+            return loops
+
+        for (z, sign), polys in zcaps.items():
+            holes = []
+            for axis, bands in axis_bands.items():
+                r = 0.0
+                if abs(bands[-1][1] - z) < 1e-9:
+                    r = bands[-1][2]           # axis reaches this (top) cap
+                elif abs(bands[0][0] - z) < 1e-9:
+                    r = bands[0][2]            # ... or this (bottom) cap
+                if r > 0:
+                    holes.append((axis, circle(axis[0], axis[1], r, axis_segs[axis])))
+            for loop in _cap_loops(polys):
+                hs = [h for (ax, h) in holes if _in_loop(ax, loop)]
+                pts2, t2 = triangulate(loop, hs)
+                out = (0.0, 0.0, float(sign))
+                for a, b, c in t2:
+                    tri((pts2[a][0], pts2[a][1], z), (pts2[b][0], pts2[b][1], z),
+                        (pts2[c][0], pts2[c][1], z), out)
+
+        # -- bore walls, counterbore shoulders, blind end caps -----------------
+        for (cx, cy), bands in axis_bands.items():
+            n = axis_segs[(cx, cy)]            # one resolution for the whole stack
+            for za, zb, r in bands:
+                ring = circle(cx, cy, r, n)
+                for i in range(n):
+                    a, b = ring[i], ring[(i + 1) % n]
+                    outw = (cx - (a[0] + b[0]) / 2, cy - (a[1] + b[1]) / 2, 0.0)
+                    tri((a[0], a[1], za), (b[0], b[1], za), (b[0], b[1], zb), outw)
+                    tri((a[0], a[1], za), (b[0], b[1], zb), (a[0], a[1], zb), outw)
+            for (za, zb, r0), (zb2, zc, r1) in zip(bands, bands[1:]):
+                if abs(r0 - r1) < 1e-12:
+                    continue
+                rin, rout = min(r0, r1), max(r0, r1)
+                out = (0.0, 0.0, 1.0 if r1 > r0 else -1.0)
+                ci, co = circle(cx, cy, rin, n), circle(cx, cy, rout, n)
+                for i in range(n):             # same n -> rings share θ, seams seal
+                    ai, bi = ci[i], ci[(i + 1) % n]
+                    ao, bo = co[i], co[(i + 1) % n]
+                    tri((ai[0], ai[1], zb), (ao[0], ao[1], zb), (bo[0], bo[1], zb), out)
+                    tri((ai[0], ai[1], zb), (bo[0], bo[1], zb), (bi[0], bi[1], zb), out)
+            zlo, zhi = bands[0][0], bands[-1][1]
+            if zlo > zmin + 1e-9:              # blind at the bottom -> end cap
+                ring = circle(cx, cy, bands[0][2], n)
+                for i in range(n):
+                    a, b = ring[i], ring[(i + 1) % n]
+                    tri((cx, cy, zlo), (a[0], a[1], zlo), (b[0], b[1], zlo), (0, 0, 1))
+            if zhi < zmax - 1e-9:              # blind at the top -> end cap
+                ring = circle(cx, cy, bands[-1][2], n)
+                for i in range(n):
+                    a, b = ring[i], ring[(i + 1) % n]
+                    tri((cx, cy, zhi), (a[0], a[1], zhi), (b[0], b[1], zhi), (0, 0, -1))
+
+        return {"vertices": verts, "triangles": tris}
+
 
 @dataclass(frozen=True)
 class Sphere:
@@ -216,6 +395,40 @@ class Sphere:
     def translated(self, x, y, z) -> "Sphere":
         return Sphere(self.cx + F(x), self.cy + F(y), self.cz + F(z), self.r)
 
+    def tessellate(self, deflection: float = 0.2) -> dict:
+        """A UV-sphere display mesh with collapsed poles (floats legal)."""
+        import math
+
+        r, cx, cy, cz = float(self.r), float(self.cx), float(self.cy), float(self.cz)
+        seg = (max(8, int(math.ceil(math.pi / math.acos(max(-1.0, 1.0 - deflection / r)))))
+               if r > deflection else 8)
+        nlat, nlon = max(4, seg), max(8, 2 * seg)
+        verts, tris = [], []
+        top = len(verts)
+        verts.append([cx, cy, cz + r])
+        rings = []
+        for i in range(1, nlat):
+            theta = math.pi * i / nlat
+            rings.append(len(verts))
+            for j in range(nlon):
+                phi = 2 * math.pi * j / nlon
+                verts.append([cx + r * math.sin(theta) * math.cos(phi),
+                              cy + r * math.sin(theta) * math.sin(phi),
+                              cz + r * math.cos(theta)])
+        bot = len(verts)
+        verts.append([cx, cy, cz - r])
+        for j in range(nlon):                  # top fan (outward, CCW from outside)
+            tris.append([top, rings[0] + j, rings[0] + (j + 1) % nlon])
+        for k in range(len(rings) - 1):        # middle quads
+            a, b = rings[k], rings[k + 1]
+            for j in range(nlon):
+                j2 = (j + 1) % nlon
+                tris.append([a + j, b + j, b + j2])
+                tris.append([a + j, b + j2, a + j2])
+        for j in range(nlon):                  # bottom fan
+            tris.append([bot, rings[-1] + (j + 1) % nlon, rings[-1] + j])
+        return {"vertices": verts, "triangles": tris}
+
 
 @dataclass(frozen=True)
 class Cone:
@@ -238,6 +451,15 @@ class Cone:
         return Cone(self.cx + F(x), self.cy + F(y), self.r1, self.r2,
                     self.z0 + F(z), self.z1 + F(z))
 
+    def tessellate(self, deflection: float = 0.2) -> dict:
+        """Display mesh (frustum wall + caps) via the lathe (floats legal)."""
+        from forgekernel.tess import lathe
+
+        r1, r2 = float(self.r1), float(self.r2)
+        z0, z1 = float(self.z0), float(self.z1)
+        profile = [(0.0, z0), (r1, z0), (r2, z1), (0.0, z1)]
+        return lathe(profile, deflection, float(self.cx), float(self.cy))
+
 
 class _Quad:
     """Exact quadratic q(z) = a z^2 + b z + c — the r^2 profile of every

{forgekernel-0.9.0 → forgekernel-0.9.1}/src/forgekernel/tess.py

@@ -56,9 +56,24 @@ def lathe(profile_rz: list[tuple], deflection: float = 0.2,
             else:
                 tris.append([a0 + k, b0 + k, b0 + kn])
                 tris.append([a0 + k, b0 + kn, a0 + kn])
+    # orient outward: the revolved profile's winding depends on its direction,
+    # so flip the whole mesh if the signed volume came out negative (inward).
+    if _signed_volume(verts, tris) < 0:
+        tris = [[t[0], t[2], t[1]] for t in tris]
     return {"vertices": verts, "triangles": tris}
 
 
+def _signed_volume(verts: list, tris: list) -> float:
+    total = 0.0
+    for a, b, c in tris:
+        ax, ay, az = verts[a]
+        bx, by, bz = verts[b]
+        cx, cy, cz = verts[c]
+        total += (ax * (by * cz - bz * cy) - ay * (bx * cz - bz * cx)
+                  + az * (bx * cy - by * cx))
+    return total
+
+
 def mesh_volume(mesh: dict) -> float:
     """Signed volume of a triangle mesh (divergence theorem) — the test
     hook proving the mesh approximates the exact solid."""

{forgekernel-0.9.0 → forgekernel-0.9.1/src/forgekernel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgekernel
-Version: 0.9.0
+Version: 0.9.1
 Summary: Exact-arithmetic B-rep CAD kernel
 Author-email: Dan Willis <danielcwillis@gmail.com>
 Maintainer-email: Dan Willis <danielcwillis@gmail.com>

{forgekernel-0.9.0 → forgekernel-0.9.1}/src/forgekernel.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ src/forgekernel/interval.py
 src/forgekernel/io.py
 src/forgekernel/kernel.py
 src/forgekernel/loft.py
+src/forgekernel/mesh2d.py
 src/forgekernel/nurbs.py
 src/forgekernel/profile2d.py
 src/forgekernel/quadric.py

{forgekernel-0.9.0 → forgekernel-0.9.1}/tests/test_hlr.py

@@ -109,6 +109,94 @@ def test_section_through_drilled_hole_splits_into_two_loops() -> None:
     assert spans == [(0, 3), (7, 10)]      # slot clears Y∈(3,7)
 
 
+def _nonmanifold(mesh):
+    from collections import defaultdict
+    ec = defaultdict(int)
+    for a, b, c in mesh["triangles"]:
+        for e in ((a, b), (b, c), (c, a)):
+            ec[tuple(sorted(e))] += 1
+    return sum(1 for n in ec.values() if n != 2)
+
+
+def _signed_volume(mesh):
+    v = mesh["vertices"]
+    t = 0.0
+    for a, b, c in mesh["triangles"]:
+        ax, ay, az = v[a]
+        bx, by, bz = v[b]
+        cx, cy, cz = v[c]
+        t += ax * (by * cz - bz * cy) - ay * (bx * cz - bz * cx) + az * (bx * cy - by * cx)
+    return t / 6.0
+
+
+def test_drilled_solid_tessellates_watertight() -> None:
+    # bolt patterns (multiple holes) and counterbores with mismatched facet
+    # buckets are the layouts that broke the first cut — pin them.
+    bolt_col = DrilledSolid(Solid.box(100, 60, 20), []).cut(
+        Cyl(50, 20, 8, 0, 20)).cut(Cyl(50, 45, 8, 0, 20))
+    grid = (DrilledSolid(Solid.box(100, 60, 20), [])
+            .cut(Cyl(35, 20, 6, 0, 20)).cut(Cyl(65, 20, 6, 0, 20))
+            .cut(Cyl(35, 40, 6, 0, 20)).cut(Cyl(65, 40, 6, 0, 20)))
+    cbore_buckets = DrilledSolid(Solid.box(30, 30, 10), []).cut(
+        Cyl(15, 15, 3, 0, 10)).cut(Cyl(15, 15, 12, 7, 10))
+    cases = [
+        (DrilledSolid(Solid.box(40, 20, 5), [Cyl(20, 10, 4, 0, 5)]),
+         40 * 20 * 5 - math.pi * 16 * 5),                       # through hole
+        (DrilledSolid(Solid.box(20, 20, 10), [Cyl(10, 10, 3, 4, 10)]),
+         20 * 20 * 10 - math.pi * 9 * 6),                       # blind hole
+        (bolt_col, 100 * 60 * 20 - 2 * math.pi * 64 * 20),      # 2-hole column
+        (grid, 100 * 60 * 20 - 4 * math.pi * 36 * 20),          # 2x2 bolt grid
+        (cbore_buckets,
+         30 * 30 * 10 - (math.pi * 9 * 7 + math.pi * 144 * 3)),  # counterbore
+    ]
+    for solid, vexp in cases:
+        mesh = solid.tessellate(0.05)
+        assert _nonmanifold(mesh) == 0                          # watertight
+        sv = _signed_volume(mesh)
+        assert sv > 0                                           # outward normals
+        assert abs(sv - vexp) / vexp < 0.02
+
+
+def test_bare_primitives_tessellate_watertight() -> None:
+    from forgekernel.quadric import Cone, Sphere
+
+    cases = [
+        (Cyl(0, 0, 4, 0, 10), math.pi * 16 * 10),
+        (Sphere(0, 0, 0, 5), 4 / 3 * math.pi * 125),
+        (Cone(0, 0, 3, 1, 0, 8), math.pi * 8 / 3 * (9 + 3 + 1)),
+        (Cone(0, 0, 3, 0, 0, 8), math.pi * 9 * 8 / 3),          # cone to a point
+    ]
+    for solid, vexp in cases:
+        mesh = solid.tessellate(0.02)
+        assert _nonmanifold(mesh) == 0
+        sv = _signed_volume(mesh)
+        assert sv > 0                                          # outward normals
+        assert abs(sv - vexp) / vexp < 0.02
+
+
+def test_earcut_handles_multi_hole_bolt_patterns() -> None:
+    from forgekernel.mesh2d import triangulate
+
+    def circle(cx, cy, r, n=32):
+        return [(cx + r * math.cos(2 * math.pi * k / n),
+                 cy + r * math.sin(2 * math.pi * k / n)) for k in range(n)]
+
+    def orient(a, b, c):
+        return (b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1])
+
+    rect = [(0, 0), (100, 0), (100, 60), (0, 60)]
+    for holes, exp in [
+        ([circle(50, 20, 8), circle(50, 45, 8)], 6000 - 2 * math.pi * 64),   # column
+        ([circle(35, 20, 6), circle(65, 20, 6),
+          circle(35, 40, 6), circle(65, 40, 6)], 6000 - 4 * math.pi * 36),   # grid
+    ]:
+        pts, tris = triangulate(rect, holes)
+        area = sum(abs(orient(pts[a], pts[b], pts[c])) / 2 for a, b, c in tris)
+        flips = sum(1 for a, b, c in tris if orient(pts[a], pts[b], pts[c]) < -1e-6)
+        assert flips == 0                                     # no inverted triangles
+        assert abs(area - exp) / exp < 0.01                   # no missing/overlap area
+
+
 def test_counterbore_sections_as_one_stepped_profile() -> None:
     # coaxial bores (r2 through + r4 counterbore over z7..10) must section as a
     # single stepped profile: two closed loops with the shoulder step, NOT the