okgeometry-api 1.22.0 → 1.24.0

package/package.json

@@ -1,60 +1,60 @@
-{
-  "name": "okgeometry-api",
-  "version": "1.22.0",
-  "description": "Geometry engine API for AEC applications - NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist/",
-    "src/"
-  ],
-  "scripts": {
-    "build:wasm": "node -e \"require('fs').rmSync('wasm',{recursive:true,force:true})\" && cd .. && wasm-pack build --target web --out-dir okgeometry-api/wasm",
-    "sync:wasm-bindings": "node scripts/sync-wasm-bindings.mjs",
-    "inline-wasm": "tsx scripts/inline-wasm.ts",
-    "build": "npm run build:wasm && npm run sync:wasm-bindings && npm run inline-wasm && tsc",
-    "bench:boolean-heavy": "npm run build && tsx scripts/bench-boolean-heavy.ts",
-    "bench:boolean-ab": "npm run build && tsx scripts/bench-boolean-ab.ts",
-    "bench:boolean-batch": "npm run build && tsx scripts/bench-boolean-batch.ts",
-    "bench:boolean-matrix": "tsx scripts/bench-boolean-matrix.ts",
-    "smoke:brep-boolean": "tsx scripts/smoke-brep-boolean.ts",
-    "prepublishOnly": "npm run build",
-    "smoke:brep-parametric": "tsx scripts/smoke-brep-parametric.ts",
-    "smoke:brep-from-mesh": "tsx scripts/smoke-brep-from-mesh.ts",
-    "smoke:brep-faces": "tsx scripts/smoke-brep-faces.ts",
-    "smoke:curve-intersections": "tsx scripts/smoke-curve-intersections.ts",
-    "smoke:brep-intersections": "tsx scripts/smoke-brep-intersections.ts",
-    "smoke:brep-sheet-boolean": "tsx scripts/smoke-brep-sheet-boolean.ts",
-    "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"
-  },
-  "keywords": [
-    "geometry",
-    "wasm",
-    "nurbs",
-    "mesh",
-    "boolean",
-    "cad",
-    "aec",
-    "3d"
-  ],
-  "author": "Mostafa El Ayoubi",
-  "license": "Proprietary License",
-  "repository": {
-    "type": "git",
-    "url": "https://www.orkestra.online"
-  },
-  "devDependencies": {
-    "tsx": "^4.7.0",
-    "typescript": "^5.4.0"
-  }
-}
+{
+  "name": "okgeometry-api",
+  "version": "1.24.0",
+  "description": "Geometry engine API for AEC applications - NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "src/"
+  ],
+  "scripts": {
+    "build:wasm": "node -e \"require('fs').rmSync('wasm',{recursive:true,force:true})\" && cd .. && wasm-pack build --target web --out-dir okgeometry-api/wasm",
+    "sync:wasm-bindings": "node scripts/sync-wasm-bindings.mjs",
+    "inline-wasm": "tsx scripts/inline-wasm.ts",
+    "build": "npm run build:wasm && npm run sync:wasm-bindings && npm run inline-wasm && tsc",
+    "bench:boolean-heavy": "npm run build && tsx scripts/bench-boolean-heavy.ts",
+    "bench:boolean-ab": "npm run build && tsx scripts/bench-boolean-ab.ts",
+    "bench:boolean-batch": "npm run build && tsx scripts/bench-boolean-batch.ts",
+    "bench:boolean-matrix": "tsx scripts/bench-boolean-matrix.ts",
+    "smoke:brep-boolean": "tsx scripts/smoke-brep-boolean.ts",
+    "prepublishOnly": "npm run build",
+    "smoke:brep-parametric": "tsx scripts/smoke-brep-parametric.ts",
+    "smoke:brep-from-mesh": "tsx scripts/smoke-brep-from-mesh.ts",
+    "smoke:brep-faces": "tsx scripts/smoke-brep-faces.ts",
+    "smoke:curve-intersections": "tsx scripts/smoke-curve-intersections.ts",
+    "smoke:brep-intersections": "tsx scripts/smoke-brep-intersections.ts",
+    "smoke:brep-sheet-boolean": "tsx scripts/smoke-brep-sheet-boolean.ts",
+    "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"
+  },
+  "keywords": [
+    "geometry",
+    "wasm",
+    "nurbs",
+    "mesh",
+    "boolean",
+    "cad",
+    "aec",
+    "3d"
+  ],
+  "author": "Mostafa El Ayoubi",
+  "license": "Proprietary License",
+  "repository": {
+    "type": "git",
+    "url": "https://www.orkestra.online"
+  },
+  "devDependencies": {
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.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/Line.ts

@@ -1,12 +1,12 @@
-import { ensureInit } from "./engine.js";
-import { Point } from "./Point.js";
-import { Vec3 } from "./Vec3.js";
-import { Mesh } from "./Mesh.js";
-import { PolyCurve } from "./PolyCurve.js";
-import { Polyline } from "./Polyline.js";
-import type { Plane } from "./Plane.js";
-import type { CurveOffsetOptions, RotationAxis } from "./types.js";
-import * as wasm from "./wasm-bindings.js";
+import { ensureInit } from "./engine.js";
+import { Point } from "./Point.js";
+import { Vec3 } from "./Vec3.js";
+import { Mesh } from "./Mesh.js";
+import { PolyCurve } from "./PolyCurve.js";
+import { Polyline } from "./Polyline.js";
+import type { Plane } from "./Plane.js";
+import type { CurveOffsetOptions, RotationAxis } from "./types.js";
+import * as wasm from "./wasm-bindings.js";
 
 /**
  * Immutable line segment defined by start and end points.
@@ -86,6 +86,15 @@ export class Line {
     return new Line(this.start.add(offset), this.end.add(offset));
   }
 
+  /**
+   * Apply a row-major 4x4 matrix to both endpoints.
+   * @param matrix - Row-major 4x4 matrix (16 entries)
+   * @returns New transformed line
+   */
+  applyMatrix(matrix: number[] | Float64Array): Line {
+    return new Line(this.start.applyMatrix(matrix), this.end.applyMatrix(matrix));
+  }
+
   /**
    * Rotate this line around an axis.
    * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
@@ -102,40 +111,40 @@ export class Line {
    * @param normal - Reference normal for determining offset direction (default Z axis)
    * @returns New offset line
    */
-  offset(distance: number, normal: Vec3 = Vec3.Z): Line {
-    ensureInit();
-    const r = wasm.line_offset(
-      this.start.x, this.start.y, this.start.z,
-      this.end.x, this.end.y, this.end.z,
+  offset(distance: number, normal: Vec3 = Vec3.Z): Line {
+    ensureInit();
+    const r = wasm.line_offset(
+      this.start.x, this.start.y, this.start.z,
+      this.end.x, this.end.y, this.end.z,
       distance,
       normal.x, normal.y, normal.z,
     );
     return new Line(
       new Point(r[0], r[1], r[2]),
-      new Point(r[3], r[4], r[5]),
-    );
-  }
-
-  /**
-   * Thicken this line into a closed PolyCurve suitable for extrusion.
-   * When `bothSides` is false, the source line forms one side of the result.
-   * When true, the thickness is added on each side of the line.
-   *
-   * If `normal` is omitted, the kernel will infer a stable fallback plane.
-   */
-  thicken(
-    distance: number,
-    bothSides = false,
-    normal?: Vec3,
-    options: CurveOffsetOptions = {},
-  ): PolyCurve {
-    return new Polyline([this.start, this.end]).thicken(distance, bothSides, normal, options);
-  }
-
-  /**
-   * Project this line onto a plane.
-   * @param plane - Target plane
-   * @param direction - Optional projection direction (default: perpendicular to plane)
+      new Point(r[3], r[4], r[5]),
+    );
+  }
+
+  /**
+   * Thicken this line into a closed PolyCurve suitable for extrusion.
+   * When `bothSides` is false, the source line forms one side of the result.
+   * When true, the thickness is added on each side of the line.
+   *
+   * If `normal` is omitted, the kernel will infer a stable fallback plane.
+   */
+  thicken(
+    distance: number,
+    bothSides = false,
+    normal?: Vec3,
+    options: CurveOffsetOptions = {},
+  ): PolyCurve {
+    return new Polyline([this.start, this.end]).thicken(distance, bothSides, normal, options);
+  }
+
+  /**
+   * Project this line onto a plane.
+   * @param plane - Target plane
+   * @param direction - Optional projection direction (default: perpendicular to plane)
    * @returns New projected line
    */
   projectOntoPlane(plane: Plane, direction?: Vec3): Line {

package/src/NurbsCurve.ts

@@ -363,6 +363,22 @@ export class NurbsCurve {
     );
   }
 
+  /**
+   * Apply a row-major 4x4 AFFINE matrix to this curve. NURBS are invariant
+   * under affine maps of their control points, so rigid transforms, scaling
+   * (uniform or not) and shear are EXACT — weights and knots are unchanged.
+   * @param matrix - Row-major 4x4 matrix (16 entries)
+   * @returns New transformed curve
+   */
+  applyMatrix(matrix: number[] | Float64Array): NurbsCurve {
+    return new NurbsCurve(
+      this.degree,
+      this.controlPoints.map(p => p.applyMatrix(matrix)),
+      this.weights,
+      this.knots
+    );
+  }
+
   /**
    * Rotate this curve around an axis.
    * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)

package/src/NurbsSurface.ts

@@ -81,6 +81,25 @@ export class NurbsSurface implements Surface {
     );
   }
 
+  /**
+   * Apply a row-major 4x4 AFFINE matrix to this surface. NURBS are invariant
+   * under affine maps of their control net, so rigid transforms, scaling
+   * (uniform or not) and shear are EXACT — weights and knots are unchanged.
+   * @param matrix - Row-major 4x4 matrix (16 entries)
+   * @returns New transformed surface
+   */
+  applyMatrix(matrix: number[] | Float64Array): NurbsSurface {
+    const newCps = this.controlPoints.map(row => row.map(p => p.applyMatrix(matrix)));
+    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]

package/src/Point.ts

@@ -1,145 +1,161 @@
-import { Vec3 } from "./Vec3.js";
-import type { Plane } from "./Plane.js";
-import type { RotationAxis } from "./types.js";
-
-/**
- * Immutable 3D point for representing positions in space.
- * All operations return new Point instances.
- */
-export class Point {
-  constructor(
-    public readonly x: number,
-    public readonly y: number,
-    public readonly z: number
-  ) {}
-
-  /**
-   * Compute the distance to another point.
-   * @param other - Target point
-   * @returns Euclidean distance between points
-   */
-  distanceTo(other: Point): number {
-    const dx = this.x - other.x;
-    const dy = this.y - other.y;
-    const dz = this.z - other.z;
-    return Math.sqrt(dx * dx + dy * dy + dz * dz);
-  }
-
-  /**
-   * Convert this point to a vector (from origin).
-   * @returns Vec3 with same coordinates
-   */
-  toVec3(): Vec3 {
-    return new Vec3(this.x, this.y, this.z);
-  }
-
-  /**
-   * Add a vector to this point.
-   * @param v - Vector to add
-   * @returns New point offset by vector
-   */
-  add(v: Vec3): Point {
-    return new Point(this.x + v.x, this.y + v.y, this.z + v.z);
-  }
-
-  /**
-   * Translate this point by an offset vector.
-   * Alias for add().
-   * @param offset - Translation vector
-   * @returns New translated point
-   */
-  translate(offset: Vec3): Point {
-    return this.add(offset);
-  }
-
-  /**
-   * Rotate around an axis by angle in radians using Rodrigues' formula.
-   * @param axis - Vec3 (rotation around origin) or Line (rotation around arbitrary axis)
-   * @param angle - Rotation angle in radians
-   * @returns Rotated point
-   */
-  rotate(axis: RotationAxis, angle: number): Point {
-    if ('start' in axis && 'end' in axis) {
-      const dir = new Vec3(axis.end.x - axis.start.x, axis.end.y - axis.start.y, axis.end.z - axis.start.z);
-      const shifted = new Point(this.x - axis.start.x, this.y - axis.start.y, this.z - axis.start.z);
-      const rotated = shifted.rotate(dir, angle);
-      return new Point(rotated.x + axis.start.x, rotated.y + axis.start.y, rotated.z + axis.start.z);
-    }
-    const len = Math.sqrt(axis.x * axis.x + axis.y * axis.y + axis.z * axis.z);
-    if (len < 1e-15) return this.clone();
-    const k = { x: axis.x / len, y: axis.y / len, z: axis.z / len };
-    const cos = Math.cos(angle);
-    const sin = Math.sin(angle);
-    const dot = k.x * this.x + k.y * this.y + k.z * this.z;
-    const cx = k.y * this.z - k.z * this.y;
-    const cy = k.z * this.x - k.x * this.z;
-    const cz = k.x * this.y - k.y * this.x;
-    return new Point(
-      this.x * cos + cx * sin + k.x * dot * (1 - cos),
-      this.y * cos + cy * sin + k.y * dot * (1 - cos),
-      this.z * cos + cz * sin + k.z * dot * (1 - cos),
-    );
-  }
-
-  /**
-   * Project this point onto a plane.
-   * @param plane - Target plane
-   * @param direction - Optional projection direction (default: perpendicular to plane)
-   * @returns Projected point on plane
-   */
-  projectOntoPlane(plane: Plane, direction?: Vec3): Point {
-    return direction ? plane.projectPointAlongDirection(this, direction) : plane.projectPoint(this);
-  }
-
-  /**
-   * Get the vector from another point to this point.
-   * @param other - Origin point
-   * @returns Vector from other to this
-   */
-  sub(other: Point): Vec3 {
-    return new Vec3(this.x - other.x, this.y - other.y, this.z - other.z);
-  }
-
-  /**
-   * Create a copy of this point.
-   * @returns New point with same coordinates
-   */
-  clone(): Point {
-    return new Point(this.x, this.y, this.z);
-  }
-
-  /**
-   * Check equality with another point within tolerance.
-   * @param other - Point to compare
-   * @param eps - Tolerance (default 1e-10)
-   * @returns True if points are approximately equal
-   */
-  equals(other: Point, eps = 1e-10): boolean {
-    return (
-      Math.abs(this.x - other.x) < eps &&
-      Math.abs(this.y - other.y) < eps &&
-      Math.abs(this.z - other.z) < eps
-    );
-  }
-
-  /**
-   * Convert to array format.
-   * @returns Tuple [x, y, z]
-   */
-  toArray(): [number, number, number] {
-    return [this.x, this.y, this.z];
-  }
-
-  /**
-   * Create a Point from a plain object or JSON.
-   * @param json - Object with x, y, z properties
-   * @returns New Point instance
-   */
-  static fromJSON(json: any): Point {
-    if (json instanceof Point) return json;
-    return new Point(json.x ?? 0, json.y ?? 0, json.z ?? 0);
-  }
-
-  /** Origin point (0, 0, 0) */
-  static readonly ORIGIN = new Point(0, 0, 0);
-}
+import { Vec3 } from "./Vec3.js";
+import type { Plane } from "./Plane.js";
+import type { RotationAxis } from "./types.js";
+
+/**
+ * Immutable 3D point for representing positions in space.
+ * All operations return new Point instances.
+ */
+export class Point {
+  constructor(
+    public readonly x: number,
+    public readonly y: number,
+    public readonly z: number
+  ) {}
+
+  /**
+   * Compute the distance to another point.
+   * @param other - Target point
+   * @returns Euclidean distance between points
+   */
+  distanceTo(other: Point): number {
+    const dx = this.x - other.x;
+    const dy = this.y - other.y;
+    const dz = this.z - other.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  /**
+   * Convert this point to a vector (from origin).
+   * @returns Vec3 with same coordinates
+   */
+  toVec3(): Vec3 {
+    return new Vec3(this.x, this.y, this.z);
+  }
+
+  /**
+   * Add a vector to this point.
+   * @param v - Vector to add
+   * @returns New point offset by vector
+   */
+  add(v: Vec3): Point {
+    return new Point(this.x + v.x, this.y + v.y, this.z + v.z);
+  }
+
+  /**
+   * Translate this point by an offset vector.
+   * Alias for add().
+   * @param offset - Translation vector
+   * @returns New translated point
+   */
+  translate(offset: Vec3): Point {
+    return this.add(offset);
+  }
+
+  /**
+   * Apply a row-major 4x4 matrix to this point (same convention as
+   * Mesh.applyMatrix / Brep.applyMatrix).
+   * @param matrix - Row-major 4x4 matrix (16 entries)
+   * @returns New transformed point
+   */
+  applyMatrix(matrix: number[] | Float64Array): Point {
+    if (matrix.length < 16) throw new Error("Point.applyMatrix: need 16 entries");
+    const m = matrix;
+    return new Point(
+      m[0] * this.x + m[1] * this.y + m[2] * this.z + m[3],
+      m[4] * this.x + m[5] * this.y + m[6] * this.z + m[7],
+      m[8] * this.x + m[9] * this.y + m[10] * this.z + m[11]
+    );
+  }
+
+  /**
+   * Rotate around an axis by angle in radians using Rodrigues' formula.
+   * @param axis - Vec3 (rotation around origin) or Line (rotation around arbitrary axis)
+   * @param angle - Rotation angle in radians
+   * @returns Rotated point
+   */
+  rotate(axis: RotationAxis, angle: number): Point {
+    if ('start' in axis && 'end' in axis) {
+      const dir = new Vec3(axis.end.x - axis.start.x, axis.end.y - axis.start.y, axis.end.z - axis.start.z);
+      const shifted = new Point(this.x - axis.start.x, this.y - axis.start.y, this.z - axis.start.z);
+      const rotated = shifted.rotate(dir, angle);
+      return new Point(rotated.x + axis.start.x, rotated.y + axis.start.y, rotated.z + axis.start.z);
+    }
+    const len = Math.sqrt(axis.x * axis.x + axis.y * axis.y + axis.z * axis.z);
+    if (len < 1e-15) return this.clone();
+    const k = { x: axis.x / len, y: axis.y / len, z: axis.z / len };
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const dot = k.x * this.x + k.y * this.y + k.z * this.z;
+    const cx = k.y * this.z - k.z * this.y;
+    const cy = k.z * this.x - k.x * this.z;
+    const cz = k.x * this.y - k.y * this.x;
+    return new Point(
+      this.x * cos + cx * sin + k.x * dot * (1 - cos),
+      this.y * cos + cy * sin + k.y * dot * (1 - cos),
+      this.z * cos + cz * sin + k.z * dot * (1 - cos),
+    );
+  }
+
+  /**
+   * Project this point onto a plane.
+   * @param plane - Target plane
+   * @param direction - Optional projection direction (default: perpendicular to plane)
+   * @returns Projected point on plane
+   */
+  projectOntoPlane(plane: Plane, direction?: Vec3): Point {
+    return direction ? plane.projectPointAlongDirection(this, direction) : plane.projectPoint(this);
+  }
+
+  /**
+   * Get the vector from another point to this point.
+   * @param other - Origin point
+   * @returns Vector from other to this
+   */
+  sub(other: Point): Vec3 {
+    return new Vec3(this.x - other.x, this.y - other.y, this.z - other.z);
+  }
+
+  /**
+   * Create a copy of this point.
+   * @returns New point with same coordinates
+   */
+  clone(): Point {
+    return new Point(this.x, this.y, this.z);
+  }
+
+  /**
+   * Check equality with another point within tolerance.
+   * @param other - Point to compare
+   * @param eps - Tolerance (default 1e-10)
+   * @returns True if points are approximately equal
+   */
+  equals(other: Point, eps = 1e-10): boolean {
+    return (
+      Math.abs(this.x - other.x) < eps &&
+      Math.abs(this.y - other.y) < eps &&
+      Math.abs(this.z - other.z) < eps
+    );
+  }
+
+  /**
+   * Convert to array format.
+   * @returns Tuple [x, y, z]
+   */
+  toArray(): [number, number, number] {
+    return [this.x, this.y, this.z];
+  }
+
+  /**
+   * Create a Point from a plain object or JSON.
+   * @param json - Object with x, y, z properties
+   * @returns New Point instance
+   */
+  static fromJSON(json: any): Point {
+    if (json instanceof Point) return json;
+    return new Point(json.x ?? 0, json.y ?? 0, json.z ?? 0);
+  }
+
+  /** Origin point (0, 0, 0) */
+  static readonly ORIGIN = new Point(0, 0, 0);
+}

package/src/Polyline.ts

@@ -135,6 +135,15 @@ export class Polyline {
     return new Polyline(this.points.map(p => p.add(offset)));
   }
 
+  /**
+   * Apply a row-major 4x4 matrix to every vertex.
+   * @param matrix - Row-major 4x4 matrix (16 entries)
+   * @returns New transformed polyline
+   */
+  applyMatrix(matrix: number[] | Float64Array): Polyline {
+    return new Polyline(this.points.map(p => p.applyMatrix(matrix)));
+  }
+
   /**
    * Rotate this polyline around an axis.
    * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)