geometrykit 0.5.1__tar.gz → 0.6.0__tar.gz

{geometrykit-0.5.1/python/geometrykit.egg-info → geometrykit-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geometrykit
-Version: 0.5.1
+Version: 0.6.0
 Summary: Geometry primitives and NURBS data model — the geometry substrate for the ifckit family
 Author: Sander Boer
 License-Expression: LGPL-3.0-or-later

{geometrykit-0.5.1 → geometrykit-0.6.0}/pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "geometrykit"
-version = "0.5.1"
+version = "0.6.0"
 description = "Geometry primitives and NURBS data model — the geometry substrate for the ifckit family"
 readme = "README.md"
 requires-python = ">=3.9"

{geometrykit-0.5.1 → geometrykit-0.6.0}/python/geometrykit/__init__.py

@@ -21,7 +21,7 @@ from geometrykit.geometry import (
     Vec,
 )
 
-__version__ = "0.5.1"
+__version__ = "0.6.0"
 
 __all__ = [
     "__version__",

{geometrykit-0.5.1 → geometrykit-0.6.0}/python/geometrykit/geometry/__init__.py

@@ -1,7 +1,8 @@
 # This file was generated with the assistance of an AI coding tool.
 # Ported from ifckit/ifckit/geometry/__init__.py (LGPL-3.0-or-later heritage;
-# ifckit is authored by the same copyright holder). panel_report and the
-# IFC serialisation layer (ifc_geom) stay in ifckit by design.
+# ifckit is authored by the same copyright holder). The IFC
+# serialisation layer (ifc_geom) stays in ifckit by design; the panel
+# metrics (panel) were promoted here per the geometry-ownership plan.
 
 """
 geometrykit.geometry
@@ -19,6 +20,7 @@ curve       — Curve
 surface     — Surface (eval/normal/tessellate kernels; OCC oracle-compare only)
 field       — Field, FieldPoint, trim_grid, crossing_grid, divide_trim_edge
 patterns    — quad/diamond/triangle/wave/anglebox/brick/truchet/hex/hankin cells
+panel       — FieldReport, cells_report, field_report (panel metrics)
 intersection — Intersection
 subdivision — catmull_clark, extract_patches, write_obj
 frames      — FrameField, transport_frames, fixed_ref_frames, upvector_frames
@@ -42,6 +44,7 @@ from geometrykit.geometry.frames import (
     upvector_frames,
 )
 from geometrykit.geometry.intersection import Intersection
+from geometrykit.geometry.panel import FieldReport, cells_report, field_report
 from geometrykit.geometry.path import Path, PathReport, assemble_path
 from geometrykit.geometry.patterns import (
     DiamondPattern,
@@ -122,6 +125,10 @@ __all__ = [
     "truchet_cells",
     "hankin_cells",
     "triangle_cells",
+    # panel
+    "FieldReport",
+    "cells_report",
+    "field_report",
     # subdivision
     "catmull_clark",
     "extract_patches",

{geometrykit-0.5.1 → geometrykit-0.6.0}/python/geometrykit/geometry/curve.py

@@ -451,12 +451,16 @@ class Curve:
         except ImportError:
             pass
 
-        n = num if num is not None else int(total / step) + 1
+        # Kernel arc-length division (no OCC), engine-dispatched
+        # (mirror or the `_rust` accelerator, bit-identical).
         from geometrykit.geometry.path import PathPoint
+        from geometrykit.runtimes import dispatch
 
         return [
             PathPoint(t=t, point=self.point_at(t), tangent=self.tangent_at(t))
-            for t in (i / (n - 1) for i in range(n))
+            for t in dispatch.arclength_divide(
+                self, total, num=num, dist=dist, even=even
+            )
         ]
 
     @property

geometrykit-0.6.0/python/geometrykit/geometry/panel.py

@@ -0,0 +1,140 @@
+# This file was generated with the assistance of an AI coding tool.
+# Promoted from ifckit/ifckit/geometry/panel_report.py (LGPL-3.0-or-later
+# heritage; ifckit is authored by the same copyright holder as
+# geometrykit).
+"""Buildability metrics for panel populations (Eigensatz 2010 vocabulary).
+
+``field_report`` measures a cell population: edge-length spread
+(limited size bandwidth), right-angle deviation and planarity per
+cell. Seam divergence/kink tracking is a follow-up once populations
+map to IFC products — the per-cell metrics here are its input. Pure
+Python.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from dataclasses import field as _dc_field
+from typing import Any, Dict, List, Optional
+
+from geometrykit.geometry.field import Field
+from geometrykit.geometry.primitives import Vec, _fmt_num, _new_id, _short_id
+
+
+@dataclass(frozen=True)
+class FieldReport:
+    """Immutable metric snapshot of a panel population.
+
+    Attributes:
+        n_cells:      Number of measured cells.
+        edge_min:     Smallest edge length.
+        edge_mean:    Mean edge length.
+        edge_max:     Largest edge length.
+        angle_max_dev: Largest absolute deviation from the regular-polygon
+            interior angle (90° for quads, 60° for triangles), in degrees.
+        planarity_max: Largest distance of a corner to the plane of the
+            first three (model units; always 0 for triangles).
+    """
+
+    type: str = "field_report"
+    id: Optional[str] = None
+    meta: Dict[str, Any] = _dc_field(default_factory=dict)
+    n_cells: int = 0
+    edge_min: float = 0.0
+    edge_mean: float = 0.0
+    edge_max: float = 0.0
+    angle_max_dev: float = 0.0
+    planarity_max: float = 0.0
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialise to a plain (JSON-safe) dict."""
+        return {
+            "type": self.type,
+            "id": self.id,
+            "meta": dict(self.meta),
+            "n_cells": self.n_cells,
+            "edge_min": self.edge_min,
+            "edge_mean": self.edge_mean,
+            "edge_max": self.edge_max,
+            "angle_max_dev": self.angle_max_dev,
+            "planarity_max": self.planarity_max,
+        }
+
+    def __str__(self) -> str:
+        return (
+            f"FieldReport(id={_short_id(self.id)}, n={self.n_cells}, "
+            f"edge=[{_fmt_num(self.edge_min)}..{_fmt_num(self.edge_max)}], "
+            f"angle_dev={_fmt_num(self.angle_max_dev)}°, "
+            f"planar={_fmt_num(self.planarity_max)})"
+        )
+
+
+def cells_report(cells: List[List[Vec]]) -> FieldReport:
+    """Measure a population of polygonal cells (any corner count >= 3).
+
+    Args:
+        cells: Corner lists (``[Vec × n]``), e.g. from ``patterns``.
+            Mixed populations are measured jointly against their own
+            regular-polygon angles.
+
+    Returns:
+        ``FieldReport`` with zeros when *cells* is empty.
+    """
+    edges: List[float] = []
+    max_dev = 0.0
+    max_flat = 0.0
+    for poly in cells:
+        n = len(poly)
+        if n < 3:
+            raise ValueError(f"Expected polygonal cells, got {n} corners")
+        ref_angle = (n - 2) * 180.0 / n
+        for k in range(n):
+            p, q = poly[k], poly[(k + 1) % n]
+            edges.append((q - p).length())
+        for k in range(n):
+            u, v = poly[(k - 1) % n] - poly[k], poly[(k + 1) % n] - poly[k]
+            denom = u.length() * v.length()
+            if denom < 1e-18:
+                continue
+            cos_a = max(-1.0, min(1.0, u.dot(v) / denom))
+            max_dev = max(max_dev, abs(ref_angle - math.degrees(math.acos(cos_a))))
+        a, b, c = poly[0], poly[1], poly[2]
+        nrm = (b - a) ** (c - a)
+        nl = nrm.length()
+        if nl > 1e-18:
+            for p in poly[3:]:
+                max_flat = max(max_flat, abs((p - a).dot(nrm / nl)))
+    if not edges:
+        return FieldReport(id=_new_id())
+    return FieldReport(
+        id=_new_id(),
+        n_cells=len(cells),
+        edge_min=min(edges),
+        edge_mean=sum(edges) / len(edges),
+        edge_max=max(edges),
+        angle_max_dev=max_dev,
+        planarity_max=max_flat,
+    )
+
+
+def field_report(field: Field) -> FieldReport:
+    """Measure the quad cells of a built field.
+
+    Args:
+        field: Built field (see ``geometrykit.geometry.field``).
+
+    Returns:
+        ``FieldReport`` over ``field.cell_points()``.
+    """
+    rep = cells_report(field.cell_points())
+    return FieldReport(
+        id=_new_id(),
+        meta={"field_id": field.id},
+        n_cells=rep.n_cells,
+        edge_min=rep.edge_min,
+        edge_mean=rep.edge_mean,
+        edge_max=rep.edge_max,
+        angle_max_dev=rep.angle_max_dev,
+        planarity_max=rep.planarity_max,
+    )

{geometrykit-0.5.1 → geometrykit-0.6.0}/python/geometrykit/geometry/surface.py

@@ -276,33 +276,54 @@ class Surface:
         material: "dict | None" = None,
         deflection: "float | object" = 0.01,
         y_up: bool = True,
+        method: str = "occ",
     ) -> dict:
-        """Triangulate the surface via OCC and return a dict for 3D viewer.
-
-        Uses OCC ``BRepMesh_IncrementalMesh`` (requires ``pythonocc-core``).
+        """Triangulate the surface and return a dict for 3D viewer.
 
         Args:
-            nu:         Ignored (OCC adaptive mesh).
-            nv:         Ignored (OCC adaptive mesh).
+            nu:         Ignored (both methods determine density themselves).
+            nv:         Ignored (both methods determine density themselves).
             label:      Display name.
             material:   Visual properties (color, opacity, …).
             deflection: Mesh deflection / ``TessellationDetail``.
             y_up:       If True (default), convert coordinates to
                         Three.js/glTF Y-up: ``(x, z, -y)``.
+            method:     ``"occ"`` (default, unchanged): OCC
+                        ``BRepMesh_IncrementalMesh`` (requires
+                        ``pythonocc-core``). ``"adaptive"``: the
+                        kernel tessellator (no OCC needed; watertight,
+                        deflection-bounded, deterministic).
 
         Returns:
             A dict with ``primitive="triangles"``, ``positions``,
             ``indices``, and optional ``label``, ``material``.
         """
-        from geometrykit.geometry.surface import occ_tessellate, require_occ
-
-        require_occ()
-        verts, tris = occ_tessellate(self, deflection)
-        if y_up:
-            positions = [c for v in verts for c in (v[0], v[2], -v[1])]
+        if method not in ("occ", "adaptive"):
+            raise ValueError(f"unknown mesh method {method!r}: use 'occ' or 'adaptive'")
+        if method == "adaptive":
+            from geometrykit.runtimes._npu import tessellate_np
+
+            tolerance = deflection if isinstance(deflection, float) else 0.01
+            verts, _normals, tris, _uvs = tessellate_np.adaptive_mesh(
+                self, deflection=tolerance
+            )
+            if y_up:
+                positions = []
+                for k in range(0, len(verts), 3):
+                    positions.extend((verts[k], verts[k + 2], -verts[k + 1]))
+            else:
+                positions = list(verts)
+            indices = [i for tri in tris for i in tri]
         else:
-            positions = [c for v in verts for c in v]
-        indices = [i - 1 for tri in tris for i in tri]
+            from geometrykit.geometry.surface import occ_tessellate, require_occ
+
+            require_occ()
+            verts, tris = occ_tessellate(self, deflection)
+            if y_up:
+                positions = [c for v in verts for c in (v[0], v[2], -v[1])]
+            else:
+                positions = [c for v in verts for c in v]
+            indices = [i - 1 for tri in tris for i in tri]
 
         d: dict = {
             "primitive": "triangles",
@@ -320,11 +341,13 @@ class Surface:
         material: "dict | None" = None,
         deflection: "float | object" = 0.01,
         y_up: bool = True,
+        method: str = "occ",
     ) -> dict:
         """Return a ``__type__: "mesh"`` dict ready for the viewer pipeline.
 
-        Uses OCC adaptive triangulation. See ``Path.preview()`` for
-        the full material documentation.
+        ``method`` selects the tessellator: ``"occ"`` (default,
+        unchanged) or ``"adaptive"`` (kernel, no OCC needed). See
+        ``Path.preview()`` for the full material documentation.
 
         Args:
             label:      Display name.
@@ -332,13 +355,15 @@ class Surface:
             deflection: Mesh deflection / ``TessellationDetail`` (see ifckit).
             y_up:       If True (default), convert coordinates to
                         Three.js/glTF Y-up: ``(x, z, -y)``.
+            method:     ``"occ"`` or ``"adaptive"`` (see ``to_mesh_dict``).
 
         Returns:
             ``{"__type__": "mesh", "primitive": "triangles", …}``
         """
         return {
             "__type__": "mesh",
-            **self.to_mesh_dict(label=label, material=material, deflection=deflection, y_up=y_up),
+            **self.to_mesh_dict(label=label, material=material, deflection=deflection, y_up=y_up,
+                                method=method),
         }
 
     # ── IFC serialisation ──────────────────────────────────────────

{geometrykit-0.5.1 → geometrykit-0.6.0}/python/geometrykit/runtimes/_npu/curve_np.py

@@ -349,3 +349,83 @@ def group_and_orient(curves: Sequence, tol: float = 1e-6) -> list:
 
     groups.append(oriented)
     return groups
+
+
+def arclength_divide(
+    point_at,
+    total: float,
+    num: "int | None" = None,
+    dist: "float | None" = None,
+    even: bool = True,
+) -> list:
+    """Kernel arc-length division: normalized parameters ``∈ [0, 1]``.
+
+    A dense chord table over ``point_at`` is inverted per target
+    distance (binary search + linear interpolation). Arc-length
+    uniformity holds within a few percent on fair curves (the old
+    parameter-uniform fallback measured 2.7x gap spread on a Hermite
+    wiggle); straight chords between outputs vary more where the
+    curve bends, which is geometric, not error.
+
+    Args:
+        point_at: callable ``t → xyz`` (t in [0, 1]).
+        total:    curve length in the same units as ``dist``.
+        num:      point count (endpoints included).
+        dist:     target spacing; ``even`` distributes evenly with the
+                  endpoints included, otherwise fixed steps from the
+                  start plus the exact endpoint.
+        even:     spacing rule for *dist* (see above).
+
+    Returns:
+        Ascending parameter list (first 0.0, last 1.0).
+    """
+    import math
+
+    if total < _EPS:
+        raise ValueError("Cannot divide a zero-length curve")
+    table_n = max(64, 8 * (num if num is not None else 16))
+    samples = [point_at(i / table_n) for i in range(table_n + 1)]
+    cumulative = [0.0]
+    for a, b in zip(samples, samples[1:]):
+        cumulative.append(
+            cumulative[-1]
+            + math.sqrt(
+                (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2 + (b[2] - a[2]) ** 2
+            )
+        )
+    table_total = cumulative[-1]
+    if table_total < _EPS:
+        raise ValueError("Cannot divide a zero-length curve")
+    if num is not None:
+        targets = [table_total * k / (num - 1) for k in range(num)]
+    elif even:
+        segs = max(1, math.ceil(table_total / dist))
+        targets = [table_total * k / segs for k in range(segs + 1)]
+    else:
+        targets = []
+        d = 0.0
+        while d < table_total:
+            targets.append(d)
+            d += dist
+        targets.append(table_total)
+
+    out = []
+    for target in targets:
+        lo, hi = 0, table_n
+        while lo < hi:
+            mid = (lo + hi) // 2
+            if cumulative[mid] < target:
+                lo = mid + 1
+            else:
+                hi = mid
+        if lo <= 0:
+            out.append(0.0)
+        elif lo > table_n:
+            out.append(1.0)
+        else:
+            span = cumulative[lo] - cumulative[lo - 1]
+            if span <= 0.0:
+                out.append(lo / table_n)
+            else:
+                out.append((lo - 1 + (target - cumulative[lo - 1]) / span) / table_n)
+    return out

geometrykit-0.6.0/python/geometrykit/runtimes/_npu/tessellate_np.py

@@ -0,0 +1,299 @@
+# This file was generated with the assistance of an AI coding tool.
+"""Adaptive kernel tessellation: OCC-free surface meshing.
+
+A restricted quadtree over the parameter domain: quads split while
+their geometric error exceeds the tolerances, neighbours are forced
+to differ by at most one level, and split edges close with a fan from
+the evaluated centroid (green closure). Every vertex is an evaluated
+surface point and every edge is shared exactly, so the mesh is
+watertight by construction; the only numerical content is the kernel
+evaluation itself.
+
+Error metric per quad: maximum edge-midpoint deviation (surface point
+at the edge midpoint vs. the 3D edge midpoint) against ``deflection``,
+and maximum corner-normal deviation against the quad normal versus
+``angle_tol`` (radians). Stations are dyadic integer lattice points
+``(iu, iv, level)`` with ``u = u0 + (u1-u0)*iu/2**level``, so shared
+edges compute bit-identical vertices on both sides.
+"""
+
+from __future__ import annotations
+
+import math
+
+from geometrykit.runtimes._npu.surface_np import (
+    _data_of,
+    _eval_all_data,
+)
+
+
+def _station_uv(u0: float, u1: float, v0: float, v1: float,
+                iu: int, iv: int, level: int) -> tuple:
+    """Domain point of a dyadic lattice station."""
+    scale = 1.0 / (1 << level)
+    return (
+        u0 + (u1 - u0) * iu * scale,
+        v0 + (v1 - v0) * iv * scale,
+    )
+
+
+def adaptive_mesh(surf, deflection: float = 0.01, angle_tol: float = 0.5,
+                  max_depth: int = 8, base_level: int = 2) -> tuple:
+    """Triangulate *surf* adaptively; ``(verts, normals, tris)``.
+
+    Args:
+        surf:       kernel Surface.
+        deflection: maximum distance of the surface from any triangle.
+        angle_tol:  maximum normal deviation within a quad (radians).
+        max_depth:  deepest quad level (base_level + refinements).
+        base_level: starting grid is ``2**base_level`` quads per side.
+
+    Returns:
+        ``(verts, normals, tris, uvs)`` — ``verts`` flat ``[x, y, z]``,
+        ``normals`` flat unit normals per vertex, ``tris`` index
+        triples, ``uvs`` flat ``[u, v]`` per vertex (the parameter
+        track, like section chains carry). Every edge is shared by
+        exactly two triangles (watertight) on non-degenerate
+        surfaces.
+    """
+    if deflection <= 0.0:
+        raise ValueError(f"deflection must be positive, got {deflection}")
+    if angle_tol <= 0.0:
+        raise ValueError(f"angle_tol must be positive, got {angle_tol}")
+    if max_depth < base_level:
+        raise ValueError(
+            f"max_depth {max_depth} below base_level {base_level}"
+        )
+    d = _data_of(surf)
+    u0, u1 = d.uflat[d.pu], d.uflat[-d.pu - 1]
+    v0, v1 = d.vflat[d.pv], d.vflat[-d.pv - 1]
+    if not (u1 > u0 and v1 > v0):
+        raise ValueError("degenerate parameter domain")
+
+    # eval cache: (iu, iv, level) -> (point, normal), one basis build
+    cache: dict = {}
+
+    def _eval(iu: int, iv: int, level: int) -> tuple:
+        key = (iu, iv, level)
+        hit = cache.get(key)
+        if hit is None:
+            u, v = _station_uv(u0, u1, v0, v1, iu, iv, level)
+            pt, su, sv = _eval_all_data(d, u, v)
+            nx = su.y * sv.z - su.z * sv.y
+            ny = su.z * sv.x - su.x * sv.z
+            nz = su.x * sv.y - su.y * sv.x
+            n = math.sqrt(nx * nx + ny * ny + nz * nz)
+            if n > 0.0:
+                nx, ny, nz = nx / n, ny / n, nz / n
+            hit = ((pt.x, pt.y, pt.z), (nx, ny, nz))
+            cache[key] = hit
+        return hit
+
+    def _corners(i: int, j: int, level: int) -> list:
+        return [(i, j, level), (i + 1, j, level),
+                (i + 1, j + 1, level), (i, j + 1, level)]
+
+    def _mid(a: tuple, b: tuple) -> tuple:
+        (aiu, aiv, al), (biu, biv, bl) = a, b
+        assert al == bl, "midpoint of mixed-level stations"
+        return (aiu + biu, aiv + biv, al + 1)
+
+    def _quad_error(i: int, j: int, level: int) -> tuple:
+        """(edge deviation, normal deviation) of one quad.
+
+        Edge deviation covers quad edges, both diagonals and the
+        centroid spoke deviations, so every emitted triangle edge is
+        bounded (green-closure fans introduce diagonals and spokes
+        that edge-only checks would miss).
+        """
+        corners = _corners(i, j, level)
+        pts = [_eval(*c)[0] for c in corners]
+        norms = [_eval(*c)[1] for c in corners]
+        edge_dev = 0.0
+        for k in range(4):
+            a, b = corners[k], corners[(k + 1) % 4]
+            mid = _eval(*_mid(a, b))[0]
+            pa, pb = pts[k], pts[(k + 1) % 4]
+            edge_dev = max(edge_dev, abs(mid[0] - 0.5 * (pa[0] + pb[0]))
+                           + abs(mid[1] - 0.5 * (pa[1] + pb[1]))
+                           + abs(mid[2] - 0.5 * (pa[2] + pb[2])))
+        # diagonals and centroid (fan spokes land here)
+        cu = (corners[0][0] + corners[2][0], corners[0][1] + corners[2][1],
+              corners[0][2] + 1)
+        cc = _eval(*cu)[0]
+        for pa, pb in ((pts[0], pts[2]), (pts[1], pts[3])):
+            edge_dev = max(edge_dev, abs(cc[0] - 0.5 * (pa[0] + pb[0]))
+                           + abs(cc[1] - 0.5 * (pa[1] + pb[1]))
+                           + abs(cc[2] - 0.5 * (pa[2] + pb[2])))
+        bil = tuple(sum(p[k] for p in pts) / 4.0 for k in range(3))
+        edge_dev = max(edge_dev, abs(cc[0] - bil[0])
+                       + abs(cc[1] - bil[1]) + abs(cc[2] - bil[2]))
+        # fan spokes: the green-closure fan connects the centroid to
+        # every boundary station, so bound every spoke midpoint (covers
+        # all split patterns; edge midpoints already evaluated above)
+        cstat = (corners[0][0] + corners[2][0], corners[0][1] + corners[2][1],
+                 corners[0][2] + 1)
+        boundary = list(corners)
+        for k in range(4):
+            a, b = corners[k], corners[(k + 1) % 4]
+            boundary.append(_mid(a, b))
+        for (biu, biv, bl) in boundary:
+            # centroid lives at level L+1, boundary at L or L+1:
+            # lift the boundary numerator before halving
+            lift = 1 << (cstat[2] - bl)
+            mstat = (cstat[0] + lift * biu, cstat[1] + lift * biv,
+                     cstat[2] + 1)
+            sm = _eval(*mstat)[0]
+            bp = _eval(biu, biv, bl)[0]
+            edge_dev = max(edge_dev, abs(sm[0] - 0.5 * (cc[0] + bp[0]))
+                           + abs(sm[1] - 0.5 * (cc[1] + bp[1]))
+                           + abs(sm[2] - 0.5 * (cc[2] + bp[2])))
+        # quad normal from the diagonals
+        d0 = (pts[2][0] - pts[0][0], pts[2][1] - pts[0][1], pts[2][2] - pts[0][2])
+        d1 = (pts[3][0] - pts[1][0], pts[3][1] - pts[1][1], pts[3][2] - pts[1][2])
+        qn = (d0[1] * d1[2] - d0[2] * d1[1],
+              d0[2] * d1[0] - d0[0] * d1[2],
+              d0[0] * d1[1] - d0[1] * d1[0])
+        ql = math.sqrt(qn[0] ** 2 + qn[1] ** 2 + qn[2] ** 2)
+        normal_dev = 0.0
+        if ql > 0.0:
+            qn = (qn[0] / ql, qn[1] / ql, qn[2] / ql)
+            for n in norms:
+                cos_a = max(-1.0, min(1.0, n[0] * qn[0] + n[1] * qn[1] + n[2] * qn[2]))
+                normal_dev = max(normal_dev, math.acos(cos_a))
+        return edge_dev, normal_dev
+
+    # leaves: (i, j, level) quads, base grid first
+    n_base = 1 << base_level
+    leaves: dict = {
+        (i, j, base_level): None
+        for i in range(n_base) for j in range(n_base)
+    }
+
+    def _neighbors(i: int, j: int, level: int) -> list:
+        """Candidate edge-neighbours at levels level-1..level+1."""
+        found = []
+        for key in ((i - 1, j, level), (i + 1, j, level),
+                    (i, j - 1, level), (i, j + 1, level),
+                    (i >> 1, j >> 1, level - 1)
+                    if level > 0 else None):
+            if key is not None and key in leaves and key not in found:
+                found.append(key)
+        for key in ((2 * i - 1, 2 * j, level + 1),
+                    (2 * i + 2, 2 * j, level + 1),
+                    (2 * i - 1, 2 * j + 1, level + 1),
+                    (2 * i + 2, 2 * j + 1, level + 1),
+                    (2 * i, 2 * j - 1, level + 1),
+                    (2 * i + 1, 2 * j - 1, level + 1),
+                    (2 * i, 2 * j + 2, level + 1),
+                    (2 * i + 1, 2 * j + 2, level + 1)):
+            if key in leaves and key not in found:
+                found.append(key)
+        return found
+
+    # refine to fixpoint: error splits, then balance (2:1 at most)
+    while True:
+        marked = set()
+        for key in sorted(leaves):
+            i, j, level = key
+            if level >= max_depth:
+                continue
+            edge_dev, normal_dev = _quad_error(i, j, level)
+            if edge_dev > deflection or normal_dev > angle_tol:
+                marked.add(key)
+        if not marked:
+            break
+        # balance: no edge-neighbour more than one level coarser
+        while True:
+            extra = set()
+            for key in sorted(leaves):
+                if key in marked:
+                    continue
+                i, j, level = key
+                for nb in _neighbors(i, j, level):
+                    if nb in marked:
+                        continue
+                    if nb[2] < level - 1 and nb[2] < max_depth:
+                        # a marked finer quad touches this one: split up
+                        if any(m[2] > nb[2] + 1 for m in marked
+                               if _quads_touch(nb, m)):
+                            extra.add(nb)
+            if not extra:
+                break
+            marked |= extra
+        for key in marked:
+            i, j, level = key
+            del leaves[key]
+            leaves[(2 * i, 2 * j, level + 1)] = None
+            leaves[(2 * i + 1, 2 * j, level + 1)] = None
+            leaves[(2 * i, 2 * j + 1, level + 1)] = None
+            leaves[(2 * i + 1, 2 * j + 1, level + 1)] = None
+
+    # triangulate with green closure: split edges fan from the
+    # evaluated centroid; every vertex is on the surface
+    verts: list = []
+    normals: list = []
+    uvs: list = []
+    index_of: dict = {}
+
+    def _vertex(station: tuple) -> int:
+        idx = index_of.get(station)
+        if idx is None:
+            (px, py, pz), (nx, ny, nz) = _eval(*station)
+            idx = len(verts) // 3
+            verts.extend((px, py, pz))
+            normals.extend((nx, ny, nz))
+            u, v = _station_uv(u0, u1, v0, v1, *station)
+            uvs.extend((u, v))
+            index_of[station] = idx
+        return idx
+
+    def _covers(candidate: tuple, a: tuple, b: tuple, level: int) -> bool:
+        """True when the level-(level+1) quad covers part of edge a-b."""
+        (ni, nj, _nl) = candidate
+        (aiu, aiv, _al), (biu, biv, _bl) = a, b
+        if aiu == biu:  # vertical edge
+            eu = 2 * aiu
+            lo, hi = sorted((2 * aiv, 2 * biv))
+            return (ni == eu or ni + 1 == eu) and nj < hi and nj + 1 > lo
+        # horizontal edge
+        ev = 2 * aiv
+        lo, hi = sorted((2 * aiu, 2 * biu))
+        return (nj == ev or nj + 1 == ev) and ni < hi and ni + 1 > lo
+
+    tris: list = []
+    for key in sorted(leaves):
+        i, j, level = key
+        corners = _corners(i, j, level)
+        finer = [nb for nb in _neighbors(i, j, level) if nb[2] == level + 1]
+        loop = [corners[0]]
+        for k in range(4):
+            a, b = corners[k], corners[(k + 1) % 4]
+            if any(_covers(nb, a, b, level) for nb in finer):
+                loop.append(_mid(a, b))
+            if k < 3:
+                loop.append(b)
+        if len(loop) == 4:
+            a, b, c, e = (_vertex(p) for p in loop)
+            tris.extend(((a, b, c), (a, c, e)))
+        else:
+            center = (corners[0][0] + corners[2][0],
+                      corners[0][1] + corners[2][1], corners[0][2] + 1)
+            c = _vertex(center)
+            ring = [_vertex(p) for p in loop]
+            for k in range(len(ring)):
+                tris.append((c, ring[k], ring[(k + 1) % len(ring)]))
+    return verts, normals, tris, uvs
+
+
+def _quads_touch(a: tuple, b: tuple) -> bool:
+    """True when quads a and b share an edge segment."""
+    (ai, aj, al), (bi, bj, bl) = a, b
+    scale = 1 << max(al, bl)
+    au0, au1 = ai * (scale >> al), (ai + 1) * (scale >> al)
+    av0, av1 = aj * (scale >> al), (aj + 1) * (scale >> al)
+    bu0, bu1 = bi * (scale >> bl), (bi + 1) * (scale >> bl)
+    bv0, bv1 = bj * (scale >> bl), (bj + 1) * (scale >> bl)
+    share_v = (au1 == bu0 or bu1 == au0) and av0 < bv1 and bv0 < av1
+    share_h = (av1 == bv0 or bv1 == av0) and au0 < bu1 and bu0 < au1
+    return share_v or share_h

{geometrykit-0.5.1 → geometrykit-0.6.0}/python/geometrykit/runtimes/dispatch.py

@@ -51,6 +51,64 @@ def basis_row_list(degree: int, uflat, stations):
     ]
 
 
+def tessellate(surf, deflection: float = 0.01, angle_tol: float = 0.5,
+               max_depth: int = 8, base_level: int = 2):
+    """Mirror `tessellate_np.adaptive_mesh` under the active engine.
+
+    Returns `(verts, normals, tris, uvs)` — flat xyz vertices, flat
+    unit normals, flat index triples, flat uv tracks. Bit-identical
+    across engines by harness.
+    """
+    from geometrykit.runtimes._npu import tessellate_np
+
+    accel = _rust()
+    if accel is None:
+        return tessellate_np.adaptive_mesh(
+            surf, deflection=deflection, angle_tol=angle_tol,
+            max_depth=max_depth, base_level=base_level,
+        )
+    from geometrykit import _rust as _ext
+
+    verts, normals, flat_tris, uvs = _ext.tessellate_grid(
+        surf, float(deflection), float(angle_tol), int(max_depth),
+        int(base_level),
+    )
+    tris = [
+        (flat_tris[k], flat_tris[k + 1], flat_tris[k + 2])
+        for k in range(0, len(flat_tris), 3)
+    ]
+    return verts, normals, tris, uvs
+
+
+def arclength_divide(curve, total: float, num=None, dist=None, even: bool = True):
+    """Mirror `curve_np.arclength_divide` under the active engine.
+
+    Returns ascending normalized parameters (first 0.0, last 1.0),
+    bit-identical across engines by harness.
+    """
+    from geometrykit.runtimes._npu import curve_np
+
+    def _sample(t: float):
+        p = curve.point_at(t)
+        return (p.x, p.y, p.z)
+
+    accel = _rust()
+    if accel is None:
+        return curve_np.arclength_divide(_sample, total, num=num, dist=dist, even=even)
+    from geometrykit import _rust as _ext
+
+    flat = []
+    for p in curve.points:
+        flat.extend((p.x, p.y, p.z))
+    weights = (
+        list(curve._weights) if curve._weights is not None else []
+    )
+    return _ext.curve_divide_grid(
+        flat, weights, int(curve.degree), list(curve.knots),
+        list(curve.multiplicities), float(total), num, dist, bool(even),
+    )
+
+
 def plane_section_chains(surf, origin, normal, offsets, nu: int, nv: int):
     """Mirror `section_np.section_levels` under the active engine.
 

{geometrykit-0.5.1 → geometrykit-0.6.0/python/geometrykit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: geometrykit
-Version: 0.5.1
+Version: 0.6.0
 Summary: Geometry primitives and NURBS data model — the geometry substrate for the ifckit family
 Author: Sander Boer
 License-Expression: LGPL-3.0-or-later

{geometrykit-0.5.1 → geometrykit-0.6.0}/python/geometrykit.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ python/geometrykit/geometry/curve.py
 python/geometrykit/geometry/field.py
 python/geometrykit/geometry/frames.py
 python/geometrykit/geometry/intersection.py
+python/geometrykit/geometry/panel.py
 python/geometrykit/geometry/path.py
 python/geometrykit/geometry/patterns.py
 python/geometrykit/geometry/primitives.py
@@ -36,6 +37,7 @@ python/geometrykit/runtimes/_npu/patch_g1.py
 python/geometrykit/runtimes/_npu/patch_np.py
 python/geometrykit/runtimes/_npu/section_np.py
 python/geometrykit/runtimes/_npu/surface_np.py
+python/geometrykit/runtimes/_npu/tessellate_np.py
 tests/test_cage.py
 tests/test_contract.py
 tests/test_engine_parity.py

{geometrykit-0.5.1 → geometrykit-0.6.0}/tests/test_engine_parity.py

@@ -112,7 +112,7 @@ class TestAcceleratorParity:
     def test_core_version_stamp(self):
         from geometrykit import _rust
 
-        assert _rust.core_version() == "geometrykit-core 0.1.0"
+        assert _rust.core_version() == "geometrykit-core 0.2.0"
 
     def test_bits_hex_agrees_with_contract(self):
         from geometrykit import _rust