okgeometry-api 1.1.6 → 1.1.7

package/src/NurbsCurve.ts

@@ -1,240 +1,240 @@
-import { ensureInit } from "./engine.js";
-import { Point } from "./Point.js";
-import { Vec3 } from "./Vec3.js";
-import { Plane } from "./Plane.js";
-import { Polyline } from "./Polyline.js";
-import type { Line } from "./Line.js";
-import type { Arc } from "./Arc.js";
-import type { RotationAxis } from "./types.js";
-import { parseIntersectionPoints } from "./BufferCodec.js";
-import * as wasm from "../wasm/okgeometrycore_bg.js";
-
-/**
- * Non-Uniform Rational B-Spline (NURBS) curve backed by WASM.
- * Provides exact representation for complex curves including conics.
- *
- * WASM data format: [degree, num_pts, x0,y0,z0, ..., w0,w1,..., k0,k1,...]
- */
-export class NurbsCurve {
-  private _data: Float64Array;
-
-  /**
-   * Create a new NURBS curve.
-   * @param degree - Polynomial degree (1 = linear, 2 = quadratic, 3 = cubic)
-   * @param controlPoints - Control points defining the curve shape
-   * @param weights - Rational weights for each control point (use 1 for non-rational)
-   * @param knots - Knot vector (length = num_points + degree + 1)
-   */
-  constructor(
-    public readonly degree: number,
-    public readonly controlPoints: Point[],
-    public readonly weights: number[],
-    public readonly knots: number[]
-  ) {
-    this._data = NurbsCurve.encode(degree, controlPoints, weights, knots);
-  }
-
-  /**
-   * Evaluate a point on the curve at normalized parameter t.
-   * @param t - Parameter in [0, 1] (0 = start, 1 = end)
-   * @returns Point on curve at parameter t
-   */
-  pointAt(t: number): Point {
-    ensureInit();
-    const r = wasm.evaluate_nurbs_curve_at(this._data, t);
-    return new Point(r[0], r[1], r[2]);
-  }
-
-  /**
-   * Sample the curve into evenly-spaced points.
-   * @param n - Number of points to generate
-   * @returns Array of n points along the curve
-   */
-  sample(n: number): Point[] {
-    ensureInit();
-    const buf = wasm.sample_nurbs_curve(this._data, n);
-    const pts: Point[] = [];
-    for (let i = 0; i < buf.length; i += 3) {
-      pts.push(new Point(buf[i], buf[i + 1], buf[i + 2]));
-    }
-    return pts;
-  }
-
-  /**
-   * Find intersection points with a plane.
-   * @param plane - Cutting plane
-   * @returns Array of intersection points
-   */
-  intersectPlane(plane: Plane): Point[] {
-    ensureInit();
-    const buf = wasm.nurbs_curve_plane_intersect(
-      this._data,
-      plane.normal.x, plane.normal.y, plane.normal.z,
-      plane.d
-    );
-    if (buf.length === 0) return [];
-    const numPts = buf[0];
-    const pts: Point[] = [];
-    for (let i = 0; i < numPts; i++) {
-      const off = 1 + i * 3;
-      pts.push(new Point(buf[off], buf[off + 1], buf[off + 2]));
-    }
-    return pts;
-  }
-
-  /**
-   * Find intersection points with another NURBS curve.
-   * @param other - Other curve to intersect with
-   * @returns Array of intersection points
-   */
-  intersectCurve(other: NurbsCurve): Point[] {
-    ensureInit();
-    const buf = wasm.nurbs_curve_curve_intersect(this._data, other._data);
-    if (buf.length === 0) return [];
-    const numPts = buf[0];
-    const pts: Point[] = [];
-    for (let i = 0; i < numPts; i++) {
-      const off = 1 + i * 3;
-      pts.push(new Point(buf[off], buf[off + 1], buf[off + 2]));
-    }
-    return pts;
-  }
-
-  /**
-   * Translate this curve by an offset vector.
-   * @param offset - Translation vector
-   * @returns New translated curve
-   */
-  translate(offset: Vec3): NurbsCurve {
-    return new NurbsCurve(
-      this.degree,
-      this.controlPoints.map(p => p.add(offset)),
-      this.weights,
-      this.knots
-    );
-  }
-
-  /**
-   * Rotate this curve around an axis.
-   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
-   * @param angle - Rotation angle in radians
-   * @returns New rotated curve
-   */
-  rotate(axis: RotationAxis, angle: number): NurbsCurve {
-    return new NurbsCurve(
-      this.degree,
-      this.controlPoints.map(p => p.rotate(axis, angle)),
-      this.weights,
-      this.knots
-    );
-  }
-
-  /**
-   * Project this curve onto a plane.
-   * @param plane - Target plane
-   * @param direction - Optional projection direction (default: perpendicular to plane)
-   * @returns New projected curve
-   */
-  projectOntoPlane(plane: Plane, direction?: Vec3): NurbsCurve {
-    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
-    return new NurbsCurve(
-      this.degree,
-      this.controlPoints.map(proj),
-      this.weights,
-      this.knots
-    );
-  }
-
-  /**
-   * 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)
-   * @returns Offset polyline approximation
-   */
-  offset(distance: number, normal?: Vec3, samples = 64): Polyline {
-    const pts = this.sample(samples);
-    const pl = new Polyline(pts);
-    return pl.offset(distance, normal);
-  }
-
-  /**
-   * Decode a NurbsCurve from WASM flat buffer.
-   * @param data - Buffer in format [degree, num_cp, xyz..., w..., k...]
-   * @returns New NurbsCurve instance
-   */
-  static fromData(data: Float64Array | number[]): NurbsCurve {
-    const d = data instanceof Float64Array ? data : new Float64Array(data);
-    const degree = d[0];
-    const n = d[1];
-    let idx = 2;
-    const pts: Point[] = [];
-    for (let i = 0; i < n; i++) {
-      pts.push(new Point(d[idx], d[idx + 1], d[idx + 2]));
-      idx += 3;
-    }
-    const weights = Array.from(d.slice(idx, idx + n)); idx += n;
-    const numKnots = n + degree + 1;
-    const knots = Array.from(d.slice(idx, idx + numKnots));
-    return new NurbsCurve(degree, pts, weights, knots);
-  }
-
-  /**
-   * Create exact degree-1 NURBS from a Line.
-   * @param line - Source line
-   * @returns Degree-1 NURBS representing the line exactly
-   */
-  static fromLine(line: Line): NurbsCurve {
-    return new NurbsCurve(1, [line.start, line.end], [1, 1], [0, 0, 1, 1]);
-  }
-
-  /**
-   * Create exact degree-2 rational NURBS from an Arc.
-   * Uses WASM circle_arc for exact conic representation.
-   * @param arc - Source arc
-   * @returns Degree-2 rational NURBS representing the arc exactly
-   */
-  static fromArc(arc: Arc): NurbsCurve {
-    ensureInit();
-    const buf = wasm.polycurve_to_nurbs(new Float64Array([
-      1, // 1 segment
-      1, // type = Arc
-      arc.center.x, arc.center.y, arc.center.z,
-      arc.normal.x, arc.normal.y, arc.normal.z,
-      arc.radius, arc.startAngle, arc.endAngle
-    ]));
-    if (buf.length < 2) throw new Error("Failed to convert Arc to NURBS");
-    return NurbsCurve.fromData(buf);
-  }
-
-  /**
-   * Get internal WASM data buffer.
-   * For advanced use cases requiring direct WASM interop.
-   */
-  get data(): Float64Array {
-    return this._data;
-  }
-
-  /** Encode to WASM format */
-  private static encode(
-    degree: number,
-    controlPoints: Point[],
-    weights: number[],
-    knots: number[]
-  ): Float64Array {
-    const n = controlPoints.length;
-    const data = new Float64Array(2 + n * 3 + weights.length + knots.length);
-    data[0] = degree;
-    data[1] = n;
-    let idx = 2;
-    for (const p of controlPoints) {
-      data[idx++] = p.x;
-      data[idx++] = p.y;
-      data[idx++] = p.z;
-    }
-    for (const w of weights) data[idx++] = w;
-    for (const k of knots) data[idx++] = k;
-    return data;
-  }
-}
+import { ensureInit } from "./engine.js";
+import { Point } from "./Point.js";
+import { Vec3 } from "./Vec3.js";
+import { Plane } from "./Plane.js";
+import { Polyline } from "./Polyline.js";
+import type { Line } from "./Line.js";
+import type { Arc } from "./Arc.js";
+import type { RotationAxis } from "./types.js";
+import { parseIntersectionPoints } from "./BufferCodec.js";
+import * as wasm from "../wasm/okgeometrycore.js";
+
+/**
+ * Non-Uniform Rational B-Spline (NURBS) curve backed by WASM.
+ * Provides exact representation for complex curves including conics.
+ *
+ * WASM data format: [degree, num_pts, x0,y0,z0, ..., w0,w1,..., k0,k1,...]
+ */
+export class NurbsCurve {
+  private _data: Float64Array;
+
+  /**
+   * Create a new NURBS curve.
+   * @param degree - Polynomial degree (1 = linear, 2 = quadratic, 3 = cubic)
+   * @param controlPoints - Control points defining the curve shape
+   * @param weights - Rational weights for each control point (use 1 for non-rational)
+   * @param knots - Knot vector (length = num_points + degree + 1)
+   */
+  constructor(
+    public readonly degree: number,
+    public readonly controlPoints: Point[],
+    public readonly weights: number[],
+    public readonly knots: number[]
+  ) {
+    this._data = NurbsCurve.encode(degree, controlPoints, weights, knots);
+  }
+
+  /**
+   * Evaluate a point on the curve at normalized parameter t.
+   * @param t - Parameter in [0, 1] (0 = start, 1 = end)
+   * @returns Point on curve at parameter t
+   */
+  pointAt(t: number): Point {
+    ensureInit();
+    const r = wasm.evaluate_nurbs_curve_at(this._data, t);
+    return new Point(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Sample the curve into evenly-spaced points.
+   * @param n - Number of points to generate
+   * @returns Array of n points along the curve
+   */
+  sample(n: number): Point[] {
+    ensureInit();
+    const buf = wasm.sample_nurbs_curve(this._data, n);
+    const pts: Point[] = [];
+    for (let i = 0; i < buf.length; i += 3) {
+      pts.push(new Point(buf[i], buf[i + 1], buf[i + 2]));
+    }
+    return pts;
+  }
+
+  /**
+   * Find intersection points with a plane.
+   * @param plane - Cutting plane
+   * @returns Array of intersection points
+   */
+  intersectPlane(plane: Plane): Point[] {
+    ensureInit();
+    const buf = wasm.nurbs_curve_plane_intersect(
+      this._data,
+      plane.normal.x, plane.normal.y, plane.normal.z,
+      plane.d
+    );
+    if (buf.length === 0) return [];
+    const numPts = buf[0];
+    const pts: Point[] = [];
+    for (let i = 0; i < numPts; i++) {
+      const off = 1 + i * 3;
+      pts.push(new Point(buf[off], buf[off + 1], buf[off + 2]));
+    }
+    return pts;
+  }
+
+  /**
+   * Find intersection points with another NURBS curve.
+   * @param other - Other curve to intersect with
+   * @returns Array of intersection points
+   */
+  intersectCurve(other: NurbsCurve): Point[] {
+    ensureInit();
+    const buf = wasm.nurbs_curve_curve_intersect(this._data, other._data);
+    if (buf.length === 0) return [];
+    const numPts = buf[0];
+    const pts: Point[] = [];
+    for (let i = 0; i < numPts; i++) {
+      const off = 1 + i * 3;
+      pts.push(new Point(buf[off], buf[off + 1], buf[off + 2]));
+    }
+    return pts;
+  }
+
+  /**
+   * Translate this curve by an offset vector.
+   * @param offset - Translation vector
+   * @returns New translated curve
+   */
+  translate(offset: Vec3): NurbsCurve {
+    return new NurbsCurve(
+      this.degree,
+      this.controlPoints.map(p => p.add(offset)),
+      this.weights,
+      this.knots
+    );
+  }
+
+  /**
+   * Rotate this curve around an axis.
+   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
+   * @param angle - Rotation angle in radians
+   * @returns New rotated curve
+   */
+  rotate(axis: RotationAxis, angle: number): NurbsCurve {
+    return new NurbsCurve(
+      this.degree,
+      this.controlPoints.map(p => p.rotate(axis, angle)),
+      this.weights,
+      this.knots
+    );
+  }
+
+  /**
+   * Project this curve onto a plane.
+   * @param plane - Target plane
+   * @param direction - Optional projection direction (default: perpendicular to plane)
+   * @returns New projected curve
+   */
+  projectOntoPlane(plane: Plane, direction?: Vec3): NurbsCurve {
+    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
+    return new NurbsCurve(
+      this.degree,
+      this.controlPoints.map(proj),
+      this.weights,
+      this.knots
+    );
+  }
+
+  /**
+   * 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)
+   * @returns Offset polyline approximation
+   */
+  offset(distance: number, normal?: Vec3, samples = 64): Polyline {
+    const pts = this.sample(samples);
+    const pl = new Polyline(pts);
+    return pl.offset(distance, normal);
+  }
+
+  /**
+   * Decode a NurbsCurve from WASM flat buffer.
+   * @param data - Buffer in format [degree, num_cp, xyz..., w..., k...]
+   * @returns New NurbsCurve instance
+   */
+  static fromData(data: Float64Array | number[]): NurbsCurve {
+    const d = data instanceof Float64Array ? data : new Float64Array(data);
+    const degree = d[0];
+    const n = d[1];
+    let idx = 2;
+    const pts: Point[] = [];
+    for (let i = 0; i < n; i++) {
+      pts.push(new Point(d[idx], d[idx + 1], d[idx + 2]));
+      idx += 3;
+    }
+    const weights = Array.from(d.slice(idx, idx + n)); idx += n;
+    const numKnots = n + degree + 1;
+    const knots = Array.from(d.slice(idx, idx + numKnots));
+    return new NurbsCurve(degree, pts, weights, knots);
+  }
+
+  /**
+   * Create exact degree-1 NURBS from a Line.
+   * @param line - Source line
+   * @returns Degree-1 NURBS representing the line exactly
+   */
+  static fromLine(line: Line): NurbsCurve {
+    return new NurbsCurve(1, [line.start, line.end], [1, 1], [0, 0, 1, 1]);
+  }
+
+  /**
+   * Create exact degree-2 rational NURBS from an Arc.
+   * Uses WASM circle_arc for exact conic representation.
+   * @param arc - Source arc
+   * @returns Degree-2 rational NURBS representing the arc exactly
+   */
+  static fromArc(arc: Arc): NurbsCurve {
+    ensureInit();
+    const buf = wasm.polycurve_to_nurbs(new Float64Array([
+      1, // 1 segment
+      1, // type = Arc
+      arc.center.x, arc.center.y, arc.center.z,
+      arc.normal.x, arc.normal.y, arc.normal.z,
+      arc.radius, arc.startAngle, arc.endAngle
+    ]));
+    if (buf.length < 2) throw new Error("Failed to convert Arc to NURBS");
+    return NurbsCurve.fromData(buf);
+  }
+
+  /**
+   * Get internal WASM data buffer.
+   * For advanced use cases requiring direct WASM interop.
+   */
+  get data(): Float64Array {
+    return this._data;
+  }
+
+  /** Encode to WASM format */
+  private static encode(
+    degree: number,
+    controlPoints: Point[],
+    weights: number[],
+    knots: number[]
+  ): Float64Array {
+    const n = controlPoints.length;
+    const data = new Float64Array(2 + n * 3 + weights.length + knots.length);
+    data[0] = degree;
+    data[1] = n;
+    let idx = 2;
+    for (const p of controlPoints) {
+      data[idx++] = p.x;
+      data[idx++] = p.y;
+      data[idx++] = p.z;
+    }
+    for (const w of weights) data[idx++] = w;
+    for (const k of knots) data[idx++] = k;
+    return data;
+  }
+}