okgeometry-api 1.23.0 → 1.24.0

package/dist/wasm-base64.js.map

@@ -1 +1 @@
-{"version":3,"file":"wasm-base64.js","sourceRoot":"","sources":["../src/wasm-base64.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,MAAM,CAAC,MAAM,QAAQ,GAAG,8kolGAA8kolG,CAAC"}
+{"version":3,"file":"wasm-base64.js","sourceRoot":"","sources":["../src/wasm-base64.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,MAAM,CAAC,MAAM,QAAQ,GAAG,04qlGAA04qlG,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okgeometry-api",
-  "version": "1.23.0",
+  "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",

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)