dgeoutils 2.2.19 → 2.3.0

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

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TraceMatrix = exports.TraceMatrixValues = void 0;
-const DPoint_1 = require("./DPoint");
-const DPolygon_1 = require("./DPolygon");
-const FastSearch_1 = require("./FastSearch");
-const utils_1 = require("./utils");
-var TraceMatrixValues;
+import { DPoint } from './DPoint';
+import { DPolygon, MIN_POINTS_IN_VALID_POLYGON } from './DPolygon';
+import { FastSearch } from './FastSearch';
+import { createArray } from './utils';
+export var TraceMatrixValues;
 (function (TraceMatrixValues) {
     TraceMatrixValues[TraceMatrixValues["f"] = 0] = "f";
     TraceMatrixValues[TraceMatrixValues["t"] = 1] = "t";
-})(TraceMatrixValues = exports.TraceMatrixValues || (exports.TraceMatrixValues = {}));
+})(TraceMatrixValues || (TraceMatrixValues = {}));
 const getByPosition = (m, p, defaultValue = TraceMatrixValues.f) => {
     if (m[p.y] === undefined || m[p.y][p.x] === undefined) {
         return defaultValue;
@@ -23,11 +20,11 @@ const setByPosition = (m, p, value) => {
     m[p.y][p.x] = value;
     return m[p.y][p.x];
 };
-class TraceMatrix {
+export class TraceMatrix {
     constructor(size, f) {
         this.size = size;
         this.findGroupByIndex = (m, s) => {
-            const res = new DPolygon_1.DPolygon();
+            const res = new DPolygon();
             if (s && getByPosition(m, s) === TraceMatrixValues.t) {
                 res.push(s);
                 let startIndex = 0;
@@ -37,7 +34,7 @@ class TraceMatrix {
                     const r = res.at(startIndex);
                     for (let i = -1; i < 2; i++) {
                         for (let j = -1; j < 2; j++) {
-                            const t = new DPoint_1.DPoint(r.x + i, r.y + j);
+                            const t = new 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);
@@ -59,7 +56,7 @@ class TraceMatrix {
             const groups = [group];
             let groupSum = group.length;
             let allGroups = [...group.points];
-            const fs = new FastSearch_1.FastSearch();
+            const fs = new FastSearch();
             fs.add(allGroups);
             while (groupSum < this.totalCountInMatrix(m)) {
                 let mark = this.findMarked(m);
@@ -76,22 +73,22 @@ class TraceMatrix {
         };
         this.traceGroup = (m, group) => {
             const 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)
+                new DPoint(-1, -1),
+                new DPoint(-1, 0),
+                new DPoint(-1, 1),
+                new DPoint(0, 1),
+                new DPoint(1, 1),
+                new DPoint(1, 0),
+                new DPoint(1, -1),
+                new DPoint(0, -1)
             ];
             const left = (d) => (d + traceDirections.length + 1) % traceDirections.length;
             const right = (d) => (d + traceDirections.length - 1) % traceDirections.length;
             if (group.length < 2) {
                 const t = group.at(0).clone();
-                return new DPolygon_1.DPolygon([t, t, t]);
+                return new DPolygon([t, t, t]);
             }
-            const points = new DPolygon_1.DPolygon();
+            const points = new DPolygon();
             let direction = 0;
             let prevDirection = Infinity;
             let p = group.at(0);
@@ -115,22 +112,22 @@ class TraceMatrix {
         };
         this.createHoleMatrix = (group) => {
             const 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)
+                new DPoint(-1, 0),
+                new DPoint(0, 1),
+                new DPoint(1, 0),
+                new DPoint(0, -1)
             ];
             group.prepareToFastSearch();
             const tmpMatrix = TraceMatrix
                 .createMatrix(this.size, (p) => group.fastHas(p) ? TraceMatrixValues.t : TraceMatrixValues.f);
-            const startCoords = new DPolygon_1.DPolygon();
+            const startCoords = new DPolygon();
             for (let 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));
+                startCoords.push(new DPoint(i, -1));
+                startCoords.push(new DPoint(i, this.size.h));
             }
             for (let 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));
+                startCoords.push(new DPoint(-1, i));
+                startCoords.push(new DPoint(this.size.w, i));
             }
             while (startCoords.length) {
                 const point = startCoords.pop();
@@ -154,7 +151,7 @@ class TraceMatrix {
         const holeMatrixs = groups.map(this.createHoleMatrix);
         const holesGroups = holeMatrixs.map((m) => m && this.findAllGroupsInMatrix(m));
         const holesPaths = holesGroups.map((hg, index) => hg && hg.map((g) => this
-            .traceGroup(holeMatrixs[index], g)).filter((r) => r.length > DPolygon_1.MIN_POINTS_IN_VALID_POLYGON));
+            .traceGroup(holeMatrixs[index], g)).filter((r) => r.length > MIN_POINTS_IN_VALID_POLYGON));
         return groups.map((g, index) => {
             const res = paths[index];
             if (holesGroups[index] && holesGroups[index].length) {
@@ -177,8 +174,8 @@ class TraceMatrix {
                     ini = true;
                     continue;
                 }
-                if (getByPosition(m, new DPoint_1.DPoint(i, j)) === TraceMatrixValues.t) {
-                    return new DPoint_1.DPoint(i, j);
+                if (getByPosition(m, new DPoint(i, j)) === TraceMatrixValues.t) {
+                    return new DPoint(i, j);
                 }
             }
         }
@@ -189,7 +186,7 @@ class TraceMatrix {
         const s = this.size;
         for (let i = 0; i < s.w; i++) {
             for (let j = 0; j < s.h; j++) {
-                if (getByPosition(m, new DPoint_1.DPoint(i, j))) {
+                if (getByPosition(m, new DPoint(i, j))) {
                     res++;
                 }
             }
@@ -197,8 +194,7 @@ class TraceMatrix {
         return res;
     }
     static createMatrix(size, f = () => TraceMatrixValues.f) {
-        return (0, utils_1.createArray)(size.h)
-            .map((v, i) => (0, utils_1.createArray)(size.w).map((v2, j) => f(new DPoint_1.DPoint(j, i))));
+        return createArray(size.h)
+            .map((v, i) => createArray(size.w).map((v2, j) => f(new DPoint(j, i))));
     }
 }
-exports.TraceMatrix = TraceMatrix;

package/dist/es2015/index.js

@@ -0,0 +1,13 @@
+export * from './DCircle';
+export * from './DLine';
+export * from './DNumbers';
+export * from './DPoint';
+export * from './DPolygon';
+export * from './FastSearch';
+export * from './TraceMatrix';
+export * from './DPolygonLoop';
+export * from './DPlane';
+export { gaussianElimination, createCanvas, createArray, createMatrix, isDefAndNotNull } from './utils';
+export const DGeo = {
+    DEBUG: false
+};

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 };