okgeometry-api 0.5.0 → 0.5.2

package/src/NurbsCurve.ts

@@ -0,0 +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;
+  }
+}

package/src/NurbsSurface.ts

@@ -0,0 +1,267 @@
+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 { Polygon } from "./Polygon.js";
+import { Line } from "./Line.js";
+import { Arc } from "./Arc.js";
+import { PolyCurve } from "./PolyCurve.js";
+import { NurbsCurve } from "./NurbsCurve.js";
+import type { LoftableCurve, RotationAxis } from "./types.js";
+import { parsePolylineBuffer as parsePolylineBuf } from "./BufferCodec.js";
+import * as wasm from "../wasm/okgeometrycore_bg.js";
+
+/**
+ * Non-Uniform Rational B-Spline (NURBS) surface backed by WASM.
+ * Tensor-product surface defined by a 2D grid of control points.
+ *
+ * WASM data format: [degree_u, degree_v, num_u, num_v, ...cp(flat)..., ...weights..., ...knots_u..., ...knots_v...]
+ */
+export class NurbsSurface {
+  private _data: Float64Array;
+
+  /**
+   * Create a new NURBS surface.
+   * @param degreeU - Polynomial degree in U direction
+   * @param degreeV - Polynomial degree in V direction
+   * @param controlPoints - 2D grid of control points [u][v]
+   * @param weights - 2D grid of weights corresponding to control points
+   * @param knotsU - Knot vector in U direction
+   * @param knotsV - Knot vector in V direction
+   */
+  constructor(
+    public readonly degreeU: number,
+    public readonly degreeV: number,
+    public readonly controlPoints: Point[][],
+    public readonly weights: number[][],
+    public readonly knotsU: number[],
+    public readonly knotsV: number[]
+  ) {
+    this._data = NurbsSurface.encode(degreeU, degreeV, controlPoints, weights, knotsU, knotsV);
+  }
+
+  /**
+   * Rotate this surface around an axis.
+   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
+   * @param angle - Rotation angle in radians
+   * @returns New rotated surface
+   */
+  rotate(axis: RotationAxis, angle: number): NurbsSurface {
+    return new NurbsSurface(
+      this.degreeU,
+      this.degreeV,
+      this.controlPoints.map(row => row.map(p => p.rotate(axis, angle))),
+      this.weights,
+      this.knotsU,
+      this.knotsV
+    );
+  }
+
+  /**
+   * Translate this surface by an offset vector.
+   * @param offset - Translation vector
+   * @returns New translated surface
+   */
+  translate(offset: Vec3): NurbsSurface {
+    const newCps = this.controlPoints.map(row => row.map(p => p.add(offset)));
+    return new NurbsSurface(
+      this.degreeU,
+      this.degreeV,
+      newCps,
+      this.weights,
+      this.knotsU,
+      this.knotsV
+    );
+  }
+
+  /**
+   * Evaluate a point on the surface at parameters (u, v).
+   * @param u - Parameter in U direction [0, 1]
+   * @param v - Parameter in V direction [0, 1]
+   * @returns Point on surface at (u, v)
+   */
+  evaluate(u: number, v: number): Point {
+    ensureInit();
+    const r = wasm.nurbs_surface_evaluate(this._data, u, v);
+    return new Point(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Tessellate this surface into a triangle mesh.
+   * @param uSegs - Number of segments in U direction
+   * @param vSegs - Number of segments in V direction
+   * @returns Mesh approximating the surface
+   */
+  tessellate(uSegs: number, vSegs: number): Mesh {
+    ensureInit();
+    const full = new Float64Array(this._data.length + 2);
+    full.set(this._data);
+    full[this._data.length] = uSegs;
+    full[this._data.length + 1] = vSegs;
+    return Mesh.fromBuffer(wasm.tessellate_nurbs_surface(full));
+  }
+
+  /**
+   * Find intersection curves with a plane.
+   * @param plane - Cutting plane
+   * @param tess - Tessellation resolution for intersection detection (default 20)
+   * @returns Array of polylines representing intersection curves
+   */
+  intersectPlane(plane: Plane, tess = 20): Polyline[] {
+    ensureInit();
+    const buf = wasm.nurbs_surface_plane_intersect(
+      this._data,
+      plane.normal.x, plane.normal.y, plane.normal.z,
+      plane.d,
+      tess
+    );
+    return parsePolylineBuf(buf).map(pts => new Polyline(pts));
+  }
+
+  /**
+   * Find intersection curves with another NURBS surface.
+   * @param other - Other surface to intersect with
+   * @param tess - Tessellation resolution for intersection detection (default 20)
+   * @returns Array of polylines representing intersection curves
+   */
+  intersectSurface(other: NurbsSurface, tess = 20): Polyline[] {
+    ensureInit();
+    const buf = wasm.nurbs_surface_surface_intersect(this._data, other._data, tess);
+    return parsePolylineBuf(buf).map(pts => new Polyline(pts));
+  }
+
+  /**
+   * Convert any supported curve type to a NurbsCurve.
+   * @param c - Curve to convert
+   * @returns NurbsCurve representation
+   */
+  private static toNurbs(c: LoftableCurve): NurbsCurve {
+    if (c instanceof NurbsCurve) return c;
+    if (c instanceof PolyCurve) return c.toNurbs();
+    if (c instanceof Polygon || c instanceof Polyline) return PolyCurve.byPoints((c as Polyline).points).toNurbs();
+    if (c instanceof Arc) return NurbsCurve.fromArc(c);
+    if (c instanceof Line) return NurbsCurve.fromLine(c);
+    throw new Error(`Unsupported curve type for loft`);
+  }
+
+  /**
+   * Loft a NURBS surface through multiple curves.
+   * Accepts NurbsCurve, PolyCurve, Polyline, Polygon, Arc, or Line.
+   * Automatically converts to NURBS and unifies knot vectors.
+   *
+   * @param curves - Array of curves to loft through (minimum 2)
+   * @param degreeV - Polynomial degree in the loft direction (default 3)
+   * @returns New NurbsSurface passing through all input curves
+   */
+  static loftCurves(curves: LoftableCurve[], degreeV = 3): NurbsSurface {
+    ensureInit();
+
+    // Step 0: Convert all curves to NurbsCurve
+    const nurbsCurves = curves.map(c => NurbsSurface.toNurbs(c));
+
+    // Step 1: Make curves compatible (unified knot vectors, same CP count)
+    let loftCurves = nurbsCurves;
+    if (nurbsCurves.length >= 2) {
+      const cpCounts = nurbsCurves.map(c => c.controlPoints.length);
+      const allSame = cpCounts.every(n => n === cpCounts[0]);
+      if (!allSame) {
+        const compatParts: number[] = [nurbsCurves.length];
+        for (const c of nurbsCurves) {
+          compatParts.push(c.degree, c.controlPoints.length);
+          for (const p of c.controlPoints) { compatParts.push(p.x, p.y, p.z); }
+          for (const w of c.weights) { compatParts.push(w); }
+          for (const k of c.knots) { compatParts.push(k); }
+        }
+        const compatBuf = wasm.make_nurbs_curves_compatible(new Float64Array(compatParts));
+        if (compatBuf.length > 0) {
+          const count = compatBuf[0];
+          const decoded: NurbsCurve[] = [];
+          let off = 1;
+          for (let i = 0; i < count; i++) {
+            const deg = compatBuf[off];
+            const n = compatBuf[off + 1];
+            const curveLen = 2 + n * 3 + n + (n + deg + 1);
+            decoded.push(NurbsCurve.fromData(compatBuf.slice(off, off + curveLen)));
+            off += curveLen;
+          }
+          loftCurves = decoded;
+        }
+      }
+    }
+
+    // Step 2: Encode for loft_nurbs_surface
+    const parts: number[] = [loftCurves.length, degreeV];
+    for (const c of loftCurves) {
+      const pts = c.controlPoints;
+      parts.push(c.degree, pts.length);
+      for (const p of pts) { parts.push(p.x, p.y, p.z); }
+      for (const w of c.weights) { parts.push(w); }
+      for (const k of c.knots) { parts.push(k); }
+    }
+    const buf = wasm.loft_nurbs_surface(new Float64Array(parts));
+    if (buf.length < 4) throw new Error("NurbsSurface loft failed");
+    const degU = buf[0], degV2 = buf[1], numU = buf[2], numV = buf[3];
+    const totalPts = numU * numV;
+    const expectedLen = 4 + totalPts * 3 + totalPts + (degU + numU + 1) + (degV2 + numV + 1);
+    if (buf.length < expectedLen) throw new Error("NurbsSurface loft: buffer too short");
+    let idx = 4;
+    const cp: Point[][] = [];
+    for (let u = 0; u < numU; u++) {
+      const row: Point[] = [];
+      for (let v = 0; v < numV; v++) {
+        row.push(new Point(buf[idx], buf[idx + 1], buf[idx + 2]));
+        idx += 3;
+      }
+      cp.push(row);
+    }
+    const weights: number[][] = [];
+    for (let u = 0; u < numU; u++) {
+      const row: number[] = [];
+      for (let v = 0; v < numV; v++) { row.push(buf[idx++]); }
+      weights.push(row);
+    }
+    const knotsULen = degU + numU + 1;
+    const knotsVLen = degV2 + numV + 1;
+    const knotsU = Array.from(buf.slice(idx, idx + knotsULen)); idx += knotsULen;
+    const knotsV = Array.from(buf.slice(idx, idx + knotsVLen));
+    return new NurbsSurface(degU, degV2, cp, weights, knotsU, knotsV);
+  }
+
+  /** Encode to WASM format */
+  private static encode(
+    degU: number,
+    degV: number,
+    controlPoints: Point[][],
+    weights: number[][],
+    knotsU: number[],
+    knotsV: number[]
+  ): Float64Array {
+    const numU = controlPoints.length;
+    const numV = controlPoints[0]?.length ?? 0;
+    const totalPts = numU * numV;
+    const data = new Float64Array(4 + totalPts * 3 + totalPts + knotsU.length + knotsV.length);
+    data[0] = degU;
+    data[1] = degV;
+    data[2] = numU;
+    data[3] = numV;
+    let idx = 4;
+    for (let u = 0; u < numU; u++) {
+      for (let v = 0; v < numV; v++) {
+        const p = controlPoints[u][v];
+        data[idx++] = p.x;
+        data[idx++] = p.y;
+        data[idx++] = p.z;
+      }
+    }
+    for (let u = 0; u < numU; u++) {
+      for (let v = 0; v < numV; v++) {
+        data[idx++] = weights[u][v];
+      }
+    }
+    for (const k of knotsU) data[idx++] = k;
+    for (const k of knotsV) data[idx++] = k;
+    return data;
+  }
+}

package/src/Plane.ts

@@ -0,0 +1,132 @@
+import { Point } from "./Point.js";
+import { Vec3 } from "./Vec3.js";
+
+export class Plane {
+  public readonly origin: Point;
+  public readonly normal: Vec3;
+  /** Optional X-axis direction in the plane (for consistent orientation) */
+  public readonly xAxis?: Vec3;
+
+  constructor(origin: Point, normal: Vec3, xAxis?: Vec3) {
+    this.origin = origin;
+    this.normal = normal.normalize();
+    // Store xAxis if provided (should be perpendicular to normal)
+    if (xAxis) {
+      // Project xAxis onto plane and normalize
+      const dot = xAxis.dot(this.normal);
+      const projected = new Vec3(
+        xAxis.x - this.normal.x * dot,
+        xAxis.y - this.normal.y * dot,
+        xAxis.z - this.normal.z * dot
+      );
+      const len = Math.sqrt(projected.x ** 2 + projected.y ** 2 + projected.z ** 2);
+      if (len > 1e-10) {
+        this.xAxis = new Vec3(projected.x / len, projected.y / len, projected.z / len);
+      }
+    }
+  }
+
+  /** Get the X-axis direction in the plane.
+   *  If not explicitly set, computes one using a heuristic. */
+  getXAxis(): Vec3 {
+    if (this.xAxis) return this.xAxis;
+    // Heuristic: cross normal with world X or Y
+    const n = this.normal;
+    let ref: Vec3;
+    if (Math.abs(n.x) > 0.9) {
+      ref = Vec3.Y;
+    } else {
+      ref = Vec3.X;
+    }
+    const cross = new Vec3(
+      n.y * ref.z - n.z * ref.y,
+      n.z * ref.x - n.x * ref.z,
+      n.x * ref.y - n.y * ref.x
+    );
+    const len = Math.sqrt(cross.x ** 2 + cross.y ** 2 + cross.z ** 2);
+    return new Vec3(cross.x / len, cross.y / len, cross.z / len);
+  }
+
+  /** Signed distance from point to plane (positive = same side as normal) */
+  distanceTo(point: Point): number {
+    return (
+      this.normal.x * (point.x - this.origin.x) +
+      this.normal.y * (point.y - this.origin.y) +
+      this.normal.z * (point.z - this.origin.z)
+    );
+  }
+
+  /** Project a point onto this plane (orthogonal to plane normal) */
+  projectPoint(point: Point): Point {
+    const d = this.distanceTo(point);
+    return new Point(
+      point.x - this.normal.x * d,
+      point.y - this.normal.y * d,
+      point.z - this.normal.z * d
+    );
+  }
+
+  /** Project a point onto this plane along a given direction (ray-plane intersection).
+   *  Falls back to orthogonal projection if direction is parallel to the plane. */
+  projectPointAlongDirection(point: Point, direction: Vec3): Point {
+    const denom = this.normal.dot(direction);
+    if (Math.abs(denom) < 1e-15) {
+      // Direction is parallel to the plane — fall back to orthogonal
+      return this.projectPoint(point);
+    }
+    const t = -(
+      this.normal.x * (point.x - this.origin.x) +
+      this.normal.y * (point.y - this.origin.y) +
+      this.normal.z * (point.z - this.origin.z)
+    ) / denom;
+    return new Point(
+      point.x + direction.x * t,
+      point.y + direction.y * t,
+      point.z + direction.z * t
+    );
+  }
+
+  /** Plane equation constant d where n·p = d */
+  get d(): number {
+    return this.normal.dot(this.origin.toVec3());
+  }
+
+  /** Bisector plane of two planes. Normal bisects the dihedral angle.
+   *  Origin is taken from planeA. */
+  static bisector(a: Plane, b: Plane): Plane {
+    const dot = a.normal.dot(b.normal);
+    const nb = dot < 0 ? b.normal.negate() : b.normal;
+    const bisectNormal = a.normal.add(nb).normalize();
+    return new Plane(a.origin, bisectNormal);
+  }
+
+  /**
+   * Compute the intersection point of three planes.
+   * Returns null if the system is degenerate (planes parallel or co-planar).
+   *
+   * Each plane is n·x = d. The solution uses Cramer's rule:
+   *   x = (d1(n2×n3) + d2(n3×n1) + d3(n1×n2)) / (n1·(n2×n3))
+   */
+  static intersect3(p1: Plane, p2: Plane, p3: Plane): Point | null {
+    const n2xn3 = p2.normal.cross(p3.normal);
+    const denom = p1.normal.dot(n2xn3);
+
+    if (Math.abs(denom) < 1e-10) return null;
+
+    const n3xn1 = p3.normal.cross(p1.normal);
+    const n1xn2 = p1.normal.cross(p2.normal);
+
+    const d1 = p1.d, d2 = p2.d, d3 = p3.d;
+    const inv = 1.0 / denom;
+
+    return new Point(
+      (d1 * n2xn3.x + d2 * n3xn1.x + d3 * n1xn2.x) * inv,
+      (d1 * n2xn3.y + d2 * n3xn1.y + d3 * n1xn2.y) * inv,
+      (d1 * n2xn3.z + d2 * n3xn1.z + d3 * n1xn2.z) * inv,
+    );
+  }
+
+  static readonly XY = new Plane(Point.ORIGIN, Vec3.Z);
+  static readonly XZ = new Plane(Point.ORIGIN, Vec3.Y);
+  static readonly YZ = new Plane(Point.ORIGIN, Vec3.X);
+}