dgeoutils 2.2.23 → 2.3.2

package/dist/cjs/TraceMatrix.js

@@ -0,0 +1,256 @@
+"use strict";
+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;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceMatrix = exports.TraceMatrixValues = void 0;
+var DPoint_1 = require("./DPoint");
+var DPolygon_1 = require("./DPolygon");
+var FastSearch_1 = require("./FastSearch");
+var utils_1 = require("./utils");
+var TraceMatrixValues;
+(function (TraceMatrixValues) {
+    TraceMatrixValues[TraceMatrixValues["f"] = 0] = "f";
+    TraceMatrixValues[TraceMatrixValues["t"] = 1] = "t";
+})(TraceMatrixValues = exports.TraceMatrixValues || (exports.TraceMatrixValues = {}));
+var getByPosition = function (m, p, defaultValue) {
+    if (defaultValue === void 0) { defaultValue = TraceMatrixValues.f; }
+    if (m[p.y] === undefined || m[p.y][p.x] === undefined) {
+        return defaultValue;
+    }
+    return m[p.y][p.x];
+};
+var setByPosition = function (m, p, value) {
+    if (m[p.y] === undefined || m[p.y][p.x] === undefined) {
+        return value;
+    }
+    m[p.y][p.x] = value;
+    return m[p.y][p.x];
+};
+var TraceMatrix = (function () {
+    function TraceMatrix(size, f) {
+        var _this = this;
+        this.size = size;
+        this.findGroupByIndex = function (m, s) {
+            var res = new DPolygon_1.DPolygon();
+            if (s && getByPosition(m, s) === TraceMatrixValues.t) {
+                res.push(s);
+                var startIndex = 0;
+                var marked = TraceMatrix.createMatrix(_this.size, function () { return TraceMatrixValues.f; });
+                setByPosition(marked, s, TraceMatrixValues.t);
+                while (startIndex < res.length) {
+                    var r = res.at(startIndex);
+                    for (var i = -1; i < 2; i++) {
+                        for (var j = -1; j < 2; j++) {
+                            var t = new DPoint_1.DPoint(r.x + i, r.y + j);
+                            if (getByPosition(marked, t, TraceMatrixValues.t) === TraceMatrixValues.f &&
+                                getByPosition(m, t, TraceMatrixValues.f) === TraceMatrixValues.t) {
+                                res.push(t);
+                                setByPosition(marked, t, TraceMatrixValues.t);
+                            }
+                        }
+                    }
+                    startIndex++;
+                }
+            }
+            return res;
+        };
+        this.findAllGroupsInMatrix = function (m) {
+            var firstMark = _this.findMarked(m);
+            if (!firstMark) {
+                return [];
+            }
+            var group = _this.findGroupByIndex(m, firstMark);
+            var groups = [group];
+            var groupSum = group.length;
+            var allGroups = __spreadArray([], __read(group.points), false);
+            var fs = new FastSearch_1.FastSearch();
+            fs.add(allGroups);
+            while (groupSum < _this.totalCountInMatrix(m)) {
+                var mark = _this.findMarked(m);
+                while (mark && fs.find(mark)) {
+                    mark = _this.findMarked(m, mark);
+                }
+                var nextGroup = _this.findGroupByIndex(m, mark);
+                groupSum += nextGroup.length;
+                allGroups = __spreadArray(__spreadArray([], __read(allGroups), false), __read(nextGroup.points), false);
+                fs.add(nextGroup.points);
+                groups.push(nextGroup);
+            }
+            return groups.filter(function (g) { return g.length > 2; });
+        };
+        this.traceGroup = function (m, group) {
+            var traceDirections = [
+                new DPoint_1.DPoint(-1, -1),
+                new DPoint_1.DPoint(-1, 0),
+                new DPoint_1.DPoint(-1, 1),
+                new DPoint_1.DPoint(0, 1),
+                new DPoint_1.DPoint(1, 1),
+                new DPoint_1.DPoint(1, 0),
+                new DPoint_1.DPoint(1, -1),
+                new DPoint_1.DPoint(0, -1)
+            ];
+            var left = function (d) { return (d + traceDirections.length + 1) % traceDirections.length; };
+            var right = function (d) { return (d + traceDirections.length - 1) % traceDirections.length; };
+            if (group.length < 2) {
+                var t = group.at(0).clone();
+                return new DPolygon_1.DPolygon([t, t, t]);
+            }
+            var points = new DPolygon_1.DPolygon();
+            var direction = 0;
+            var prevDirection = Infinity;
+            var p = group.at(0);
+            while (!p.equal(group.at(0)) || points.length < 2) {
+                while (true) {
+                    var nextValue = getByPosition(m, p.clone().move(traceDirections[direction]));
+                    var nextNeighbourValue = getByPosition(m, p.clone().move(traceDirections[left(direction)]));
+                    if (nextValue === TraceMatrixValues.t && nextNeighbourValue === TraceMatrixValues.f) {
+                        break;
+                    }
+                    direction = right(direction);
+                }
+                if (prevDirection !== direction) {
+                    points.push(p);
+                    prevDirection = direction;
+                }
+                p = p.clone().move(traceDirections[direction]);
+                direction = left(left(direction));
+            }
+            return points.approximation().close();
+        };
+        this.createHoleMatrix = function (group) {
+            var e_1, _a;
+            var fullTraceDirections = [
+                new DPoint_1.DPoint(-1, 0),
+                new DPoint_1.DPoint(0, 1),
+                new DPoint_1.DPoint(1, 0),
+                new DPoint_1.DPoint(0, -1)
+            ];
+            group.prepareToFastSearch();
+            var tmpMatrix = TraceMatrix
+                .createMatrix(_this.size, function (p) { return group.fastHas(p) ? TraceMatrixValues.t : TraceMatrixValues.f; });
+            var startCoords = new DPolygon_1.DPolygon();
+            for (var i = 0; i < _this.size.w; i++) {
+                startCoords.push(new DPoint_1.DPoint(i, -1));
+                startCoords.push(new DPoint_1.DPoint(i, _this.size.h));
+            }
+            for (var i = 0; i < _this.size.h; i++) {
+                startCoords.push(new DPoint_1.DPoint(-1, i));
+                startCoords.push(new DPoint_1.DPoint(_this.size.w, i));
+            }
+            while (startCoords.length) {
+                var point = startCoords.pop();
+                try {
+                    for (var fullTraceDirections_1 = (e_1 = void 0, __values(fullTraceDirections)), fullTraceDirections_1_1 = fullTraceDirections_1.next(); !fullTraceDirections_1_1.done; fullTraceDirections_1_1 = fullTraceDirections_1.next()) {
+                        var direction = fullTraceDirections_1_1.value;
+                        var tmpPoint = point.clone().move(direction);
+                        var value = getByPosition(tmpMatrix, tmpPoint, TraceMatrixValues.t);
+                        if (value === TraceMatrixValues.f) {
+                            setByPosition(tmpMatrix, tmpPoint, TraceMatrixValues.t);
+                            startCoords.push(tmpPoint);
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (fullTraceDirections_1_1 && !fullTraceDirections_1_1.done && (_a = fullTraceDirections_1.return)) _a.call(fullTraceDirections_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            var t = _this.reverseMatrix(tmpMatrix);
+            return _this.totalCountInMatrix(t) ? t : null;
+        };
+        this.m = TraceMatrix.createMatrix(this.size, f);
+    }
+    TraceMatrix.prototype.fullMatrixTrace = function () {
+        var _this = this;
+        var groups = this.findAllGroupsInMatrix(this.m);
+        var paths = groups.map(function (g) { return _this.traceGroup(_this.m, g); });
+        var holeMatrixs = groups.map(this.createHoleMatrix);
+        var holesGroups = holeMatrixs.map(function (m) { return m && _this.findAllGroupsInMatrix(m); });
+        var holesPaths = holesGroups.map(function (hg, index) { return hg && hg.map(function (g) { return _this
+            .traceGroup(holeMatrixs[index], g); }).filter(function (r) { return r.length > DPolygon_1.MIN_POINTS_IN_VALID_POLYGON; }); });
+        return groups.map(function (g, index) {
+            var res = paths[index];
+            if (holesGroups[index] && holesGroups[index].length) {
+                res.holes = holesPaths[index];
+            }
+            return res;
+        });
+    };
+    TraceMatrix.prototype.reverseMatrix = function (m) {
+        return TraceMatrix.createMatrix(this.size, function (p) { return getByPosition(m, p) === TraceMatrixValues.f ? TraceMatrixValues.t : TraceMatrixValues.f; });
+    };
+    TraceMatrix.prototype.findMarked = function (m, init) {
+        var s = this.size;
+        var ini = false;
+        for (var i = 0; i < s.w; i++) {
+            for (var j = 0; j < s.h; j++) {
+                if (!ini && init) {
+                    i = init.x;
+                    j = init.y;
+                    ini = true;
+                    continue;
+                }
+                if (getByPosition(m, new DPoint_1.DPoint(i, j)) === TraceMatrixValues.t) {
+                    return new DPoint_1.DPoint(i, j);
+                }
+            }
+        }
+        return null;
+    };
+    TraceMatrix.prototype.totalCountInMatrix = function (m) {
+        var res = 0;
+        var s = this.size;
+        for (var i = 0; i < s.w; i++) {
+            for (var j = 0; j < s.h; j++) {
+                if (getByPosition(m, new DPoint_1.DPoint(i, j))) {
+                    res++;
+                }
+            }
+        }
+        return res;
+    };
+    TraceMatrix.createMatrix = function (size, f) {
+        if (f === void 0) { f = function () { return TraceMatrixValues.f; }; }
+        return (0, utils_1.createArray)(size.h)
+            .map(function (v, i) { return (0, utils_1.createArray)(size.w).map(function (v2, j) { return f(new DPoint_1.DPoint(j, i)); }); });
+    };
+    return TraceMatrix;
+}());
+exports.TraceMatrix = TraceMatrix;

package/dist/cjs/utils.js

@@ -0,0 +1,191 @@
+"use strict";
+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;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCanvas = exports.gaussianElimination = exports.createMatrix = exports.createArray = exports.checkFunction = exports.isDefAndNotNull = exports.warn = void 0;
+var index_1 = require("./index");
+var DPoint_1 = require("./DPoint");
+var warn = function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    if (index_1.DGeo.DEBUG) {
+        console.warn.apply(console, __spreadArray([], __read(args), false));
+    }
+};
+exports.warn = warn;
+var isDefAndNotNull = function (a) { return a != undefined; };
+exports.isDefAndNotNull = isDefAndNotNull;
+var hook = function (scope) { return function () { return scope; }; };
+var shouldBeInt = function (scope, funcName, argName) { return function (p) {
+    if (!p.clone().round()
+        .equal(p)) {
+        (0, exports.warn)("\"" + funcName + "\" -> \"" + argName + "\" should be Int!");
+    }
+    return scope;
+}; };
+var shouldBeUInt = function (scope, funcName, argName) { return function (p) {
+    if (!p.clone().round()
+        .equal(p) || !p.gtOrEqual(DPoint_1.DPoint.zero())) {
+        (0, exports.warn)("\"" + funcName + "\" -> \"" + argName + "\" should be UInt!");
+    }
+    return scope;
+}; };
+var shouldBeDegree = function (scope, funcName, argName) { return function (p) {
+    if (!p.likeWorldGeodeticSystem) {
+        (0, exports.warn)("\"" + funcName + "\" -> \"" + argName + "\" should be degree!");
+    }
+    return scope;
+}; };
+var shouldBeRadians = function (scope, funcName, argName) { return function (p) {
+    if (!p.likeRadians) {
+        (0, exports.warn)("\"" + funcName + "\" -> \"" + argName + "\" should be radians!");
+    }
+    return scope;
+}; };
+var shouldExist = function (scope, funcName, argName) { return function (p) {
+    if (!(0, exports.isDefAndNotNull)(p)) {
+        (0, exports.warn)("\"" + funcName + "\" -> \"" + argName + "\" should exist!");
+    }
+    return scope;
+}; };
+var shouldBeMeters = function (scope, funcName, argName) { return function (p) {
+    if (!p.likePseudoMercator) {
+        (0, exports.warn)("\"" + funcName + "\" -> \"" + argName + "\" should be meters!");
+    }
+    return scope;
+}; };
+var checkFunction = function (funcName) { return ({
+    checkArgument: function (argName) {
+        if (!index_1.DGeo.DEBUG) {
+            return {
+                shouldBeDegree: hook(this),
+                shouldBeMeters: hook(this),
+                shouldBeInt: hook(this),
+                shouldBeUInt: hook(this),
+                shouldBeRadians: hook(this),
+                shouldExist: hook(this)
+            };
+        }
+        return {
+            shouldBeDegree: shouldBeDegree(this, funcName, argName),
+            shouldBeMeters: shouldBeMeters(this, funcName, argName),
+            shouldBeInt: shouldBeInt(this, funcName, argName),
+            shouldBeUInt: shouldBeUInt(this, funcName, argName),
+            shouldBeRadians: shouldBeRadians(this, funcName, argName),
+            shouldExist: shouldExist(this, funcName, argName)
+        };
+    }
+}); };
+exports.checkFunction = checkFunction;
+var createArray = function (v, fillSymbol) {
+    if (fillSymbol === void 0) { fillSymbol = 0; }
+    return new Array(v).fill(fillSymbol);
+};
+exports.createArray = createArray;
+var createMatrix = function (_a, fillSymbol) {
+    var h = _a.h, w = _a.w;
+    if (fillSymbol === void 0) { fillSymbol = 0; }
+    return (0, exports.createArray)(h)
+        .map(function () { return (0, exports.createArray)(w, fillSymbol); });
+};
+exports.createMatrix = createMatrix;
+var gaussianElimination = function (matrix) {
+    var n = matrix.length;
+    var matrixClone = (0, exports.createMatrix)(new DPoint_1.DPoint(n + 1, n));
+    for (var i = 0; i < n; i++) {
+        for (var j = 0; j < n + 1; j++) {
+            matrix[i][j] = matrix[i][j] === 0 ? exports.gaussianElimination.MIN : matrix[i][j];
+            matrixClone[i][j] = matrix[i][j];
+        }
+    }
+    for (var k = 0; k < n; k++) {
+        for (var i = 0; i < n + 1; i++) {
+            matrixClone[k][i] /= matrix[k][k];
+        }
+        for (var i = k + 1; i < n; i++) {
+            var K = matrixClone[i][k] / matrixClone[k][k];
+            for (var j = 0; j < n + 1; j++) {
+                matrixClone[i][j] -= matrixClone[k][j] * K;
+            }
+        }
+        for (var i = 0; i < n; i++) {
+            for (var j = 0; j < n + 1; j++) {
+                matrix[i][j] = matrixClone[i][j];
+            }
+        }
+    }
+    for (var k = n - 1; k > -1; k--) {
+        for (var i = n; i > -1; i--) {
+            matrixClone[k][i] /= matrix[k][k];
+        }
+        for (var i = k - 1; i > -1; i--) {
+            var K = matrixClone[i][k] / matrixClone[k][k];
+            for (var j = n; j > -1; j--) {
+                matrixClone[i][j] -= matrixClone[k][j] * K;
+            }
+        }
+    }
+    var answer = (0, exports.createArray)(n);
+    for (var i = 0; i < n; i++) {
+        answer[i] = matrixClone[i][n];
+    }
+    return answer;
+};
+exports.gaussianElimination = gaussianElimination;
+exports.gaussianElimination.MIN = 1e-10;
+var createCanvas = function (a, b, c) {
+    var _a;
+    var w = 0;
+    var h = 0;
+    var offscreen = false;
+    if (a instanceof DPoint_1.DPoint) {
+        var x = a.x, y = a.y;
+        w = x;
+        h = y;
+    }
+    else {
+        w = a;
+        h = a;
+    }
+    if (typeof b === 'boolean') {
+        offscreen = b;
+    }
+    else if (typeof b === 'number') {
+        h = b;
+    }
+    if (typeof c === 'boolean') {
+        offscreen = c;
+    }
+    var canvas = offscreen ? new OffscreenCanvas(w, h) : ((_a = exports.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/{DCircle.js → es2015/DCircle.js}

@@ -1,11 +1,8 @@
-"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) {
+import { DPoint, EARTH_RADIUS_IN_METERS } from './DPoint';
+import { DPolygon } from './DPolygon';
+import { checkFunction } from './utils';
+export class DCircle {
+    constructor(center = DPoint.zero(), r = 0) {
         this.center = center;
         this.r = r;
     }
@@ -40,10 +37,10 @@ class DCircle {
         const y32 = y2 + hd * dx;
         const res = [];
         if (!isNaN(x31) && !isNaN(y31)) {
-            res.push(new DPoint_1.DPoint(x31, y31));
+            res.push(new DPoint(x31, y31));
         }
         if (!isNaN(x32) && !isNaN(y32) && !(x31 === x32 && y31 === y32)) {
-            res.push(new DPoint_1.DPoint(x32, y32));
+            res.push(new DPoint(x32, y32));
         }
         return res;
     }
@@ -55,17 +52,17 @@ class DCircle {
         const points = [];
         let angle = startAngle;
         while (angle < stopAngle - step) {
-            points.push(new DPoint_1.DPoint(this.r).scale(Math.cos(angle), Math.sin(angle))
+            points.push(new 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;
-        points.push(new DPoint_1.DPoint(x, y));
-        return new DPolygon_1.DPolygon(points);
+        points.push(new DPoint(x, y));
+        return new DPolygon(points);
     }
     findPolygonInsideOnSphere(pointCount = 64, startAngle = 0, stopAngle = 2 * Math.PI) {
-        (0, utils_1.checkFunction)('findPolygonInsideOnSphere')
+        checkFunction('findPolygonInsideOnSphere')
             .checkArgument('center')
             .shouldBeDegree(this.center);
         const step = 2 * Math.PI / pointCount;
@@ -76,16 +73,15 @@ class DCircle {
             angle += step;
         }
         points.push(this.sphereOffset(stopAngle));
-        return new DPolygon_1.DPolygon(points);
+        return new DPolygon(points);
     }
-    sphereOffset(bearing, earthRadius = DPoint_1.EARTH_RADIUS_IN_METERS) {
+    sphereOffset(bearing, earthRadius = 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) +
             Math.cos(lat1) * Math.sin(dByR) * Math.cos(bearing));
         const 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 new DPoint(lon, lat).radiansToDegrees();
     }
 }
-exports.DCircle = DCircle;

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

@@ -1,11 +1,8 @@
-"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()) {
+import { DPoint } from './DPoint';
+import { checkFunction } from './utils';
+import { DNumbers } from './DNumbers';
+export class DLine {
+    constructor(a, b, c, begin = DPoint.zero(), end = DPoint.zero()) {
         this.a = a;
         this.b = b;
         this.c = c;
@@ -16,7 +13,7 @@ class DLine {
         return new DLine(this.a, this.b, this.c, this.begin.clone(), this.end.clone());
     }
     findPerpendicular(p) {
-        (0, utils_1.checkFunction)('findPerpendicular')
+        checkFunction('findPerpendicular')
             .checkArgument('this.begin')
             .shouldBeMeters(this.begin)
             .checkArgument('this.end')
@@ -26,7 +23,7 @@ class DLine {
         return new DLine(-this.b, this.a, this.b * p.x - this.a * p.y);
     }
     perpendicularDistance(p) {
-        (0, utils_1.checkFunction)('perpendicularDistance')
+        checkFunction('perpendicularDistance')
             .checkArgument('this.begin')
             .shouldBeMeters(this.begin)
             .checkArgument('this.end')
@@ -140,21 +137,21 @@ class DLine {
     }
     x(p) {
         if (this.isParallelY) {
-            return new DPoint_1.DPoint(-this.c / this.a, p.y);
+            return new DPoint(-this.c / this.a, p.y);
         }
         if (this.isParallelX) {
-            return new DPoint_1.DPoint(p.x, -this.c / this.b);
+            return new DPoint(p.x, -this.c / this.b);
         }
-        return new DPoint_1.DPoint(-this.b / this.a * p.y - this.c / this.a, p.y);
+        return new DPoint(-this.b / this.a * p.y - this.c / this.a, p.y);
     }
     y(p) {
         if (this.isParallelY) {
-            return new DPoint_1.DPoint(-this.c / this.a, p.y);
+            return new DPoint(-this.c / this.a, p.y);
         }
         if (this.isParallelX) {
-            return new DPoint_1.DPoint(p.x, -this.c / this.b);
+            return new DPoint(p.x, -this.c / this.b);
         }
-        return new DPoint_1.DPoint(p.x, -this.a / this.b * p.x - this.c / this.b);
+        return new DPoint(p.x, -this.a / this.b * p.x - this.c / this.b);
     }
     findPoint(l) {
         if (this.isParallelY && l.isParallelY) {
@@ -164,28 +161,28 @@ class DLine {
             return null;
         }
         if (this.isParallelX && l.isParallelY) {
-            return new DPoint_1.DPoint(-l.c / l.a, -this.c / this.b);
+            return new DPoint(-l.c / l.a, -this.c / this.b);
         }
         if (this.isParallelY && l.isParallelX) {
-            return new DPoint_1.DPoint(-this.c / this.a, -l.c / l.b);
+            return new DPoint(-this.c / this.a, -l.c / l.b);
         }
         if (this.isParallelY) {
             const x = -this.c / this.a;
-            return l.y(new DPoint_1.DPoint(x));
+            return l.y(new DPoint(x));
         }
         if (this.isParallelX) {
             const y = -this.c / this.b;
-            return l.x(new DPoint_1.DPoint(0, y));
+            return l.x(new DPoint(0, y));
         }
         if (l.isParallelY) {
             const x = -l.c / l.a;
-            return this.y(new DPoint_1.DPoint(x));
+            return this.y(new DPoint(x));
         }
         if (l.isParallelX) {
             const y = -l.c / l.b;
-            return this.x(new DPoint_1.DPoint(0, y));
+            return this.x(new 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)));
+        const 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;
         }
@@ -204,7 +201,7 @@ class DLine {
         return [this.begin, this.end];
     }
     getFi() {
-        (0, utils_1.checkFunction)('getFi')
+        checkFunction('getFi')
             .checkArgument('this.begin')
             .shouldBeMeters(this.begin)
             .checkArgument('this.end')
@@ -222,12 +219,12 @@ class DLine {
     }
     movePoint(p, d) {
         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 td = this.x(new DPoint(1, 1)).distance(this.x(new DPoint(2, 2))) / 2;
+        const sinCos = new DPoint(Math.sin(fi), Math.cos(fi));
         const dt = sinCos.clone().scale(td);
         const p1T = p.clone().move(dt.clone().minus());
         const p2T = p.clone().move(dt);
-        if (DNumbers_1.DNumbers.like(this.y(p1T).y, p1T.y) || DNumbers_1.DNumbers.like(this.y(p2T).y, p2T.y)) {
+        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(({ x }) => -x));
@@ -248,4 +245,3 @@ class DLine {
         return new DLine(w * c - e * b, e * a - q * c, q * b - w * a);
     }
 }
-exports.DLine = DLine;

package/dist/es2015/DNumbers.js

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