dgeoutils 2.2.14 → 2.2.18

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,5 +102,5 @@ export declare class DPoint {
     setIfLessThan(p: DPoint): DPoint;
     minus(): DPoint;
     orthodromicPath(point: DPoint, pointsCount?: number): DPolygon;
-    findCloserPoint(p: DPolygon): DPoint;
+    sortByDistance(p: DPolygon): DPolygon;
 }

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,17 +462,15 @@ 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;
+    sortByDistance(p) {
+        return p
+            .clone()
+            .map((d, index) => {
+            d.properties.distance = d.distance(this);
+            d.properties.index = index;
+            return d;
+        })
+            .sort((a, b) => a.properties.distance - b.properties.distance);
     }
 }
 exports.DPoint = DPoint;

package/dist/DPolygon.d.ts

@@ -58,6 +58,7 @@ export declare class DPolygon {
     filter(f: (p: DPoint) => boolean): DPolygon;
     map(f: (r: DPoint) => DPoint): DPolygon;
     map(f: (r: DPoint, index: number) => DPoint): DPolygon;
+    sort(f: (a: DPoint, b: DPoint) => number): DPolygon;
     at(index: number): DPoint;
     pop(): DPoint;
     push(...args: DPoint[]): number;
@@ -102,6 +103,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);
     }
@@ -348,6 +349,10 @@ class DPolygon {
         this.holes = this.holes.map((h) => h.map(f));
         return this;
     }
+    sort(f) {
+        this.points.sort(f);
+        return this;
+    }
     at(index) {
         const { length } = this;
         return this.points[(index % length + length) % length];
@@ -814,6 +819,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;
@@ -19,7 +22,6 @@ export declare const gaussianElimination: {
     (matrix: number[][]): number[];
     MIN: number;
 };
-export declare const isDefAndNotNull: (a: any) => boolean;
 declare type True = true;
 export declare const createCanvas: {
     (size: number): [HTMLCanvasElement, CanvasRenderingContext2D];

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)
         };
     }
 });
@@ -112,8 +122,6 @@ const gaussianElimination = (matrix) => {
 };
 exports.gaussianElimination = gaussianElimination;
 exports.gaussianElimination.MIN = 1e-10;
-const isDefAndNotNull = (a) => a != undefined;
-exports.isDefAndNotNull = isDefAndNotNull;
 const createCanvas = (a, b, c) => {
     var _a;
     let w = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dgeoutils",
-  "version": "2.2.14",
+  "version": "2.2.18",
   "description": "",
   "scripts": {
     "build": "node_modules/.bin/tsc",