dgeoutils 2.4.12 → 2.4.13

package/dist/cjs/DPoint.d.ts

@@ -1,7 +1,7 @@
 import { DLine } from './DLine';
 import { DPolygon } from './DPolygon';
 import { Point } from 'geojson';
-export declare const EARTH_RADIUS_IN_METERS = 6371008.8;
+export declare const EARTH_RADIUS_IN_METERS = 6378137;
 export declare type DCoord = [number, number] | [number, number, number];
 export interface LatLng {
     lat: number;
@@ -83,6 +83,14 @@ export declare class DPoint {
     divide(p: DPoint): DPoint;
     divide(x: number, y: number): DPoint;
     divide(x: number, y: number, z: number): DPoint;
+    mod(v: number): DPoint;
+    mod(p: DPoint): DPoint;
+    mod(x: number, y: number): DPoint;
+    mod(x: number, y: number, z: number): DPoint;
+    div(v: number): DPoint;
+    div(p: DPoint): DPoint;
+    div(x: number, y: number): DPoint;
+    div(x: number, y: number, z: number): DPoint;
     equal(p: DPoint): boolean;
     like(p: DPoint, d?: number): boolean;
     flipVertically(size: DPoint): DPoint;

package/dist/cjs/DPoint.js

@@ -35,11 +35,11 @@ var diff = 0;
 var radiansPolygon = new DPolygon_1.DPolygon();
 var pseudoMercatorPolygon = new DPolygon_1.DPolygon();
 var worldGeodeticPolygon = new DPolygon_1.DPolygon();
-exports.EARTH_RADIUS_IN_METERS = 6371008.8;
-var EARTH_IN_MITERS = 20037508.34;
+exports.EARTH_RADIUS_IN_METERS = 6378137;
+var EARTH_IN_METERS = 20037508.34;
 var DEGREES_IN_EARTH = 180;
-var MITERS_IN_ONE_DEGREE = EARTH_IN_MITERS / DEGREES_IN_EARTH;
-var DEGREES_IN_ONE_MITER = DEGREES_IN_EARTH / EARTH_IN_MITERS;
+var METERS_IN_ONE_DEGREE = EARTH_IN_METERS / DEGREES_IN_EARTH;
+var DEGREES_IN_ONE_METER = DEGREES_IN_EARTH / EARTH_IN_METERS;
 exports.HALF_PI_IN_DEGREE = 90;
 exports.PI_IN_DEGREE = 180;
 exports.DOUBLE_PI_IN_DEGREE = 360;
@@ -335,9 +335,9 @@ var DPoint = (function () {
         (0, utils_1.checkFunction)('degreeToMeters')
             .checkArgument('this')
             .shouldBeDegree(this);
-        var x = ((this.x + exports.PI_IN_DEGREE) % exports.DOUBLE_PI_IN_DEGREE - exports.PI_IN_DEGREE) * MITERS_IN_ONE_DEGREE;
+        var x = ((this.x + exports.PI_IN_DEGREE) % exports.DOUBLE_PI_IN_DEGREE - exports.PI_IN_DEGREE) * METERS_IN_ONE_DEGREE;
         var y = (Math.log(Math.tan(((this.y + exports.HALF_PI_IN_DEGREE) % exports.PI_IN_DEGREE) *
-            (Math.PI / exports.DOUBLE_PI_IN_DEGREE))) / exports.PI_TO_DEGREE) * MITERS_IN_ONE_DEGREE;
+            (Math.PI / exports.DOUBLE_PI_IN_DEGREE))) / exports.PI_TO_DEGREE) * METERS_IN_ONE_DEGREE;
         this.x = x;
         this.y = y;
         return this;
@@ -346,8 +346,8 @@ var DPoint = (function () {
         (0, utils_1.checkFunction)('metersToDegree')
             .checkArgument('this')
             .shouldBeMeters(this);
-        var lon = this.x * DEGREES_IN_ONE_MITER;
-        var lat = Math.atan(Math.pow(Math.E, ((this.y / MITERS_IN_ONE_DEGREE) * exports.PI_TO_DEGREE))) *
+        var lon = this.x * DEGREES_IN_ONE_METER;
+        var lat = Math.atan(Math.pow(Math.E, ((this.y / METERS_IN_ONE_DEGREE) * exports.PI_TO_DEGREE))) *
             (exports.DOUBLE_PI_IN_DEGREE / Math.PI) - exports.HALF_PI_IN_DEGREE;
         this.x = lon;
         this.y = lat;
@@ -455,6 +455,58 @@ var DPoint = (function () {
         }
         return this;
     };
+    DPoint.prototype.mod = function (x, y, z) {
+        if (y === void 0) { y = x; }
+        var xV = 0;
+        var yV = 0;
+        var zV = undefined;
+        if (x instanceof DPoint) {
+            xV = this.x % x.x;
+            yV = this.y % x.y;
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(x.z)) {
+                zV = this.z % x.z;
+            }
+        }
+        else {
+            xV = this.x % x;
+            yV = this.y % y;
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(z)) {
+                zV = this.z % z;
+            }
+        }
+        this.x = xV;
+        this.y = yV;
+        if ((0, utils_1.isDefAndNotNull)(zV)) {
+            this.z = zV;
+        }
+        return this;
+    };
+    DPoint.prototype.div = function (x, y, z) {
+        if (y === void 0) { y = x; }
+        var xV = 0;
+        var yV = 0;
+        var zV = undefined;
+        if (x instanceof DPoint) {
+            xV = (0, utils_1.div)(this.x, x.x);
+            yV = (0, utils_1.div)(this.y, x.y);
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(x.z)) {
+                zV = (0, utils_1.div)(this.z, x.z);
+            }
+        }
+        else {
+            xV = (0, utils_1.div)(this.x, x);
+            yV = (0, utils_1.div)(this.y, y);
+            if ((0, utils_1.isDefAndNotNull)(this.z) && (0, utils_1.isDefAndNotNull)(z)) {
+                zV = (0, utils_1.div)(this.z, z);
+            }
+        }
+        this.x = xV;
+        this.y = yV;
+        if ((0, utils_1.isDefAndNotNull)(zV)) {
+            this.z = zV;
+        }
+        return this;
+    };
     DPoint.prototype.equal = function (p) {
         return this.x === p.x && this.y === p.y && this.z === p.z;
     };

package/dist/cjs/DPolygonLoop.d.ts

@@ -36,6 +36,12 @@ export declare class DPolygonLoop {
     divide(v: number): DPolygonLoop;
     divide(p: DPoint): DPolygonLoop;
     divide(x: number, y: number): DPolygonLoop;
+    div(v: number): DPolygonLoop;
+    div(p: DPoint): DPolygonLoop;
+    div(x: number, y: number): DPolygonLoop;
+    mod(v: number): DPolygonLoop;
+    mod(p: DPoint): DPolygonLoop;
+    mod(x: number, y: number): DPolygonLoop;
     degreeToRadians(): DPolygonLoop;
     radiansToDegrees(): DPolygonLoop;
     radiansToMeters(): DPolygonLoop;

package/dist/cjs/DPolygonLoop.js

@@ -36,6 +36,8 @@ var LoopFunctions;
     LoopFunctions[LoopFunctions["metersToDegree"] = 30] = "metersToDegree";
     LoopFunctions[LoopFunctions["flipVertically"] = 31] = "flipVertically";
     LoopFunctions[LoopFunctions["setProperties"] = 32] = "setProperties";
+    LoopFunctions[LoopFunctions["div"] = 33] = "div";
+    LoopFunctions[LoopFunctions["mod"] = 34] = "mod";
 })(LoopFunctions || (LoopFunctions = {}));
 var decodePoolRecord = function (a, _a) {
     var functionName = _a.functionName, pointArg = _a.pointArg, numberPointArg = _a.numberPointArg, numberArg = _a.numberArg, setterArg = _a.setterArg, setterArgByObject = _a.setterArgByObject;
@@ -113,6 +115,14 @@ var decodePoolRecord = function (a, _a) {
             res = function (k, index) { return a(k, index)
                 .divide(numberPointArg, numberArg); };
             break;
+        case LoopFunctions.div:
+            res = function (k, index) { return a(k, index)
+                .div(numberPointArg, numberArg); };
+            break;
+        case LoopFunctions.mod:
+            res = function (k, index) { return a(k, index)
+                .mod(numberPointArg, numberArg); };
+            break;
         case LoopFunctions.degreeToRadians:
             res = function (k, index) { return a(k, index)
                 .degreeToRadians(); };
@@ -322,6 +332,22 @@ var DPolygonLoop = (function () {
         });
         return this;
     };
+    DPolygonLoop.prototype.div = function (x, y) {
+        this.pool.push({
+            functionName: LoopFunctions.div,
+            numberPointArg: x,
+            numberArg: y
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.mod = function (x, y) {
+        this.pool.push({
+            functionName: LoopFunctions.mod,
+            numberPointArg: x,
+            numberArg: y
+        });
+        return this;
+    };
     DPolygonLoop.prototype.degreeToRadians = function () {
         this.pool.push({
             functionName: LoopFunctions.degreeToRadians

package/dist/cjs/utils.d.ts

@@ -39,4 +39,5 @@ export declare const cartesianProduct: {
     <T>(a: T[], ...b: T[][]): T[][];
 };
 export declare const getCombinations: <T>(arr: T[][]) => T[][];
+export declare const div: (a: number, b: number) => number;
 export {};

package/dist/cjs/utils.js

@@ -25,7 +25,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCombinations = exports.cartesianProduct = exports.createCanvas = exports.gaussianElimination = exports.createMatrix = exports.createArray = exports.checkFunction = exports.isDefAndNotNull = exports.warn = exports.DGeo = void 0;
+exports.div = exports.getCombinations = exports.cartesianProduct = exports.createCanvas = exports.gaussianElimination = exports.createMatrix = exports.createArray = exports.checkFunction = exports.isDefAndNotNull = exports.warn = exports.DGeo = void 0;
 var DPoint_1 = require("./DPoint");
 exports.DGeo = {
     DEBUG: false
@@ -214,3 +214,5 @@ var getCombinations = function (arr) {
     return ans;
 };
 exports.getCombinations = getCombinations;
+var div = function (a, b) { return Math.floor(a / b); };
+exports.div = div;

package/dist/es2015/DPoint.js

@@ -1,15 +1,15 @@
 import { DLine } from './DLine';
 import { DPolygon } from './DPolygon';
-import { checkFunction, createArray, isDefAndNotNull } from './utils';
+import { checkFunction, createArray, div, isDefAndNotNull } from './utils';
 const diff = 0;
 const radiansPolygon = new DPolygon();
 const pseudoMercatorPolygon = new DPolygon();
 const worldGeodeticPolygon = new DPolygon();
-export const EARTH_RADIUS_IN_METERS = 6371008.8;
-const EARTH_IN_MITERS = 20037508.34;
+export const EARTH_RADIUS_IN_METERS = 6378137;
+const EARTH_IN_METERS = 20037508.34;
 const DEGREES_IN_EARTH = 180;
-const MITERS_IN_ONE_DEGREE = EARTH_IN_MITERS / DEGREES_IN_EARTH;
-const DEGREES_IN_ONE_MITER = DEGREES_IN_EARTH / EARTH_IN_MITERS;
+const METERS_IN_ONE_DEGREE = EARTH_IN_METERS / DEGREES_IN_EARTH;
+const DEGREES_IN_ONE_METER = DEGREES_IN_EARTH / EARTH_IN_METERS;
 export const HALF_PI_IN_DEGREE = 90;
 export const PI_IN_DEGREE = 180;
 export const DOUBLE_PI_IN_DEGREE = 360;
@@ -295,9 +295,9 @@ export class DPoint {
         checkFunction('degreeToMeters')
             .checkArgument('this')
             .shouldBeDegree(this);
-        const x = ((this.x + PI_IN_DEGREE) % DOUBLE_PI_IN_DEGREE - PI_IN_DEGREE) * MITERS_IN_ONE_DEGREE;
+        const x = ((this.x + PI_IN_DEGREE) % DOUBLE_PI_IN_DEGREE - PI_IN_DEGREE) * METERS_IN_ONE_DEGREE;
         const y = (Math.log(Math.tan(((this.y + HALF_PI_IN_DEGREE) % PI_IN_DEGREE) *
-            (Math.PI / DOUBLE_PI_IN_DEGREE))) / PI_TO_DEGREE) * MITERS_IN_ONE_DEGREE;
+            (Math.PI / DOUBLE_PI_IN_DEGREE))) / PI_TO_DEGREE) * METERS_IN_ONE_DEGREE;
         this.x = x;
         this.y = y;
         return this;
@@ -306,8 +306,8 @@ export class DPoint {
         checkFunction('metersToDegree')
             .checkArgument('this')
             .shouldBeMeters(this);
-        const lon = this.x * DEGREES_IN_ONE_MITER;
-        const lat = Math.atan(Math.pow(Math.E, ((this.y / MITERS_IN_ONE_DEGREE) * PI_TO_DEGREE))) *
+        const lon = this.x * DEGREES_IN_ONE_METER;
+        const lat = Math.atan(Math.pow(Math.E, ((this.y / METERS_IN_ONE_DEGREE) * PI_TO_DEGREE))) *
             (DOUBLE_PI_IN_DEGREE / Math.PI) - HALF_PI_IN_DEGREE;
         this.x = lon;
         this.y = lat;
@@ -412,6 +412,56 @@ export class DPoint {
         }
         return this;
     }
+    mod(x, y = x, z) {
+        let xV = 0;
+        let yV = 0;
+        let zV = undefined;
+        if (x instanceof DPoint) {
+            xV = this.x % x.x;
+            yV = this.y % x.y;
+            if (isDefAndNotNull(this.z) && isDefAndNotNull(x.z)) {
+                zV = this.z % x.z;
+            }
+        }
+        else {
+            xV = this.x % x;
+            yV = this.y % y;
+            if (isDefAndNotNull(this.z) && isDefAndNotNull(z)) {
+                zV = this.z % z;
+            }
+        }
+        this.x = xV;
+        this.y = yV;
+        if (isDefAndNotNull(zV)) {
+            this.z = zV;
+        }
+        return this;
+    }
+    div(x, y = x, z) {
+        let xV = 0;
+        let yV = 0;
+        let zV = undefined;
+        if (x instanceof DPoint) {
+            xV = div(this.x, x.x);
+            yV = div(this.y, x.y);
+            if (isDefAndNotNull(this.z) && isDefAndNotNull(x.z)) {
+                zV = div(this.z, x.z);
+            }
+        }
+        else {
+            xV = div(this.x, x);
+            yV = div(this.y, y);
+            if (isDefAndNotNull(this.z) && isDefAndNotNull(z)) {
+                zV = div(this.z, z);
+            }
+        }
+        this.x = xV;
+        this.y = yV;
+        if (isDefAndNotNull(zV)) {
+            this.z = zV;
+        }
+        return this;
+    }
     equal(p) {
         return this.x === p.x && this.y === p.y && this.z === p.z;
     }

package/dist/es2015/DPolygonLoop.js

@@ -33,6 +33,8 @@ var LoopFunctions;
     LoopFunctions[LoopFunctions["metersToDegree"] = 30] = "metersToDegree";
     LoopFunctions[LoopFunctions["flipVertically"] = 31] = "flipVertically";
     LoopFunctions[LoopFunctions["setProperties"] = 32] = "setProperties";
+    LoopFunctions[LoopFunctions["div"] = 33] = "div";
+    LoopFunctions[LoopFunctions["mod"] = 34] = "mod";
 })(LoopFunctions || (LoopFunctions = {}));
 const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg, setterArg, setterArgByObject }) => {
     let res = a;
@@ -109,6 +111,14 @@ const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg
             res = (k, index) => a(k, index)
                 .divide(numberPointArg, numberArg);
             break;
+        case LoopFunctions.div:
+            res = (k, index) => a(k, index)
+                .div(numberPointArg, numberArg);
+            break;
+        case LoopFunctions.mod:
+            res = (k, index) => a(k, index)
+                .mod(numberPointArg, numberArg);
+            break;
         case LoopFunctions.degreeToRadians:
             res = (k, index) => a(k, index)
                 .degreeToRadians();
@@ -315,6 +325,22 @@ export class DPolygonLoop {
         });
         return this;
     }
+    div(x, y) {
+        this.pool.push({
+            functionName: LoopFunctions.div,
+            numberPointArg: x,
+            numberArg: y
+        });
+        return this;
+    }
+    mod(x, y) {
+        this.pool.push({
+            functionName: LoopFunctions.mod,
+            numberPointArg: x,
+            numberArg: y
+        });
+        return this;
+    }
     degreeToRadians() {
         this.pool.push({
             functionName: LoopFunctions.degreeToRadians

package/dist/es2015/utils.js

@@ -160,3 +160,4 @@ export const getCombinations = (arr) => {
     }
     return ans;
 };
+export const div = (a, b) => Math.floor(a / b);

package/dist/esm/DPoint.js

@@ -27,16 +27,16 @@ var __read = (this && this.__read) || function (o, n) {
 };
 import { DLine } from './DLine';
 import { DPolygon } from './DPolygon';
-import { checkFunction, createArray, isDefAndNotNull } from './utils';
+import { checkFunction, createArray, div, isDefAndNotNull } from './utils';
 var diff = 0;
 var radiansPolygon = new DPolygon();
 var pseudoMercatorPolygon = new DPolygon();
 var worldGeodeticPolygon = new DPolygon();
-export var EARTH_RADIUS_IN_METERS = 6371008.8;
-var EARTH_IN_MITERS = 20037508.34;
+export var EARTH_RADIUS_IN_METERS = 6378137;
+var EARTH_IN_METERS = 20037508.34;
 var DEGREES_IN_EARTH = 180;
-var MITERS_IN_ONE_DEGREE = EARTH_IN_MITERS / DEGREES_IN_EARTH;
-var DEGREES_IN_ONE_MITER = DEGREES_IN_EARTH / EARTH_IN_MITERS;
+var METERS_IN_ONE_DEGREE = EARTH_IN_METERS / DEGREES_IN_EARTH;
+var DEGREES_IN_ONE_METER = DEGREES_IN_EARTH / EARTH_IN_METERS;
 export var HALF_PI_IN_DEGREE = 90;
 export var PI_IN_DEGREE = 180;
 export var DOUBLE_PI_IN_DEGREE = 360;
@@ -332,9 +332,9 @@ var DPoint = (function () {
         checkFunction('degreeToMeters')
             .checkArgument('this')
             .shouldBeDegree(this);
-        var x = ((this.x + PI_IN_DEGREE) % DOUBLE_PI_IN_DEGREE - PI_IN_DEGREE) * MITERS_IN_ONE_DEGREE;
+        var x = ((this.x + PI_IN_DEGREE) % DOUBLE_PI_IN_DEGREE - PI_IN_DEGREE) * METERS_IN_ONE_DEGREE;
         var y = (Math.log(Math.tan(((this.y + HALF_PI_IN_DEGREE) % PI_IN_DEGREE) *
-            (Math.PI / DOUBLE_PI_IN_DEGREE))) / PI_TO_DEGREE) * MITERS_IN_ONE_DEGREE;
+            (Math.PI / DOUBLE_PI_IN_DEGREE))) / PI_TO_DEGREE) * METERS_IN_ONE_DEGREE;
         this.x = x;
         this.y = y;
         return this;
@@ -343,8 +343,8 @@ var DPoint = (function () {
         checkFunction('metersToDegree')
             .checkArgument('this')
             .shouldBeMeters(this);
-        var lon = this.x * DEGREES_IN_ONE_MITER;
-        var lat = Math.atan(Math.pow(Math.E, ((this.y / MITERS_IN_ONE_DEGREE) * PI_TO_DEGREE))) *
+        var lon = this.x * DEGREES_IN_ONE_METER;
+        var lat = Math.atan(Math.pow(Math.E, ((this.y / METERS_IN_ONE_DEGREE) * PI_TO_DEGREE))) *
             (DOUBLE_PI_IN_DEGREE / Math.PI) - HALF_PI_IN_DEGREE;
         this.x = lon;
         this.y = lat;
@@ -452,6 +452,58 @@ var DPoint = (function () {
         }
         return this;
     };
+    DPoint.prototype.mod = function (x, y, z) {
+        if (y === void 0) { y = x; }
+        var xV = 0;
+        var yV = 0;
+        var zV = undefined;
+        if (x instanceof DPoint) {
+            xV = this.x % x.x;
+            yV = this.y % x.y;
+            if (isDefAndNotNull(this.z) && isDefAndNotNull(x.z)) {
+                zV = this.z % x.z;
+            }
+        }
+        else {
+            xV = this.x % x;
+            yV = this.y % y;
+            if (isDefAndNotNull(this.z) && isDefAndNotNull(z)) {
+                zV = this.z % z;
+            }
+        }
+        this.x = xV;
+        this.y = yV;
+        if (isDefAndNotNull(zV)) {
+            this.z = zV;
+        }
+        return this;
+    };
+    DPoint.prototype.div = function (x, y, z) {
+        if (y === void 0) { y = x; }
+        var xV = 0;
+        var yV = 0;
+        var zV = undefined;
+        if (x instanceof DPoint) {
+            xV = div(this.x, x.x);
+            yV = div(this.y, x.y);
+            if (isDefAndNotNull(this.z) && isDefAndNotNull(x.z)) {
+                zV = div(this.z, x.z);
+            }
+        }
+        else {
+            xV = div(this.x, x);
+            yV = div(this.y, y);
+            if (isDefAndNotNull(this.z) && isDefAndNotNull(z)) {
+                zV = div(this.z, z);
+            }
+        }
+        this.x = xV;
+        this.y = yV;
+        if (isDefAndNotNull(zV)) {
+            this.z = zV;
+        }
+        return this;
+    };
     DPoint.prototype.equal = function (p) {
         return this.x === p.x && this.y === p.y && this.z === p.z;
     };

package/dist/esm/DPolygonLoop.js

@@ -33,6 +33,8 @@ var LoopFunctions;
     LoopFunctions[LoopFunctions["metersToDegree"] = 30] = "metersToDegree";
     LoopFunctions[LoopFunctions["flipVertically"] = 31] = "flipVertically";
     LoopFunctions[LoopFunctions["setProperties"] = 32] = "setProperties";
+    LoopFunctions[LoopFunctions["div"] = 33] = "div";
+    LoopFunctions[LoopFunctions["mod"] = 34] = "mod";
 })(LoopFunctions || (LoopFunctions = {}));
 var decodePoolRecord = function (a, _a) {
     var functionName = _a.functionName, pointArg = _a.pointArg, numberPointArg = _a.numberPointArg, numberArg = _a.numberArg, setterArg = _a.setterArg, setterArgByObject = _a.setterArgByObject;
@@ -110,6 +112,14 @@ var decodePoolRecord = function (a, _a) {
             res = function (k, index) { return a(k, index)
                 .divide(numberPointArg, numberArg); };
             break;
+        case LoopFunctions.div:
+            res = function (k, index) { return a(k, index)
+                .div(numberPointArg, numberArg); };
+            break;
+        case LoopFunctions.mod:
+            res = function (k, index) { return a(k, index)
+                .mod(numberPointArg, numberArg); };
+            break;
         case LoopFunctions.degreeToRadians:
             res = function (k, index) { return a(k, index)
                 .degreeToRadians(); };
@@ -319,6 +329,22 @@ var DPolygonLoop = (function () {
         });
         return this;
     };
+    DPolygonLoop.prototype.div = function (x, y) {
+        this.pool.push({
+            functionName: LoopFunctions.div,
+            numberPointArg: x,
+            numberArg: y
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.mod = function (x, y) {
+        this.pool.push({
+            functionName: LoopFunctions.mod,
+            numberPointArg: x,
+            numberArg: y
+        });
+        return this;
+    };
     DPolygonLoop.prototype.degreeToRadians = function () {
         this.pool.push({
             functionName: LoopFunctions.degreeToRadians

package/dist/esm/utils.js

@@ -202,3 +202,4 @@ export var getCombinations = function (arr) {
     }
     return ans;
 };
+export var div = function (a, b) { return Math.floor(a / b); };