okgeometry-api 1.21.0 → 1.23.0

package/src/Brep.ts

@@ -485,6 +485,30 @@ export class Brep {
     );
   }
 
+  /**
+   * Wireframe of the whole BREP in ONE WASM crossing: per face, `uCount`
+   * curves running along u plus `vCount` along v, at evenly spaced INTERIOR
+   * normalized parameters (i+1)/(count+1), each clipped to that face's
+   * trimmed region. The body JSON is parsed once for the entire sweep, so
+   * this scales to large face counts where per-face
+   * {@link faceIsoCurvesTrimmedNormalized} calls would re-parse the body
+   * repeatedly. Boundary parameters are excluded (they coincide with the
+   * BREP's edges); faces that fail to evaluate are skipped atomically.
+   */
+  wireframeCurves(uCount: number, vCount: number): NurbsCurve[] {
+    ensureInit();
+    const buf = wasm.brep_wireframe_curves(this.json, uCount, vCount);
+    // An empty buffer (not even a zero count header) means the call failed
+    // outright, e.g. unparseable JSON — surface the reason instead of
+    // pretending the wireframe is empty.
+    if (buf.length < 1) {
+      throw new Error(
+        `Brep.wireframeCurves() failed: ${wasm.geometry_last_error() || "unknown error"}`,
+      );
+    }
+    return Brep.parseCurveList(buf);
+  }
+
   /** Parse [count, (bufLen, curveData…)·count] into NurbsCurves. */
   private static parseCurveList(buf: Float64Array): NurbsCurve[] {
     if (buf.length < 1) return [];

package/src/Mesh.ts

@@ -3809,6 +3809,43 @@ export class Mesh {
     return wasm.mesh_boundary_edge_segments(this._vertexCount, this._buffer);
   }
 
+  /**
+   * Chamfer feature edges of this closed solid. Each entry in `edges` is one
+   * picked segment `{ a, b }` on a feature edge; the kernel expands it to the
+   * full chain separating the same two smooth face groups (a straight box
+   * edge, or a whole tessellated rim loop from a single pick). `distance` is
+   * the setback along each adjacent face, Rhino-style. Convex edges cut a
+   * flat; concave edges fill the notch. The result is watertight.
+   *
+   * Throws for open meshes, smooth (non-feature) picks, or when the distance
+   * exceeds what the adjacent faces allow.
+   */
+  chamferEdges(
+    edges: Array<{ a: Point | Vec3; b: Point | Vec3 }>,
+    distance: number,
+  ): Mesh {
+    ensureInit();
+    if (edges.length === 0) {
+      throw new Error("Mesh.chamferEdges() requires at least one edge");
+    }
+    const edgeBuf = new Float64Array(edges.length * 6);
+    edges.forEach((edge, i) => {
+      edgeBuf[i * 6] = edge.a.x;
+      edgeBuf[i * 6 + 1] = edge.a.y;
+      edgeBuf[i * 6 + 2] = edge.a.z;
+      edgeBuf[i * 6 + 3] = edge.b.x;
+      edgeBuf[i * 6 + 4] = edge.b.y;
+      edgeBuf[i * 6 + 5] = edge.b.z;
+    });
+    const r = wasm.mesh_chamfer_edges(this._vertexCount, this._buffer, edgeBuf, distance);
+    if (!r.length) {
+      throw new Error(
+        `Mesh.chamferEdges() failed: ${wasm.geometry_last_error() || "unknown error"}`,
+      );
+    }
+    return Mesh.fromTrustedBuffer(r as Float64Array);
+  }
+
   /**
    * Geometry-preserving repair: weld coincident vertices, drop degenerate /
    * duplicate triangles, remove orphan vertices, make winding consistent +

package/src/NurbsCurve.ts

@@ -394,32 +394,9 @@ export class NurbsCurve {
     );
   }
 
-  /**
-   * Offset this curve by a distance.
-   * Note: NURBS offset is approximated by sampling and offsetting as polyline.
-   * @param distance - Offset distance
-   * @param normal - Reference normal for determining offset direction
-   * @param samples - Number of sample points (default 64)
-   * @param arcSamples - Number of samples per exact arc segment in the returned polyline(s)
-   * @param options - Offset options such as join style
-   * @returns Offset polyline approximation
-   */
-  offset(
-    distance: number,
-    normal?: Vec3,
-    samples = 64,
-    arcSamples = 32,
-    options: CurveOffsetOptions = {},
-  ): Polyline {
-    const results = this.offsetAll(distance, normal, samples, arcSamples, options);
-    if (results.length === 1) return results[0];
-    if (results.length === 0) {
-      throw new Error("NurbsCurve.offset() collapsed and produced no valid result polylines");
-    }
-    throw new Error(
-      `NurbsCurve.offset() produced ${results.length} result polylines. Use NurbsCurve.offsetAll() instead.`,
-    );
-  }
+  // NOTE: `offset()` (exact NURBS offset, kernel-refit to tolerance) lives
+  // further down next to `data`. The former sampled-polyline `offset()` was
+  // replaced by it; the sampled multi-result path remains as `offsetAll()`.
 
   /**
    * Offset this curve by a distance and return every sampled result polyline.
@@ -566,6 +543,38 @@ export class NurbsCurve {
     return NurbsCurve.fromData(buf);
   }
 
+  /**
+   * Offset this planar curve by `distance` within the plane with the given
+   * `normal`. Positive distance offsets toward `normal × tangent` (the same
+   * convention as Polyline/PolyCurve offsets). The result is refit to
+   * `tolerance` (default 1e-6) against the exact offset locus; rational
+   * curves (exact arcs) offset exactly. Closed curves stay closed.
+   *
+   * Throws for non-planar or kinked curves, or when the offset cannot reach
+   * tolerance (for example offsetting inward past the curvature radius).
+   */
+  offset(
+    distance: number,
+    normal: Vec3 = Vec3.Z,
+    options: { tolerance?: number } = {},
+  ): NurbsCurve {
+    ensureInit();
+    const buf = wasm.nurbs_curve_offset(
+      this.data,
+      distance,
+      normal.x,
+      normal.y,
+      normal.z,
+      options.tolerance ?? 1e-6,
+    );
+    if (buf.length < 2) {
+      throw new Error(
+        `NurbsCurve.offset() failed: ${wasm.geometry_last_error() || "unknown error"}`,
+      );
+    }
+    return NurbsCurve.fromData(buf);
+  }
+
   /**
    * Get internal WASM data buffer.
    * For advanced use cases requiring direct WASM interop.

package/src/NurbsSurface.ts

@@ -312,6 +312,26 @@ export class NurbsSurface implements Surface {
     return this._data;
   }
 
+  /**
+   * Offset this surface by `distance` along its oriented normal field,
+   * refit to `tolerance` (default 1e-4) against the exact offset. Rational
+   * surfaces (cylinders, spheres, revolves) offset exactly; closed seams
+   * stay closed and degenerate poles stay degenerate.
+   *
+   * Throws for creased surfaces or when the offset cannot reach tolerance
+   * (for example offsetting inward past the curvature radius).
+   */
+  offset(distance: number, options: { tolerance?: number } = {}): NurbsSurface {
+    ensureInit();
+    const buf = wasm.nurbs_surface_offset(this.data, distance, options.tolerance ?? 1e-4);
+    if (buf.length < 4) {
+      throw new Error(
+        `NurbsSurface.offset() failed: ${wasm.geometry_last_error() || "unknown error"}`,
+      );
+    }
+    return NurbsSurface.fromData(buf);
+  }
+
   // ── Analytic queries ──
 
   /**

package/src/Polyline.ts

@@ -240,6 +240,51 @@ export class Polyline {
     return PolyCurve.fromSegmentData(buf);
   }
 
+  /**
+   * Chamfer corners of this polyline with straight cuts of the given
+   * setback distance (clamped per corner to half the shorter adjacent
+   * segment). Closed polylines (duplicated end point) chamfer every corner
+   * including the seam and stay closed; open polylines never touch their
+   * endpoints. `options.corners` selects vertex indices to chamfer
+   * (indices into the unique point list, seam duplicate excluded).
+   */
+  chamfer(distance: number, options: { corners?: number[] } = {}): Polyline {
+    ensureInit();
+    const pts = this.points;
+    if (pts.length < 3) {
+      throw new Error("Polyline.chamfer() requires at least 3 points");
+    }
+    const first = pts[0];
+    const last = pts[pts.length - 1];
+    const closed =
+      pts.length >= 4 &&
+      Math.abs(first.x - last.x) < 1e-10 &&
+      Math.abs(first.y - last.y) < 1e-10 &&
+      Math.abs(first.z - last.z) < 1e-10;
+    const unique = closed ? pts.slice(0, -1) : pts;
+    const coords = new Float64Array(unique.length * 3);
+    unique.forEach((p, i) => {
+      coords[i * 3] = p.x;
+      coords[i * 3 + 1] = p.y;
+      coords[i * 3 + 2] = p.z;
+    });
+    const cornerBuf = new Float64Array(options.corners ?? []);
+    const buf = wasm.chamfer_polyline_corners(coords, closed, distance, cornerBuf);
+    if (buf.length < 6) {
+      throw new Error(
+        `Polyline.chamfer() failed: ${wasm.geometry_last_error() || "unknown error"}`,
+      );
+    }
+    const out: Point[] = [];
+    for (let i = 0; i + 2 < buf.length; i += 3) {
+      out.push(new Point(buf[i], buf[i + 1], buf[i + 2]));
+    }
+    if (closed && out.length > 0) {
+      out.push(out[0]);
+    }
+    return new Polyline(out);
+  }
+
   /**
    * Convert this polyline to a PolyCurve (line segments only).
    * @returns PolyCurve with Line segments connecting consecutive points