okgeometry-api 1.2.1 → 1.4.0

package/src/NurbsCurve.ts

@@ -1,14 +1,14 @@
 import { ensureInit } from "./engine.js";
 import { Point } from "./Point.js";
-import { Vec3 } from "./Vec3.js";
-import { Plane } from "./Plane.js";
-import { Mesh } from "./Mesh.js";
-import { Polyline } from "./Polyline.js";
-import { PolyCurve } from "./PolyCurve.js";
-import type { Line } from "./Line.js";
-import type { Arc } from "./Arc.js";
-import type { CurveOffsetOptions, RotationAxis } from "./types.js";
-import * as wasm from "./wasm-bindings.js";
+import { Vec3 } from "./Vec3.js";
+import { Plane } from "./Plane.js";
+import { Mesh } from "./Mesh.js";
+import { Polyline } from "./Polyline.js";
+import { PolyCurve } from "./PolyCurve.js";
+import type { Line } from "./Line.js";
+import type { Arc } from "./Arc.js";
+import type { CurveOffsetOptions, RotationAxis } from "./types.js";
+import * as wasm from "./wasm-bindings.js";
 
 /**
  * Non-Uniform Rational B-Spline (NURBS) curve backed by WASM.
@@ -155,83 +155,129 @@ 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.`,
-    );
-  }
-
-  /**
-   * Offset this curve by a distance and return every sampled result polyline.
-   * 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 used to approximate the source curve
-   * @param arcSamples - Number of samples per exact arc segment in the returned polylines
-   * @param options - Offset options such as join style
-   * @returns Every valid offset polyline approximation
-   */
-  offsetAll(
-    distance: number,
-    normal?: Vec3,
-    samples = 64,
-    arcSamples = 32,
-    options: CurveOffsetOptions = {},
-  ): Polyline[] {
-    const pts = this.sample(samples);
-    const pl = new Polyline(pts);
-    return pl.offsetAll(distance, normal, arcSamples, options);
-  }
-
-  /**
-   * Thicken this curve into a closed PolyCurve.
-   * Note: this is approximated by sampling the NURBS curve into a polyline first.
-   *
-   * When `bothSides` is false, the sampled source curve forms one side of the
-   * result. When true, the distance is applied on each side of the sampled curve.
-   */
-  thicken(
-    distance: number,
-    bothSides = false,
-    normal?: Vec3,
-    samples = 64,
-    options: CurveOffsetOptions = {},
-  ): PolyCurve {
-    const pts = this.sample(samples);
-    return new Polyline(pts).thicken(distance, bothSides, normal, options);
-  }
-
-  /**
-   * Extrude this closed NURBS curve into a trusted solid suitable for booleans.
-   * @param direction - Extrusion direction and magnitude
-   * @param segments - Number of curve samples used for tessellation (default 64)
+  /**
+   * 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.`,
+    );
+  }
+
+  /**
+   * Offset this curve by a distance and return every sampled result polyline.
+   * 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 used to approximate the source curve
+   * @param arcSamples - Number of samples per exact arc segment in the returned polylines
+   * @param options - Offset options such as join style
+   * @returns Every valid offset polyline approximation
+   */
+  offsetAll(
+    distance: number,
+    normal?: Vec3,
+    samples = 64,
+    arcSamples = 32,
+    options: CurveOffsetOptions = {},
+  ): Polyline[] {
+    const pts = this.sample(samples);
+    const pl = new Polyline(pts);
+    return pl.offsetAll(distance, normal, arcSamples, options);
+  }
+
+  /**
+   * Thicken this curve into a closed PolyCurve.
+   * Note: this is approximated by sampling the NURBS curve into a polyline first.
+   *
+   * When `bothSides` is false, the sampled source curve forms one side of the
+   * result. When true, the distance is applied on each side of the sampled curve.
+   */
+  thicken(
+    distance: number,
+    bothSides = false,
+    normal?: Vec3,
+    samples = 64,
+    options: CurveOffsetOptions = {},
+  ): PolyCurve {
+    const pts = this.sample(samples);
+    return new Polyline(pts).thicken(distance, bothSides, normal, options);
+  }
+
+  /**
+   * Extrude this curve along a direction vector.
+   * Note: this is approximated by sampling the NURBS curve into a polyline
+   * first. Open curves produce an open sheet; closed curves an uncapped tube
+   * unless `caps` is true (see extrudeAsSolid for a boolean-ready solid).
+   * @param direction - Extrusion direction and magnitude
+   * @param segments - Number of segments along the extrusion (default 1)
+   * @param caps - Whether to cap the ends of a closed profile (default false)
+   * @param samples - Number of curve samples used for tessellation (default 64)
+   * @returns Mesh representing the extruded surface
+   */
+  extrude(direction: Vec3, segments = 1, caps = false, samples = 64): Mesh {
+    const pts = this.sample(samples);
+    return new Polyline(pts).extrude(direction, segments, caps);
+  }
+
+  /**
+   * Extrude this closed NURBS curve into a trusted solid suitable for booleans.
+   * @param direction - Extrusion direction and magnitude
+   * @param segments - Number of curve samples used for tessellation (default 64)
    * @returns Closed mesh solid ready for boolean operations
    */
   extrudeAsSolid(direction: Vec3, segments = 64): Mesh {
     return Mesh.extrudeCurveAsSolid(this, direction, segments);
   }
 
+  /**
+   * Build a NURBS curve from raw control points with kernel-managed knots and
+   * uniform weights.
+   *
+   * Open curves use a clamped uniform knot vector (curve interpolates the first
+   * and last control points). Closed curves are periodic (C^{degree-1}
+   * continuous loops); the first control point must NOT be repeated at the end.
+   *
+   * @param degree - Requested degree (clamped by the kernel to the valid range)
+   * @param controlPoints - Control points (min 2 open / 3 closed)
+   * @param closed - Build a periodic closed loop (default false)
+   * @returns New NurbsCurve instance
+   */
+  static fromPoints(degree: number, controlPoints: Point[], closed = false): NurbsCurve {
+    ensureInit();
+    const coords = new Float64Array(controlPoints.length * 3);
+    for (let i = 0; i < controlPoints.length; i++) {
+      coords[i * 3] = controlPoints[i].x;
+      coords[i * 3 + 1] = controlPoints[i].y;
+      coords[i * 3 + 2] = controlPoints[i].z;
+    }
+    const buf = wasm.build_nurbs_curve(degree, coords, closed);
+    if (buf.length < 2) {
+      throw new Error(
+        `NurbsCurve.fromPoints failed (degree ${degree}, ${controlPoints.length} points, closed=${closed})`,
+      );
+    }
+    return NurbsCurve.fromData(buf);
+  }
+
   /**
    * Decode a NurbsCurve from WASM flat buffer.
    * @param data - Buffer in format [degree, num_cp, xyz..., w..., k...]