okgeometry-api 1.25.0 → 1.26.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okgeometry-api",
-  "version": "1.25.0",
+  "version": "1.26.1",
   "description": "Geometry engine API for AEC applications - NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
   "type": "module",
   "main": "dist/index.js",
@@ -35,7 +35,8 @@
     "smoke:geometry-boolean": "tsx scripts/smoke-geometry-boolean.ts",
     "smoke:curve-region": "tsx scripts/smoke-curve-region.ts",
     "smoke:sculpt": "tsx scripts/smoke-sculpt.ts",
-    "smoke:offset-chamfer": "tsx scripts/smoke-offset-chamfer.ts"
+    "smoke:offset-chamfer": "tsx scripts/smoke-offset-chamfer.ts",
+    "smoke:rebuild": "tsx scripts/smoke-rebuild.ts"
   },
   "keywords": [
     "geometry",

package/src/Brep.ts

@@ -509,6 +509,62 @@ export class Brep {
     return Brep.parseCurveList(buf);
   }
 
+  /**
+   * Rebuild every NURBS face surface of this Brep with the given degrees and
+   * control counts (Rhino-style Rebuild), keeping the topology (trims,
+   * pcurves, edges) intact. Each face surface is refit AT ITS ORIGINAL
+   * PARAMETERS over its original domain, so parameter-space references stay
+   * coherent within the reported deviation.
+   *
+   * Each face replacement is gated by `tolerance` (default 1e-4): a face
+   * whose fit misses tolerance keeps its exact original surface and is
+   * counted in `skippedFaces`. Pass `tolerance: 0` to accept every fit.
+   * Planar faces pass through untouched (`planarFaces`).
+   *
+   * Throws for invalid degree/count combinations or unparseable bodies.
+   */
+  rebuildSurfaces(options: {
+    degreeU?: number;
+    degreeV?: number;
+    countU: number;
+    countV: number;
+    tolerance?: number;
+  }): {
+    brep: Brep;
+    maxDeviation: number;
+    rebuiltFaces: number;
+    skippedFaces: number;
+    planarFaces: number;
+  } {
+    ensureInit();
+    const raw = wasm.brep_rebuild_surfaces(
+      this.json,
+      options.degreeU ?? 3,
+      options.degreeV ?? 3,
+      options.countU,
+      options.countV,
+      options.tolerance ?? 1e-4,
+    );
+    const parsed = JSON.parse(raw) as {
+      error?: string;
+      maxDeviation?: number;
+      rebuiltFaces?: number;
+      skippedFaces?: number;
+      planarFaces?: number;
+      brep?: unknown;
+    };
+    if (parsed.error || parsed.brep === undefined) {
+      throw new Error(`Brep.rebuildSurfaces() failed: ${parsed.error || "unknown error"}`);
+    }
+    return {
+      brep: Brep.fromJson(JSON.stringify(parsed.brep)),
+      maxDeviation: parsed.maxDeviation ?? 0,
+      rebuiltFaces: parsed.rebuiltFaces ?? 0,
+      skippedFaces: parsed.skippedFaces ?? 0,
+      planarFaces: parsed.planarFaces ?? 0,
+    };
+  }
+
   /** Parse [count, (bufLen, curveData…)·count] into NurbsCurves. */
   private static parseCurveList(buf: Float64Array): NurbsCurve[] {
     if (buf.length < 1) return [];

package/src/NurbsCurve.ts

@@ -591,6 +591,38 @@ export class NurbsCurve {
     return NurbsCurve.fromData(buf);
   }
 
+  /**
+   * Rebuild this curve with the given degree and control point count
+   * (Rhino-style Rebuild): a global least-squares refit with clean
+   * approximation knots and chord-length-ish parameterization over [0, 1].
+   * The result is always NON-RATIONAL; geometrically closed curves stay
+   * seamlessly closed (periodic basis, C^(degree-1) across the seam); open
+   * curves keep their exact end points.
+   *
+   * Returns the rebuilt curve together with the measured deviation from the
+   * original (max and mean over dense validation samples).
+   *
+   * Throws for invalid degree/count combinations (degree 1..11, pointCount
+   * >= degree + 1) or degenerate (zero-length) curves.
+   */
+  rebuild(
+    degree: number,
+    pointCount: number,
+  ): { curve: NurbsCurve; maxDeviation: number; avgDeviation: number } {
+    ensureInit();
+    const buf = wasm.nurbs_curve_rebuild(this.data, degree, pointCount);
+    if (buf.length < 4) {
+      throw new Error(
+        `NurbsCurve.rebuild() failed: ${wasm.geometry_last_error() || "unknown error"}`,
+      );
+    }
+    return {
+      maxDeviation: Number(buf[0]),
+      avgDeviation: Number(buf[1]),
+      curve: NurbsCurve.fromData(buf.subarray(2)),
+    };
+  }
+
   /**
    * Get internal WASM data buffer.
    * For advanced use cases requiring direct WASM interop.

package/src/NurbsSurface.ts

@@ -351,6 +351,47 @@ export class NurbsSurface implements Surface {
     return NurbsSurface.fromData(buf);
   }
 
+  /**
+   * Rebuild this surface with the given degrees and control point counts
+   * (Rhino-style Rebuild): a two-stage global least-squares refit with clean
+   * approximation knots and chord-length-ish parameterization over
+   * [0, 1] x [0, 1]. The result is always NON-RATIONAL; closed directions
+   * stay seamlessly closed (periodic basis); degenerate pole rows (spheres,
+   * cones of revolution) stay exactly degenerate; open boundaries keep their
+   * exact corner points.
+   *
+   * Returns the rebuilt surface together with the measured deviation from
+   * the original (max and mean over a dense validation grid).
+   *
+   * Throws for invalid degree/count combinations (degree 1..11, counts
+   * >= degree + 1, per-direction cap 512) or degenerate surfaces.
+   */
+  rebuild(options: {
+    degreeU: number;
+    degreeV: number;
+    countU: number;
+    countV: number;
+  }): { surface: NurbsSurface; maxDeviation: number; avgDeviation: number } {
+    ensureInit();
+    const buf = wasm.nurbs_surface_rebuild(
+      this.data,
+      options.degreeU,
+      options.degreeV,
+      options.countU,
+      options.countV,
+    );
+    if (buf.length < 6) {
+      throw new Error(
+        `NurbsSurface.rebuild() failed: ${wasm.geometry_last_error() || "unknown error"}`,
+      );
+    }
+    return {
+      maxDeviation: Number(buf[0]),
+      avgDeviation: Number(buf[1]),
+      surface: NurbsSurface.fromData(buf.subarray(2)),
+    };
+  }
+
   // ── Analytic queries ──
 
   /**