dgeoutils 2.4.48 → 2.5.0

package/dist/es2015/DPlane.js

@@ -0,0 +1,105 @@
+import { DPoint } from './DPoint';
+import { gaussianElimination } from './utils';
+import { DNumbers } from './DNumbers';
+export class DPlane {
+    constructor(a, b, c, d, p1 = DPoint.zero(), p2 = DPoint.zero(), p3 = DPoint.zero()) {
+        this.a = a;
+        this.b = b;
+        this.c = c;
+        this.d = d;
+        this.p1 = p1;
+        this.p2 = p2;
+        this.p3 = p3;
+    }
+    static find(p1, p2, p3) {
+        if (p1.x === p2.x && p2.x === p3.x) {
+            return new DPlane(1, 0, 0, -p1.x, p1, p2, p3);
+        }
+        if (p1.y === p2.y && p2.y === p3.y) {
+            return new DPlane(0, 1, 0, -p1.y, p1, p2, p3);
+        }
+        if (p1.z === p2.z && p2.z === p3.z) {
+            return new DPlane(0, 0, 1, -p1.z, p1, p2, p3);
+        }
+        const d = 1;
+        const [a, b, c] = gaussianElimination([
+            [p1.x, p1.y, p1.z, -d],
+            [p2.x, p2.y, p2.z, -d],
+            [p3.x, p3.y, p3.z, -d]
+        ]);
+        return new DPlane(a, b, c, d, p1, p2, p3);
+    }
+    x(p) {
+        if (p instanceof DPoint) {
+            const { a, b, c, d } = this;
+            const { y, z } = p;
+            p.x = -(b * y + c * z + d) / a;
+            return p;
+        }
+        return p.map((t) => this.x(t));
+    }
+    y(p) {
+        if (p instanceof DPoint) {
+            const { a, b, c, d } = this;
+            const { x, z } = p;
+            p.y = -(a * x + c * z + d) / b;
+            return p;
+        }
+        return p.map((t) => this.y(t));
+    }
+    z(p) {
+        if (p instanceof DPoint) {
+            const { a, b, c, d } = this;
+            const { x, y } = p;
+            p.z = -(a * x + b * y + d) / c;
+            return p;
+        }
+        return p.map((t) => this.z(t));
+    }
+    clone() {
+        const { a, b, c, d, p1, p2, p3 } = this;
+        return new DPlane(a, b, c, d, p1, p2, p3);
+    }
+    distance(p) {
+        if (p instanceof DPoint) {
+            const { x, y, z } = p;
+            const { a, b, c, d } = this;
+            return Math.abs(a * x + b * y + c * z + d) / Math.sqrt(a * a + b * b + c * c);
+        }
+        const { a, b, c, d } = p;
+        const { d: r } = this;
+        return Math.abs(d - r) / Math.sqrt(a * a + b * b + c * c);
+    }
+    equal(p) {
+        const { a, b, c, d } = p;
+        const { a: q, b: w, c: e, d: r } = this;
+        return DNumbers.like(a, q) &&
+            DNumbers.like(b, w) &&
+            DNumbers.like(c, e) &&
+            DNumbers.like(d, r);
+    }
+    same(p) {
+        const { a, b, c, d } = p;
+        const { a: q, b: w, c: e, d: r } = this;
+        const t = a / q;
+        const y = b / w;
+        const u = c / e;
+        const i = d / r;
+        return DNumbers.like(t, y) &&
+            DNumbers.like(t, u) &&
+            DNumbers.like(t, c) &&
+            DNumbers.like(t, i);
+    }
+    parallel(p) {
+        const { a, b, c, d } = p;
+        const { a: q, b: w, c: e, d: r } = this;
+        const t = a / q;
+        const y = b / w;
+        const u = c / e;
+        const i = d / r;
+        return DNumbers.like(t, y) &&
+            DNumbers.like(t, u) &&
+            DNumbers.like(t, c) &&
+            !DNumbers.like(t, i);
+    }
+}