dgeoutils 2.2.23 → 2.3.2

package/dist/{utils.js → es2015/utils.js}

@@ -1,58 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCanvas = exports.gaussianElimination = exports.createMatrix = exports.createArray = exports.checkFunction = exports.isDefAndNotNull = exports.warn = void 0;
-const index_1 = require("./index");
-const DPoint_1 = require("./DPoint");
-const warn = (...args) => {
-    if (index_1.DGeo.DEBUG) {
+import { DGeo } from './index';
+import { DPoint } from './DPoint';
+export const warn = (...args) => {
+    if (DGeo.DEBUG) {
         console.warn(...args);
     }
 };
-exports.warn = warn;
-const isDefAndNotNull = (a) => a != undefined;
-exports.isDefAndNotNull = isDefAndNotNull;
+export const isDefAndNotNull = (a) => a != undefined;
 const hook = (scope) => () => scope;
 const shouldBeInt = (scope, funcName, argName) => (p) => {
     if (!p.clone().round()
         .equal(p)) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be Int!`);
+        warn(`"${funcName}" -> "${argName}" should be Int!`);
     }
     return scope;
 };
 const shouldBeUInt = (scope, funcName, argName) => (p) => {
     if (!p.clone().round()
-        .equal(p) || !p.gtOrEqual(DPoint_1.DPoint.zero())) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be UInt!`);
+        .equal(p) || !p.gtOrEqual(DPoint.zero())) {
+        warn(`"${funcName}" -> "${argName}" should be UInt!`);
     }
     return scope;
 };
 const shouldBeDegree = (scope, funcName, argName) => (p) => {
     if (!p.likeWorldGeodeticSystem) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be degree!`);
+        warn(`"${funcName}" -> "${argName}" should be degree!`);
     }
     return scope;
 };
 const shouldBeRadians = (scope, funcName, argName) => (p) => {
     if (!p.likeRadians) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be radians!`);
+        warn(`"${funcName}" -> "${argName}" should be radians!`);
     }
     return scope;
 };
 const shouldExist = (scope, funcName, argName) => (p) => {
-    if (!(0, exports.isDefAndNotNull)(p)) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should exist!`);
+    if (!isDefAndNotNull(p)) {
+        warn(`"${funcName}" -> "${argName}" should exist!`);
     }
     return scope;
 };
 const shouldBeMeters = (scope, funcName, argName) => (p) => {
     if (!p.likePseudoMercator) {
-        (0, exports.warn)(`"${funcName}" -> "${argName}" should be meters!`);
+        warn(`"${funcName}" -> "${argName}" should be meters!`);
     }
     return scope;
 };
-const checkFunction = (funcName) => ({
+export const checkFunction = (funcName) => ({
     checkArgument: function (argName) {
-        if (!index_1.DGeo.DEBUG) {
+        if (!DGeo.DEBUG) {
             return {
                 shouldBeDegree: hook(this),
                 shouldBeMeters: hook(this),
@@ -72,18 +67,15 @@ const checkFunction = (funcName) => ({
         };
     }
 });
-exports.checkFunction = checkFunction;
-const createArray = (v, fillSymbol = 0) => new Array(v).fill(fillSymbol);
-exports.createArray = createArray;
-const createMatrix = ({ h, w }, fillSymbol = 0) => (0, exports.createArray)(h)
-    .map(() => (0, exports.createArray)(w, fillSymbol));
-exports.createMatrix = createMatrix;
-const gaussianElimination = (matrix) => {
+export const createArray = (v, fillSymbol = 0) => new Array(v).fill(fillSymbol);
+export const createMatrix = ({ h, w }, fillSymbol = 0) => createArray(h)
+    .map(() => createArray(w, fillSymbol));
+export const gaussianElimination = (matrix) => {
     const n = matrix.length;
-    const matrixClone = (0, exports.createMatrix)(new DPoint_1.DPoint(n + 1, n));
+    const matrixClone = createMatrix(new DPoint(n + 1, n));
     for (let i = 0; i < n; i++) {
         for (let j = 0; j < n + 1; j++) {
-            matrix[i][j] = matrix[i][j] === 0 ? exports.gaussianElimination.MIN : matrix[i][j];
+            matrix[i][j] = matrix[i][j] === 0 ? gaussianElimination.MIN : matrix[i][j];
             matrixClone[i][j] = matrix[i][j];
         }
     }
@@ -114,20 +106,19 @@ const gaussianElimination = (matrix) => {
             }
         }
     }
-    const answer = (0, exports.createArray)(n);
+    const answer = createArray(n);
     for (let i = 0; i < n; i++) {
         answer[i] = matrixClone[i][n];
     }
     return answer;
 };
-exports.gaussianElimination = gaussianElimination;
-exports.gaussianElimination.MIN = 1e-10;
-const createCanvas = (a, b, c) => {
+gaussianElimination.MIN = 1e-10;
+export const createCanvas = (a, b, c) => {
     var _a;
     let w = 0;
     let h = 0;
     let offscreen = false;
-    if (a instanceof DPoint_1.DPoint) {
+    if (a instanceof DPoint) {
         const { x, y } = a;
         w = x;
         h = y;
@@ -145,11 +136,10 @@ const createCanvas = (a, b, c) => {
     if (typeof c === 'boolean') {
         offscreen = c;
     }
-    const canvas = offscreen ? new OffscreenCanvas(w, h) : ((_a = exports.createCanvas.document) !== null && _a !== void 0 ? _a : document).createElement('canvas');
+    const canvas = offscreen ? new OffscreenCanvas(w, h) : ((_a = createCanvas.document) !== null && _a !== void 0 ? _a : document).createElement('canvas');
     if (!offscreen) {
         canvas.width = w;
         canvas.height = h;
     }
     return [canvas, canvas.getContext('2d')];
 };
-exports.createCanvas = createCanvas;

package/dist/esm/DCircle.js

@@ -0,0 +1,99 @@
+import { DPoint, EARTH_RADIUS_IN_METERS } from './DPoint';
+import { DPolygon } from './DPolygon';
+import { checkFunction } from './utils';
+var DCircle = (function () {
+    function DCircle(center, r) {
+        if (center === void 0) { center = DPoint.zero(); }
+        if (r === void 0) { r = 0; }
+        this.center = center;
+        this.r = r;
+    }
+    DCircle.prototype.toString = function () {
+        return "(" + this.center.toString() + ", " + this.r + ")";
+    };
+    DCircle.prototype.getValue = function () {
+        return { center: this.center, r: this.r };
+    };
+    DCircle.prototype.clone = function () {
+        return new DCircle(this.center, this.r);
+    };
+    DCircle.prototype.findPoints = function (c) {
+        if (this.equal(c)) {
+            return Infinity;
+        }
+        var _a = this, _b = _a.center, x0 = _b.x, y0 = _b.y, r0 = _a.r;
+        var _c = c.center, x1 = _c.x, y1 = _c.y, r1 = c.r;
+        var r02 = r0 * r0;
+        var d = this.center.distance(c.center);
+        var a = (r02 - r1 * r1 + d * d) / (2 * d);
+        var h = Math.sqrt(r02 - a * a);
+        var ad = a / d;
+        var dy = y1 - y0;
+        var dx = x1 - x0;
+        var hd = h / d;
+        var x2 = x0 + ad * (x1 - x0);
+        var y2 = y0 + ad * (y1 - y0);
+        var x31 = x2 + hd * dy;
+        var y31 = y2 - hd * dx;
+        var x32 = x2 - hd * dy;
+        var y32 = y2 + hd * dx;
+        var res = [];
+        if (!isNaN(x31) && !isNaN(y31)) {
+            res.push(new DPoint(x31, y31));
+        }
+        if (!isNaN(x32) && !isNaN(y32) && !(x31 === x32 && y31 === y32)) {
+            res.push(new DPoint(x32, y32));
+        }
+        return res;
+    };
+    DCircle.prototype.equal = function (_a) {
+        var center = _a.center, r = _a.r;
+        return this.center.equal(center) && this.r === r;
+    };
+    DCircle.prototype.findPolygonInside = function (pointCount, startAngle, stopAngle) {
+        if (pointCount === void 0) { pointCount = 64; }
+        if (startAngle === void 0) { startAngle = 0; }
+        if (stopAngle === void 0) { stopAngle = 2 * Math.PI; }
+        var step = 2 * Math.PI / pointCount;
+        var points = [];
+        var angle = startAngle;
+        while (angle < stopAngle - step) {
+            points.push(new DPoint(this.r).scale(Math.cos(angle), Math.sin(angle))
+                .move(this.center));
+            angle += step;
+        }
+        var x = this.r * Math.cos(stopAngle) + this.center.x;
+        var y = this.r * Math.sin(stopAngle) + this.center.y;
+        points.push(new DPoint(x, y));
+        return new DPolygon(points);
+    };
+    DCircle.prototype.findPolygonInsideOnSphere = function (pointCount, startAngle, stopAngle) {
+        if (pointCount === void 0) { pointCount = 64; }
+        if (startAngle === void 0) { startAngle = 0; }
+        if (stopAngle === void 0) { stopAngle = 2 * Math.PI; }
+        checkFunction('findPolygonInsideOnSphere')
+            .checkArgument('center')
+            .shouldBeDegree(this.center);
+        var step = 2 * Math.PI / pointCount;
+        var points = [];
+        var angle = startAngle;
+        while (angle < stopAngle - step) {
+            points.push(this.sphereOffset(angle));
+            angle += step;
+        }
+        points.push(this.sphereOffset(stopAngle));
+        return new DPolygon(points);
+    };
+    DCircle.prototype.sphereOffset = function (bearing, earthRadius) {
+        if (earthRadius === void 0) { earthRadius = EARTH_RADIUS_IN_METERS; }
+        var _a = this.center.clone().degreeToRadians(), lon1 = _a.x, lat1 = _a.y;
+        var dByR = this.r / earthRadius;
+        var lat = Math.asin(Math.sin(lat1) * Math.cos(dByR) +
+            Math.cos(lat1) * Math.sin(dByR) * Math.cos(bearing));
+        var lon = lon1 +
+            Math.atan2(Math.sin(bearing) * Math.sin(dByR) * Math.cos(lat1), Math.cos(dByR) - Math.sin(lat1) * Math.sin(lat));
+        return new DPoint(lon, lat).radiansToDegrees();
+    };
+    return DCircle;
+}());
+export { DCircle };

package/dist/esm/DLine.js

@@ -0,0 +1,297 @@
+import { DPoint } from './DPoint';
+import { checkFunction } from './utils';
+import { DNumbers } from './DNumbers';
+var DLine = (function () {
+    function DLine(a, b, c, begin, end) {
+        if (begin === void 0) { begin = DPoint.zero(); }
+        if (end === void 0) { end = DPoint.zero(); }
+        this.a = a;
+        this.b = b;
+        this.c = c;
+        this.begin = begin;
+        this.end = end;
+    }
+    DLine.prototype.clone = function () {
+        return new DLine(this.a, this.b, this.c, this.begin.clone(), this.end.clone());
+    };
+    DLine.prototype.findPerpendicular = function (p) {
+        checkFunction('findPerpendicular')
+            .checkArgument('this.begin')
+            .shouldBeMeters(this.begin)
+            .checkArgument('this.end')
+            .shouldBeMeters(this.end)
+            .checkArgument('p')
+            .shouldBeMeters(p);
+        return new DLine(-this.b, this.a, this.b * p.x - this.a * p.y);
+    };
+    DLine.prototype.perpendicularDistance = function (p) {
+        checkFunction('perpendicularDistance')
+            .checkArgument('this.begin')
+            .shouldBeMeters(this.begin)
+            .checkArgument('this.end')
+            .shouldBeMeters(this.end)
+            .checkArgument('p')
+            .shouldBeMeters(p);
+        var perpendicularLine = this.findPerpendicular(p);
+        var targetPoint = perpendicularLine.findPoint(this);
+        return targetPoint.distance(p);
+    };
+    DLine.prototype.intersection = function (l, d, includeOnly) {
+        if (d === void 0) { d = 0; }
+        if (includeOnly === void 0) { includeOnly = false; }
+        var p = this.findPoint(l);
+        if (p) {
+            if (includeOnly) {
+                return this.insideRange(p, d) && l.insideRange(p, d) ? p : null;
+            }
+            return this.inRange(p, d) && l.inRange(p, d) ? p : null;
+        }
+        return null;
+    };
+    DLine.prototype.intersectionWithCircle = function (circle) {
+        var center = circle.center, r = circle.r;
+        var per = this.findPerpendicular(center);
+        var t = this.findPoint(per);
+        var distance = t.distance(center);
+        if (this.begin.equal(center)) {
+            distance = 0;
+        }
+        if (this.end.equal(center)) {
+            distance = 0;
+        }
+        if (distance < r) {
+            var _a = this, a = _a.a, b = _a.b, c = _a.c;
+            if (this.isParallel) {
+                var ct = center.distance(t);
+                var move = Math.sqrt(r * r - ct * ct);
+                if (this.isParallelY) {
+                    t.x = this.begin.x;
+                    var r1_1 = t.clone().move(0, -move);
+                    var r2_1 = t.clone().move(0, move);
+                    return [r1_1, r2_1];
+                }
+                if (this.isParallelX) {
+                    t.y = this.begin.y;
+                    var r1_2 = t.clone().move(move, 0);
+                    var r2_2 = t.clone().move(-move, 0);
+                    return [r1_2, r2_2];
+                }
+            }
+            if (this.begin.like(center)) {
+                var p = this.begin.clone();
+                return [this.movePoint(p, r), this.movePoint(p, -r)];
+            }
+            if (this.end.like(center)) {
+                var p = this.end.clone();
+                return [this.movePoint(p, r), this.movePoint(p, -r)];
+            }
+            var s = a * a + b * b;
+            var d = r * r - c * c / s;
+            var mult = Math.sqrt(d / s);
+            var r1 = t.clone().move(b * mult, -a * mult);
+            var r2 = t.clone().move(-b * mult, a * mult);
+            return [r1, r2];
+        }
+        if (distance === r) {
+            return t;
+        }
+        return null;
+    };
+    DLine.prototype.inRange = function (p, d) {
+        if (d === void 0) { d = 0; }
+        var _a = this, minX = _a.minX, minY = _a.minY, maxX = _a.maxX, maxY = _a.maxY;
+        var x = p.x, y = p.y;
+        var isInX = x >= minX - d && x <= maxX + d;
+        var isInY = y >= minY - d && y <= maxY + d;
+        return isInX && isInY;
+    };
+    DLine.prototype.insideRange = function (p, d) {
+        if (d === void 0) { d = 0; }
+        var _a = this, begin = _a.begin, end = _a.end;
+        return this.inRange(p, d) && !begin.like(p, 0.00001) && !end.like(p, 0.00001);
+    };
+    Object.defineProperty(DLine.prototype, "center", {
+        get: function () {
+            return this.begin
+                .clone()
+                .setIfLessThan(this.end)
+                .move(this.end
+                .clone()
+                .move(this.begin
+                .clone()
+                .minus())
+                .abs()
+                .minus()
+                .divide(2));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DLine.prototype, "minX", {
+        get: function () {
+            return Math.min(this.begin.x, this.end.x);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DLine.prototype, "minY", {
+        get: function () {
+            return Math.min(this.begin.y, this.end.y);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DLine.prototype, "maxX", {
+        get: function () {
+            return Math.max(this.begin.x, this.end.x);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DLine.prototype, "maxY", {
+        get: function () {
+            return Math.max(this.begin.y, this.end.y);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DLine.prototype.toString = function () {
+        return "(" + this.a + ", " + this.b + ", " + this.c + ")";
+    };
+    DLine.prototype.getValue = function () {
+        return [this.a, this.b, this.c];
+    };
+    DLine.prototype.x = function (p) {
+        if (this.isParallelY) {
+            return new DPoint(-this.c / this.a, p.y);
+        }
+        if (this.isParallelX) {
+            return new DPoint(p.x, -this.c / this.b);
+        }
+        return new DPoint(-this.b / this.a * p.y - this.c / this.a, p.y);
+    };
+    DLine.prototype.y = function (p) {
+        if (this.isParallelY) {
+            return new DPoint(-this.c / this.a, p.y);
+        }
+        if (this.isParallelX) {
+            return new DPoint(p.x, -this.c / this.b);
+        }
+        return new DPoint(p.x, -this.a / this.b * p.x - this.c / this.b);
+    };
+    DLine.prototype.findPoint = function (l) {
+        if (this.isParallelY && l.isParallelY) {
+            return null;
+        }
+        if (this.isParallelX && l.isParallelX) {
+            return null;
+        }
+        if (this.isParallelX && l.isParallelY) {
+            return new DPoint(-l.c / l.a, -this.c / this.b);
+        }
+        if (this.isParallelY && l.isParallelX) {
+            return new DPoint(-this.c / this.a, -l.c / l.b);
+        }
+        if (this.isParallelY) {
+            var x = -this.c / this.a;
+            return l.y(new DPoint(x));
+        }
+        if (this.isParallelX) {
+            var y = -this.c / this.b;
+            return l.x(new DPoint(0, y));
+        }
+        if (l.isParallelY) {
+            var x = -l.c / l.a;
+            return this.y(new DPoint(x));
+        }
+        if (l.isParallelX) {
+            var y = -l.c / l.b;
+            return this.x(new DPoint(0, y));
+        }
+        var res = this.y(new DPoint((l.c / l.b - this.c / this.b) / (this.a / this.b - l.a / l.b)));
+        if (!isFinite(res.x) && !isFinite(res.y)) {
+            return null;
+        }
+        return res;
+    };
+    Object.defineProperty(DLine.prototype, "isParallel", {
+        get: function () {
+            return this.isParallelX || this.isParallelY;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DLine.prototype, "isParallelY", {
+        get: function () {
+            return Math.abs(this.b) < 0.001;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DLine.prototype, "isParallelX", {
+        get: function () {
+            return Math.abs(this.a) < 0.001;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DLine.prototype, "points", {
+        get: function () {
+            return [this.begin, this.end];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DLine.prototype.getFi = function () {
+        checkFunction('getFi')
+            .checkArgument('this.begin')
+            .shouldBeMeters(this.begin)
+            .checkArgument('this.end')
+            .shouldBeMeters(this.end);
+        var _a = this.end.clone().move(this.begin.clone().minus()), x = _a.x, y = _a.y;
+        var v = Math.atan2(y, x) - Math.PI;
+        if (v > 0) {
+            v = Math.PI - v;
+        }
+        return (Math.PI - v) % (Math.PI * 2);
+    };
+    DLine.prototype.toWKT = function () {
+        var _a = this, _b = _a.begin, x1 = _b.x, y1 = _b.y, _c = _a.end, x2 = _c.x, y2 = _c.y;
+        return "LINESTRING (" + x1 + " " + y1 + ", " + x2 + " " + y2 + ")";
+    };
+    DLine.prototype.movePoint = function (p, d) {
+        var fi = this.findFi(new DLine(1, 0, 0));
+        var td = this.x(new DPoint(1, 1)).distance(this.x(new DPoint(2, 2))) / 2;
+        var sinCos = new DPoint(Math.sin(fi), Math.cos(fi));
+        var dt = sinCos.clone().scale(td);
+        var p1T = p.clone().move(dt.clone().minus());
+        var p2T = p.clone().move(dt);
+        if (DNumbers.like(this.y(p1T).y, p1T.y) || DNumbers.like(this.y(p2T).y, p2T.y)) {
+            return p.clone().move(sinCos.scale(d));
+        }
+        return p.clone().move(sinCos.scale(d).setX(function (_a) {
+            var x = _a.x;
+            return -x;
+        }));
+    };
+    DLine.prototype.findFi = function (_a, delta) {
+        var a = _a.a, b = _a.b;
+        if (delta === void 0) { delta = 1.0001; }
+        var _b = this, q = _b.a, w = _b.b;
+        var val = (q * a + w * b) / (Math.sqrt(q * q + w * w) * Math.sqrt(a * a + b * b));
+        if (val > 1 && val < delta) {
+            val = 1;
+        }
+        else if (val < -1 && val > -delta) {
+            val = -1;
+        }
+        return Math.acos(val);
+    };
+    DLine.prototype.vectorProduct = function (_a) {
+        var a = _a.a, b = _a.b, c = _a.c;
+        var _b = this, q = _b.a, w = _b.b, e = _b.c;
+        return new DLine(w * c - e * b, e * a - q * c, q * b - w * a);
+    };
+    return DLine;
+}());
+export { DLine };

package/dist/esm/DNumbers.js

@@ -0,0 +1,27 @@
+import { DEGREE_TO_PI, DOUBLE_PI_IN_DEGREE, PI_IN_DEGREE, PI_TO_DEGREE } from './DPoint';
+var delta = 0.001;
+var DNumbers = (function () {
+    function DNumbers() {
+    }
+    DNumbers.like = function (v, s, d) {
+        if (d === void 0) { d = delta; }
+        return Math.abs(v - s) < d;
+    };
+    DNumbers.likeZero = function (v) {
+        return DNumbers.like(v, 0);
+    };
+    DNumbers.like2PI = function (v) {
+        return DNumbers.like(DNumbers.rad2Deg(v), DOUBLE_PI_IN_DEGREE);
+    };
+    DNumbers.likePI = function (v) {
+        return DNumbers.like(DNumbers.rad2Deg(v), PI_IN_DEGREE);
+    };
+    DNumbers.rad2Deg = function (v) {
+        return v * DEGREE_TO_PI;
+    };
+    DNumbers.deg2Rad = function (v) {
+        return v * PI_TO_DEGREE;
+    };
+    return DNumbers;
+}());
+export { DNumbers };

package/dist/esm/DPlane.js

@@ -0,0 +1,129 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { DPoint } from './DPoint';
+import { gaussianElimination } from './utils';
+import { DNumbers } from './DNumbers';
+var DPlane = (function () {
+    function DPlane(a, b, c, d, p1, p2, p3) {
+        if (p1 === void 0) { p1 = DPoint.zero(); }
+        if (p2 === void 0) { p2 = DPoint.zero(); }
+        if (p3 === void 0) { p3 = DPoint.zero(); }
+        this.a = a;
+        this.b = b;
+        this.c = c;
+        this.d = d;
+        this.p1 = p1;
+        this.p2 = p2;
+        this.p3 = p3;
+    }
+    DPlane.find = function (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);
+        }
+        var d = 1;
+        var _a = __read(gaussianElimination([
+            [p1.x, p1.y, p1.z, -d],
+            [p2.x, p2.y, p2.z, -d],
+            [p3.x, p3.y, p3.z, -d]
+        ]), 3), a = _a[0], b = _a[1], c = _a[2];
+        return new DPlane(a, b, c, d, p1, p2, p3);
+    };
+    DPlane.prototype.x = function (p) {
+        var _this = this;
+        if (p instanceof DPoint) {
+            var _a = this, a = _a.a, b = _a.b, c = _a.c, d = _a.d;
+            var y = p.y, z = p.z;
+            p.x = -(b * y + c * z + d) / a;
+            return p;
+        }
+        return p.map(function (t) { return _this.x(t); });
+    };
+    DPlane.prototype.y = function (p) {
+        var _this = this;
+        if (p instanceof DPoint) {
+            var _a = this, a = _a.a, b = _a.b, c = _a.c, d = _a.d;
+            var x = p.x, z = p.z;
+            p.y = -(a * x + c * z + d) / b;
+            return p;
+        }
+        return p.map(function (t) { return _this.y(t); });
+    };
+    DPlane.prototype.z = function (p) {
+        var _this = this;
+        if (p instanceof DPoint) {
+            var _a = this, a = _a.a, b = _a.b, c = _a.c, d = _a.d;
+            var x = p.x, y = p.y;
+            p.z = -(a * x + b * y + d) / c;
+            return p;
+        }
+        return p.map(function (t) { return _this.z(t); });
+    };
+    DPlane.prototype.clone = function () {
+        var _a = this, a = _a.a, b = _a.b, c = _a.c, d = _a.d, p1 = _a.p1, p2 = _a.p2, p3 = _a.p3;
+        return new DPlane(a, b, c, d, p1, p2, p3);
+    };
+    DPlane.prototype.distance = function (p) {
+        if (p instanceof DPoint) {
+            var x = p.x, y = p.y, z = p.z;
+            var _a = this, a_1 = _a.a, b_1 = _a.b, c_1 = _a.c, d_1 = _a.d;
+            return Math.abs(a_1 * x + b_1 * y + c_1 * z + d_1) / Math.sqrt(a_1 * a_1 + b_1 * b_1 + c_1 * c_1);
+        }
+        var _b = p, a = _b.a, b = _b.b, c = _b.c, d = _b.d;
+        var r = this.d;
+        return Math.abs(d - r) / Math.sqrt(a * a + b * b + c * c);
+    };
+    DPlane.prototype.equal = function (p) {
+        var a = p.a, b = p.b, c = p.c, d = p.d;
+        var _a = this, q = _a.a, w = _a.b, e = _a.c, r = _a.d;
+        return DNumbers.like(a, q) &&
+            DNumbers.like(b, w) &&
+            DNumbers.like(c, e) &&
+            DNumbers.like(d, r);
+    };
+    DPlane.prototype.same = function (p) {
+        var a = p.a, b = p.b, c = p.c, d = p.d;
+        var _a = this, q = _a.a, w = _a.b, e = _a.c, r = _a.d;
+        var t = a / q;
+        var y = b / w;
+        var u = c / e;
+        var i = d / r;
+        return DNumbers.like(t, y) &&
+            DNumbers.like(t, u) &&
+            DNumbers.like(t, c) &&
+            DNumbers.like(t, i);
+    };
+    DPlane.prototype.parallel = function (p) {
+        var a = p.a, b = p.b, c = p.c, d = p.d;
+        var _a = this, q = _a.a, w = _a.b, e = _a.c, r = _a.d;
+        var t = a / q;
+        var y = b / w;
+        var u = c / e;
+        var i = d / r;
+        return DNumbers.like(t, y) &&
+            DNumbers.like(t, u) &&
+            DNumbers.like(t, c) &&
+            !DNumbers.like(t, i);
+    };
+    return DPlane;
+}());
+export { DPlane };