dgeoutils 2.2.2 → 2.2.6

package/dist/DCircle.d.ts

@@ -3,7 +3,11 @@ import { DPolygon } from './DPolygon';
 export declare class DCircle {
     center: DPoint;
     r: number;
-    constructor(center: DPoint, r: number);
+    /**
+     * @param [center=(0,0)]
+     * @param [r=0]
+     */
+    constructor(center?: DPoint, r?: number);
     toString(): string;
     getValue(): {
         center: DPoint;

package/dist/DCircle.js

@@ -5,12 +5,16 @@ const DPoint_1 = require("./DPoint");
 const DPolygon_1 = require("./DPolygon");
 const DNumbers_1 = require("./DNumbers");
 const utils_1 = require("./utils");
+// eslint-disable-next-line padded-blocks
 class DCircle {
-    constructor(center, r) {
-        this.center = DPoint_1.DPoint.Zero();
-        this.r = 0;
-        this.r = r;
+    /**
+     * @param [center=(0,0)]
+     * @param [r=0]
+     */
+    // eslint-disable-next-line no-useless-constructor,no-empty-function
+    constructor(center = DPoint_1.DPoint.zero(), r = 0) {
         this.center = center;
+        this.r = r;
     }
     toString() {
         return `(${this.center.toString()}, ${this.r})`;

package/dist/DLine.d.ts

@@ -4,9 +4,16 @@ export declare class DLine {
     a: number;
     b: number;
     c: number;
-    p1: DPoint;
-    p2: DPoint;
-    constructor(a?: number, b?: number, c?: number, p1?: DPoint, p2?: DPoint);
+    begin: DPoint;
+    end: DPoint;
+    /**
+     * @param a
+     * @param b
+     * @param c
+     * @param [begin=DPoint.zero()]
+     * @param [end=DPoint.zero()]
+     */
+    constructor(a: number, b: number, c: number, begin?: DPoint, end?: DPoint);
     clone(): DLine;
     findPerpendicular(p: DPoint): DLine;
     perpendicularDistance(p: DPoint): number;
@@ -28,7 +35,7 @@ export declare class DLine {
     /**
      * Check if point below to line segment, but not equal star or end point.
      * @param p
-     * @param d
+     * @param [d=0]
      */
     insideRange(p: DPoint, d?: number): boolean;
     get center(): DPoint;
@@ -80,10 +87,10 @@ export declare class DLine {
      * @param l
      * @param delta
      */
-    findFi(l: DLine, delta?: number): number;
+    findFi({ a, b }: DLine, delta?: number): number;
     /**
      * [Cross product](https://en.wikipedia.org/wiki/Cross_product)
-     * @param l
+     * @param l {DLine}
      */
-    vectorProduct(l: DLine): DLine;
+    vectorProduct({ a, b, c }: DLine): DLine;
 }

package/dist/DLine.js

@@ -3,38 +3,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DLine = void 0;
 const DPoint_1 = require("./DPoint");
 const utils_1 = require("./utils");
+// eslint-disable-next-line padded-blocks
 class DLine {
-    constructor(a = 0, b = 0, c = 0, p1 = DPoint_1.DPoint.Zero(), p2 = DPoint_1.DPoint.Zero()) {
-        this.a = 0;
-        this.b = 0;
-        this.c = 0;
-        this.p1 = DPoint_1.DPoint.Zero();
-        this.p2 = DPoint_1.DPoint.Zero();
+    /**
+     * @param a
+     * @param b
+     * @param c
+     * @param [begin=DPoint.zero()]
+     * @param [end=DPoint.zero()]
+     */
+    // eslint-disable-next-line no-useless-constructor
+    constructor(a, b, c, begin = DPoint_1.DPoint.zero(), end = DPoint_1.DPoint.zero()
+    // eslint-disable-next-line no-empty-function
+    ) {
         this.a = a;
         this.b = b;
         this.c = c;
-        this.p1 = p1;
-        this.p2 = p2;
+        this.begin = begin;
+        this.end = end;
     }
     clone() {
-        return new DLine(this.a, this.b, this.c, this.p1.clone(), this.p2.clone());
+        return new DLine(this.a, this.b, this.c, this.begin.clone(), this.end.clone());
     }
     findPerpendicular(p) {
         (0, utils_1.checkFunction)('findPerpendicular')
-            .checkArgument('this.p1')
-            .shouldBeMeters(this.p1)
-            .checkArgument('this.p2')
-            .shouldBeMeters(this.p2)
+            .checkArgument('this.begin')
+            .shouldBeMeters(this.begin)
+            .checkArgument('this.end')
+            .shouldBeMeters(this.end)
             .checkArgument('p')
             .shouldBeMeters(p);
         return new DLine(-this.b, this.a, this.b * p.x - this.a * p.y);
     }
     perpendicularDistance(p) {
         (0, utils_1.checkFunction)('perpendicularDistance')
-            .checkArgument('this.p1')
-            .shouldBeMeters(this.p1)
-            .checkArgument('this.p2')
-            .shouldBeMeters(this.p2)
+            .checkArgument('this.begin')
+            .shouldBeMeters(this.begin)
+            .checkArgument('this.end')
+            .shouldBeMeters(this.end)
             .checkArgument('p')
             .shouldBeMeters(p);
         const perpendicularLine = this.findPerpendicular(p);
@@ -63,10 +69,10 @@ class DLine {
         const per = this.findPerpendicular(center);
         const t = this.intersection(per, Infinity);
         let distance = t.distance(center);
-        if (this.p1.equal(center)) {
+        if (this.begin.equal(center)) {
             distance = 0;
         }
-        if (this.p2.equal(center)) {
+        if (this.end.equal(center)) {
             distance = 0;
         }
         if (distance < r) {
@@ -76,25 +82,25 @@ class DLine {
                 const move = Math.sqrt(r * r - ct * ct);
                 // Mean "|" x = const
                 if (this.isParallelY) {
-                    t.x = this.p1.x;
+                    t.x = this.begin.x;
                     const r1 = t.clone().move(0, -move);
                     const r2 = t.clone().move(0, move);
                     return [r1, r2];
                 }
                 // Mean "-" y = const
                 if (this.isParallelX) {
-                    t.y = this.p1.y;
+                    t.y = this.begin.y;
                     const r1 = t.clone().move(move, 0);
                     const r2 = t.clone().move(-move, 0);
                     return [r1, r2];
                 }
             }
-            if (this.p1.like(center)) {
-                const p = this.p1.clone();
+            if (this.begin.like(center)) {
+                const p = this.begin.clone();
                 return [this.movePoint(p, r), this.movePoint(p, -r)];
             }
-            if (this.p2.like(center)) {
-                const p = this.p2.clone();
+            if (this.end.like(center)) {
+                const p = this.end.clone();
                 return [this.movePoint(p, r), this.movePoint(p, -r)];
             }
             const s = a * a + b * b;
@@ -124,19 +130,19 @@ class DLine {
     /**
      * Check if point below to line segment, but not equal star or end point.
      * @param p
-     * @param d
+     * @param [d=0]
      */
     insideRange(p, d = 0) {
-        const { p1, p2 } = this;
-        return this.inRange(p, d) && !p1.like(p, 0.00001) && !p2.like(p, 0.00001);
+        const { begin, end } = this;
+        return this.inRange(p, d) && !begin.like(p, 0.00001) && !end.like(p, 0.00001);
     }
     get center() {
-        return this.p1
+        return this.begin
             .clone()
-            .setIfLessThan(this.p2)
-            .move(this.p2
+            .setIfLessThan(this.end)
+            .move(this.end
             .clone()
-            .move(this.p1
+            .move(this.begin
             .clone()
             .minus())
             .abs()
@@ -144,16 +150,16 @@ class DLine {
             .divide(2));
     }
     get minX() {
-        return Math.min(this.p1.x, this.p2.x);
+        return Math.min(this.begin.x, this.end.x);
     }
     get minY() {
-        return Math.min(this.p1.y, this.p2.y);
+        return Math.min(this.begin.y, this.end.y);
     }
     get maxX() {
-        return Math.max(this.p1.x, this.p2.x);
+        return Math.max(this.begin.x, this.end.x);
     }
     get maxY() {
-        return Math.max(this.p1.y, this.p2.y);
+        return Math.max(this.begin.y, this.end.y);
     }
     toString() {
         return `(${this.a}, ${this.b}, ${this.c})`;
@@ -243,47 +249,26 @@ class DLine {
      * Get lines segment start and end points as array
      */
     get points() {
-        return [this.p1, this.p2];
+        return [this.begin, this.end];
     }
     /**
      * Get line segment direction (from start point to end point)
      */
     getFi() {
         (0, utils_1.checkFunction)('getFi')
-            .checkArgument('this.p1')
-            .shouldBeMeters(this.p1)
-            .checkArgument('this.p2')
-            .shouldBeMeters(this.p2);
-        const l = new DLine(0, 1, 0);
-        const result = this.findFi(l);
-        if (this.p1.x === this.p2.x) {
-            if (this.p1.y === this.p2.y) {
-                return 0;
-            }
-            else if (this.p1.y < this.p2.y) {
-                return Math.PI + Math.PI / 2;
-            }
-            return Math.PI / 2;
+            .checkArgument('this.begin')
+            .shouldBeMeters(this.begin)
+            .checkArgument('this.end')
+            .shouldBeMeters(this.end);
+        const { x, y } = this.end.clone().move(this.begin.clone().minus());
+        let v = Math.atan2(y, x) - Math.PI;
+        if (v > 0) {
+            v = Math.PI - v;
         }
-        else if (this.p1.x < this.p2.x) {
-            if (this.p1.y === this.p2.y) {
-                return 0;
-            }
-            else if (this.p1.y < this.p2.y) {
-                return Math.PI - result + Math.PI;
-            }
-            return result;
-        }
-        if (this.p1.y === this.p2.y) {
-            return Math.PI;
-        }
-        else if (this.p1.y < this.p2.y) {
-            return Math.PI - result + Math.PI;
-        }
-        return result;
+        return (Math.PI - v) % (Math.PI * 2);
     }
     toWKT() {
-        const { p1: { x: x1, y: y1 }, p2: { x: x2, y: y2 } } = this;
+        const { begin: { x: x1, y: y1 }, end: { x: x2, y: y2 } } = this;
         return `LINESTRING (${x1} ${y1}, ${x2} ${y2})`;
     }
     /**
@@ -293,7 +278,7 @@ class DLine {
      */
     movePoint(p, d) {
         const fi = this.findFi(new DLine(1, 0, 0));
-        const td = this.p1.distance(this.p2) / 2;
+        const td = this.begin.distance(this.end) / 2;
         const dcosT = td * Math.cos(fi);
         const dsinT = td * Math.sin(fi);
         const p1T = new DPoint_1.DPoint(p.x - dsinT, p.y - dcosT);
@@ -312,8 +297,9 @@ class DLine {
      * @param l
      * @param delta
      */
-    findFi(l, delta = 1.0001) {
-        let val = (this.a * l.a + this.b * l.b) / (Math.sqrt(this.a * this.a + this.b * this.b) * Math.sqrt(l.a * l.a + l.b * l.b));
+    findFi({ a, b }, delta = 1.0001) {
+        const { a: q, b: w } = this;
+        let val = (q * a + w * b) / (Math.sqrt(q * q + w * w) * Math.sqrt(a * a + b * b));
         if (val > 1 && val < delta) {
             val = 1;
         }
@@ -324,13 +310,11 @@ class DLine {
     }
     /**
      * [Cross product](https://en.wikipedia.org/wiki/Cross_product)
-     * @param l
+     * @param l {DLine}
      */
-    vectorProduct(l) {
-        const i = this.b * l.c - this.c * l.b;
-        const j = this.c * l.a - this.a * l.c;
-        const k = this.a * l.b - this.b * l.a;
-        return new DLine(i, j, k);
+    vectorProduct({ a, b, c }) {
+        const { a: q, b: w, c: e } = this;
+        return new DLine(w * c - e * b, e * a - q * c, q * b - w * a);
     }
 }
 exports.DLine = DLine;

package/dist/DPoint.d.ts

@@ -15,22 +15,36 @@ export declare type SetterFunction = (t: DPoint) => number;
 export declare class DPoint {
     x: number;
     y: number;
-    z?: number;
+    z?: number | undefined;
     properties: {
         [key: string]: any;
     };
     /**
-     *
+     * Create point with zero coords `(0, 0)`
+     */
+    constructor();
+    /**
+     * Create point
+     * @param xy - `x` and `y` value
+     */
+    constructor(xy: number);
+    /**
+     * Create point
+     * @param x - lng, meters to East, radians to East or width
+     * @param y - lat, meters to North, radians to North or height
+     */
+    constructor(x: number, y: number);
+    /**
+     * Create point
      * @param x - lng, meters to East, radians to East or width
      * @param y - lat, meters to North, radians to North or height
      * @param z - height
      */
-    constructor(x?: number, y?: number, z?: number);
-    static Zero(): DPoint;
+    constructor(x: number, y: number, z?: number);
+    static zero(): DPoint;
     static parse(c: LatLng | number[] | DCoord): DPoint;
-    static isPoint(p: unknown): boolean;
     static parseFromWKT(wkt: string): DPoint;
-    static Random(): DPoint;
+    static random(): DPoint;
     /**
      * @remark Point should be Lng/Lat.
      *
@@ -59,8 +73,26 @@ export declare class DPoint {
     height(z: number): DPoint;
     toWKT(): string;
     distance(p: DPoint): number;
-    setX(x: number | SetterFunction): DPoint;
-    setY(y: number | SetterFunction): DPoint;
+    /**
+     * Set `x` value
+     * @param x
+     */
+    setX(x: number): DPoint;
+    /**
+     * Transform `x` value by function
+     * @param f
+     */
+    setX(f: SetterFunction): DPoint;
+    /**
+     * Set `y` value
+     * @param y
+     */
+    setY(y: number): DPoint;
+    /**
+     * Transform `y` value by function
+     * @param f
+     */
+    setY(f: SetterFunction): DPoint;
     clone(): DPoint;
     gt(p: DPoint): boolean;
     lt(p: DPoint): boolean;
@@ -71,7 +103,22 @@ export declare class DPoint {
      * @param a radians
      */
     rotate(a: number): DPoint;
-    move(x?: number | DPoint, y?: number): DPoint;
+    /**
+     * Add `v` to `x` and `y`
+     * @param v
+     */
+    move(v: number): DPoint;
+    /**
+     * Add `p.x` to `x` field and `p.y` to `y` field.
+     * @param p
+     */
+    move(p: DPoint): DPoint;
+    /**
+     * Add `x` to `x` field and `y` to `y` field.
+     * @param x
+     * @param y
+     */
+    move(x: number, y: number): DPoint;
     degreeToMeters(): DPoint;
     metersToDegree(): DPoint;
     degreeToRadians(): DPoint;
@@ -81,13 +128,59 @@ export declare class DPoint {
     round(): DPoint;
     ceil(): DPoint;
     floor(): DPoint;
+    /**
+     * @param [n=2]
+     */
     toFixed(n?: number): DPoint;
     abs(): DPoint;
-    scale(x?: number | DPoint, y?: number): DPoint;
-    divide(x?: number | DPoint, y?: number): DPoint;
+    /**
+     * Multiply `v` to `x` and `y`
+     * @param v
+     */
+    scale(v: number): DPoint;
+    /**
+     * Multiply `p.x` to `x` field and `p.y` to `y` field.
+     * @param p
+     */
+    scale(p: DPoint): DPoint;
+    /**
+     * Multiply `x` to `x` field and `y` to `y` field.
+     * @param x
+     * @param y
+     */
+    scale(x: number, y: number): DPoint;
+    /**
+     * Divide `x` and `y` to `v`
+     * @param v
+     */
+    divide(v: number): DPoint;
+    /**
+     * Divide `x` field to `p.x` and `y` field to `p.y`.
+     * @param p
+     */
+    divide(p: DPoint): DPoint;
+    /**
+     * Divide `x` field to `x` and `y` field to `y`.
+     * @param x
+     * @param y
+     */
+    divide(x: number, y: number): DPoint;
     equal(p: DPoint): boolean;
+    /**
+     * @param p
+     * @param [d=0.001]
+     */
     like(p: DPoint, d?: number): boolean;
-    flipVertically(size: DPoint | number): DPoint;
+    /**
+     * Flip vertically
+     * @param size canvas size
+     */
+    flipVertically(size: DPoint): DPoint;
+    /**
+     * Flip vertically
+     * @param height canvas height
+     */
+    flipVertically(height: number): DPoint;
     /**
      * Check if point looks like radians
      */

package/dist/DPoint.js

@@ -19,23 +19,16 @@ exports.DOUBLE_PI_IN_DEGREE = 360;
 exports.PI_TO_DEGREE = Math.PI / exports.PI_IN_DEGREE;
 exports.DEGREE_TO_PI = exports.PI_IN_DEGREE / Math.PI;
 class DPoint {
-    /**
-     *
-     * @param x - lng, meters to East, radians to East or width
-     * @param y - lat, meters to North, radians to North or height
-     * @param z - height
-     */
-    constructor(x = 0, y = 0, z) {
-        this.x = 0;
-        this.y = 0;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.properties = {};
+    // eslint-disable-next-line no-empty-function,no-useless-constructor
+    constructor(x = 0, y = x, z) {
         this.x = x;
         this.y = y;
         this.z = z;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.properties = {};
     }
-    static Zero() {
-        return new DPoint(0, 0);
+    static zero() {
+        return new DPoint();
     }
     static parse(c) {
         const { lat, lng } = c;
@@ -45,9 +38,6 @@ class DPoint {
         const [x, y, z] = c;
         return new DPoint(x, y, z);
     }
-    static isPoint(p) {
-        return p instanceof DPoint;
-    }
     static parseFromWKT(wkt) {
         const regexp = /POINT \((?<data>(?:(?!\)).)*?)\)$/miu;
         const data = wkt.trim().toUpperCase();
@@ -55,7 +45,7 @@ class DPoint {
         const [x, y, z] = res.groups.data.split(' ').map(Number);
         return new DPoint(x, y, z);
     }
-    static Random() {
+    static random() {
         return new DPoint(Math.random(), Math.random());
     }
     /**
@@ -194,7 +184,7 @@ class DPoint {
         this.y = y;
         return this;
     }
-    move(x = 0, y = x) {
+    move(x, y = x) {
         let xV = 0;
         let yV = 0;
         if (x instanceof DPoint) {
@@ -270,6 +260,9 @@ class DPoint {
         this.y = Math.floor(this.y);
         return this;
     }
+    /**
+     * @param [n=2]
+     */
     toFixed(n = 2) {
         this.x = parseFloat(this.x.toFixed(n));
         this.y = parseFloat(this.y.toFixed(n));
@@ -280,7 +273,7 @@ class DPoint {
         this.y = Math.abs(this.y);
         return this;
     }
-    scale(x = 0, y = x) {
+    scale(x, y = x) {
         let xV = 0;
         let yV = 0;
         if (x instanceof DPoint) {
@@ -295,7 +288,7 @@ class DPoint {
         this.y = yV;
         return this;
     }
-    divide(x = 0, y = x) {
+    divide(x, y = x) {
         let xV = 0;
         let yV = 0;
         if (x instanceof DPoint) {
@@ -313,6 +306,10 @@ class DPoint {
     equal(p) {
         return this.x === p.x && this.y === p.y && this.z === p.z;
     }
+    /**
+     * @param p
+     * @param [d=0.001]
+     */
     like(p, d = 0.001) {
         if (this.equal(p)) {
             return true;
@@ -439,7 +436,7 @@ class DPoint {
         const p = point.clone().degreeToRadians();
         const d = Math.sin(p.x - t.x);
         const step = (p.x - t.x) / (pointsCount - 1);
-        return new DPolygon_1.DPolygon(Array.from(new Array(pointsCount))
+        return new DPolygon_1.DPolygon((0, utils_1.createArray)(pointsCount)
             .map((v, i) => {
             const x = t.x + step * i;
             const y = Math.atan((Math.tan(t.y) * Math.sin(p.x - x)) / d +