dgeoutils 2.2.0 → 2.2.1

package/dist/DCircle.d.ts

@@ -12,11 +12,31 @@ export declare class DCircle {
     clone(): DCircle;
     /**
      * Find intersection points with other circle.
+     *
+     * ![Example](/media/examples/findPoints.png)
      * @param c
      */
     findPoints(c: DCircle): DPoint[] | number;
     equal({ center, r }: DCircle): boolean;
+    /**
+     * Transform circle to polygon
+     *
+     * ![Example](/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](/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](/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](/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](/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,32 @@ 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 { minX, minY, maxX, maxY, p1, p2 } = this;
+        const { x, y } = p;
+        return this.inRange(p, d) && !p1.like(p, 0.00001) && !p2.like(p, 0.00001);
+        const isInX = x > minX - d && x < maxX + d;
+        const isInY = y > minY - d && y < maxY + d;
+        return isInX && isInY && !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

@@ -31,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;
     /**
@@ -104,5 +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;
 }

package/dist/DPoint.js

@@ -58,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')
@@ -66,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')
@@ -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')

package/dist/DPolygon.d.ts

@@ -130,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
@@ -266,6 +267,17 @@ 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](/media/examples/toTriangles.png)
+     */
+    toTriangles(): DPolygon[];
+    /**
+     * @internal
+     */
+    getTriangle(): DPolygon | void;
+    private innerAndNotIntersect;
     private simpleIncludeX;
     private simpleIncludeY;
     private douglasPeucker;

package/dist/DPolygon.js

@@ -386,14 +386,15 @@ class DPolygon {
     /**
      * Check polygon intersection with line
      * @param l
+     * @param [includeOnly=false]
      */
-    intersection(l) {
+    intersection(l, includeOnly = false) {
         const res = [];
         for (let i = 0; i < this.pPoints.length - 1; i++) {
             const p1 = this.pPoints[i];
             const p2 = this.pPoints[i + 1];
             const line = p1.findLine(p2);
-            const intersect = line.intersection(l);
+            const intersect = line.intersection(l, 0, includeOnly);
             if (intersect) {
                 res.push(intersect);
             }
@@ -662,7 +663,7 @@ class DPolygon {
         if (lineWidth) {
             ctx.lineWidth = lineWidth;
         }
-        if (fillColor) {
+        if (fillColor || strokeColor) {
             ctx.beginPath();
         }
         this.goByPath(ctx, steps % this.length);
@@ -902,6 +903,67 @@ class DPolygon {
         }
         return res;
     }
+    /**
+     * Divide polygon to triangles
+     *
+     * ![Example](/media/examples/toTriangles.png)
+     */
+    toTriangles() {
+        const p = this.clone().clockWise.open();
+        while (p.holes.length) {
+            const h = p.holes.shift()
+                .clone()
+                .clockWise
+                .reverse()
+                .close();
+            for (let i = 0; i < p.length; i++) {
+                if (p.innerAndNotIntersect(p.first, h.first)) {
+                    p.insertAfter(0, ...h.points, p.first);
+                    break;
+                }
+                p.push(p.shift());
+            }
+        }
+        const res = [];
+        while (p.length > 3) {
+            const triangle = p.getTriangle();
+            if (triangle) {
+                res.push(triangle);
+            }
+        }
+        res.push(p);
+        return res;
+    }
+    /**
+     * @internal
+     */
+    getTriangle() {
+        for (let i = 0; i < this.length; i++) {
+            const p0 = this.p(0);
+            const p1 = this.p(1);
+            const p2 = this.p(2);
+            if (this.innerAndNotIntersect(p0, p2)) {
+                this.removePart(0, 1);
+                return new DPolygon([
+                    p0.clone(),
+                    p1.clone(),
+                    p2.clone()
+                ]);
+            }
+            this.push(this.shift());
+        }
+        return undefined;
+    }
+    innerAndNotIntersect(p1, p2) {
+        const l = p1.findLine(p2);
+        const { center } = l;
+        const intersections = this.holes.reduce((a, hole) => a && Boolean(hole.clone().close()
+            .intersection(l, true).length), Boolean(this.clone().close()
+            .intersection(l, true).length));
+        const contain = this.holes.reduce((a, hole) => a && !hole
+            .contain(center), this.contain(center));
+        return !intersections && contain;
+    }
     simpleIncludeX(p) {
         const { x } = p;
         return this.minX <= x && this.maxX >= x;

package/package.json

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