dgeoutils 2.1.0 → 2.2.3

package/dist/DPolygon.js

@@ -13,13 +13,13 @@ const APPROXIMATION_VALUE = 0.1;
 const MAX_CONVEX_ITERATIONS = 100;
 const CLOSE_TO_INTERSECTION_DISTANCE = 0.001;
 class DPolygon {
-    constructor(points = []) {
+    // eslint-disable-next-line no-useless-constructor,no-empty-function
+    constructor(pPoints = []) {
+        this.pPoints = pPoints;
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         this.properties = {};
         this.holes = [];
-        this.pPoints = [];
         this.searchStore = {};
-        this.pPoints = points;
     }
     /**
      * Get size of min area rectangle.
@@ -93,7 +93,7 @@ class DPolygon {
         return res;
     }
     static createSquareBySize(size) {
-        return new DPolygon([DPoint_1.DPoint.Zero(), size.clone().setX(0), size.clone(), size.clone().setY(0)]).close();
+        return new DPolygon([DPoint_1.DPoint.zero(), size.clone().setX(0), size.clone(), size.clone().setY(0)]).close();
     }
     loop() {
         return new DPolygonLoop_1.DPolygonLoop(this);
@@ -209,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);
@@ -222,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))) {
@@ -246,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
@@ -268,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;
@@ -338,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);
@@ -360,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;
@@ -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);
             }
@@ -405,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 = '';
@@ -414,15 +417,6 @@ class DPolygon {
         }
         return `POLYGON ((${this.deintersection.pPoints.map((r) => `${r.x} ${r.y}`).join(', ')})${h})`;
     }
-    /**
-     * Rotate polygon with center in point {0, 0}
-     * @param a Radians
-     */
-    rotate(a) {
-        this.pPoints = this.pPoints.map((p) => p.rotate(a));
-        this.holes = this.holes.map((h) => h.rotate(a));
-        return this;
-    }
     /**
      * Filter points
      * @param f
@@ -431,60 +425,14 @@ class DPolygon {
         this.pPoints = this.pPoints.filter(f);
         return this;
     }
-    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;
-    }
-    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;
-    }
-    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;
-    }
-    round() {
-        this.pPoints = this.pPoints.map((p) => p.round());
-        this.holes = this.holes.map((h) => h.round());
-        return this;
-    }
-    floor() {
-        this.pPoints = this.pPoints.map((p) => p.floor());
-        this.holes = this.holes.map((h) => h.floor());
-        return this;
-    }
-    ceil() {
-        this.pPoints = this.pPoints.map((p) => p.ceil());
-        this.holes = this.holes.map((h) => h.ceil());
-        return this;
-    }
-    flipVertically(size) {
-        this.pPoints = this.pPoints.map((p) => p.flipVertically(size));
-        this.holes = this.holes.map((h) => h.flipVertically(size));
-        return this;
-    }
-    toFixed(n = 2) {
-        this.pPoints = this.pPoints.map((p) => p.toFixed(n));
-        this.holes = this.holes.map((h) => h.toFixed(n));
-        return this;
-    }
     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();
@@ -507,26 +455,6 @@ class DPolygon {
         return (this.pPoints.map((r) => r.getValue()) + this.holes
             .reduce((a, h) => a + h.getValue(), ''));
     }
-    degreeToMeters() {
-        this.pPoints = this.pPoints.map((r) => r.degreeToMeters());
-        this.holes = this.holes.map((h) => h.degreeToMeters());
-        return this;
-    }
-    metersToDegree() {
-        this.pPoints = this.pPoints.map((r) => r.metersToDegree());
-        this.holes = this.holes.map((h) => h.metersToDegree());
-        return this;
-    }
-    radiansToMeters() {
-        this.pPoints = this.pPoints.map((r) => r.radiansToMeters());
-        this.holes = this.holes.map((h) => h.radiansToMeters());
-        return this;
-    }
-    metersToRadians() {
-        this.pPoints = this.pPoints.map((r) => r.metersToRadians());
-        this.holes = this.holes.map((h) => h.metersToRadians());
-        return this;
-    }
     toString() {
         return `(${this.pPoints.map((r) => r.toString()).join(', ')})`;
     }
@@ -550,15 +478,6 @@ class DPolygon {
         }
         return this;
     }
-    /**
-     * Set `height` (`z`)
-     * @param z
-     */
-    height(z) {
-        this.map((p) => p.height(z));
-        this.holes = this.holes.map((h) => h.height(z));
-        return this;
-    }
     add(poly) {
         const res = new DPolygon([...this.points, ...poly.points]).close();
         res.holes = [...this.holes, ...poly.holes].map((h) => h.clone());
@@ -585,7 +504,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) &&
@@ -596,20 +515,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));
@@ -617,7 +534,7 @@ 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 = Math.sqrt(this.perimeter) * APPROXIMATION_VALUE) {
         return new DPolygon(this.clone().douglasPeucker(this.pPoints, e));
@@ -662,7 +579,7 @@ class DPolygon {
         if (lineWidth) {
             ctx.lineWidth = lineWidth;
         }
-        if (fillColor) {
+        if (fillColor || strokeColor) {
             ctx.beginPath();
         }
         this.goByPath(ctx, steps % this.length);
@@ -691,10 +608,10 @@ 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, isBorderInside = false, move = DPoint_1.DPoint.Zero()) {
+    contain(p, isBorderInside = false, move = DPoint_1.DPoint.zero()) {
         const simpleInclude = this.simpleInclude(p);
         if (!simpleInclude) {
             return false;
@@ -707,7 +624,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);
@@ -732,8 +649,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) {
@@ -757,8 +674,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--;
@@ -766,11 +683,6 @@ class DPolygon {
         }
         return this;
     }
-    /**
-     * Parse from [OpenLayers](https://openlayers.org/) coordinates or
-     * [GeoJSON](https://en.wikipedia.org/wiki/GeoJSON) coordinates
-     * @param a
-     */
     static parse(a) {
         return new DPolygon(a.map((r) => DPoint_1.DPoint.parse(r)));
     }
@@ -902,6 +814,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;
@@ -934,7 +904,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);
         }
     }
@@ -950,8 +920,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

@@ -2,27 +2,97 @@ 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(f?: LoopFunction): DPolygon;
+    run(): DPolygon;
+    /**
+     * @param zoom default value would be `z` of point
+     */
     getTileFromCoords(zoom?: number): DPolygonLoop;
+    /**
+     * @param zoom default value would be `z` of point
+     */
     getCoordsFromTile(zoom?: number): DPolygonLoop;
     height(z: number): DPolygonLoop;
-    setX(x: number | SetterFunction): DPolygonLoop;
-    setY(y: number | SetterFunction): DPolygonLoop;
+    /**
+     * Set `x` value
+     * @param x
+     */
+    setX(x: number): DPolygonLoop;
+    /**
+     * Transform `x` value by function
+     * @param f
+     */
+    setX(f: SetterFunction): DPolygonLoop;
+    /**
+     * Set `y` value
+     * @param y
+     */
+    setY(y: number): DPolygonLoop;
+    /**
+     * Transform `y` value by function
+     * @param f
+     */
+    setY(f: SetterFunction): DPolygonLoop;
     rotate(a: number): DPolygonLoop;
-    move(x?: number | DPoint, y?: number): DPolygonLoop;
+    /**
+     * Add `v` to `x` and `y`
+     * @param v
+     */
+    move(v: number): DPolygonLoop;
+    /**
+     * Add `p.x` to `x` field and `p.y` to `y` field.
+     * @param p
+     */
+    move(p: DPoint): DPolygonLoop;
+    /**
+     * Add `x` to `x` field and `y` to `y` field.
+     * @param x
+     * @param y
+     */
+    move(x: number, y: number): DPolygonLoop;
     round(): DPolygonLoop;
     ceil(): DPolygonLoop;
     floor(): DPolygonLoop;
     toFixed(n?: number): DPolygonLoop;
     abs(): DPolygonLoop;
-    scale(x?: number | DPoint, y?: number): DPolygonLoop;
-    divide(x?: number | DPoint, y?: number): DPolygonLoop;
+    /**
+     * Multiply `v` to `x` and `y`
+     * @param v
+     */
+    scale(v: number): DPolygonLoop;
+    /**
+     * Multiply `p.x` to `x` field and `p.y` to `y` field.
+     * @param p
+     */
+    scale(p: DPoint): DPolygonLoop;
+    /**
+     * Multiply `x` to `x` field and `y` to `y` field.
+     * @param x
+     * @param y
+     */
+    scale(x: number, y: number): DPolygonLoop;
+    /**
+     * Divide `x` and `y` to `v`
+     * @param v
+     */
+    divide(v: number): DPolygonLoop;
+    /**
+     * Divide `x` field to `p.x` and `y` field to `p.y`.
+     * @param p
+     */
+    divide(p: DPoint): DPolygonLoop;
+    /**
+     * Divide `x` field to `x` and `y` field to `y`.
+     * @param x
+     * @param y
+     */
+    divide(x: number, y: number): DPolygonLoop;
     degreeToRadians(): DPolygonLoop;
     radiansToDegrees(): DPolygonLoop;
     radiansToMeters(): DPolygonLoop;
@@ -36,5 +106,14 @@ export declare class DPolygonLoop {
     minus(): DPolygonLoop;
     degreeToMeters(): DPolygonLoop;
     metersToDegree(): DPolygonLoop;
-    flipVertically(size: DPoint | number): DPolygonLoop;
+    /**
+     * Flip vertically
+     * @param size canvas size
+     */
+    flipVertically(size: DPoint): DPolygonLoop;
+    /**
+     * Flip vertically
+     * @param height canvas height
+     */
+    flipVertically(height: number): DPolygonLoop;
 }