dgeoutils 2.0.2 → 2.2.2

package/dist/DCircle.d.ts

@@ -12,11 +12,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

@@ -23,6 +23,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 +59,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 +76,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 +96,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
+     */
+    insideRange(p: DPoint, d?: number): boolean;
+    get center(): DPoint;
     get minX(): number;
     get minY(): number;
     get maxX(): number;

package/dist/DLine.js

@@ -45,11 +45,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 +121,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
+     */
+    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

@@ -1,19 +1,5 @@
 import { DLine } from './DLine';
 import { DPolygon } from './DPolygon';
-/**
- * Meters
- * Projected bounds:
- * -20026376.39 -20048966.10
- * 20026376.39 20048966.10
- */
-export declare const PSEUDO_MERCATOR = "EPSG:3857";
-/**
- * Degrees
- * Projected bounds:
- * -180.0 -90.0
- * 180.0 90.0
- */
-export declare const WORLD_GEODETIC_SYSTEM = "EPSG:4326";
 export declare const EARTH_RADIUS_IN_METERS = 6371008.8;
 export declare type DCoord = [number, number] | [number, number, number];
 export interface LatLng {
@@ -45,7 +31,21 @@ export declare class DPoint {
     static isPoint(p: unknown): boolean;
     static parseFromWKT(wkt: string): 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;
     /**
@@ -54,7 +54,6 @@ export declare class DPoint {
      */
     findLine(p: DPoint): DLine;
     findInnerAngle(p1: DPoint, p3: DPoint): number;
-    transform(from?: string, to?: string): DPoint;
     toString(): string;
     getValue(): [number, number];
     height(z: number): DPoint;
@@ -73,8 +72,12 @@ export declare class DPoint {
      */
     rotate(a: number): DPoint;
     move(x?: number | DPoint, y?: number): DPoint;
-    asRadians(): DPoint;
-    asDegrees(): DPoint;
+    degreeToMeters(): DPoint;
+    metersToDegree(): DPoint;
+    degreeToRadians(): DPoint;
+    radiansToDegrees(): DPoint;
+    radiansToMeters(): DPoint;
+    metersToRadians(): DPoint;
     round(): DPoint;
     ceil(): DPoint;
     floor(): DPoint;
@@ -84,6 +87,7 @@ export declare class DPoint {
     divide(x?: number | DPoint, y?: number): DPoint;
     equal(p: DPoint): boolean;
     like(p: DPoint, d?: number): boolean;
+    flipVertically(size: DPoint | number): DPoint;
     /**
      * Check if point looks like radians
      */
@@ -114,7 +118,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;
-    private degrees2meters;
-    private meters2degrees;
 }

package/dist/DPoint.js

@@ -1,26 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DPoint = exports.DEGREE_TO_PI = exports.PI_TO_DEGREE = exports.DOUBLE_PI_IN_DEGREE = exports.PI_IN_DEGREE = exports.HALF_PI_IN_DEGREE = exports.EARTH_RADIUS_IN_METERS = exports.WORLD_GEODETIC_SYSTEM = exports.PSEUDO_MERCATOR = void 0;
+exports.DPoint = exports.DEGREE_TO_PI = exports.PI_TO_DEGREE = exports.DOUBLE_PI_IN_DEGREE = exports.PI_IN_DEGREE = exports.HALF_PI_IN_DEGREE = exports.EARTH_RADIUS_IN_METERS = void 0;
 const DLine_1 = require("./DLine");
 const DPolygon_1 = require("./DPolygon");
 const utils_1 = require("./utils");
 const diff = 0;
 const radiansPolygon = new DPolygon_1.DPolygon();
-/**
- * Meters
- * Projected bounds:
- * -20026376.39 -20048966.10
- * 20026376.39 20048966.10
- */
-exports.PSEUDO_MERCATOR = 'EPSG:3857';
 const pseudoMercatorPolygon = new DPolygon_1.DPolygon();
-/**
- * Degrees
- * Projected bounds:
- * -180.0 -90.0
- * 180.0 90.0
- */
-exports.WORLD_GEODETIC_SYSTEM = 'EPSG:4326';
 const worldGeodeticPolygon = new DPolygon_1.DPolygon();
 exports.EARTH_RADIUS_IN_METERS = 6371008.8;
 const EARTH_IN_MITERS = 20037508.34;
@@ -72,6 +58,13 @@ class DPoint {
     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')
@@ -80,6 +73,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')
@@ -134,18 +134,6 @@ class DPoint {
         }
         return a2 + Math.PI * 2 - a1;
     }
-    transform(from = exports.PSEUDO_MERCATOR, to = exports.WORLD_GEODETIC_SYSTEM) {
-        if (from === to && [exports.PSEUDO_MERCATOR, exports.WORLD_GEODETIC_SYSTEM].includes(from)) {
-            return this;
-        }
-        if (from === exports.PSEUDO_MERCATOR && to === exports.WORLD_GEODETIC_SYSTEM) {
-            return this.meters2degrees();
-        }
-        if (from === exports.WORLD_GEODETIC_SYSTEM && to === exports.PSEUDO_MERCATOR) {
-            return this.degrees2meters();
-        }
-        return this;
-    }
     toString() {
         return `${this.x} ${this.y}`;
     }
@@ -221,18 +209,52 @@ class DPoint {
         this.y = yV;
         return this;
     }
-    asRadians() {
-        (0, utils_1.checkFunction)('asRadians')
+    degreeToMeters() {
+        (0, utils_1.checkFunction)('degreeToMeters')
+            .checkArgument('this')
+            .shouldBeDegree(this);
+        const x = ((this.x + exports.PI_IN_DEGREE) % exports.DOUBLE_PI_IN_DEGREE - exports.PI_IN_DEGREE) * MITERS_IN_ONE_DEGREE;
+        const 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;
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+    metersToDegree() {
+        (0, utils_1.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) * exports.PI_TO_DEGREE))) *
+            (exports.DOUBLE_PI_IN_DEGREE / Math.PI) - exports.HALF_PI_IN_DEGREE;
+        this.x = lon;
+        this.y = lat;
+        return this;
+    }
+    degreeToRadians() {
+        (0, utils_1.checkFunction)('degreeToRadians')
             .checkArgument('this')
             .shouldBeDegree(this);
         return this.scale(exports.PI_TO_DEGREE);
     }
-    asDegrees() {
-        (0, utils_1.checkFunction)('asDegrees')
+    radiansToDegrees() {
+        (0, utils_1.checkFunction)('radiansToDegrees')
             .checkArgument('this')
             .shouldBeRadians(this);
         return this.scale(exports.DEGREE_TO_PI);
     }
+    radiansToMeters() {
+        (0, utils_1.checkFunction)('radiansToMeters')
+            .checkArgument('this')
+            .shouldBeRadians(this);
+        return this.radiansToDegrees().degreeToMeters();
+    }
+    metersToRadians() {
+        (0, utils_1.checkFunction)('metersToRadians')
+            .checkArgument('this')
+            .shouldBeMeters(this);
+        return this.metersToDegree().degreeToRadians();
+    }
     round() {
         this.x = Math.round(this.x);
         this.y = Math.round(this.y);
@@ -292,11 +314,22 @@ class DPoint {
         return this.x === p.x && this.y === p.y && this.z === p.z;
     }
     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) {
+        let v = size;
+        if (size instanceof DPoint) {
+            v = size.y;
+        }
+        this.y = v - this.y;
+        return this;
+    }
     /**
      * Check if point looks like radians
      */
@@ -386,14 +419,24 @@ 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')
             .shouldBeDegree(this)
             .checkArgument('point')
             .shouldBeDegree(point);
-        const t = this.clone().asRadians();
-        const p = point.clone().asRadians();
+        const t = this.clone().degreeToRadians();
+        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))
@@ -401,30 +444,8 @@ class DPoint {
             const x = t.x + step * i;
             const y = Math.atan((Math.tan(t.y) * Math.sin(p.x - x)) / d +
                 (Math.tan(p.y) * Math.sin(x - t.x)) / d);
-            return new DPoint(x, y).asDegrees();
+            return new DPoint(x, y).radiansToDegrees();
         }));
     }
-    degrees2meters() {
-        (0, utils_1.checkFunction)('degrees2meters')
-            .checkArgument('this')
-            .shouldBeDegree(this);
-        const x = ((this.x + exports.PI_IN_DEGREE) % exports.DOUBLE_PI_IN_DEGREE - exports.PI_IN_DEGREE) * MITERS_IN_ONE_DEGREE;
-        const 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;
-        this.x = x;
-        this.y = y;
-        return this;
-    }
-    meters2degrees() {
-        (0, utils_1.checkFunction)('meters2degrees')
-            .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) * exports.PI_TO_DEGREE))) *
-            (exports.DOUBLE_PI_IN_DEGREE / Math.PI) - exports.HALF_PI_IN_DEGREE;
-        this.x = lon;
-        this.y = lat;
-        return this;
-    }
 }
 exports.DPoint = DPoint;

package/dist/DPolygon.d.ts

@@ -2,10 +2,6 @@
 import { DCoord, DPoint, LatLng } from './DPoint';
 import { DLine } from './DLine';
 import { DPolygonLoop } from './DPolygonLoop';
-interface ParseProps {
-    dataProjection: string;
-    featureProjection: string;
-}
 export declare const MIN_POINTS_IN_VALID_POLYGON = 3;
 export declare class DPolygon {
     properties: {
@@ -30,7 +26,7 @@ export declare class DPolygon {
      * @param poly should be `minAreaRectangle`
      */
     static minAreaRectangleDirection(poly: DPolygon): number;
-    static parseFromWKT(wkt: string, optProps?: ParseProps): DPolygon;
+    static parseFromWKT(wkt: string): DPolygon;
     static createSquareBySize(size: DPoint): DPolygon;
     loop(): DPolygonLoop;
     set points(p: DPoint[]);
@@ -134,8 +130,9 @@ 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
@@ -145,6 +142,7 @@ export declare class DPolygon {
     /**
      * Rotate polygon with center in point {0, 0}
      * @param a Radians
+     * @deprecated Better to use loop
      */
     rotate(a: number): DPolygon;
     /**
@@ -152,22 +150,70 @@ export declare class DPolygon {
      * @param f
      */
     filter(f: (p: DPoint) => boolean): DPolygon;
+    /**
+     * @deprecated Better to use loop
+     * @param [x=0]
+     * @param [y=x]
+     */
     move(x?: number | DPoint, y?: number): DPolygon;
+    /**
+     * @deprecated Better to use loop
+     * @param [x=0]
+     * @param [y=x]
+     */
     scale(x?: number | DPoint, y?: number): DPolygon;
+    /**
+     * @deprecated Better to use loop
+     * @param [x=0]
+     * @param [y=x]
+     */
     divide(x?: number | DPoint, y?: number): DPolygon;
+    /**
+     * @deprecated Better to use loop
+     */
     round(): DPolygon;
+    /**
+     * @deprecated Better to use loop
+     */
     floor(): DPolygon;
+    /**
+     * @deprecated Better to use loop
+     */
     ceil(): DPolygon;
+    /**
+     * @deprecated Better to use loop
+     * @param size
+     */
+    flipVertically(size: DPoint | number): DPolygon;
+    /**
+     * @deprecated Better to use loop
+     * @param [n=2]
+     */
     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;
-    transform(from?: string, to?: string): DPolygon;
+    /**
+     * @deprecated Better to use loop
+     */
+    degreeToMeters(): DPolygon;
+    /**
+     * @deprecated Better to use loop
+     */
+    metersToDegree(): DPolygon;
+    /**
+     * @deprecated Better to use loop
+     */
+    radiansToMeters(): DPolygon;
+    /**
+     * @deprecated Better to use loop
+     */
+    metersToRadians(): DPolygon;
     toString(): string;
     /**
      * Add to the end of polygon point equal to first point if it not exist
@@ -180,6 +226,7 @@ export declare class DPolygon {
     /**
      * Set `height` (`z`)
      * @param z
+     * @deprecated Better to use loop
      */
     height(z: number): DPolygon;
     add(poly: DPolygon): DPolygon;
@@ -266,6 +313,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;
@@ -274,4 +327,3 @@ export declare class DPolygon {
     private getJSTSGeometry;
     private simpleLogicFunction;
 }
-export {};