forgekernel 0.9.0__tar.gz → 0.9.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgekernel
-Version: 0.9.0
+Version: 0.9.2
 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.2}/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.2"

{forgekernel-0.9.0 → forgekernel-0.9.2}/src/forgekernel/brep.py

@@ -188,25 +188,21 @@ class Solid:
         moment) and closure requires the SIGNED interval coverage on every
         line to cancel exactly. Zero everywhere == closed surface."""
         from collections import defaultdict
-        from math import gcd as _gcd
 
         def canon_dir(d: Vec) -> Vec | None:
-            den = 1
+            # Canonical (scale- and sign-invariant) representative of a
+            # direction: divide through by the first nonzero component so any
+            # scalar multiple ±λ·d maps to the same tuple. Works whether the
+            # components are rational (ℚ) or quadratic surds (ℚ[√d]) — an
+            # exactly-rotated solid carries √d edge directions.
+            lead = None
             for v in d:
-                den = den * v.denominator // _gcd(den, v.denominator)
-            ints = [int(v * den) for v in d]
-            g = 0
-            for v in ints:
-                g = _gcd(g, abs(v))
-            if g == 0:
-                return None
-            ints = [v // g for v in ints]
-            for v in ints:
                 if v != 0:
-                    if v < 0:
-                        ints = [-w for w in ints]
+                    lead = v
                     break
-            return (F(ints[0]), F(ints[1]), F(ints[2]))
+            if lead is None:
+                return None
+            return tuple(v / lead for v in d)
 
         lines: dict = defaultdict(list)
         for p in self.polys:
@@ -298,24 +294,16 @@ def _ear_clip(loop: list[tuple]) -> list[tuple]:
 
 
 def _canon_dir(d: Vec):
-    from math import gcd as _g
-
-    den = 1
+    # Scale- and sign-invariant direction key: divide by the first nonzero
+    # component. Rational (ℚ) or quadratic-surd (ℚ[√d], from exact rotation).
+    lead = None
     for v in d:
-        den = den * v.denominator // _g(den, v.denominator)
-    ints = [int(v * den) for v in d]
-    g = 0
-    for v in ints:
-        g = _g(g, abs(v))
-    if g == 0:
-        return None
-    ints = [v // g for v in ints]
-    for v in ints:
         if v != 0:
-            if v < 0:
-                ints = [-w for w in ints]
+            lead = v
             break
-    return (F(ints[0]), F(ints[1]), F(ints[2]))
+    if lead is None:
+        return None
+    return tuple(v / lead for v in d)
 
 
 def logical_edges(solid: Solid) -> list[dict]:

{forgekernel-0.9.0 → forgekernel-0.9.2}/src/forgekernel/exact.py

@@ -87,24 +87,17 @@ class Plane:
         return Plane(neg(self.n), -self.d)
 
     def canonical(self) -> tuple:
-        """Hashable canonical form: normal scaled to coprime integers with a
-        sign convention — coplanarity comparisons become tuple equality."""
-        nums = [self.n[0], self.n[1], self.n[2], self.d]
-        den = 1
-        for v in nums:
-            den = den * v.denominator // gcd(den, v.denominator)
-        ints = [int(v * den) for v in nums]
-        g = 0
-        for v in ints:
-            g = gcd(g, abs(v))
-        if g:
-            ints = [v // g for v in ints]
-        for v in ints[:3]:
+        """Hashable canonical form: (normal, d) divided through by the normal's
+        first nonzero component, so any scalar multiple ±λ·(n, d) maps to the
+        same tuple — coplanarity becomes tuple equality. Works over ℚ and over
+        ℚ[√d] (an exactly-rotated solid carries surd face normals)."""
+        nums = (self.n[0], self.n[1], self.n[2], self.d)
+        lead = None
+        for v in nums[:3]:
             if v != 0:
-                if v < 0:
-                    ints = [-w for w in ints]
+                lead = v
                 break
-        return tuple(ints)
+        return tuple(v / lead for v in nums)
 
     def coplanar_key(self) -> tuple:
         """Canonical form ignoring orientation (for adjacency grouping)."""

{forgekernel-0.9.0 → forgekernel-0.9.2}/src/forgekernel/kernel.py

@@ -51,6 +51,69 @@ def rotate_quarter(s: Solid, axis: str, quarters: int) -> Solid:
     return s.rotated_quarter(axis, quarters)
 
 
+def _cos_sin_deg(deg):
+    """Exact (cos, sin) of an angle in degrees, in ℚ[√d] — or None if the angle
+    needs a larger field. Covers the multiples of 30° and 45° (so circular
+    patterns of 3/4/6/8/12 and the diagonal sketch-plane rotations are exact)."""
+    from forgekernel.surd import SurdVal
+
+    from fractions import Fraction
+
+    d = int(deg) % 360
+    if deg != int(deg):
+        return None
+    if d % 90 == 0:
+        return [(F(1), F(0)), (F(0), F(1)), (F(-1), F(0)), (F(0), F(-1))][d // 90]
+    h = Fraction(1, 2)
+    r3, r2 = SurdVal(0, h, 3), SurdVal(0, h, 2)      # √3/2, √2/2
+    table = {30: (r3, h), 60: (h, r3), 120: (-h, r3), 150: (-r3, h),
+             210: (-r3, -h), 240: (-h, -r3), 300: (h, -r3), 330: (r3, -h),
+             45: (r2, r2), 135: (-r2, r2), 225: (-r2, -r2), 315: (r2, -r2)}
+    return table.get(d)
+
+
+def _rotation_matrix(axis, deg):
+    """Exact Rodrigues rotation matrix (list of 3 rows) about ``axis`` by
+    ``deg``, over ℚ[√d]. Raises ValueError if the angle is not representable."""
+    from forgekernel.surd import SurdVal, sqrt_rational
+
+    cs = _cos_sin_deg(deg)
+    if cs is None:
+        raise ValueError(
+            f"rotation by {deg}° is not exactly representable in ℚ[√d] "
+            "(only multiples of 30° and 45°)")
+    c, s = cs
+    ax, ay, az = F(axis[0]), F(axis[1]), F(axis[2])
+    n2 = ax * ax + ay * ay + az * az                 # |axis|², rational
+    if n2 == 0:
+        raise ValueError("zero rotation axis")
+    one = SurdVal(1, 0, 1)
+    s_over_n = (s if isinstance(s, SurdVal) else SurdVal(s)) / sqrt_rational(n2)
+    k2c = (one - (c if isinstance(c, SurdVal) else SurdVal(c))) / n2
+    k = [[F(0), -az, ay], [az, F(0), -ax], [-ay, ax, F(0)]]          # [axis]×
+    k2 = [[sum(k[i][t] * k[t][j] for t in range(3)) for j in range(3)]
+          for i in range(3)]
+    return [[(F(1) if i == j else F(0)) + s_over_n * k[i][j] + k2c * k2[i][j]
+             for j in range(3)] for i in range(3)]
+
+
+def rotate(s: Solid, axis, deg) -> Solid:
+    """Exact rotation of a planar solid about an arbitrary axis by an angle in
+    ℚ[√d] (multiples of 30°/45°). Rigid motion — volume is preserved exactly and
+    the result is a Solid with exact ℚ[√d] coordinates. Raises ValueError for
+    angles a larger field would be needed for (the seam turns that into an
+    honest refusal)."""
+    r = _rotation_matrix(axis, deg)
+
+    def fn(v):
+        x, y, z = v
+        return (r[0][0] * x + r[0][1] * y + r[0][2] * z,
+                r[1][0] * x + r[1][1] * y + r[1][2] * z,
+                r[2][0] * x + r[2][1] * y + r[2][2] * z)
+
+    return s.mapped(fn)
+
+
 def chamfer(s: Solid, distance) -> Solid:
     """Exact chamfer on all convex rational-normal edges, with industrial
     corner-triangle vertex truncation (oracle-matched semantics)."""

forgekernel-0.9.2/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.2}/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.2}/src/forgekernel/surd.py

@@ -76,6 +76,9 @@ class SurdVal:
         o = self._co(o)
         return SurdVal(self.a - o.a, self.b - o.b, self._radical(o))
 
+    def __rsub__(self, o) -> "SurdVal":     # o − self, for rational/int on the left
+        return self._co(o) - self
+
     def __mul__(self, o) -> "SurdVal":
         o = self._co(o)
         if self.b == 0 or o.b == 0:
@@ -89,12 +92,63 @@ class SurdVal:
 
     __rmul__ = __mul__
 
+    def __neg__(self) -> "SurdVal":
+        return SurdVal(-self.a, -self.b, self.d)
+
+    def __truediv__(self, o) -> "SurdVal":
+        if isinstance(o, (int, Fraction)):
+            r = F(o)
+            return SurdVal(self.a / r, self.b / r, self.d)
+        o = self._co(o)
+        if o.b == 0:                             # divide by a rational
+            return SurdVal(self.a / o.a, self.b / o.a, self.d)
+        # divide by (c+e√d) via the conjugate: ·(c−e√d)/(c²−e²d)
+        denom = o.a * o.a - o.b * o.b * o.d      # rational, nonzero
+        num = self * SurdVal(o.a, -o.b, o.d)
+        return SurdVal(num.a / denom, num.b / denom, num.d)
+
+    def __rtruediv__(self, o) -> "SurdVal":
+        return self._co(o) / self
+
+    def _sign(self) -> int:
+        """Exact sign of a + b√d (d ≥ 1, √d > 0) — decides comparisons."""
+        if self.b == 0:
+            return (self.a > 0) - (self.a < 0)
+        if self.a == 0:
+            return (self.b > 0) - (self.b < 0)
+        sa = (self.a > 0) - (self.a < 0)
+        sb = (self.b > 0) - (self.b < 0)
+        if sa == sb:                             # both terms same sign
+            return sa
+        # opposite signs: compare magnitudes a² vs b²·d (squaring is monotone)
+        da, db = self.a * self.a, self.b * self.b * self.d
+        if da == db:
+            return 0
+        return sa if da > db else sb
+
+    def __lt__(self, o) -> bool:
+        return (self - self._co(o))._sign() < 0
+
+    def __le__(self, o) -> bool:
+        return (self - self._co(o))._sign() <= 0
+
+    def __gt__(self, o) -> bool:
+        return (self - self._co(o))._sign() > 0
+
+    def __ge__(self, o) -> bool:
+        return (self - self._co(o))._sign() >= 0
+
     def __eq__(self, o: object) -> bool:
         o = self._co(o)
         if self.b == 0 and o.b == 0:
             return self.a == o.a
         return self.a == o.a and self.b == o.b and self.d == o.d
 
+    def __hash__(self) -> int:
+        if self.b == 0:                          # a pure rational hashes as itself
+            return hash(self.a)
+        return hash((self.a, self.b, self.d))
+
     def __float__(self) -> float:
         return float(self.a) + float(self.b) * math.sqrt(self.d)
 

{forgekernel-0.9.0 → forgekernel-0.9.2}/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.2/src/forgekernel.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: forgekernel
-Version: 0.9.0
+Version: 0.9.2
 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.2}/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
@@ -38,5 +39,6 @@ tests/test_k7_bsolid.py
 tests/test_k7_stepexport.py
 tests/test_k7_trim.py
 tests/test_k7_trimflux.py
+tests/test_rotate.py
 tests/test_rust_oracle.py
 tests/test_scaffold.py

{forgekernel-0.9.0 → forgekernel-0.9.2}/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

forgekernel-0.9.2/tests/test_rotate.py

@@ -0,0 +1,87 @@
+"""Exact rotation over ℚ[√d] — the K2.2 circular-pattern / diagonal-sketch-plane
+enabler. Rotation is a rigid motion, so volume is preserved EXACTLY (rational),
+and representable angles (multiples of 30°/45°) keep coordinates exact."""
+
+from __future__ import annotations
+
+import math
+
+import pytest
+
+from forgekernel import kernel as fk
+from forgekernel.surd import SurdVal, sqrt_rational
+
+
+def test_rotation_preserves_volume_exactly() -> None:
+    b = fk.box(10, 4, 3)
+    for axis, deg in [((0, 0, 1), 60), ((0, 0, 1), 45), ((1, 0, 0), 30),
+                      ((1, 1, 1), 120)]:
+        r = fk.rotate(b, axis, deg)
+        assert r.volume() == 120           # exact rational, not a float
+
+
+def test_six_sixty_degree_rotations_are_the_identity() -> None:
+    b = fk.box(7, 5, 2)
+    acc = b
+    for _ in range(6):
+        acc = fk.rotate(acc, (0, 0, 1), 60)
+    orig = {tuple(float(c) for c in v) for p in b.polys for v in p.verts}
+    back = {tuple(float(c) for c in v) for p in acc.polys for v in p.verts}
+    assert orig == back                    # 6·60° = 360° back to start, exactly
+
+
+def test_diagonal_120_is_a_rational_axis_permutation() -> None:
+    p = fk.rotate(fk.box(3, 5, 7), (1, 1, 1), 120)
+    # 120° about the body diagonal cyclically permutes the axes — the surds
+    # cancel, leaving purely rational coordinates.
+    assert all(not isinstance(c, SurdVal) or c.b == 0
+               for poly in p.polys for v in poly.verts for c in v)
+    assert p.volume() == 105
+
+
+def test_unrepresentable_angle_is_refused() -> None:
+    with pytest.raises(ValueError):
+        fk.rotate(fk.box(2, 2, 2), (0, 0, 1), 37)
+
+
+def test_boolean_union_of_rotated_copies_is_watertight_and_exact() -> None:
+    # the circular-pattern path: union disjoint rotated copies (surd coords)
+    seed = fk.translate(fk.box(5, 2, 3), 10, -1, 0)
+    out = seed
+    for i in range(1, 6):
+        out = fk.boolean("union", out, fk.rotate(seed, (0, 0, 1), 60 * i))
+    assert out.volume() == 6 * 5 * 2 * 3   # disjoint -> exact sum, no leaks
+    assert out.watertight_violations() == []
+
+
+def test_overlapping_boolean_mixes_rational_and_surd_coords() -> None:
+    # the case disjoint patterns miss: an axis-aligned (ℚ) body booleaned with
+    # an OVERLAPPING rotated (ℚ[√3]) body — BSP clipping makes mixed-type
+    # polygons, so Fraction−SurdVal must resolve (needs SurdVal.__rsub__).
+    from fractions import Fraction as F
+
+    a = fk.box(2, 2, 2)
+    b = fk.rotate(fk.translate(fk.box(2, 2, 2), F(1, 2), F(1, 2), 0), (0, 0, 1), 30)
+    vu = float(fk.boolean("union", a, b).volume())
+    vi = float(fk.boolean("intersect", a, b).volume())
+    vc = float(fk.boolean("cut", a, b).volume())
+    assert vi > 0                                   # they genuinely overlap
+    assert abs(vu + vi - 16) < 1e-9                 # |A∪B| + |A∩B| = |A| + |B|
+    assert abs(vc - (8 - vi)) < 1e-9                # |A∖B| = |A| − |A∩B|
+    for op in ("union", "cut", "intersect"):
+        assert fk.boolean(op, a, b).watertight_violations() == []
+
+
+def test_surd_is_an_ordered_field() -> None:
+    import random
+    random.seed(0)
+    for _ in range(2000):
+        d = random.choice([2, 3, 5, 6])
+        from fractions import Fraction as F
+        x = SurdVal(F(random.randint(-9, 9), random.randint(1, 4)),
+                    F(random.randint(-9, 9), random.randint(1, 4)), d)
+        y = SurdVal(F(random.randint(-9, 9), random.randint(1, 4)),
+                    F(random.randint(-9, 9), random.randint(1, 4)), d)
+        if abs(float(x) - float(y)) > 1e-9:
+            assert (x < y) == (float(x) < float(y))
+        assert (x / y) * y == x if float(y) != 0 else True