forgekernel 0.9.2__tar.gz → 0.9.5__tar.gz

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

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

{forgekernel-0.9.2 → forgekernel-0.9.5}/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.2"
+__version__ = "0.9.5"

{forgekernel-0.9.2 → forgekernel-0.9.5}/src/forgekernel/quadric.py

@@ -93,6 +93,35 @@ class Cyl:
         return lathe(profile, deflection, float(self.cx), float(self.cy))
 
 
+def _xy_inside_footprint(solid: Solid, px, py) -> bool:
+    """Exact: is (px, py) inside the solid's xy footprint?
+
+    The footprint boundary is the xy projection of the lateral (non-horizontal)
+    faces. Ray parity along +x with the half-open upward-crossing rule — all
+    rational, no tolerance. Needed because "the bore does not CROSS a lateral
+    wall" does not distinguish a bore strictly inside from one entirely
+    outside: neither crosses anything."""
+    segs = set()
+    for p in solid.polys:
+        n = p.plane.n
+        if n[0] == 0 and n[1] == 0:
+            continue                           # horizontal face: no footprint edge
+        m = len(p.verts)
+        for i in range(m):
+            a, b = p.verts[i], p.verts[(i + 1) % m]
+            if a[0] == b[0] and a[1] == b[1]:
+                continue                       # vertical edge: projects to a point
+            key = ((a[0], a[1]), (b[0], b[1]))
+            segs.add(key if key[0] <= key[1] else (key[1], key[0]))
+    inside = False
+    for (x1, y1), (x2, y2) in segs:
+        if (y1 > py) != (y2 > py):
+            xc = x1 + (py - y1) * (x2 - x1) / (y2 - y1)
+            if px < xc:
+                inside = not inside
+    return inside
+
+
 def _dist2_point_seg(px, py, ax, ay, bx, by) -> Fraction:
     """Exact squared distance from point to segment (all rational)."""
     dx, dy = bx - ax, by - ay
@@ -140,6 +169,12 @@ class DrilledSolid:
                     raise ValueError(
                         "bore crosses a lateral wall — general quadric "
                         "booleans arrive at K2.1")
+        # The wall check above proves the bore straddles no wall; it does NOT
+        # say which side it is on. Without this, a bore placed entirely outside
+        # the footprint is recorded as a phantom hole and its volume silently
+        # subtracted from a solid it never touches.
+        if not _xy_inside_footprint(self.base, c.cx, c.cy):
+            raise ValueError("bore misses the solid in xy (nothing to drill)")
         for o in self.bores:
             if o.cx == c.cx and o.cy == c.cy:
                 continue                       # coaxial stack (counterbore)
@@ -616,17 +651,23 @@ class AxisStack:
 
 class RevolveSolid:
     """A closed line-segment profile in the (r, z) half-plane revolved
-    360 degrees about the z axis. Green gives exact metrics:
-    V = pi * contour_integral(r^2 dz), each edge contributing
-    (z2-z1)(r1^2 + r1 r2 + r2^2)/3."""
+    360 degrees about a z-parallel axis through ``(cx, cy)``. Green gives
+    exact metrics: V = pi * contour_integral(r^2 dz), each edge contributing
+    (z2-z1)(r1^2 + r1 r2 + r2^2)/3. The profile need not touch r = 0 — an
+    annular loop is a tube (a bored cylinder), still exact."""
 
-    def __init__(self, loop_rz: list) -> None:
+    def __init__(self, loop_rz: list, cx=0, cy=0) -> None:
         self.loop = [(F(r), F(z)) for r, z in loop_rz]
+        self.cx, self.cy = F(cx), F(cy)
         if any(r < 0 for r, _ in self.loop):
             raise ValueError("revolve profile must stay at r >= 0")
         if self._v3() < 0:
             self.loop = list(reversed(self.loop))
 
+    def translated(self, x, y, z) -> "RevolveSolid":
+        return RevolveSolid([(r, zz + F(z)) for r, zz in self.loop],
+                            self.cx + F(x), self.cy + F(y))
+
     def _edges(self):
         n = len(self.loop)
         for i in range(n):
@@ -648,18 +689,53 @@ class RevolveSolid:
             num += dz * (z1 * (3 * r1 * r1 + 2 * r1 * r2 + r2 * r2)
                          + z2 * (r1 * r1 + 2 * r1 * r2 + 3 * r2 * r2)) / 12
         v3 = self._v3()
-        return (0.0, 0.0, float(num / v3 * 3) if v3 else 0.0)
+        return (float(self.cx), float(self.cy),
+                float(num / v3 * 3) if v3 else 0.0)
 
     def bbox(self):
         rmax = max(r for r, _ in self.loop)
         zs = [z for _, z in self.loop]
-        return ((-float(rmax), -float(rmax), float(min(zs))),
-                (float(rmax), float(rmax), float(max(zs))))
+        cx, cy = float(self.cx), float(self.cy)
+        return ((cx - float(rmax), cy - float(rmax), float(min(zs))),
+                (cx + float(rmax), cy + float(rmax), float(max(zs))))
 
     def tessellate(self, deflection: float = 0.2) -> dict:
         from forgekernel.tess import lathe
 
-        return lathe([(float(r), float(z)) for r, z in self.loop], deflection)
+        return lathe([(float(r), float(z)) for r, z in self.loop], deflection,
+                     float(self.cx), float(self.cy))
+
+
+def bore_cyl(cyl: "Cyl", bore: "Cyl") -> object:
+    """Cut a COAXIAL bore out of a z-cylinder, exactly.
+
+    A cylinder minus a coaxial cylindrical bore is still a solid of
+    revolution, so the result is a ``RevolveSolid`` whose (r, z) profile is
+    the cylinder's rectangle minus the bore's — exact in ℚ, with the volume
+    following in ℚ[π] from Green's theorem. Returns ``cyl`` unchanged when
+    the bore misses it in z. Raises ValueError for the cases that are not a
+    single revolved region (a bore floating strictly inside — a closed
+    cavity — or one that consumes the whole cylinder)."""
+    if bore.cx != cyl.cx or bore.cy != cyl.cy:
+        raise ValueError("bore is not coaxial with the cylinder — K2.3")
+    if bore.r >= cyl.r:
+        raise ValueError("bore is not narrower than the cylinder — K2.3")
+    z0, z1 = cyl.z0, cyl.z1
+    b0, b1 = max(bore.z0, z0), min(bore.z1, z1)
+    if b1 <= b0:
+        return cyl                              # bore misses in z: unchanged
+    R, rb = cyl.r, bore.r
+    if b0 <= z0 and b1 >= z1:                   # through bore -> annulus
+        loop = [(rb, z0), (R, z0), (R, z1), (rb, z1)]
+    elif b0 <= z0:                              # blind from the bottom
+        loop = [(rb, z0), (R, z0), (R, z1), (0, z1), (0, b1), (rb, b1)]
+    elif b1 >= z1:                              # blind from the top
+        loop = [(0, z0), (R, z0), (R, z1), (rb, z1), (rb, b0), (0, b0)]
+    else:
+        raise ValueError(
+            "bore floats strictly inside the cylinder (a closed cavity) — "
+            "general quadric booleans arrive at K2.3")
+    return RevolveSolid(loop, cyl.cx, cyl.cy)
 
 
 def _member_volume(m):
@@ -696,6 +772,59 @@ class DisjointUnion:
             _classify_pair(m, other)
         return DisjointUnion(self.members + [other])
 
+    def tessellate(self, deflection: float = 0.2) -> dict:
+        """Display mesh = the members' meshes merged. Valid as one mesh
+        because the members are disjoint (at most tangent), so the shells
+        never interpenetrate."""
+        verts: list = []
+        tris: list = []
+        for m in self.members:
+            if not hasattr(m, "tessellate"):    # bare Sphere/Cone: via a stack
+                m = AxisStack(m.cx, m.cy, [m])
+            try:
+                sub = m.tessellate(deflection)
+            except TypeError:                   # planar Solid: meshes exactly
+                sub = m.tessellate()
+            off = len(verts)
+            verts.extend(sub["vertices"])
+            tris.extend([a + off, b + off, c + off] for a, b, c in sub["triangles"])
+        return {"vertices": verts, "triangles": tris}
+
+    @classmethod
+    def _unchecked(cls, members: list) -> "DisjointUnion":
+        """Build without re-running the pairwise predicates — for members
+        derived from an already-validated union by an operation that can only
+        SHRINK them (see ``cut``)."""
+        u = cls.__new__(cls)
+        u.members = list(members)
+        return u
+
+    def cut(self, tool) -> "DisjointUnion":
+        """Subtract ``tool`` from every member: (A ∪ B) ∖ C = (A∖C) ∪ (B∖C).
+        Members that the tool misses come back unchanged. Disjointness is
+        preserved because cutting only shrinks a member — (A∖C) ∩ (B∖C) ⊆
+        A ∩ B, already proven measure-zero — so the result needs no
+        re-validation (and its members may now be other exact types)."""
+        from forgekernel.brep import Solid
+
+        out = []
+        for m in self.members:
+            if isinstance(m, Cyl) and isinstance(tool, Cyl):
+                out.append(bore_cyl(m, tool))
+            elif isinstance(m, (Solid, DrilledSolid)) and isinstance(tool, Cyl):
+                base = DrilledSolid(m, []) if isinstance(m, Solid) else m
+                try:
+                    out.append(base.cut(tool))
+                except ValueError as exc:
+                    if "misses the solid in" not in str(exc):
+                        raise                   # a real precondition violation
+                    out.append(m)               # tool misses this member (z or xy)
+            else:
+                raise ValueError(
+                    f"cut of {type(m).__name__} by {type(tool).__name__} in a "
+                    "disjoint union arrives at K2.3")
+        return DisjointUnion._unchecked(out)
+
     def volume(self) -> "PiVal":
         total = PiVal(0, 0)
         for m in self.members:
@@ -748,10 +877,12 @@ def _classify_pair(a, b) -> None:
         if za[1] <= zb[0] or zb[1] <= za[0]:
             return                            # disjoint in z
         d2 = (a.cx - b.cx) ** 2 + (a.cy - b.cy) ** 2
-        outer = (a.r + b.r) ** 2
-        inner = (a.r - b.r) ** 2
-        if d2 >= outer or d2 <= inner:
-            return                            # externally/internally clear
+        if d2 >= (a.r + b.r) ** 2:
+            return                            # externally clear (or tangent)
+        # NOTE: d2 <= (ra−rb)² is CONTAINMENT, not separation — these are solid
+        # cylinders, not tubes, so a nested one overlaps with positive measure
+        # (identical cylinders land here too, at d2 = 0). Treating it as clear
+        # silently doubled the volume; it must refuse.
         raise ValueError(
             "overlapping cylinders — general quadric booleans arrive at K2.3")
     # sphere / planar Solid
@@ -761,11 +892,20 @@ def _classify_pair(a, b) -> None:
     if isinstance(b, Sphere) and isinstance(a, Solid):
         _sphere_solid(b, a)
         return
+    # z-cylinder / planar Solid (a mounting boss standing on a face)
+    if isinstance(a, Cyl) and isinstance(b, Solid):
+        _cyl_solid(a, b)
+        return
+    if isinstance(b, Cyl) and isinstance(a, Solid):
+        _cyl_solid(b, a)
+        return
     # sphere / sphere
     if isinstance(a, Sphere) and isinstance(b, Sphere):
         d2 = (a.cx - b.cx) ** 2 + (a.cy - b.cy) ** 2 + (a.cz - b.cz) ** 2
-        if d2 >= (a.r + b.r) ** 2 or d2 <= (a.r - b.r) ** 2:
-            return
+        if d2 >= (a.r + b.r) ** 2:
+            return                            # externally clear (or tangent)
+        # containment (d2 ≤ (ra−rb)²) is an overlap, not a separation — see the
+        # cylinder note above; SphereOverlap already rejects it as "nesting".
         raise ValueError(
             "overlapping spheres — general quadric booleans arrive at K2.3")
     raise ValueError(
@@ -773,6 +913,28 @@ def _classify_pair(a, b) -> None:
         "at K2.3")
 
 
+def _require_convex(solid: "Solid", what: str) -> None:
+    """Raise unless every vertex is on the inward side of every face plane.
+
+    The separating-plane predicates below are sound ONLY for a convex solid: a
+    convex body is the intersection of its face half-spaces, so "outside one
+    face plane" implies "outside the solid". For a non-convex solid that
+    implication fails — a bore sitting inside an L-bracket's arm is outside the
+    plane of the other arm's face — and accepting it would silently double-count
+    the overlap. Exact (rational comparisons); refuses rather than guesses."""
+    planes, verts = {}, set()
+    for p in solid.polys:
+        planes.setdefault(p.plane.canonical(), (p.plane.n, p.plane.d))
+        verts.update(p.verts)
+    for n, dpl in planes.values():
+        for v in verts:
+            if dot(n, v) - dpl > 0:
+                raise ValueError(
+                    f"{what} against a non-convex solid — the separating-plane "
+                    "test is not sound there; general quadric booleans arrive "
+                    "at K2.3")
+
+
 def _sphere_solid(s: "Sphere", solid: "Solid") -> None:
     """Disjoint/tangent iff the sphere center lies on the far side of (or
     exactly on) some face plane by at least the radius — exact, sqrt-free:
@@ -780,6 +942,7 @@ def _sphere_solid(s: "Sphere", solid: "Solid") -> None:
     g² ≥ r²·(n·n) (both sides squared, exact). Convex-solid sufficient
     condition; a sphere separated from a convex solid is separated by one
     of its face planes."""
+    _require_convex(solid, "sphere")
     c = (s.cx, s.cy, s.cz)
     seen = set()
     for p in solid.polys:
@@ -795,6 +958,35 @@ def _sphere_solid(s: "Sphere", solid: "Solid") -> None:
         "sphere overlaps the solid — general quadric booleans arrive at K2.3")
 
 
+def _cyl_solid(c: "Cyl", solid: "Solid") -> None:
+    """Disjoint/tangent iff some face plane of the solid separates the
+    z-cylinder — exact and sqrt-free. For outward plane n·x = d, the
+    cylinder's minimum of n·x is
+
+        n_x·cx + n_y·cy + min(n_z·z0, n_z·z1) − r·√(n_x² + n_y²),
+
+    so the cylinder is clear of that plane iff A ≥ r·√(n_x²+n_y²) where
+    A = n_x·cx + n_y·cy + min(n_z·z0, n_z·z1) − d. Both sides are squared
+    (A ≥ 0 and A² ≥ r²·(n_x²+n_y²)) to stay in ℚ. A mounting boss standing
+    ON a face gives A = 0 exactly — tangent, measure-zero, admitted.
+    Sufficient for a convex solid (separating-plane argument); for a
+    non-convex one it is conservative, so it refuses rather than guesses."""
+    _require_convex(solid, "cylinder")
+    seen = set()
+    for p in solid.polys:
+        key = p.plane.canonical()
+        if key in seen:
+            continue
+        seen.add(key)
+        n, dpl = p.plane.n, p.plane.d
+        a = (n[0] * c.cx + n[1] * c.cy
+             + min(n[2] * c.z0, n[2] * c.z1) - dpl)
+        if a >= 0 and a * a >= c.r * c.r * (n[0] * n[0] + n[1] * n[1]):
+            return                            # separated by this face plane
+    raise ValueError(
+        "cylinder overlaps the solid — general quadric booleans arrive at K2.3")
+
+
 class RoundedBox:
     """An axis-aligned box with ALL edges and corners filleted radius r —
     the Minkowski sum of the inner core box (a-2r)x(b-2r)x(c-2r) with a

{forgekernel-0.9.2 → forgekernel-0.9.5}/src/forgekernel/stepio.py

@@ -359,10 +359,32 @@ def _perp(n):
     return (p[0] / m, p[1] / m, p[2] / m)
 
 
-def write_step_planar_solid(solid, *, name: str = "gitcad_part") -> str:
-    """Emit a planar-faced forge Solid as a valid AP214 STEP file
-    (full product structure + MANIFOLD_SOLID_BREP with shared straight
-    edges). Round-trips through OCCT and :func:`read_step_planar_solid`."""
+def _poly_contains_xy(verts, px, py) -> bool:
+    """Ray parity in xy for a face polygon (used to decide which cap fragment
+    a bore breaks through)."""
+    inside = False
+    n = len(verts)
+    for i in range(n):
+        (x1, y1) = verts[i][0], verts[i][1]
+        (x2, y2) = verts[(i + 1) % n][0], verts[(i + 1) % n][1]
+        if (y1 > py) != (y2 > py):
+            if px < x1 + (py - y1) * (x2 - x1) / (y2 - y1):
+                inside = not inside
+    return inside
+
+
+def write_step_planar_solid(solid, *, name: str = "gitcad_part",
+                            bores=()) -> str:
+    """Emit a forge solid as a valid AP214 STEP file (full product structure +
+    MANIFOLD_SOLID_BREP with shared edges).
+
+    ``solid`` supplies the planar faces; ``bores`` is an optional list of z-axis
+    ``Cyl`` bores drilled through it. A bore contributes a CYLINDRICAL_SURFACE
+    wall (as two half-faces, so no periodic seam is needed), a circular inner
+    bound on each cap it breaks through, and a flat disk face where it ends
+    blind. Circles and cylinders are emitted as EXACT analytic surfaces, not
+    faceted — a drilled plate exports as a real cylindrical hole that any CAD
+    system reads back as a hole."""
     lines: list[str] = []
     nid = [0]
 
@@ -424,6 +446,36 @@ def write_step_planar_solid(solid, *, name: str = "gitcad_part") -> str:
                           ka, kb)
         return edges[key]
 
+    def zplacement(cx, cy, z, up=1):
+        """AXIS2_PLACEMENT_3D on the +z (or −z) axis through (cx, cy, z),
+        ref direction +x — the frame every circle and cylinder here uses."""
+        o = emit(f"CARTESIAN_POINT('',({_dec(cx)},{_dec(cy)},{_dec(z)}))")
+        ax = emit(f"DIRECTION('',(0.,0.,{'1.' if up > 0 else '-1.'}))")
+        rd = emit(f"DIRECTION('',(1.,0.,0.))")
+        return emit(f"AXIS2_PLACEMENT_3D('',#{o},#{ax},#{rd})")
+
+    def rim_edges(c, z):
+        """The two half-circle EDGE_CURVEs of a bore's rim at height z, split at
+        angles 0 and π so the cylindrical face needs no periodic seam. Cached,
+        so the cap's inner bound and the wall share the very same edges."""
+        key = ("rim", c.cx, c.cy, c.r, z)
+        if key in edges:
+            return edges[key]
+        p0 = (c.cx + c.r, c.cy, z)
+        p1 = (c.cx - c.r, c.cy, z)
+        circ = emit(f"CIRCLE('',#{zplacement(c.cx, c.cy, z)},{_dec(c.r)})")
+        e_a = emit(f"EDGE_CURVE('',#{vertex(p0)},#{vertex(p1)},#{circ},.T.)")
+        e_b = emit(f"EDGE_CURVE('',#{vertex(p1)},#{vertex(p0)},#{circ},.T.)")
+        edges[key] = (e_a, e_b, p0, p1)
+        return edges[key]
+
+    def oriented(eid, fwd):
+        return emit(f"ORIENTED_EDGE('',*,*,#{eid},{'.T.' if fwd else '.F.'})")
+
+    def loop_of(oes):
+        return emit(f"EDGE_LOOP('',({','.join('#' + str(x) for x in oes)}))")
+
+    bores = list(bores)
     face_ids = []
     for poly in solid.polys:
         vs = [tuple(v) for v in poly.verts]
@@ -432,10 +484,24 @@ def write_step_planar_solid(solid, *, name: str = "gitcad_part") -> str:
             a, b = vs[i], vs[(i + 1) % len(vs)]
             ec, ka, kb = edge_curve(a, b)
             fwd = (a[0], a[1], a[2]) == ka
-            oe.append(emit(f"ORIENTED_EDGE('',*,*,#{ec},"
-                           f"{'.T.' if fwd else '.F.'})"))
-        loop = emit(f"EDGE_LOOP('',({','.join('#' + str(x) for x in oe)}))")
-        bound = emit(f"FACE_OUTER_BOUND('',#{loop},.T.)")
+            oe.append(oriented(ec, fwd))
+        bound = emit(f"FACE_OUTER_BOUND('',#{loop_of(oe)},.T.)")
+        bounds = [bound]
+        # a z-cap gets a circular INNER bound for every bore that breaks it
+        n = poly.plane.n
+        if n[0] == 0 and n[1] == 0:
+            zc = vs[0][2]
+            for c in bores:
+                if (c.z0 < zc < c.z1 or c.z0 == zc or c.z1 == zc) and \
+                        _poly_contains_xy(vs, c.cx, c.cy):
+                    a_e, b_e, _, _ = rim_edges(c, zc)
+                    # each rim half-circle is shared with the bore wall, which
+                    # traverses the LOWER rim forward and the UPPER rim
+                    # backward; the cap must take the opposite sense so every
+                    # edge is used once .T. and once .F. (manifold closure).
+                    fwd = n[2] > 0                       # top cap vs bottom cap
+                    hole = loop_of([oriented(a_e, fwd), oriented(b_e, fwd)])
+                    bounds.append(emit(f"FACE_BOUND('',#{hole},.T.)"))
         (nx, ny, nz), _ = _unit3(poly.plane.n)
         rx, ry, rz = _perp((nx, ny, nz))
         origin = emit(f"CARTESIAN_POINT('',({_dec(vs[0][0])},{_dec(vs[0][1])},"
@@ -444,7 +510,41 @@ def write_step_planar_solid(solid, *, name: str = "gitcad_part") -> str:
         rdir = emit(f"DIRECTION('',({fnum(rx)},{fnum(ry)},{fnum(rz)}))")
         place = emit(f"AXIS2_PLACEMENT_3D('',#{origin},#{axis},#{rdir})")
         plane = emit(f"PLANE('',#{place})")
-        face_ids.append(emit(f"ADVANCED_FACE('',(#{bound}),#{plane},.T.)"))
+        blist = ",".join("#" + str(b) for b in bounds)
+        face_ids.append(emit(f"ADVANCED_FACE('',({blist}),#{plane},.T.)"))
+
+    # -- bore walls (two half-cylinder faces) + blind end caps ----------------
+    (_, _, sz0), (_, _, sz1) = solid.bbox()
+    for c in bores:
+        z0, z1 = max(c.z0, sz0), min(c.z1, sz1)
+        if z1 <= z0:
+            continue
+        lo_a, lo_b, lp0, lp1 = rim_edges(c, z0)
+        hi_a, hi_b, hp0, hp1 = rim_edges(c, z1)
+        seam0 = edge_curve(lp0, hp0)[0]         # the two vertical seam edges
+        seam1 = edge_curve(lp1, hp1)[0]
+        cyl = emit(f"CYLINDRICAL_SURFACE('',#{zplacement(c.cx, c.cy, z0)},"
+                   f"{_dec(c.r)})")
+        for lo_e, hi_e, s_from, s_to in ((lo_a, hi_a, seam1, seam0),
+                                         (lo_b, hi_b, seam0, seam1)):
+            oes = [oriented(lo_e, True), oriented(s_from, True),
+                   oriented(hi_e, False), oriented(s_to, False)]
+            b = emit(f"FACE_OUTER_BOUND('',#{loop_of(oes)},.T.)")
+            # material lies OUTSIDE a bore, so the solid's outward normal points
+            # toward the axis — opposite the cylinder's own normal: .F.
+            face_ids.append(emit(f"ADVANCED_FACE('',(#{b}),#{cyl},.F.)"))
+        # A blind end gets a flat disk. Its outward normal points INTO the bore
+        # (material is on the far side): +z at the floor, −z at the ceiling.
+        # The loop sense is independent of that — it mirrors the wall, which
+        # takes the lower rim forward and the upper rim backward.
+        for zb, axis_up, fwd in ((z0, 1, False), (z1, -1, True)):
+            if (zb == sz0 and c.z0 <= sz0) or (zb == sz1 and c.z1 >= sz1):
+                continue                        # breaks through: no disk here
+            a_e, b_e, _, _ = rim_edges(c, zb)
+            disk = loop_of([oriented(a_e, fwd), oriented(b_e, fwd)])
+            b = emit(f"FACE_OUTER_BOUND('',#{disk},.T.)")
+            pl = emit(f"PLANE('',#{zplacement(c.cx, c.cy, zb, axis_up)})")
+            face_ids.append(emit(f"ADVANCED_FACE('',(#{b}),#{pl},.T.)"))
 
     shell = emit(f"CLOSED_SHELL('',({','.join('#' + str(x) for x in face_ids)}))")
     brep = emit(f"MANIFOLD_SOLID_BREP('{name}',#{shell})")

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

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

{forgekernel-0.9.2 → forgekernel-0.9.5}/src/forgekernel.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ src/forgekernel.egg-info/SOURCES.txt
 src/forgekernel.egg-info/dependency_links.txt
 src/forgekernel.egg-info/requires.txt
 src/forgekernel.egg-info/top_level.txt
+tests/test_boss.py
 tests/test_hlr.py
 tests/test_k1_exact.py
 tests/test_k37_loft.py
@@ -41,4 +42,5 @@ tests/test_k7_trim.py
 tests/test_k7_trimflux.py
 tests/test_rotate.py
 tests/test_rust_oracle.py
-tests/test_scaffold.py
+tests/test_scaffold.py
+tests/test_step_drilled.py

forgekernel-0.9.5/tests/test_boss.py

@@ -0,0 +1,134 @@
+"""Bosses and bored cylinders — a z-cylinder standing on a planar face
+(tangent, measure-zero) and coaxial bores through solids of revolution.
+
+A cylinder minus a coaxial bore is still a solid of revolution, so the result
+stays an exact ℚ[π] object rather than degrading to a mesh.
+"""
+
+from __future__ import annotations
+
+import math
+from collections import defaultdict
+
+import pytest
+
+from forgekernel.brep import Solid
+from forgekernel.quadric import Cyl, DisjointUnion, RevolveSolid, bore_cyl
+
+
+def _nonmanifold(mesh):
+    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 test_boss_standing_on_a_plate_is_a_tangent_union() -> None:
+    # the cylinder's base sits EXACTLY on the plate's top face: contact is
+    # measure-zero, so the union volume is exactly the sum.
+    plate = Solid.box(30, 30, 3)
+    boss = Cyl(15, 15, 4, 3, 9)
+    u = DisjointUnion([plate, boss])
+    assert float(u.volume()) == pytest.approx(30 * 30 * 3 + math.pi * 16 * 6)
+
+
+def test_boss_sunk_into_the_plate_is_refused() -> None:
+    plate = Solid.box(30, 30, 3)
+    with pytest.raises(ValueError, match="overlaps the solid"):
+        DisjointUnion([plate, Cyl(15, 15, 4, 2, 9)])     # base below the top face
+
+
+def test_cylinder_beside_the_plate_is_separated_by_a_side_face() -> None:
+    plate = Solid.box(10, 10, 10)
+    DisjointUnion([plate, Cyl(20, 5, 3, 0, 10)])         # clear in x: no raise
+
+
+def test_non_convex_solids_refuse_rather_than_double_count() -> None:
+    """SOUNDNESS: the separating-plane test only holds for a convex solid.
+
+    In an L-prism, a bore buried in one arm lies outside the plane of the
+    OTHER arm's face — so a plane-only test would call it disjoint and silently
+    add its volume twice. Both predicates must refuse instead."""
+    from forgekernel import kernel as fk
+    from forgekernel.quadric import Sphere
+
+    ell = fk.prism([(0, 0), (10, 0), (10, 4), (4, 4), (4, 10), (0, 10)], 5)
+    for buried in (Cyl(2, 7, 1, 1, 4), Sphere(2, 7, 2, 1)):
+        with pytest.raises(ValueError, match="non-convex"):
+            DisjointUnion([ell, buried])
+
+
+def test_a_bore_outside_the_footprint_is_not_a_phantom_hole() -> None:
+    """SOUNDNESS: "the bore crosses no lateral wall" does not mean "the bore is
+    inside" — a bore entirely OUTSIDE the footprint crosses nothing either. It
+    used to be recorded as a hole, silently deleting volume from a solid the
+    tool never touched (a Ø4 tool 40 mm away removed 125.66 mm³ from a box)."""
+    from forgekernel.quadric import DrilledSolid
+
+    box = Solid.box(10, 10, 10)
+    with pytest.raises(ValueError, match="misses the solid in xy"):
+        DrilledSolid(box, []).cut(Cyl(50, 50, 2, 0, 10))
+    inside = DrilledSolid(box, []).cut(Cyl(5, 5, 2, 0, 10))     # a real hole
+    assert float(inside.volume()) == pytest.approx(1000 - math.pi * 4 * 10)
+
+
+def test_cut_leaves_members_the_tool_misses_untouched() -> None:
+    # a post standing 50 mm clear of a plate; boring the POST must not shrink
+    # the plate (the tool never enters it in xy).
+    plate, post = Solid.box(100, 100, 10), Cyl(150, 50, 8, 0, 20)
+    out = DisjointUnion([plate, post]).cut(Cyl(150, 50, 4, 0, 20))
+    assert float(out.volume()) == pytest.approx(100000 + (64 - 16) * 20 * math.pi)
+
+
+def test_coaxial_bore_of_a_cylinder_is_an_exact_revolve() -> None:
+    cyl = Cyl(0, 0, 10, 0, 2)
+    washer = bore_cyl(cyl, Cyl(0, 0, 4, 0, 2))           # through bore: annulus
+    assert isinstance(washer, RevolveSolid)
+    assert float(washer.volume()) == pytest.approx(math.pi * (100 - 16) * 2)
+    mesh = washer.tessellate(0.05)
+    assert _nonmanifold(mesh) == 0                       # watertight tube
+
+    blind = bore_cyl(Cyl(0, 0, 4, 3, 9), Cyl(0, 0, 1, 4, 9))   # blind from top
+    assert float(blind.volume()) == pytest.approx(math.pi * 16 * 6 - math.pi * 1 * 5)
+
+    up = bore_cyl(Cyl(0, 0, 4, 0, 6), Cyl(0, 0, 1, -5, 2))     # blind from below
+    assert float(up.volume()) == pytest.approx(math.pi * 16 * 6 - math.pi * 1 * 2)
+
+
+def test_bore_that_misses_in_z_leaves_the_cylinder_unchanged() -> None:
+    cyl = Cyl(0, 0, 4, 0, 6)
+    assert bore_cyl(cyl, Cyl(0, 0, 1, 10, 12)) is cyl
+
+
+def test_non_representable_bores_refuse() -> None:
+    cyl = Cyl(0, 0, 4, 0, 6)
+    with pytest.raises(ValueError, match="not coaxial"):
+        bore_cyl(cyl, Cyl(1, 0, 1, 0, 6))
+    with pytest.raises(ValueError, match="not narrower"):
+        bore_cyl(cyl, Cyl(0, 0, 4, 0, 6))
+    with pytest.raises(ValueError, match="closed cavity"):
+        bore_cyl(cyl, Cyl(0, 0, 1, 2, 4))                # floats strictly inside
+
+
+def test_cut_distributes_over_a_disjoint_union() -> None:
+    # the boss + pilot: (plate ∪ boss) ∖ pilot, pilot blind in the boss only
+    plate = Solid.box(30, 30, 3)
+    u = DisjointUnion([plate, Cyl(15, 15, 4, 3, 9)])
+    out = u.cut(Cyl(15, 15, 1, 4, 9))
+    expect = 30 * 30 * 3 + math.pi * 16 * 6 - math.pi * 1 * 5
+    assert float(out.volume()) == pytest.approx(expect)
+    # the plate member is untouched (the tool misses it in z)
+    assert any(isinstance(m, Solid) for m in out.members)
+    assert _nonmanifold(out.tessellate(0.05)) == 0
+
+
+def test_revolve_solid_can_sit_off_axis() -> None:
+    loop = [(0, 0), (2, 0), (2, 5), (0, 5)]              # a plain cylinder r=2
+    at_origin, moved = RevolveSolid(loop), RevolveSolid(loop, 7, -3)
+    assert float(at_origin.volume()) == float(moved.volume())
+    assert moved.centroid_f()[0] == pytest.approx(7.0)
+    assert moved.centroid_f()[1] == pytest.approx(-3.0)
+    lo, hi = moved.bbox()
+    assert (lo[0], hi[0]) == pytest.approx((5.0, 9.0))
+    assert (lo[1], hi[1]) == pytest.approx((-5.0, -1.0))

{forgekernel-0.9.2 → forgekernel-0.9.5}/tests/test_k1_exact.py

@@ -270,11 +270,26 @@ def test_disjoint_in_z_passes_despite_close_axes() -> None:
     assert u.volume() == PiVal(0, 1000)
 
 
-def test_internally_tangent_cylinders_exact() -> None:
+def test_internally_tangent_cylinders_are_an_overlap_not_a_union() -> None:
+    """INTERNAL tangency of two SOLID cylinders is containment, not disjointness.
+
+    r=10 at the origin and r=4 at (6,0): d² = 36 = (10−4)², so they touch at
+    (10,0) — but the small cylinder lies wholly INSIDE the big one (its farthest
+    point is 6+4 = 10 = the big radius) and their z-ranges coincide. The union is
+    therefore just the big cylinder, 800π — NOT 928π. An earlier version of this
+    test asserted 928π, and that is what let ``_classify_pair`` admit nested
+    cylinders into a DisjointUnion and silently double-count the overlap. Only
+    EXTERNAL separation (d² ≥ (ra+rb)²) certifies disjointness.
+    """
+    import pytest
+
     from forgekernel.quadric import Cyl, DisjointUnion, PiVal
 
-    # r=10 and r=4, centers 6 apart: d^2 = 36 = (10-4)^2 internally tangent
-    u = DisjointUnion([Cyl.make(10, 8), Cyl.make(4, 8).translated(6, 0, 0)])
+    with pytest.raises(ValueError, match="overlapping cylinders"):
+        DisjointUnion([Cyl.make(10, 8), Cyl.make(4, 8).translated(6, 0, 0)])
+
+    # externally tangent (d² = (ra+rb)²) IS measure-zero contact: exact sum
+    u = DisjointUnion([Cyl.make(10, 8), Cyl.make(4, 8).translated(14, 0, 0)])
     assert u.volume() == PiVal(0, (100 + 16) * 8)
 
 

forgekernel-0.9.5/tests/test_step_drilled.py

@@ -0,0 +1,112 @@
+"""STEP export of drilled solids — exact cylindrical holes, not facets.
+
+A hole is emitted as a real CYLINDRICAL_SURFACE with CIRCLE edges, so any CAD
+system reads it back as a hole (with a diameter you can query) rather than a
+polygon soup. The oracle here is topological: in a valid MANIFOLD_SOLID_BREP
+every edge is used exactly twice, once in each direction — an orientation slip
+anywhere in the caps, walls or blind disks breaks that immediately.
+"""
+
+from __future__ import annotations
+
+import re
+from collections import defaultdict
+
+import pytest
+
+from forgekernel.brep import Solid
+from forgekernel.quadric import Cyl, DrilledSolid
+from forgekernel.stepio import write_step_planar_solid
+
+
+def _entities(text):
+    ent = {}
+    for m in re.finditer(r"^#(\d+) = ([A-Z0-9_]+)\((.*)\);$", text, re.M):
+        ent[int(m.group(1))] = (m.group(2), m.group(3))
+    return ent
+
+
+def _refs(s):
+    return [int(x) for x in re.findall(r"#(\d+)", s)]
+
+
+def _edge_uses(text):
+    """edge id -> list of traversal senses across every face loop."""
+    ent = _entities(text)
+    use = defaultdict(list)
+    for fid, (t, args) in ent.items():
+        if t != "ADVANCED_FACE":
+            continue
+        for b in _refs(args):
+            if ent.get(b, ("", ""))[0] not in ("FACE_OUTER_BOUND", "FACE_BOUND"):
+                continue
+            for lp in _refs(ent[b][1]):
+                if ent.get(lp, ("", ""))[0] != "EDGE_LOOP":
+                    continue
+                for oe in _refs(ent[lp][1]):
+                    if ent.get(oe, ("", ""))[0] != "ORIENTED_EDGE":
+                        continue
+                    use[_refs(ent[oe][1])[0]].append(
+                        ".T." in ent[oe][1].split(",")[-1])
+    return use
+
+
+def _assert_manifold(text):
+    use = _edge_uses(text)
+    assert use, "no edges found"
+    for eid, senses in use.items():
+        assert len(senses) == 2, f"edge #{eid} used {len(senses)}x, want 2"
+        assert senses[0] != senses[1], f"edge #{eid} traversed the same way twice"
+
+
+def _assert_refs_resolve(text):
+    ids = {int(m) for m in re.findall(r"^#(\d+) =", text, re.M)}
+    used = {int(m) for m in re.findall(r"#(\d+)", text)}
+    assert not (used - ids), f"dangling refs: {sorted(used - ids)[:5]}"
+
+
+CASES = {
+    "through hole": DrilledSolid(Solid.box(40, 20, 5), [Cyl(20, 10, 4, 0, 5)]),
+    "blind from top": DrilledSolid(Solid.box(30, 30, 10), [Cyl(15, 15, 3, 4, 10)]),
+    "blind from bottom": DrilledSolid(Solid.box(30, 30, 10), [Cyl(15, 15, 3, 0, 6)]),
+    "two holes": DrilledSolid(Solid.box(60, 30, 5),
+                              [Cyl(15, 15, 3, 0, 5), Cyl(45, 15, 3, 0, 5)]),
+    "counterbore": DrilledSolid(Solid.box(30, 30, 10),
+                                [Cyl(15, 15, 2, 0, 10), Cyl(15, 15, 4, 7, 10)]),
+}
+
+
+@pytest.mark.parametrize("label", sorted(CASES))
+def test_drilled_step_is_a_closed_oriented_brep(label) -> None:
+    solid = CASES[label]
+    text = write_step_planar_solid(solid.base, bores=solid.bores)
+    assert text.startswith("ISO-10303-21;")
+    assert text.rstrip().endswith("END-ISO-10303-21;")
+    _assert_refs_resolve(text)
+    _assert_manifold(text)
+
+
+def test_a_hole_is_an_exact_cylinder_not_facets() -> None:
+    solid = DrilledSolid(Solid.box(40, 20, 5), [Cyl(20, 10, 4, 0, 5)])
+    text = write_step_planar_solid(solid.base, bores=solid.bores)
+    # one analytic cylinder of the right radius on the right axis...
+    cyls = re.findall(r"CYLINDRICAL_SURFACE\('',#(\d+),([0-9.]+)\)", text)
+    assert len(cyls) == 1 and float(cyls[0][1]) == pytest.approx(4.0)
+    # ...two rim circles, same radius
+    circles = re.findall(r"CIRCLE\('',#(\d+),([0-9.]+)\)", text)
+    assert len(circles) == 2
+    assert all(float(r) == pytest.approx(4.0) for _, r in circles)
+    # ...and the axis really is at the bore centre
+    ent = _entities(text)
+    place = ent[int(cyls[0][0])][1]
+    origin = ent[_refs(place)[0]][1]
+    xs = [float(v) for v in re.findall(r"-?[0-9.]+", origin)]
+    assert xs[0] == pytest.approx(20.0) and xs[1] == pytest.approx(10.0)
+    # the caps carry the hole as an INNER bound (FACE_BOUND), not an outer one
+    assert len(re.findall(r"= FACE_BOUND\(", text)) == 2
+
+
+def test_planar_export_is_unchanged_by_the_bore_support() -> None:
+    box = Solid.box(20, 20, 5)
+    assert write_step_planar_solid(box) == write_step_planar_solid(box, bores=[])
+    _assert_manifold(write_step_planar_solid(box))