dgeoutils 2.2.24 → 2.3.0

package/dist/esm/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 var DGeo = {
+    DEBUG: false
+};

package/dist/esm/utils.js

@@ -0,0 +1,181 @@
+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));
+};
+import { DGeo } from './index';
+import { DPoint } from './DPoint';
+export var warn = function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    if (DGeo.DEBUG) {
+        console.warn.apply(console, __spreadArray([], __read(args), false));
+    }
+};
+export var isDefAndNotNull = function (a) { return a != undefined; };
+var hook = function (scope) { return function () { return scope; }; };
+var shouldBeInt = function (scope, funcName, argName) { return function (p) {
+    if (!p.clone().round()
+        .equal(p)) {
+        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.zero())) {
+        warn("\"" + funcName + "\" -> \"" + argName + "\" should be UInt!");
+    }
+    return scope;
+}; };
+var shouldBeDegree = function (scope, funcName, argName) { return function (p) {
+    if (!p.likeWorldGeodeticSystem) {
+        warn("\"" + funcName + "\" -> \"" + argName + "\" should be degree!");
+    }
+    return scope;
+}; };
+var shouldBeRadians = function (scope, funcName, argName) { return function (p) {
+    if (!p.likeRadians) {
+        warn("\"" + funcName + "\" -> \"" + argName + "\" should be radians!");
+    }
+    return scope;
+}; };
+var shouldExist = function (scope, funcName, argName) { return function (p) {
+    if (!isDefAndNotNull(p)) {
+        warn("\"" + funcName + "\" -> \"" + argName + "\" should exist!");
+    }
+    return scope;
+}; };
+var shouldBeMeters = function (scope, funcName, argName) { return function (p) {
+    if (!p.likePseudoMercator) {
+        warn("\"" + funcName + "\" -> \"" + argName + "\" should be meters!");
+    }
+    return scope;
+}; };
+export var checkFunction = function (funcName) { return ({
+    checkArgument: function (argName) {
+        if (!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)
+        };
+    }
+}); };
+export var createArray = function (v, fillSymbol) {
+    if (fillSymbol === void 0) { fillSymbol = 0; }
+    return new Array(v).fill(fillSymbol);
+};
+export var createMatrix = function (_a, fillSymbol) {
+    var h = _a.h, w = _a.w;
+    if (fillSymbol === void 0) { fillSymbol = 0; }
+    return createArray(h)
+        .map(function () { return createArray(w, fillSymbol); });
+};
+export var gaussianElimination = function (matrix) {
+    var n = matrix.length;
+    var matrixClone = createMatrix(new 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 ? 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 = createArray(n);
+    for (var i = 0; i < n; i++) {
+        answer[i] = matrixClone[i][n];
+    }
+    return answer;
+};
+gaussianElimination.MIN = 1e-10;
+export var createCanvas = function (a, b, c) {
+    var _a;
+    var w = 0;
+    var h = 0;
+    var offscreen = false;
+    if (a instanceof 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 = createCanvas.document) !== null && _a !== void 0 ? _a : document).createElement('canvas');
+    if (!offscreen) {
+        canvas.width = w;
+        canvas.height = h;
+    }
+    return [canvas, canvas.getContext('2d')];
+};