dgeoutils 2.0.2 → 2.2.2

package/dist/DPolygon.js

@@ -66,7 +66,7 @@ class DPolygon {
         }
         return first.findLine(last).getFi();
     }
-    static parseFromWKT(wkt, optProps) {
+    static parseFromWKT(wkt) {
         const data = wkt.trim().toUpperCase();
         let res = new DPolygon();
         if (data.indexOf('POLYGON') === 0) {
@@ -90,9 +90,6 @@ class DPolygon {
         if (data.indexOf('POINT') === 0) {
             res = new DPolygon([DPoint_1.DPoint.parseFromWKT(data)]);
         }
-        if (optProps) {
-            return res.transform(optProps.dataProjection, optProps.featureProjection);
-        }
         return res;
     }
     static createSquareBySize(size) {
@@ -212,8 +209,8 @@ class DPolygon {
         const closed = this.deintersection;
         let sum = 0;
         for (let i = 1; i < closed.length; i++) {
-            const cur = closed.p(i);
-            const prev = closed.p(i - 1);
+            const cur = closed.at(i);
+            const prev = closed.at(i - 1);
             sum += prev.x * cur.y - prev.y * cur.x;
         }
         return Math.abs(sum / 2) - this.holes.reduce((a, hole) => a + hole.area, 0);
@@ -225,8 +222,8 @@ class DPolygon {
         const p = this.clone().close();
         for (let i = 0; i < p.length - 1; i++) {
             for (let j = i + 2; j < p.length - 1; j++) {
-                const firstLine = p.p(i).findLine(p.p(i + 1));
-                const secondLine = p.p(j).findLine(p.p(j + 1));
+                const firstLine = p.at(i).findLine(p.at(i + 1));
+                const secondLine = p.at(j).findLine(p.at(j + 1));
                 const intersectionPoint = firstLine.intersection(secondLine);
                 if (intersectionPoint &&
                     ![...firstLine.points, ...secondLine.points].some((t) => t.like(intersectionPoint))) {
@@ -249,19 +246,19 @@ class DPolygon {
      * Get first point
      */
     get first() {
-        return this.p(0);
+        return this.at(0);
     }
     /**
      * Get second point
      */
     get second() {
-        return this.p(1);
+        return this.at(1);
     }
     /**
      * Get last point
      */
     get last() {
-        return this.p(this.length - 1);
+        return this.at(this.length - 1);
     }
     /**
      * Get min area rectangle
@@ -271,21 +268,21 @@ class DPolygon {
         let resultPolygon = new DPolygon();
         let resultArea = Infinity;
         for (let k = 0; k < p.length - 1; k++) {
-            const l = p.p(k).findLine(p.p(k + 1));
+            const l = p.at(k).findLine(p.at(k + 1));
             let maxWidth = 0;
             let maxWidthPoint1 = null;
             let maxWidthPoint2 = null;
             let maxHeight = 0;
             let maxHeightPoint = null;
             for (let i = 0; i < p.length - 1; i++) {
-                const p1 = l.findPoint(l.findPerpendicular(p.p(i)));
-                const h = p1.distance(p.p(i));
+                const p1 = l.findPoint(l.findPerpendicular(p.at(i)));
+                const h = p1.distance(p.at(i));
                 if (h >= maxHeight) {
                     maxHeight = h;
-                    maxHeightPoint = p.p(i);
+                    maxHeightPoint = p.at(i);
                 }
                 for (let j = i; j < p.length - 1; j++) {
-                    const p2 = l.findPoint(l.findPerpendicular(p.p(j)));
+                    const p2 = l.findPoint(l.findPerpendicular(p.at(j)));
                     const w = p1.distance(p2);
                     if (w >= maxWidth) {
                         maxWidth = w;
@@ -341,9 +338,9 @@ class DPolygon {
             p = p.deintersection;
             l = p.length;
             for (let i = 1; i < p.length - 1; i++) {
-                const p1 = p.p(i - 1);
-                const p2 = p.p(i);
-                const p3 = p.p(i + 1);
+                const p1 = p.at(i - 1);
+                const p2 = p.at(i);
+                const p3 = p.at(i + 1);
                 const d = p2.findInnerAngle(p1, p3);
                 if (d > Math.PI || DNumbers_1.DNumbers.likeZero(DNumbers_1.DNumbers.rad2Deg(d)) || DNumbers_1.DNumbers.likePI(d) || DNumbers_1.DNumbers.like2PI(d)) {
                     p.removePart(--i, 1);
@@ -363,8 +360,8 @@ class DPolygon {
         let sum = 0;
         const p = this.clone().close();
         for (let i = 1; i < p.length; i++) {
-            const p1 = p.p(i - 1);
-            const p2 = p.p(i);
+            const p1 = p.at(i - 1);
+            const p2 = p.at(i);
             sum += (p2.x - p1.x) * (p2.y + p1.y);
         }
         return sum < 0;
@@ -389,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);
             }
@@ -408,7 +406,9 @@ class DPolygon {
      * @param newCenter
      */
     setCenter(newCenter) {
-        return this.clone().move(newCenter.clone().move(this.center.minus()));
+        return this.loop()
+            .move(newCenter.clone().move(this.center.minus()))
+            .run();
     }
     toWKT() {
         let h = '';
@@ -420,11 +420,10 @@ class DPolygon {
     /**
      * Rotate polygon with center in point {0, 0}
      * @param a Radians
+     * @deprecated Better to use loop
      */
     rotate(a) {
-        this.pPoints = this.pPoints.map((p) => p.rotate(a));
-        this.holes = this.holes.map((h) => h.rotate(a));
-        return this;
+        return this.map((h) => h.rotate(a));
     }
     /**
      * Filter points
@@ -434,55 +433,70 @@ class DPolygon {
         this.pPoints = this.pPoints.filter(f);
         return this;
     }
+    /**
+     * @deprecated Better to use loop
+     * @param [x=0]
+     * @param [y=x]
+     */
     move(x = 0, y) {
-        this.pPoints = this.pPoints.map((p) => p.move(x, y));
-        this.holes = this.holes.map((h) => h.move(x, y));
-        return this;
+        return this.map((h) => h.move(x, y));
     }
+    /**
+     * @deprecated Better to use loop
+     * @param [x=0]
+     * @param [y=x]
+     */
     scale(x = 0, y) {
-        this.pPoints = this.pPoints.map((p) => p.scale(x, y));
-        this.holes = this.holes.map((h) => h.scale(x, y));
-        return this;
+        return this.map((h) => h.scale(x, y));
     }
+    /**
+     * @deprecated Better to use loop
+     * @param [x=0]
+     * @param [y=x]
+     */
     divide(x = 0, y) {
-        this.pPoints = this.pPoints.map((p) => p.divide(x, y));
-        this.holes = this.holes.map((h) => h.divide(x, y));
-        return this;
+        return this.map((h) => h.divide(x, y));
     }
+    /**
+     * @deprecated Better to use loop
+     */
     round() {
-        this.pPoints = this.pPoints.map((p) => p.round());
-        this.holes = this.holes.map((h) => h.round());
-        return this;
+        return this.map((h) => h.round());
     }
+    /**
+     * @deprecated Better to use loop
+     */
     floor() {
-        this.pPoints = this.pPoints.map((p) => p.floor());
-        this.holes = this.holes.map((h) => h.floor());
-        return this;
+        return this.map((h) => h.floor());
     }
+    /**
+     * @deprecated Better to use loop
+     */
     ceil() {
-        this.pPoints = this.pPoints.map((p) => p.ceil());
-        this.holes = this.holes.map((h) => h.ceil());
-        return this;
+        return this.map((h) => h.ceil());
+    }
+    /**
+     * @deprecated Better to use loop
+     * @param size
+     */
+    flipVertically(size) {
+        return this.map((h) => h.flipVertically(size));
     }
+    /**
+     * @deprecated Better to use loop
+     * @param [n=2]
+     */
     toFixed(n = 2) {
-        this.pPoints = this.pPoints.map((p) => p.toFixed(n));
-        this.holes = this.holes.map((h) => h.toFixed(n));
-        return this;
+        return this.map((h) => h.toFixed(n));
     }
     map(f) {
         this.pPoints = this.pPoints.map(f);
         this.holes = this.holes.map((h) => h.map(f));
         return this;
     }
-    p(index, divide = false) {
-        if (divide) {
-            let t = index;
-            while (t < 0) {
-                t += this.length;
-            }
-            return this.pPoints[t % this.length];
-        }
-        return this.pPoints[index];
+    at(index) {
+        const { length } = this;
+        return this.points[(index % length + length) % length];
     }
     pop() {
         return this.pPoints.pop();
@@ -505,10 +519,29 @@ class DPolygon {
         return (this.pPoints.map((r) => r.getValue()) + this.holes
             .reduce((a, h) => a + h.getValue(), ''));
     }
-    transform(from = DPoint_1.PSEUDO_MERCATOR, to = DPoint_1.WORLD_GEODETIC_SYSTEM) {
-        this.pPoints = this.pPoints.map((r) => r.transform(from, to));
-        this.holes = this.holes.map((h) => h.transform(from, to));
-        return this;
+    /**
+     * @deprecated Better to use loop
+     */
+    degreeToMeters() {
+        return this.map((r) => r.degreeToMeters());
+    }
+    /**
+     * @deprecated Better to use loop
+     */
+    metersToDegree() {
+        return this.map((r) => r.metersToDegree());
+    }
+    /**
+     * @deprecated Better to use loop
+     */
+    radiansToMeters() {
+        return this.map((r) => r.radiansToMeters());
+    }
+    /**
+     * @deprecated Better to use loop
+     */
+    metersToRadians() {
+        return this.map((r) => r.metersToRadians());
     }
     toString() {
         return `(${this.pPoints.map((r) => r.toString()).join(', ')})`;
@@ -536,11 +569,10 @@ class DPolygon {
     /**
      * Set `height` (`z`)
      * @param z
+     * @deprecated Better to use loop
      */
     height(z) {
-        this.map((p) => p.height(z));
-        this.holes = this.holes.map((h) => h.height(z));
-        return this;
+        return this.map((p) => p.height(z));
     }
     add(poly) {
         const res = new DPolygon([...this.points, ...poly.points]).close();
@@ -568,7 +600,7 @@ class DPolygon {
         if (!(p instanceof DPolygon)) {
             return false;
         }
-        if (this.clone().open().length !== p.clone().open().length || this.holes.length !== p.holes.length) {
+        if (this.length !== p.length || this.holes.length !== p.holes.length) {
             return false;
         }
         return (this.same(p) &&
@@ -579,20 +611,18 @@ class DPolygon {
      * @param p
      */
     same(p) {
-        const pClone = p.clone().open();
-        const thisClone = this.clone().open();
-        const thisAsString = thisClone.toString();
-        return thisClone.points.reduce((a) => {
-            const f = pClone.shift();
-            pClone.push(f);
-            return (a ||
-                thisAsString === pClone.toString() ||
-                thisAsString ===
-                    pClone
-                        .clone()
-                        .reverse()
-                        .toString());
-        }, false);
+        const pClone = p.clone().close();
+        const thisAsString = this.clone()
+            .close()
+            .toString();
+        for (let i = 0; i < pClone.length; i++) {
+            if (thisAsString === pClone.toString() || thisAsString === pClone.clone().reverse()
+                .toString()) {
+                return true;
+            }
+            pClone.nextStart();
+        }
+        return false;
     }
     findIndex(p) {
         return this.points.findIndex((t) => t.equal(p));
@@ -645,7 +675,7 @@ class DPolygon {
         if (lineWidth) {
             ctx.lineWidth = lineWidth;
         }
-        if (fillColor) {
+        if (fillColor || strokeColor) {
             ctx.beginPath();
         }
         this.goByPath(ctx, steps % this.length);
@@ -690,7 +720,7 @@ class DPolygon {
         const poly = this.deintersection;
         const intersectionPoints = [];
         for (let i = 0; i < poly.length - 1; i++) {
-            const polygonLine = poly.p(i).findLine(poly.p(i + 1));
+            const polygonLine = poly.at(i).findLine(poly.at(i + 1));
             const intersection = line.intersection(polygonLine, CLOSE_TO_INTERSECTION_DISTANCE);
             if (intersection) {
                 intersectionPoints.push(intersection);
@@ -715,8 +745,8 @@ class DPolygon {
                 return true;
             }
             for (let i = 0; i < poly.length - 1; i++) {
-                const p0 = poly.p(i);
-                const p1 = poly.p(i + 1);
+                const p0 = poly.at(i);
+                const p1 = poly.at(i + 1);
                 const polygonLine = p0.findLine(p1);
                 const onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
                 if (onBorder) {
@@ -740,8 +770,8 @@ class DPolygon {
      */
     removeDuplicates() {
         for (let i = 0; i < this.length - 1; i++) {
-            const p1 = this.p(i);
-            const p2 = this.p(i + 1);
+            const p1 = this.at(i);
+            const p2 = this.at(i + 1);
             if (p1.equal(p2)) {
                 this.removePart(i, 1);
                 i--;
@@ -885,6 +915,64 @@ class DPolygon {
         }
         return res;
     }
+    /**
+     * Divide polygon to triangles
+     *
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/toTriangles.png)
+     */
+    toTriangles() {
+        const innerAndNotIntersect = (poly, p1, p2) => {
+            const l = p1.findLine(p2);
+            const { center } = l;
+            const intersections = poly.holes.reduce((a, hole) => a && Boolean(hole.clone().close()
+                .intersection(l, true).length), Boolean(poly.clone().close()
+                .intersection(l, true).length));
+            const contain = poly.holes.reduce((a, hole) => a && !hole
+                .contain(center), poly.contain(center));
+            return !intersections && contain;
+        };
+        const getTriangle = (poly) => {
+            for (let i = 0; i < poly.length; i++) {
+                const p0 = poly.at(0);
+                const p1 = poly.at(1);
+                const p2 = poly.at(2);
+                if (innerAndNotIntersect(poly, p0, p2)) {
+                    poly.removePart(0, 1);
+                    return new DPolygon([
+                        p0.clone(),
+                        p1.clone(),
+                        p2.clone()
+                    ]);
+                }
+                poly.push(poly.shift());
+            }
+            return undefined;
+        };
+        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 (innerAndNotIntersect(p, p.first, h.first)) {
+                    p.insertAfter(0, ...h.points, p.first);
+                    break;
+                }
+                p.push(p.shift());
+            }
+        }
+        const res = [];
+        while (p.length > 3) {
+            const triangle = getTriangle(p);
+            if (triangle) {
+                res.push(triangle);
+            }
+        }
+        res.push(p);
+        return res;
+    }
     simpleIncludeX(p) {
         const { x } = p;
         return this.minX <= x && this.maxX >= x;
@@ -917,7 +1005,7 @@ class DPolygon {
         const start = this.first;
         ctx.moveTo(start.x, start.y);
         for (let i = 1; i <= (steps % this.length); i++) {
-            const { x, y } = this.p(i);
+            const { x, y } = this.at(i);
             ctx.lineTo(x, y);
         }
     }
@@ -933,8 +1021,8 @@ class DPolygon {
         const poly = this.deintersection;
         let totalFi = 0;
         for (let i = 0; i < poly.length - 1; i++) {
-            const p1 = poly.p(i);
-            const p2 = poly.p(i + 1);
+            const p1 = poly.at(i);
+            const p2 = poly.at(i + 1);
             const line1 = new DLine_1.DLine(p1.x - p.x, p1.y - p.y, 0);
             const line2 = new DLine_1.DLine(p2.x - p.x, p2.y - p.y, 0);
             const fiDif = line1.findFi(line2);

package/dist/DPolygonLoop.d.ts

@@ -1,12 +1,17 @@
 import { DPolygon } from './DPolygon';
 import { DPoint, SetterFunction } from './DPoint';
+export declare type LoopFunction = (k: DPoint) => DPoint;
 export declare class DPolygonLoop {
-    private f;
     private readonly parent;
+    private pool;
     constructor(parent: DPolygon);
+    private getLoopFunction;
+    /**
+     * Run loop
+     */
+    run(): DPolygon;
     getTileFromCoords(zoom?: number): DPolygonLoop;
     getCoordsFromTile(zoom?: number): DPolygonLoop;
-    transform(from?: string, to?: string): DPolygonLoop;
     height(z: number): DPolygonLoop;
     setX(x: number | SetterFunction): DPolygonLoop;
     setY(y: number | SetterFunction): DPolygonLoop;
@@ -19,8 +24,10 @@ export declare class DPolygonLoop {
     abs(): DPolygonLoop;
     scale(x?: number | DPoint, y?: number): DPolygonLoop;
     divide(x?: number | DPoint, y?: number): DPolygonLoop;
-    asRadians(): DPolygonLoop;
-    asDegrees(): DPolygonLoop;
+    degreeToRadians(): DPolygonLoop;
+    radiansToDegrees(): DPolygonLoop;
+    radiansToMeters(): DPolygonLoop;
+    metersToRadians(): DPolygonLoop;
     getHipPoint(): DPolygonLoop;
     getXPoint(): DPolygonLoop;
     getYPoint(): DPolygonLoop;
@@ -28,5 +35,7 @@ export declare class DPolygonLoop {
     getHPoint(): DPolygonLoop;
     setIfLessThan(p: DPoint): DPolygonLoop;
     minus(): DPolygonLoop;
-    run(): DPolygon;
+    degreeToMeters(): DPolygonLoop;
+    metersToDegree(): DPolygonLoop;
+    flipVertically(size: DPoint | number): DPolygonLoop;
 }