dgeoutils 2.1.0 → 2.2.3

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;
@@ -12,11 +16,31 @@ export declare class DCircle {
     clone(): DCircle;
     /**
      * Find intersection points with other circle.
+     *
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPoints.png)
      * @param c
      */
     findPoints(c: DCircle): DPoint[] | number;
     equal({ center, r }: DCircle): boolean;
+    /**
+     * Transform circle to polygon
+     *
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPolygonInside.png)
+     * @param [pointCount=64]
+     */
     findPolygonInside(pointCount?: number): DPolygon;
+    /**
+     * Transform circle to polygon on sphere. It would be different for different latitude.
+     *
+     * @remarks
+     * Center should be Lng/Lat.
+     *
+     * @remarks
+     * Radius should be in meters.
+     *
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPolygonInsideOnSphere.png)
+     * @param [pointCount=64]
+     */
     findPolygonInsideOnSphere(pointCount?: number): DPolygon;
     private sphereOffset;
 }

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})`;
@@ -23,6 +27,8 @@ class DCircle {
     }
     /**
      * Find intersection points with other circle.
+     *
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPoints.png)
      * @param c
      */
     findPoints(c) {
@@ -57,6 +63,12 @@ class DCircle {
     equal({ center, r }) {
         return this.center.equal(center) && this.r === r;
     }
+    /**
+     * Transform circle to polygon
+     *
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPolygonInside.png)
+     * @param [pointCount=64]
+     */
     findPolygonInside(pointCount = 64) {
         const preAngle = 2 * Math.PI / pointCount;
         const points = [];
@@ -68,6 +80,18 @@ class DCircle {
         }
         return new DPolygon_1.DPolygon([...points, points[0]]);
     }
+    /**
+     * Transform circle to polygon on sphere. It would be different for different latitude.
+     *
+     * @remarks
+     * Center should be Lng/Lat.
+     *
+     * @remarks
+     * Radius should be in meters.
+     *
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPolygonInsideOnSphere.png)
+     * @param [pointCount=64]
+     */
     findPolygonInsideOnSphere(pointCount = 64) {
         (0, utils_1.checkFunction)('findPolygonInsideOnSphere')
             .checkArgument('center')
@@ -76,7 +100,7 @@ class DCircle {
         for (let i = 0; i < pointCount; i++) {
             res.push(this.sphereOffset(2 * Math.PI * i / pointCount));
         }
-        return res;
+        return res.close();
     }
     sphereOffset(bearing, earthRadius = DPoint_1.EARTH_RADIUS_IN_METERS) {
         const lat1 = DNumbers_1.DNumbers.deg2Rad(this.center.y);

package/dist/DLine.d.ts

@@ -14,9 +14,10 @@ export declare class DLine {
      * Find intersection of two lines segments.
      * For intersection of two lines use [[findPoint]]
      * @param l
-     * @param d
+     * @param [d=0]
+     * @param [includeOnly=false]
      */
-    intersection(l: DLine, d?: number): DPoint | null;
+    intersection(l: DLine, d?: number, includeOnly?: boolean): DPoint | null;
     intersectionWithCircle(circle: DCircle): DPoint | [DPoint, DPoint] | null;
     /**
      * Check if point below to line segment
@@ -24,6 +25,13 @@ export declare class DLine {
      * @param d
      */
     inRange(p: DPoint, d?: number): boolean;
+    /**
+     * Check if point below to line segment, but not equal star or end point.
+     * @param p
+     * @param [d=0]
+     */
+    insideRange(p: DPoint, d?: number): boolean;
+    get center(): DPoint;
     get minX(): number;
     get minY(): number;
     get maxX(): number;

package/dist/DLine.js

@@ -4,12 +4,10 @@ exports.DLine = void 0;
 const DPoint_1 = require("./DPoint");
 const utils_1 = require("./utils");
 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();
+    // eslint-disable-next-line no-useless-constructor
+    constructor(a = 0, b = 0, c = 0, p1 = DPoint_1.DPoint.zero(), p2 = DPoint_1.DPoint.zero()
+    // eslint-disable-next-line no-empty-function
+    ) {
         this.a = a;
         this.b = b;
         this.c = c;
@@ -45,11 +43,15 @@ class DLine {
      * Find intersection of two lines segments.
      * For intersection of two lines use [[findPoint]]
      * @param l
-     * @param d
+     * @param [d=0]
+     * @param [includeOnly=false]
      */
-    intersection(l, d = 0) {
+    intersection(l, d = 0, includeOnly = false) {
         const p = this.findPoint(l);
         if (p) {
+            if (includeOnly) {
+                return this.insideRange(p, d) && l.insideRange(p, d) ? p : null;
+            }
             return this.inRange(p, d) && l.inRange(p, d) ? p : null;
         }
         return null;
@@ -117,6 +119,28 @@ class DLine {
         const isInY = y >= minY - d && y <= maxY + d;
         return isInX && isInY;
     }
+    /**
+     * Check if point below to line segment, but not equal star or end point.
+     * @param p
+     * @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);
+    }
+    get center() {
+        return this.p1
+            .clone()
+            .setIfLessThan(this.p2)
+            .move(this.p2
+            .clone()
+            .move(this.p1
+            .clone()
+            .minus())
+            .abs()
+            .minus()
+            .divide(2));
+    }
     get minX() {
         return Math.min(this.p1.x, this.p2.x);
     }

package/dist/DPoint.d.ts

@@ -15,23 +15,48 @@ 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();
+    /**
+     * @param xy - `x` and `y` value
+     */
+    constructor(xy: number);
+    /**
+     * @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);
+    /**
      * @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.
+     *
+     * @remark `z` value default for `zoom` argument.
+     *
+     * @param [zoom=this.z]
+     */
     getTileFromCoords(zoom?: number): DPoint;
+    /**
+     * Result would be Lng/Lat.
+     *
+     * @remark `z` value default for `zoom` argument.
+     *
+     * @param [zoom=this.z]
+     */
     getCoordsFromTile(zoom?: number): DPoint;
     toCoords(): DCoord;
     /**
@@ -45,8 +70,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;
@@ -57,7 +100,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;
@@ -67,13 +125,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
      */
@@ -104,5 +208,15 @@ export declare class DPoint {
     };
     setIfLessThan(p: DPoint): DPoint;
     minus(): DPoint;
+    /**
+     * Find [orthodromic path](https://en.wikipedia.org/wiki/Great-circle_navigation) between to points.
+     *
+     * @remark Points should be Lng/Lat.
+     *
+     * ![example](/media/examples/orthodromicPath.png)
+     *
+     * @param point
+     * @param [pointsCount=360]
+     */
     orthodromicPath(point: DPoint, pointsCount?: number): DPolygon;
 }

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,9 +45,16 @@ 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());
     }
+    /**
+     * @remark Point should be Lng/Lat.
+     *
+     * @remark `z` value default for `zoom` argument.
+     *
+     * @param [zoom=this.z]
+     */
     getTileFromCoords(zoom = this.z) {
         (0, utils_1.checkFunction)('getTileFromCoords')
             .checkArgument('this')
@@ -66,6 +63,13 @@ class DPoint {
         const y = Math.floor((1 - Math.log(Math.tan(this.y * exports.PI_TO_DEGREE) + 1 / Math.cos(this.y * exports.PI_TO_DEGREE)) / Math.PI) / 2 * (Math.pow(2, zoom)));
         return new DPoint(x, y, zoom);
     }
+    /**
+     * Result would be Lng/Lat.
+     *
+     * @remark `z` value default for `zoom` argument.
+     *
+     * @param [zoom=this.z]
+     */
     getCoordsFromTile(zoom = this.z) {
         (0, utils_1.checkFunction)('getCoordsFromTile')
             .checkArgument('this')
@@ -180,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) {
@@ -256,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));
@@ -266,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) {
@@ -281,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) {
@@ -299,10 +306,17 @@ 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;
+        }
         const likeX = Math.abs(this.x - p.x) < d;
         const likeY = Math.abs(this.y - p.y) < d;
-        const likeZ = this.z === p.z || Math.abs(this.z - p.z) < d;
+        const likeZ = Math.abs((this.z || 0) - (p.z || 0)) < d;
         return likeX && likeY && likeZ;
     }
     flipVertically(size) {
@@ -402,6 +416,16 @@ class DPoint {
     minus() {
         return this.clone().scale(-1);
     }
+    /**
+     * Find [orthodromic path](https://en.wikipedia.org/wiki/Great-circle_navigation) between to points.
+     *
+     * @remark Points should be Lng/Lat.
+     *
+     * ![example](/media/examples/orthodromicPath.png)
+     *
+     * @param point
+     * @param [pointsCount=360]
+     */
     orthodromicPath(point, pointsCount = 360) {
         (0, utils_1.checkFunction)('orthodromicPath')
             .checkArgument('this')
@@ -412,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 +

package/dist/DPolygon.d.ts

@@ -4,13 +4,13 @@ import { DLine } from './DLine';
 import { DPolygonLoop } from './DPolygonLoop';
 export declare const MIN_POINTS_IN_VALID_POLYGON = 3;
 export declare class DPolygon {
+    private pPoints;
     properties: {
         [key: string]: any;
     };
     holes: DPolygon[];
-    private pPoints;
     private searchStore;
-    constructor(points?: DPoint[]);
+    constructor(pPoints?: DPoint[]);
     /**
      * Get size of min area rectangle.
      * @param poly should be `minAreaRectangle`
@@ -130,44 +130,28 @@ export declare class DPolygon {
     /**
      * Check polygon intersection with line
      * @param l
+     * @param [includeOnly=false]
      */
-    intersection(l: DLine): DPoint[];
+    intersection(l: DLine, includeOnly?: boolean): DPoint[];
     /**
      * Set polygon center
      * @param newCenter
      */
     setCenter(newCenter: DPoint): DPolygon;
     toWKT(): string;
-    /**
-     * Rotate polygon with center in point {0, 0}
-     * @param a Radians
-     */
-    rotate(a: number): DPolygon;
     /**
      * Filter points
      * @param f
      */
     filter(f: (p: DPoint) => boolean): DPolygon;
-    move(x?: number | DPoint, y?: number): DPolygon;
-    scale(x?: number | DPoint, y?: number): DPolygon;
-    divide(x?: number | DPoint, y?: number): DPolygon;
-    round(): DPolygon;
-    floor(): DPolygon;
-    ceil(): DPolygon;
-    flipVertically(size: DPoint | number): DPolygon;
-    toFixed(n?: number): DPolygon;
     map(f: (r: DPoint, index?: number) => DPoint): DPolygon;
-    p(index: number, divide?: boolean): DPoint;
+    at(index: number): DPoint;
     pop(): DPoint;
     push(...args: DPoint[]): number;
     shift(): DPoint;
     unshift(...args: DPoint[]): number;
     reverse(): DPolygon;
     getValue(): string;
-    degreeToMeters(): DPolygon;
-    metersToDegree(): DPolygon;
-    radiansToMeters(): DPolygon;
-    metersToRadians(): DPolygon;
     toString(): string;
     /**
      * Add to the end of polygon point equal to first point if it not exist
@@ -177,11 +161,6 @@ export declare class DPolygon {
      * Remove from the end of polygon point equal to first point if it exist
      */
     open(): DPolygon;
-    /**
-     * Set `height` (`z`)
-     * @param z
-     */
-    height(z: number): DPolygon;
     add(poly: DPolygon): DPolygon;
     /**
      * Check if has point in list of points
@@ -203,7 +182,7 @@ export declare class DPolygon {
     /**
      * Get polygon approximation by
      * [Ramer–Douglas–Peucker algorithm](https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm)
-     * @param e
+     * @param [e=Math.sqrt(this.perimeter)*APPROXIMATION_VALUE]
      */
     approximation(e?: number): DPolygon;
     insertAfter(index: number, ...points: DPoint[]): void;
@@ -223,8 +202,8 @@ export declare class DPolygon {
     /**
      * Check if contain point
      * @param p
-     * @param isBorderInside
-     * @param move Ignore this parameter
+     * @param [isBorderInside=false]
+     * @param [move=(0,0)] Ignore this parameter
      */
     contain(p: DPoint, isBorderInside?: boolean, move?: DPoint): boolean;
     /**
@@ -241,11 +220,20 @@ export declare class DPolygon {
      */
     removeDuplicates(): DPolygon;
     /**
-     * Parse from [OpenLayers](https://openlayers.org/) coordinates or
-     * [GeoJSON](https://en.wikipedia.org/wiki/GeoJSON) coordinates
+     * Parse from [OpenLayers](https://openlayers.org/) coordinates
+     * @param a
+     */
+    static parse(a: LatLng[]): DPolygon;
+    /**
+     * Parse from [GeoJSON](https://en.wikipedia.org/wiki/GeoJSON) coordinates
      * @param a
      */
-    static parse(a: LatLng[] | number[][] | DCoord[]): DPolygon;
+    static parse(a: number[][]): DPolygon;
+    /**
+     * Parse from [OpenLayers](https://openlayers.org/) coordinates
+     * @param a
+     */
+    static parse(a: DCoord[]): DPolygon;
     /**
      * Transform to array of coordinates for [OpenLayers](https://openlayers.org/) or
      * [GeoJSON](https://en.wikipedia.org/wiki/GeoJSON)
@@ -266,6 +254,12 @@ export declare class DPolygon {
     simpleIntersection(p: DPolygon): DPolygon | null | DPolygon[];
     simpleDifference(p: DPolygon): DPolygon | null | DPolygon[];
     smartUnion(p: DPolygon): DPolygon | null;
+    /**
+     * Divide polygon to triangles
+     *
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/toTriangles.png)
+     */
+    toTriangles(): DPolygon[];
     private simpleIncludeX;
     private simpleIncludeY;
     private douglasPeucker;