fluidcad 0.0.2

package/lib/dist/math/plane.d.ts

@@ -0,0 +1,60 @@
+import { Point, Point2D } from "./point.js";
+import { Vector3d } from "./vector3d.js";
+import { Axis, AxisLike } from "./axis.js";
+import { Matrix4 } from "./matrix4.js";
+import { PlaneObjectBase } from "../features/plane-renderable-base.js";
+import { IPlane } from "../core/interfaces.js";
+export type RotationSpace = 'local' | 'global';
+export interface PlaneTransformOptions {
+    offset?: number;
+    rotateX?: number;
+    rotateY?: number;
+    rotateZ?: number;
+    rotationSpace?: RotationSpace;
+}
+export declare class Plane {
+    readonly origin: Point;
+    readonly xDirection: Vector3d;
+    readonly normal: Vector3d;
+    readonly yDirection: Vector3d;
+    readonly xAxis: Axis;
+    readonly yAxis: Axis;
+    readonly zAxis: Axis;
+    constructor(origin: Point, xDirection: Vector3d, normal: Vector3d, yDirection?: Vector3d);
+    worldToLocal(point: Point): Point2D;
+    localToWorld(point: Point2D): Point;
+    offset(distance: number): Plane;
+    transform(options: PlaneTransformOptions): Plane;
+    applyMatrix(matrix: Matrix4): Plane;
+    translateAlongNormal(distance: number): Plane;
+    translate(dx: number, dy: number, dz: number): Plane;
+    translateVector(v: Vector3d): Plane;
+    rotateAroundAxis(axis: Axis, angle: number): Plane;
+    normalizeAxis(axis: AxisLike): Axis | null;
+    normalizeAxisSafe(axis: AxisLike): Axis | null;
+    projectPoint(point: Point): Point;
+    distanceToPoint(point: Point): number;
+    distanceToPlane(other: Plane): number;
+    signedDistanceToPoint(point: Point): number;
+    containsPoint(point: Point, tolerance?: number): boolean;
+    isParallelTo(other: Plane, tolerance?: number): boolean;
+    isCoplanarWith(other: Plane, linearTolerance?: number, angularTolerance?: number): boolean;
+    reverse(): Plane;
+    withReversedNormal(): Plane;
+    mirrorAroundPoint(point: Point): Plane;
+    mirrorAroundPlane(planeNormal: Vector3d, pointOnPlane: Point): Plane;
+    mirrorAroundAxis(axis: Axis): Plane;
+    compareTo(other: Plane, tolerance?: number): boolean;
+    clone(): Plane;
+    toString(): string;
+    static XY(): Plane;
+    static XZ(): Plane;
+    static YZ(): Plane;
+    static fromPointAndNormal(point: Point, normal: Vector3d): Plane;
+    static fromThreePoints(p1: Point, p2: Point, p3: Point): Plane;
+    static projectPoint(point: Point, planeOrigin: Point, planeNormal: Vector3d): Point;
+}
+export type StandardPlane = "xy" | "xz" | "yz" | "-xy" | "-xz" | "-yz" | "top" | "bottom" | "front" | "back" | "left" | "right";
+export type PlaneLike = StandardPlane | Plane | IPlane | PlaneObjectBase;
+export declare function isPlaneLike(value: unknown): value is PlaneLike;
+export declare function toPlane(value: PlaneLike): Plane;

package/lib/dist/math/plane.js

@@ -0,0 +1,243 @@
+import { Point, Point2D } from "./point.js";
+import { Vector3d } from "./vector3d.js";
+import { Axis } from "./axis.js";
+import { Matrix4 } from "./matrix4.js";
+import { Quaternion } from "./quaternion.js";
+import { rad } from "../helpers/math-helpers.js";
+import { PlaneObjectBase } from "../features/plane-renderable-base.js";
+export class Plane {
+    origin;
+    xDirection;
+    normal;
+    yDirection;
+    xAxis;
+    yAxis;
+    zAxis;
+    constructor(origin, xDirection, normal, yDirection) {
+        this.origin = origin;
+        this.xDirection = xDirection;
+        this.normal = normal;
+        this.yDirection = yDirection ?? this.xDirection.cross(this.normal).normalize().multiply(-1);
+        this.xAxis = new Axis(this.origin, this.xDirection);
+        this.yAxis = new Axis(this.origin, this.yDirection);
+        this.zAxis = new Axis(this.origin, this.normal);
+    }
+    worldToLocal(point) {
+        const v = this.origin.vectorTo(point);
+        return new Point2D(v.dot(this.xDirection), v.dot(this.yDirection));
+    }
+    localToWorld(point) {
+        return this.origin
+            .add(this.xDirection.multiply(point.x))
+            .add(this.yDirection.multiply(point.y));
+    }
+    offset(distance) {
+        const newOrigin = this.origin.add(this.normal.multiply(distance));
+        return new Plane(newOrigin, this.xDirection, this.normal);
+    }
+    transform(options) {
+        let result = this;
+        if (options.offset) {
+            result = result.offset(options.offset);
+        }
+        const hasRotation = options.rotateX || options.rotateY || options.rotateZ;
+        if (!hasRotation) {
+            return result;
+        }
+        const useGlobal = options.rotationSpace === 'global';
+        // Determine rotation axes based on rotation space
+        const xAxis = useGlobal ? Vector3d.unitX() : result.xDirection;
+        const yAxis = useGlobal ? Vector3d.unitY() : result.yDirection;
+        const zAxis = useGlobal ? Vector3d.unitZ() : result.normal;
+        // Compose all rotations into a single quaternion to avoid gimbal lock
+        let q = Quaternion.identity();
+        if (options.rotateX) {
+            q = q.multiply(Quaternion.fromAxisAngle(xAxis, rad(options.rotateX)));
+        }
+        if (options.rotateY) {
+            q = q.multiply(Quaternion.fromAxisAngle(yAxis, rad(options.rotateY)));
+        }
+        if (options.rotateZ) {
+            q = q.multiply(Quaternion.fromAxisAngle(zAxis, rad(options.rotateZ)));
+        }
+        // Apply the composed rotation around the plane's origin
+        const toOrigin = Matrix4.fromTranslation(-result.origin.x, -result.origin.y, -result.origin.z);
+        const rotation = Matrix4.fromQuaternion(q);
+        const fromOrigin = Matrix4.fromTranslation(result.origin.x, result.origin.y, result.origin.z);
+        const matrix = fromOrigin.multiply(rotation).multiply(toOrigin);
+        return result.applyMatrix(matrix);
+    }
+    applyMatrix(matrix) {
+        return new Plane(matrix.transformPoint(this.origin), matrix.transformDirection(this.xDirection), matrix.transformDirection(this.normal), matrix.transformDirection(this.yDirection));
+    }
+    translateAlongNormal(distance) {
+        return this.offset(distance);
+    }
+    translate(dx, dy, dz) {
+        return new Plane(this.origin.translate(dx, dy, dz), this.xDirection, this.normal);
+    }
+    translateVector(v) {
+        return this.translate(v.x, v.y, v.z);
+    }
+    rotateAroundAxis(axis, angle) {
+        const toOrigin = Matrix4.fromTranslation(-axis.origin.x, -axis.origin.y, -axis.origin.z);
+        const rotate = Matrix4.fromAxisAngle(axis.direction, angle);
+        const fromOrigin = Matrix4.fromTranslation(axis.origin.x, axis.origin.y, axis.origin.z);
+        const matrix = fromOrigin.multiply(rotate).multiply(toOrigin);
+        return this.applyMatrix(matrix);
+    }
+    normalizeAxis(axis) {
+        if (typeof axis === "string") {
+            switch (axis) {
+                case "x":
+                    return this.xAxis;
+                case "y":
+                    return this.yAxis;
+                case "z":
+                    return this.zAxis;
+            }
+        }
+        if (axis instanceof Axis) {
+            return axis;
+        }
+        return null;
+    }
+    normalizeAxisSafe(axis) {
+        try {
+            return this.normalizeAxis(axis);
+        }
+        catch {
+            return null;
+        }
+    }
+    projectPoint(point) {
+        const v = this.origin.vectorTo(point);
+        const distance = v.dot(this.normal);
+        return point.subtract(this.normal.multiply(distance));
+    }
+    distanceToPoint(point) {
+        const v = this.origin.vectorTo(point);
+        return Math.abs(v.dot(this.normal));
+    }
+    distanceToPlane(other) {
+        return Math.abs(this.signedDistanceToPoint(other.origin));
+    }
+    signedDistanceToPoint(point) {
+        const v = this.origin.vectorTo(point);
+        return v.dot(this.normal);
+    }
+    containsPoint(point, tolerance = 1e-10) {
+        return Math.abs(this.signedDistanceToPoint(point)) <= tolerance;
+    }
+    isParallelTo(other, tolerance = 1e-10) {
+        return this.normal.isParallelTo(other.normal, tolerance);
+    }
+    isCoplanarWith(other, linearTolerance = 1e-10, angularTolerance = 1e-10) {
+        if (!this.isParallelTo(other, angularTolerance)) {
+            return false;
+        }
+        return this.containsPoint(other.origin, linearTolerance);
+    }
+    reverse() {
+        return new Plane(this.origin, this.xDirection.negate(), this.normal.negate());
+    }
+    withReversedNormal() {
+        return new Plane(this.origin, this.xDirection.negate(), this.normal.negate());
+    }
+    mirrorAroundPoint(point) {
+        const matrix = Matrix4.mirrorPoint(point);
+        return this.applyMatrix(matrix);
+    }
+    mirrorAroundPlane(planeNormal, pointOnPlane) {
+        const matrix = Matrix4.mirrorPlane(planeNormal, pointOnPlane);
+        return this.applyMatrix(matrix);
+    }
+    mirrorAroundAxis(axis) {
+        const matrix = Matrix4.mirrorAxis(axis.origin, axis.direction);
+        return this.applyMatrix(matrix);
+    }
+    compareTo(other, tolerance = 0) {
+        return (this.origin.equals(other.origin, tolerance) &&
+            this.xDirection.equals(other.xDirection, tolerance) &&
+            this.normal.equals(other.normal, tolerance));
+    }
+    clone() {
+        return new Plane(this.origin.clone(), this.xDirection.clone(), this.normal.clone());
+    }
+    toString() {
+        return `Plane(origin: ${this.origin.toString()}, xDirection: ${this.xDirection.toString()}, normal: ${this.normal.toString()})`;
+    }
+    static XY() {
+        return new Plane(Point.origin(), Vector3d.unitX(), Vector3d.unitZ());
+    }
+    static XZ() {
+        return new Plane(Point.origin(), Vector3d.unitX(), Vector3d.unitY().negate());
+    }
+    static YZ() {
+        return new Plane(Point.origin(), Vector3d.unitY(), Vector3d.unitX());
+    }
+    static fromPointAndNormal(point, normal) {
+        const n = normal.normalize();
+        let xDir;
+        if (Math.abs(n.x) < 0.9) {
+            xDir = n.cross(Vector3d.unitX()).normalize();
+        }
+        else {
+            xDir = n.cross(Vector3d.unitY()).normalize();
+        }
+        return new Plane(point, xDir, n);
+    }
+    static fromThreePoints(p1, p2, p3) {
+        const v1 = p1.vectorTo(p2);
+        const v2 = p1.vectorTo(p3);
+        const normal = v1.cross(v2).normalize();
+        const xDir = v1.normalize();
+        return new Plane(p1, xDir, normal);
+    }
+    static projectPoint(point, planeOrigin, planeNormal) {
+        const v = planeOrigin.vectorTo(point);
+        const distance = v.dot(planeNormal);
+        return point.subtract(planeNormal.multiply(distance));
+    }
+}
+export function isPlaneLike(value) {
+    return (value instanceof Plane ||
+        value instanceof PlaneObjectBase ||
+        value === "xy" ||
+        value === "xz" ||
+        value === "yz" ||
+        value === "-xy" ||
+        value === "-xz" ||
+        value === "-yz" ||
+        value === "top" ||
+        value === "bottom" ||
+        value === "front" ||
+        value === "back" ||
+        value === "left" ||
+        value === "right");
+}
+export function toPlane(value) {
+    if (value instanceof Plane) {
+        return value;
+    }
+    switch (value) {
+        case "xy":
+        case "top":
+            return Plane.XY();
+        case "-xy":
+        case "bottom":
+            return Plane.XY().reverse();
+        case "xz":
+        case "front":
+            return Plane.XZ();
+        case "-xz":
+        case "back":
+            return Plane.XZ().reverse();
+        case "yz":
+        case "right":
+            return Plane.YZ();
+        case "-yz":
+        case "left":
+            return Plane.YZ().reverse();
+    }
+}

package/lib/dist/math/plane.test.d.ts

@@ -0,0 +1 @@
+export {};