dgeoutils 2.2.13 → 2.2.17

package/README.md

@@ -13,6 +13,8 @@
 [![Coverage branches](https://edejin.github.io/DGeoUtils/media/badges/badge-branches.svg)](https://edejin.github.io/DGeoUtils/media/lcov-report/index.html)
 [![Coverage statements](https://edejin.github.io/DGeoUtils/media/badges/badge-statements.svg)](https://edejin.github.io/DGeoUtils/media/lcov-report/index.html)
 
+[Test time report](https://edejin.github.io/DGeoUtils/media/time-report.html)
+
 [Docs](https://edejin.github.io/DGeoUtils/index.html)
 
 [ESLint Report](https://edejin.github.io/DGeoUtils/media/eslit.html)

package/dist/DCircle.d.ts

@@ -12,7 +12,7 @@ export declare class DCircle {
     clone(): DCircle;
     findPoints(c: DCircle): DPoint[] | number;
     equal({ center, r }: DCircle): boolean;
-    findPolygonInside(pointCount?: number): DPolygon;
-    findPolygonInsideOnSphere(pointCount?: number): DPolygon;
+    findPolygonInside(pointCount?: number, startAngle?: number, stopAngle?: number): DPolygon;
+    findPolygonInsideOnSphere(pointCount?: number, startAngle?: number, stopAngle?: number): DPolygon;
     private sphereOffset;
 }

package/dist/DCircle.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DCircle = void 0;
 const DPoint_1 = require("./DPoint");
 const DPolygon_1 = require("./DPolygon");
-const DNumbers_1 = require("./DNumbers");
 const utils_1 = require("./utils");
 class DCircle {
     constructor(center = DPoint_1.DPoint.zero(), r = 0) {
@@ -51,36 +50,42 @@ class DCircle {
     equal({ center, r }) {
         return this.center.equal(center) && this.r === r;
     }
-    findPolygonInside(pointCount = 64) {
-        const preAngle = 2 * Math.PI / pointCount;
+    findPolygonInside(pointCount = 64, startAngle = 0, stopAngle = 2 * Math.PI) {
+        const step = 2 * Math.PI / pointCount;
         const points = [];
-        for (let i = 0; i < pointCount; i++) {
-            const angle = preAngle * i;
-            const x = this.r * Math.cos(angle) + this.center.x;
-            const y = this.r * Math.sin(angle) + this.center.y;
-            points.push(new DPoint_1.DPoint(x, y));
+        let 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;
         }
-        return new DPolygon_1.DPolygon([...points, points[0]]);
+        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);
     }
-    findPolygonInsideOnSphere(pointCount = 64) {
+    findPolygonInsideOnSphere(pointCount = 64, startAngle = 0, stopAngle = 2 * Math.PI) {
         (0, utils_1.checkFunction)('findPolygonInsideOnSphere')
             .checkArgument('center')
             .shouldBeDegree(this.center);
-        const res = new DPolygon_1.DPolygon();
-        for (let i = 0; i < pointCount; i++) {
-            res.push(this.sphereOffset(2 * Math.PI * i / pointCount));
+        const step = 2 * Math.PI / pointCount;
+        const points = [];
+        let angle = startAngle;
+        while (angle < stopAngle - step) {
+            points.push(this.sphereOffset(angle));
+            angle += step;
         }
-        return res.close();
+        points.push(this.sphereOffset(stopAngle));
+        return new DPolygon_1.DPolygon(points);
     }
     sphereOffset(bearing, earthRadius = DPoint_1.EARTH_RADIUS_IN_METERS) {
-        const lat1 = DNumbers_1.DNumbers.deg2Rad(this.center.y);
-        const lon1 = DNumbers_1.DNumbers.deg2Rad(this.center.x);
+        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(DNumbers_1.DNumbers.rad2Deg(lon), DNumbers_1.DNumbers.rad2Deg(lat));
+        return new DPoint_1.DPoint(lon, lat).radiansToDegrees();
     }
 }
 exports.DCircle = DCircle;

package/dist/DPoint.d.ts

@@ -37,6 +37,7 @@ export declare class DPoint {
     height(z: number): DPoint;
     toWKT(): string;
     distance(p: DPoint): number;
+    distance3d(p: DPoint): number;
     setX(x: number): DPoint;
     setX(f: SetterFunction): DPoint;
     setZ(z: number): DPoint;
@@ -101,4 +102,5 @@ export declare class DPoint {
     setIfLessThan(p: DPoint): DPoint;
     minus(): DPoint;
     orthodromicPath(point: DPoint, pointsCount?: number): DPolygon;
+    findCloserPoint(p: DPolygon): DPoint;
 }

package/dist/DPoint.js

@@ -128,6 +128,21 @@ class DPoint {
         const dy = p.y - this.y;
         return Math.sqrt(dx * dx + dy * dy);
     }
+    distance3d(p) {
+        (0, utils_1.checkFunction)('distance3d')
+            .checkArgument('this')
+            .shouldBeMeters(this)
+            .checkArgument('p')
+            .shouldBeMeters(p)
+            .checkArgument('this.z')
+            .shouldExist(this.z)
+            .checkArgument('p.z')
+            .shouldExist(p.z);
+        const dx = p.x - this.x;
+        const dy = p.y - this.y;
+        const dz = p.z - this.z;
+        return Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
     setX(x) {
         this.x = typeof x === 'number' ? x : x(this);
         return this;
@@ -447,5 +462,17 @@ class DPoint {
             return new DPoint(x, y).radiansToDegrees();
         }));
     }
+    findCloserPoint(p) {
+        let d = Infinity;
+        let res = DPoint.zero();
+        for (const t of p.points) {
+            const td = this.distance(t);
+            if (td < d) {
+                d = td;
+                res = t.clone();
+            }
+        }
+        return res;
+    }
 }
 exports.DPoint = DPoint;

package/dist/DPolygon.d.ts

@@ -102,6 +102,7 @@ export declare class DPolygon {
     get closed(): boolean;
     buffer(v: number, quadrantSegments?: number, type?: number): DPolygon;
     bezier(step?: number): DPolygon;
+    setGrowingHeight(from: number, to: number): DPolygon;
     private getBezierPoint;
     private simpleIncludeX;
     private simpleIncludeY;

package/dist/DPolygon.js

@@ -7,6 +7,7 @@ const DCircle_1 = require("./DCircle");
 const DNumbers_1 = require("./DNumbers");
 const jsts_1 = require("jsts");
 const DPolygonLoop_1 = require("./DPolygonLoop");
+const utils_1 = require("./utils");
 const { buffer: { BufferParameters: { CAP_ROUND, CAP_FLAT, CAP_SQUARE } } } = jsts_1.operation;
 exports.MIN_POINTS_IN_VALID_POLYGON = 3;
 const APPROXIMATION_VALUE = 0.1;
@@ -19,11 +20,11 @@ class DPolygon {
         this.holes = [];
         this.searchStore = {};
     }
-    static arrayOfTrianglesToVertices(triangles, height = 0) {
-        return triangles.map((v) => v
+    static arrayOfTrianglesToVertices(triangles, height) {
+        return triangles.map((v) => ((0, utils_1.isDefAndNotNull)(height) ? v
             .loop()
             .height(height)
-            .run()
+            .run() : v)
             .toArrayOfCoords())
             .flat(2);
     }
@@ -814,6 +815,20 @@ class DPolygon {
         }
         return res;
     }
+    setGrowingHeight(from, to) {
+        const { fullLength } = this;
+        let { first: prevPoint } = this;
+        const d = to - from;
+        let currentDistance = 0;
+        this.loop()
+            .setZ((p) => {
+            currentDistance += prevPoint.distance(p);
+            prevPoint = p;
+            return from + currentDistance / fullLength * d;
+        })
+            .run();
+        return this;
+    }
     getBezierPoint(v) {
         if (this.length === 1) {
             return this.first;

package/dist/utils.d.ts

@@ -1,13 +1,16 @@
 /// <reference types="offscreencanvas" />
 import { DPoint } from './DPoint';
 export declare const warn: (...args: any[]) => void;
+export declare const isDefAndNotNull: (a: any) => boolean;
 declare type CheckFunc = (p: DPoint) => CheckFunction;
+declare type CheckFunc2 = (p: any) => CheckFunction;
 interface CheckArgument {
     shouldBeDegree: CheckFunc;
     shouldBeMeters: CheckFunc;
     shouldBeInt: CheckFunc;
     shouldBeUInt: CheckFunc;
     shouldBeRadians: CheckFunc;
+    shouldExist: CheckFunc2;
 }
 interface CheckFunction {
     checkArgument: (argName: string) => CheckArgument;
@@ -15,12 +18,18 @@ interface CheckFunction {
 export declare const checkFunction: (funcName: string) => CheckFunction;
 export declare const createArray: (v: number, fillSymbol?: any) => number[];
 export declare const createMatrix: ({ h, w }: DPoint, fillSymbol?: any) => number[][];
-export declare const gaussianElimination: (matrix: number[][]) => number[];
-export declare const isDefAndNotNull: (a: any) => boolean;
-declare function createCanvas(size: number): [HTMLCanvasElement, CanvasRenderingContext2D];
-declare function createCanvas(size: number, offscreen: boolean): [OffscreenCanvas, OffscreenCanvasRenderingContext2D];
-declare function createCanvas(w: number, h: number): [HTMLCanvasElement, CanvasRenderingContext2D];
-declare function createCanvas(w: number, h: number, offscreen: boolean): [OffscreenCanvas, OffscreenCanvasRenderingContext2D];
-declare function createCanvas(size: DPoint): [HTMLCanvasElement, CanvasRenderingContext2D];
-declare function createCanvas(size: DPoint, offscreen: boolean): [OffscreenCanvas, OffscreenCanvasRenderingContext2D];
-export { createCanvas };
+export declare const gaussianElimination: {
+    (matrix: number[][]): number[];
+    MIN: number;
+};
+declare type True = true;
+export declare const createCanvas: {
+    (size: number): [HTMLCanvasElement, CanvasRenderingContext2D];
+    (size: number, offscreen: True): [OffscreenCanvas, OffscreenCanvasRenderingContext2D];
+    (w: number, h: number): [HTMLCanvasElement, CanvasRenderingContext2D];
+    (w: number, h: number, offscreen: True): [OffscreenCanvas, OffscreenCanvasRenderingContext2D];
+    (size: DPoint): [HTMLCanvasElement, CanvasRenderingContext2D];
+    (size: DPoint, offscreen: True): [OffscreenCanvas, OffscreenCanvasRenderingContext2D];
+    document?: Document;
+};
+export {};

package/dist/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCanvas = exports.isDefAndNotNull = exports.gaussianElimination = exports.createMatrix = exports.createArray = exports.checkFunction = exports.warn = void 0;
+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) => {
@@ -9,6 +9,8 @@ const warn = (...args) => {
     }
 };
 exports.warn = warn;
+const isDefAndNotNull = (a) => a != undefined;
+exports.isDefAndNotNull = isDefAndNotNull;
 const hook = (scope) => () => scope;
 const shouldBeInt = (scope, funcName, argName) => (p) => {
     if (!p.clone().round()
@@ -36,6 +38,12 @@ const shouldBeRadians = (scope, funcName, argName) => (p) => {
     }
     return scope;
 };
+const shouldExist = (scope, funcName, argName) => (p) => {
+    if (!(0, exports.isDefAndNotNull)(p)) {
+        (0, exports.warn)(`"${funcName}" -> "${argName}" should exist!`);
+    }
+    return scope;
+};
 const shouldBeMeters = (scope, funcName, argName) => (p) => {
     if (!p.likePseudoMercator) {
         (0, exports.warn)(`"${funcName}" -> "${argName}" should be meters!`);
@@ -50,7 +58,8 @@ const checkFunction = (funcName) => ({
                 shouldBeMeters: hook(this),
                 shouldBeInt: hook(this),
                 shouldBeUInt: hook(this),
-                shouldBeRadians: hook(this)
+                shouldBeRadians: hook(this),
+                shouldExist: hook(this)
             };
         }
         return {
@@ -58,7 +67,8 @@ const checkFunction = (funcName) => ({
             shouldBeMeters: shouldBeMeters(this, funcName, argName),
             shouldBeInt: shouldBeInt(this, funcName, argName),
             shouldBeUInt: shouldBeUInt(this, funcName, argName),
-            shouldBeRadians: shouldBeRadians(this, funcName, argName)
+            shouldBeRadians: shouldBeRadians(this, funcName, argName),
+            shouldExist: shouldExist(this, funcName, argName)
         };
     }
 });
@@ -68,13 +78,12 @@ exports.createArray = createArray;
 const createMatrix = ({ h, w }, fillSymbol = 0) => (0, exports.createArray)(h)
     .map(() => (0, exports.createArray)(w, fillSymbol));
 exports.createMatrix = createMatrix;
-const GAUSSIAN_ELIMINATION_MIN = 1e-10;
 const gaussianElimination = (matrix) => {
     const n = matrix.length;
     const matrixClone = (0, exports.createMatrix)(new DPoint_1.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 ? GAUSSIAN_ELIMINATION_MIN : matrix[i][j];
+            matrix[i][j] = matrix[i][j] === 0 ? exports.gaussianElimination.MIN : matrix[i][j];
             matrixClone[i][j] = matrix[i][j];
         }
     }
@@ -112,9 +121,8 @@ const gaussianElimination = (matrix) => {
     return answer;
 };
 exports.gaussianElimination = gaussianElimination;
-const isDefAndNotNull = (a) => a != undefined;
-exports.isDefAndNotNull = isDefAndNotNull;
-function createCanvas(a, b, c) {
+exports.gaussianElimination.MIN = 1e-10;
+const createCanvas = (a, b, c) => {
     var _a;
     let w = 0;
     let h = 0;
@@ -137,12 +145,11 @@ function createCanvas(a, b, c) {
     if (typeof c === 'boolean') {
         offscreen = c;
     }
-    const canvas = offscreen ? new OffscreenCanvas(w, h) : ((_a = createCanvas.document) !== null && _a !== void 0 ? _a : document).createElement('canvas');
+    const 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;
     }
-    const ctx = canvas.getContext('2d');
-    return [canvas, ctx];
-}
+    return [canvas, canvas.getContext('2d')];
+};
 exports.createCanvas = createCanvas;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dgeoutils",
-  "version": "2.2.13",
+  "version": "2.2.17",
   "description": "",
   "scripts": {
     "build": "node_modules/.bin/tsc",
@@ -42,6 +42,7 @@
     "jest": "^27.0.6",
     "jest-canvas-mock": "^2.3.1",
     "jest-coverage-badges": "^1.1.2",
+    "jest-html-reporter": "^3.4.2",
     "jsdom": "^17.0.0",
     "ts-jest": "^27.0.4",
     "typedoc": "^0.21.9",