dgeoutils 2.4.1 → 2.4.4

package/dist/cjs/DCircle.js

@@ -1,44 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DCircle = void 0;
-const DPoint_1 = require("./DPoint");
-const DPolygon_1 = require("./DPolygon");
-const utils_1 = require("./utils");
-class DCircle {
-    constructor(center = DPoint_1.DPoint.zero(), r = 0) {
+var DPoint_1 = require("./DPoint");
+var DPolygon_1 = require("./DPolygon");
+var utils_1 = require("./utils");
+var DCircle = (function () {
+    function DCircle(center, r) {
+        if (center === void 0) { center = DPoint_1.DPoint.zero(); }
+        if (r === void 0) { r = 0; }
         this.center = center;
         this.r = r;
     }
-    toString() {
-        return `(${this.center.toString()}, ${this.r})`;
-    }
-    getValue() {
+    DCircle.prototype.toString = function () {
+        return "(".concat(this.center.toString(), ", ").concat(this.r, ")");
+    };
+    DCircle.prototype.getValue = function () {
         return { center: this.center, r: this.r };
-    }
-    clone() {
+    };
+    DCircle.prototype.clone = function () {
         return new DCircle(this.center, this.r);
-    }
-    findPoints(c) {
+    };
+    DCircle.prototype.findPoints = function (c) {
         if (this.equal(c)) {
             return Infinity;
         }
-        const { center: { x: x0, y: y0 }, r: r0 } = this;
-        const { center: { x: x1, y: y1 }, r: r1 } = c;
-        const r02 = r0 * r0;
-        const d = this.center.distance(c.center);
-        const a = (r02 - r1 * r1 + d * d) / (2 * d);
-        const h = Math.sqrt(r02 - a * a);
-        const ad = a / d;
-        const dy = y1 - y0;
-        const dx = x1 - x0;
-        const hd = h / d;
-        const x2 = x0 + ad * (x1 - x0);
-        const y2 = y0 + ad * (y1 - y0);
-        const x31 = x2 + hd * dy;
-        const y31 = y2 - hd * dx;
-        const x32 = x2 - hd * dy;
-        const y32 = y2 + hd * dx;
-        const res = [];
+        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_1.DPoint(x31, y31));
         }
@@ -46,46 +48,55 @@ class DCircle {
             res.push(new DPoint_1.DPoint(x32, y32));
         }
         return res;
-    }
-    equal({ center, r }) {
+    };
+    DCircle.prototype.equal = function (_a) {
+        var center = _a.center, r = _a.r;
         return this.center.equal(center) && this.r === r;
-    }
-    findPolygonInside(pointCount = 64, startAngle = 0, stopAngle = 2 * Math.PI) {
-        const step = 2 * Math.PI / pointCount;
-        const points = [];
-        let angle = startAngle;
+    };
+    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_1.DPoint(this.r).scale(Math.cos(angle), Math.sin(angle))
                 .move(this.center));
             angle += step;
         }
-        const x = this.r * Math.cos(stopAngle) + this.center.x;
-        const y = this.r * Math.sin(stopAngle) + this.center.y;
+        var x = this.r * Math.cos(stopAngle) + this.center.x;
+        var y = this.r * Math.sin(stopAngle) + this.center.y;
         points.push(new DPoint_1.DPoint(x, y));
         return new DPolygon_1.DPolygon(points);
-    }
-    findPolygonInsideOnSphere(pointCount = 64, startAngle = 0, stopAngle = 2 * Math.PI) {
+    };
+    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; }
         (0, utils_1.checkFunction)('findPolygonInsideOnSphere')
             .checkArgument('center')
             .shouldBeDegree(this.center);
-        const step = 2 * Math.PI / pointCount;
-        const points = [];
-        let angle = startAngle;
+        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_1.DPolygon(points);
-    }
-    sphereOffset(bearing, earthRadius = DPoint_1.EARTH_RADIUS_IN_METERS) {
-        const { x: lon1, y: lat1 } = this.center.clone().degreeToRadians();
-        const dByR = this.r / earthRadius;
-        const lat = Math.asin(Math.sin(lat1) * Math.cos(dByR) +
+    };
+    DCircle.prototype.sphereOffset = function (bearing, earthRadius) {
+        if (earthRadius === void 0) { earthRadius = DPoint_1.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));
-        const lon = lon1 +
+        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_1.DPoint(lon, lat).radiansToDegrees();
-    }
-}
+    };
+    return DCircle;
+}());
 exports.DCircle = DCircle;

package/dist/cjs/DLine.js

@@ -1,21 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DLine = void 0;
-const DPoint_1 = require("./DPoint");
-const utils_1 = require("./utils");
-const DNumbers_1 = require("./DNumbers");
-class DLine {
-    constructor(a, b, c, begin = DPoint_1.DPoint.zero(), end = DPoint_1.DPoint.zero()) {
+var DPoint_1 = require("./DPoint");
+var utils_1 = require("./utils");
+var DNumbers_1 = require("./DNumbers");
+var DLine = (function () {
+    function DLine(a, b, c, begin, end) {
+        if (begin === void 0) { begin = DPoint_1.DPoint.zero(); }
+        if (end === void 0) { end = DPoint_1.DPoint.zero(); }
         this.a = a;
         this.b = b;
         this.c = c;
         this.begin = begin;
         this.end = end;
     }
-    clone() {
+    DLine.prototype.clone = function () {
         return new DLine(this.a, this.b, this.c, this.begin.clone(), this.end.clone());
-    }
-    findPerpendicular(p) {
+    };
+    DLine.prototype.findPerpendicular = function (p) {
         (0, utils_1.checkFunction)('findPerpendicular')
             .checkArgument('this.begin')
             .shouldBeMeters(this.begin)
@@ -24,8 +26,8 @@ class DLine {
             .checkArgument('p')
             .shouldBeMeters(p);
         return new DLine(-this.b, this.a, this.b * p.x - this.a * p.y);
-    }
-    perpendicularDistance(p) {
+    };
+    DLine.prototype.perpendicularDistance = function (p) {
         (0, utils_1.checkFunction)('perpendicularDistance')
             .checkArgument('this.begin')
             .shouldBeMeters(this.begin)
@@ -33,12 +35,14 @@ class DLine {
             .shouldBeMeters(this.end)
             .checkArgument('p')
             .shouldBeMeters(p);
-        const perpendicularLine = this.findPerpendicular(p);
-        const targetPoint = perpendicularLine.findPoint(this);
+        var perpendicularLine = this.findPerpendicular(p);
+        var targetPoint = perpendicularLine.findPoint(this);
         return targetPoint.distance(p);
-    }
-    intersection(l, d = 0, includeOnly = false) {
-        const p = this.findPoint(l);
+    };
+    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;
@@ -46,12 +50,12 @@ class DLine {
             return this.inRange(p, d) && l.inRange(p, d) ? p : null;
         }
         return null;
-    }
-    intersectionWithCircle(circle) {
-        const { center, r } = circle;
-        const per = this.findPerpendicular(center);
-        const t = this.findPoint(per);
-        let distance = t.distance(center);
+    };
+    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;
         }
@@ -59,86 +63,108 @@ class DLine {
             distance = 0;
         }
         if (distance < r) {
-            const { a, b, c } = this;
+            var _a = this, a = _a.a, b = _a.b, c = _a.c;
             if (this.isParallel) {
-                const ct = center.distance(t);
-                const move = Math.sqrt(r * r - ct * ct);
+                var ct = center.distance(t);
+                var move = Math.sqrt(r * r - ct * ct);
                 if (this.isParallelY) {
                     t.x = this.begin.x;
-                    const r1 = t.clone().move(0, -move);
-                    const r2 = t.clone().move(0, move);
-                    return [r1, r2];
+                    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;
-                    const r1 = t.clone().move(move, 0);
-                    const r2 = t.clone().move(-move, 0);
-                    return [r1, r2];
+                    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)) {
-                const p = this.begin.clone();
+                var p = this.begin.clone();
                 return [this.movePoint(p, r), this.movePoint(p, -r)];
             }
             if (this.end.like(center)) {
-                const p = this.end.clone();
+                var p = this.end.clone();
                 return [this.movePoint(p, r), this.movePoint(p, -r)];
             }
-            const s = a * a + b * b;
-            const d = r * r - c * c / s;
-            const mult = Math.sqrt(d / s);
-            const r1 = t.clone().move(b * mult, -a * mult);
-            const r2 = t.clone().move(-b * mult, a * mult);
+            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;
-    }
-    inRange(p, d = 0) {
-        const { minX, minY, maxX, maxY } = this;
-        const { x, y } = p;
-        const isInX = x >= minX - d && x <= maxX + d;
-        const isInY = y >= minY - d && y <= maxY + d;
+    };
+    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;
-    }
-    insideRange(p, d = 0) {
-        const { begin, end } = this;
+    };
+    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);
-    }
-    get center() {
-        return this.begin
-            .clone()
-            .setIfLessThan(this.end)
-            .move(this.end
-            .clone()
-            .move(this.begin
-            .clone()
-            .minus())
-            .abs()
-            .minus()
-            .divide(2));
-    }
-    get minX() {
-        return Math.min(this.begin.x, this.end.x);
-    }
-    get minY() {
-        return Math.min(this.begin.y, this.end.y);
-    }
-    get maxX() {
-        return Math.max(this.begin.x, this.end.x);
-    }
-    get maxY() {
-        return Math.max(this.begin.y, this.end.y);
-    }
-    toString() {
-        return `(${this.a}, ${this.b}, ${this.c})`;
-    }
-    getValue() {
+    };
+    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 "(".concat(this.a, ", ").concat(this.b, ", ").concat(this.c, ")");
+    };
+    DLine.prototype.getValue = function () {
         return [this.a, this.b, this.c];
-    }
-    x(p) {
+    };
+    DLine.prototype.x = function (p) {
         if (this.isParallelY) {
             return new DPoint_1.DPoint(-this.c / this.a, p.y);
         }
@@ -146,8 +172,8 @@ class DLine {
             return new DPoint_1.DPoint(p.x, -this.c / this.b);
         }
         return new DPoint_1.DPoint(-this.b / this.a * p.y - this.c / this.a, p.y);
-    }
-    y(p) {
+    };
+    DLine.prototype.y = function (p) {
         if (this.isParallelY) {
             return new DPoint_1.DPoint(-this.c / this.a, p.y);
         }
@@ -155,8 +181,8 @@ class DLine {
             return new DPoint_1.DPoint(p.x, -this.c / this.b);
         }
         return new DPoint_1.DPoint(p.x, -this.a / this.b * p.x - this.c / this.b);
-    }
-    findPoint(l) {
+    };
+    DLine.prototype.findPoint = function (l) {
         if (this.isParallelY && l.isParallelY) {
             return null;
         }
@@ -170,81 +196,102 @@ class DLine {
             return new DPoint_1.DPoint(-this.c / this.a, -l.c / l.b);
         }
         if (this.isParallelY) {
-            const x = -this.c / this.a;
+            var x = -this.c / this.a;
             return l.y(new DPoint_1.DPoint(x));
         }
         if (this.isParallelX) {
-            const y = -this.c / this.b;
+            var y = -this.c / this.b;
             return l.x(new DPoint_1.DPoint(0, y));
         }
         if (l.isParallelY) {
-            const x = -l.c / l.a;
+            var x = -l.c / l.a;
             return this.y(new DPoint_1.DPoint(x));
         }
         if (l.isParallelX) {
-            const y = -l.c / l.b;
+            var y = -l.c / l.b;
             return this.x(new DPoint_1.DPoint(0, y));
         }
-        const res = this.y(new DPoint_1.DPoint((l.c / l.b - this.c / this.b) / (this.a / this.b - l.a / l.b)));
+        var res = this.y(new DPoint_1.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;
-    }
-    get isParallel() {
-        return this.isParallelX || this.isParallelY;
-    }
-    get isParallelY() {
-        return Math.abs(this.b) < 0.001;
-    }
-    get isParallelX() {
-        return Math.abs(this.a) < 0.001;
-    }
-    get points() {
-        return [this.begin, this.end];
-    }
-    getFi() {
+    };
+    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 () {
         (0, utils_1.checkFunction)('getFi')
             .checkArgument('this.begin')
             .shouldBeMeters(this.begin)
             .checkArgument('this.end')
             .shouldBeMeters(this.end);
-        const { x, y } = this.end.clone().move(this.begin.clone().minus());
-        let v = Math.atan2(y, x) - Math.PI;
+        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);
-    }
-    toWKT() {
-        const { begin: { x: x1, y: y1 }, end: { x: x2, y: y2 } } = this;
-        return `LINESTRING (${x1} ${y1}, ${x2} ${y2})`;
-    }
-    movePoint(i, k) {
-        const isArray = Array.isArray(i);
-        const p = isArray ? i : [i];
-        const d = (isArray ? k : [k]);
-        const fi = this.findFi(new DLine(1, 0, 0));
-        const td = this.x(new DPoint_1.DPoint(1, 1)).distance(this.x(new DPoint_1.DPoint(2, 2))) / 2;
-        const sinCos = new DPoint_1.DPoint(Math.sin(fi), Math.cos(fi));
-        const dt = sinCos.clone().scale(td);
-        const p1T = p[0].clone().move(dt.clone().minus());
-        const p2T = p[0].clone().move(dt);
-        let res = [];
+    };
+    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 (".concat(x1, " ").concat(y1, ", ").concat(x2, " ").concat(y2, ")");
+    };
+    DLine.prototype.movePoint = function (i, k) {
+        var isArray = Array.isArray(i);
+        var p = isArray ? i : [i];
+        var d = (isArray ? k : [k]);
+        var fi = this.findFi(new DLine(1, 0, 0));
+        var td = this.x(new DPoint_1.DPoint(1, 1)).distance(this.x(new DPoint_1.DPoint(2, 2))) / 2;
+        var sinCos = new DPoint_1.DPoint(Math.sin(fi), Math.cos(fi));
+        var dt = sinCos.clone().scale(td);
+        var p1T = p[0].clone().move(dt.clone().minus());
+        var p2T = p[0].clone().move(dt);
+        var res = [];
         if (DNumbers_1.DNumbers.like(this.y(p1T).y, p1T.y) || DNumbers_1.DNumbers.like(this.y(p2T).y, p2T.y)) {
-            res = p.map((t, index) => t.clone()
-                .move(sinCos.clone().scale(d[index])));
+            res = p.map(function (t, index) { return t.clone()
+                .move(sinCos.clone().scale(d[index])); });
         }
         else {
-            res = p.map((t, index) => t.clone()
+            res = p.map(function (t, index) { return t.clone()
                 .move(sinCos.clone().scale(d[index])
-                .setX(({ x }) => -x)));
+                .setX(function (_a) {
+                var x = _a.x;
+                return -x;
+            })); });
         }
         return isArray ? res : res[0];
-    }
-    findFi({ a, b }, delta = 1.0001) {
-        const { a: q, b: w } = this;
-        let val = (q * a + w * b) / (Math.sqrt(q * q + w * w) * Math.sqrt(a * a + b * b));
+    };
+    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;
         }
@@ -252,10 +299,12 @@ class DLine {
             val = -1;
         }
         return Math.acos(val);
-    }
-    vectorProduct({ a, b, c }) {
-        const { a: q, b: w, c: e } = this;
+    };
+    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;
+}());
 exports.DLine = DLine;

package/dist/cjs/DNumbers.js

@@ -1,26 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DNumbers = void 0;
-const DPoint_1 = require("./DPoint");
-const delta = 0.001;
-class DNumbers {
-    static like(v, s, d = delta) {
-        return Math.abs(v - s) < d;
+var DPoint_1 = require("./DPoint");
+var delta = 0.001;
+var DNumbers = (function () {
+    function DNumbers() {
     }
-    static likeZero(v) {
+    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);
-    }
-    static like2PI(v) {
+    };
+    DNumbers.like2PI = function (v) {
         return DNumbers.like(DNumbers.rad2Deg(v), DPoint_1.DOUBLE_PI_IN_DEGREE);
-    }
-    static likePI(v) {
+    };
+    DNumbers.likePI = function (v) {
         return DNumbers.like(DNumbers.rad2Deg(v), DPoint_1.PI_IN_DEGREE);
-    }
-    static rad2Deg(v) {
+    };
+    DNumbers.rad2Deg = function (v) {
         return v * DPoint_1.DEGREE_TO_PI;
-    }
-    static deg2Rad(v) {
+    };
+    DNumbers.deg2Rad = function (v) {
         return v * DPoint_1.PI_TO_DEGREE;
-    }
-}
+    };
+    return DNumbers;
+}());
 exports.DNumbers = DNumbers;