geometrykit 0.5.0__tar.gz → 0.6.0__tar.gz

geometrykit-0.6.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: geometrykit
+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
+Project-URL: Homepage, https://github.com/maucworks/geometrykit
+Project-URL: Changelog, https://github.com/maucworks/geometrykit/blob/master/CHANGELOG.md
+Keywords: geometry,nurbs,vector,curve,surface,splines
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Multimedia :: Graphics :: 3D Modeling
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: COPYING.LESSER
+License-File: COPYING
+Provides-Extra: dev
+Requires-Dist: pytest<10,>=7; extra == "dev"
+Requires-Dist: pytest-cov<8,>=7; extra == "dev"
+Requires-Dist: hypothesis<8,>=6; extra == "dev"
+Dynamic: license-file
+
+# geometrykit
+
+OCC-free NURBS geometry for the ifckit family: value types (`Vec`,
+`Plane`, `Line`, `Arc`, `Polyline`, `Path`, `Curve`, `Surface`), NURBS
+evaluation / tangents / normals / projection, energy-minimising patch
+fills with G1/G2 continuity options, plane × surface sections with
+pcurve tracks, and STEP/OBJ/STL writers. No OCCT, no compiled
+toolchain required to install.
+
+## Install
+
+```bash
+pip install geometrykit   # Python >= 3.9, incl. Rhino 8's CPython 3.9
+```
+
+Binary wheels (`cp39-abi3`) carry the compiled Rust core
+(`geometrykit._rust`) where a platform build exists, and the public
+API routes to it automatically. Platforms without a matching wheel get
+the pure-Python/numpy mirror instead: same API, same results, slower.
+`GEOMETRYKIT_ENGINE=npu` forces the mirror; the default prefers the
+accelerator when importable.
+
+## Quickstart
+
+```python
+from geometrykit import engine
+from geometrykit.geometry import Curve, Surface
+from geometrykit.geometry.primitives import Vec
+
+curves = [
+    Curve.from_tangents(start=Vec(0, 0, 2.4), tan_start=Vec(1, 0, 0),
+                        end=Vec(8, 0, 2.8), tan_end=Vec(1, 0, 0), scale=3.0),
+    Curve.from_tangents(start=Vec(8, 0, 2.8), tan_start=Vec(0, 1, 0),
+                        end=Vec(8, 6, 2.9), tan_end=Vec(0, 1, 0), scale=3.0),
+    Curve.from_tangents(start=Vec(0, 6, 3.2), tan_start=Vec(1, 0, 0),
+                        end=Vec(8, 6, 2.9), tan_end=Vec(1, 0, 0), scale=3.0),
+    Curve.from_tangents(start=Vec(0, 6, 3.2), tan_start=Vec(0, -1, 0),
+                        end=Vec(0, 0, 2.4), tan_end=Vec(0, -1, 0), scale=3.0),
+]
+surface = Surface.patch(curves, fill="energy", nu=16, nv=16, tangency=0.75)
+proj, (u, v) = surface.project(Vec(-1.0, -1.0, 3.0))
+print(engine.engine(), proj, (u, v))
+```
+
+## What is in here
+
+- NURBS evaluation, analytic tangents and normals, closest-point
+  projection (kernel Newton, no OCC).
+- Energy-minimising patch fill over a boundary ring
+  (`Surface.patch(..., fill="energy")`), with tangency strength and
+  optional G2 and adaptive re-fit.
+- Plane × surface sections with parameter tracks, batch level sets,
+  and node-exact diagrid weaving.
+- Writers: STEP (AP214 B-rep), OBJ, STL.
+- `geometrykit-core` on crates.io: the same kernels as a pure-Rust
+  dependency (no bindings, no unsafe code).
+
+Out of scope by design: B-rep booleans and tolerant topology (volumes
+are OCCT's domain); IFC serialisation lives in ifckit.
+
+## Development
+
+```bash
+python3 -m venv .venv && .venv/bin/pip install -e ".[dev]"
+.venv/bin/python -m pytest tests/ -q
+GEOMETRYKIT_ENGINE=npu .venv/bin/python -m pytest tests/ -q
+GEOMETRYKIT_ENGINE=rust .venv/bin/python -m pytest tests/ -q
+```
+
+The oracle tier checks the kernel against OCCT and stays local
+(`pythonocc-core` is conda-only; see AGENTS.md). Every suite train
+runs in both engine configurations before a commit lands.
+
+## Licensing
+
+LGPL-3.0-or-later (`COPYING.LESSER`, `COPYING`). Kernel code promoted
+from ifckit's geometry package carries a provenance header recording
+its origin.

geometrykit-0.6.0/README.md

@@ -0,0 +1,78 @@
+# geometrykit
+
+OCC-free NURBS geometry for the ifckit family: value types (`Vec`,
+`Plane`, `Line`, `Arc`, `Polyline`, `Path`, `Curve`, `Surface`), NURBS
+evaluation / tangents / normals / projection, energy-minimising patch
+fills with G1/G2 continuity options, plane × surface sections with
+pcurve tracks, and STEP/OBJ/STL writers. No OCCT, no compiled
+toolchain required to install.
+
+## Install
+
+```bash
+pip install geometrykit   # Python >= 3.9, incl. Rhino 8's CPython 3.9
+```
+
+Binary wheels (`cp39-abi3`) carry the compiled Rust core
+(`geometrykit._rust`) where a platform build exists, and the public
+API routes to it automatically. Platforms without a matching wheel get
+the pure-Python/numpy mirror instead: same API, same results, slower.
+`GEOMETRYKIT_ENGINE=npu` forces the mirror; the default prefers the
+accelerator when importable.
+
+## Quickstart
+
+```python
+from geometrykit import engine
+from geometrykit.geometry import Curve, Surface
+from geometrykit.geometry.primitives import Vec
+
+curves = [
+    Curve.from_tangents(start=Vec(0, 0, 2.4), tan_start=Vec(1, 0, 0),
+                        end=Vec(8, 0, 2.8), tan_end=Vec(1, 0, 0), scale=3.0),
+    Curve.from_tangents(start=Vec(8, 0, 2.8), tan_start=Vec(0, 1, 0),
+                        end=Vec(8, 6, 2.9), tan_end=Vec(0, 1, 0), scale=3.0),
+    Curve.from_tangents(start=Vec(0, 6, 3.2), tan_start=Vec(1, 0, 0),
+                        end=Vec(8, 6, 2.9), tan_end=Vec(1, 0, 0), scale=3.0),
+    Curve.from_tangents(start=Vec(0, 6, 3.2), tan_start=Vec(0, -1, 0),
+                        end=Vec(0, 0, 2.4), tan_end=Vec(0, -1, 0), scale=3.0),
+]
+surface = Surface.patch(curves, fill="energy", nu=16, nv=16, tangency=0.75)
+proj, (u, v) = surface.project(Vec(-1.0, -1.0, 3.0))
+print(engine.engine(), proj, (u, v))
+```
+
+## What is in here
+
+- NURBS evaluation, analytic tangents and normals, closest-point
+  projection (kernel Newton, no OCC).
+- Energy-minimising patch fill over a boundary ring
+  (`Surface.patch(..., fill="energy")`), with tangency strength and
+  optional G2 and adaptive re-fit.
+- Plane × surface sections with parameter tracks, batch level sets,
+  and node-exact diagrid weaving.
+- Writers: STEP (AP214 B-rep), OBJ, STL.
+- `geometrykit-core` on crates.io: the same kernels as a pure-Rust
+  dependency (no bindings, no unsafe code).
+
+Out of scope by design: B-rep booleans and tolerant topology (volumes
+are OCCT's domain); IFC serialisation lives in ifckit.
+
+## Development
+
+```bash
+python3 -m venv .venv && .venv/bin/pip install -e ".[dev]"
+.venv/bin/python -m pytest tests/ -q
+GEOMETRYKIT_ENGINE=npu .venv/bin/python -m pytest tests/ -q
+GEOMETRYKIT_ENGINE=rust .venv/bin/python -m pytest tests/ -q
+```
+
+The oracle tier checks the kernel against OCCT and stays local
+(`pythonocc-core` is conda-only; see AGENTS.md). Every suite train
+runs in both engine configurations before a commit lands.
+
+## Licensing
+
+LGPL-3.0-or-later (`COPYING.LESSER`, `COPYING`). Kernel code promoted
+from ifckit's geometry package carries a provenance header recording
+its origin.

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

@@ -12,7 +12,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "geometrykit"
-version = "0.5.0"
+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.0 → geometrykit-0.6.0}/python/geometrykit/__init__.py

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

{geometrykit-0.5.0 → 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.0 → 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.0 → 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.0 → 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