dgeoutils 2.2.1 → 2.2.2

package/dist/DCircle.d.ts

@@ -13,7 +13,7 @@ export declare class DCircle {
     /**
      * Find intersection points with other circle.
      *
-     * ![Example](/media/examples/findPoints.png)
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPoints.png)
      * @param c
      */
     findPoints(c: DCircle): DPoint[] | number;
@@ -21,7 +21,7 @@ export declare class DCircle {
     /**
      * Transform circle to polygon
      *
-     * ![Example](/media/examples/findPolygonInside.png)
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPolygonInside.png)
      * @param [pointCount=64]
      */
     findPolygonInside(pointCount?: number): DPolygon;
@@ -34,7 +34,7 @@ export declare class DCircle {
      * @remarks
      * Radius should be in meters.
      *
-     * ![Example](/media/examples/findPolygonInsideOnSphere.png)
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPolygonInsideOnSphere.png)
      * @param [pointCount=64]
      */
     findPolygonInsideOnSphere(pointCount?: number): DPolygon;

package/dist/DCircle.js

@@ -24,7 +24,7 @@ class DCircle {
     /**
      * Find intersection points with other circle.
      *
-     * ![Example](/media/examples/findPoints.png)
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPoints.png)
      * @param c
      */
     findPoints(c) {
@@ -62,7 +62,7 @@ class DCircle {
     /**
      * Transform circle to polygon
      *
-     * ![Example](/media/examples/findPolygonInside.png)
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPolygonInside.png)
      * @param [pointCount=64]
      */
     findPolygonInside(pointCount = 64) {
@@ -85,7 +85,7 @@ class DCircle {
      * @remarks
      * Radius should be in meters.
      *
-     * ![Example](/media/examples/findPolygonInsideOnSphere.png)
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/findPolygonInsideOnSphere.png)
      * @param [pointCount=64]
      */
     findPolygonInsideOnSphere(pointCount = 64) {

package/dist/DLine.js

@@ -127,12 +127,8 @@ class DLine {
      * @param d
      */
     insideRange(p, d = 0) {
-        const { minX, minY, maxX, maxY, p1, p2 } = this;
-        const { x, y } = p;
+        const { p1, p2 } = this;
         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

package/dist/DPoint.js

@@ -314,9 +314,12 @@ 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) {

package/dist/DPolygon.d.ts

@@ -142,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;
     /**
@@ -149,25 +150,69 @@ 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;
+    /**
+     * @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;
     /**
@@ -181,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;
@@ -270,14 +316,9 @@ export declare class DPolygon {
     /**
      * Divide polygon to triangles
      *
-     * ![Example](/media/examples/toTriangles.png)
+     * ![Example](https://edejin.github.io/DGeoUtils/media/examples/toTriangles.png)
      */
     toTriangles(): DPolygon[];
-    /**
-     * @internal
-     */
-    getTriangle(): DPolygon | void;
-    private innerAndNotIntersect;
     private simpleIncludeX;
     private simpleIncludeY;
     private douglasPeucker;

package/dist/DPolygon.js

@@ -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;
@@ -406,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 = '';
@@ -418,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
@@ -432,60 +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) {
-        this.pPoints = this.pPoints.map((p) => p.flipVertically(size));
-        this.holes = this.holes.map((h) => h.flipVertically(size));
-        return this;
+        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();
@@ -508,25 +519,29 @@ class DPolygon {
         return (this.pPoints.map((r) => r.getValue()) + this.holes
             .reduce((a, h) => a + h.getValue(), ''));
     }
+    /**
+     * @deprecated Better to use loop
+     */
     degreeToMeters() {
-        this.pPoints = this.pPoints.map((r) => r.degreeToMeters());
-        this.holes = this.holes.map((h) => h.degreeToMeters());
-        return this;
+        return this.map((r) => r.degreeToMeters());
     }
+    /**
+     * @deprecated Better to use loop
+     */
     metersToDegree() {
-        this.pPoints = this.pPoints.map((r) => r.metersToDegree());
-        this.holes = this.holes.map((h) => h.metersToDegree());
-        return this;
+        return this.map((r) => r.metersToDegree());
     }
+    /**
+     * @deprecated Better to use loop
+     */
     radiansToMeters() {
-        this.pPoints = this.pPoints.map((r) => r.radiansToMeters());
-        this.holes = this.holes.map((h) => h.radiansToMeters());
-        return this;
+        return this.map((r) => r.radiansToMeters());
     }
+    /**
+     * @deprecated Better to use loop
+     */
     metersToRadians() {
-        this.pPoints = this.pPoints.map((r) => r.metersToRadians());
-        this.holes = this.holes.map((h) => h.metersToRadians());
-        return this;
+        return this.map((r) => r.metersToRadians());
     }
     toString() {
         return `(${this.pPoints.map((r) => r.toString()).join(', ')})`;
@@ -554,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();
@@ -586,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) &&
@@ -597,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));
@@ -708,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);
@@ -733,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) {
@@ -758,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--;
@@ -906,9 +918,36 @@ class DPolygon {
     /**
      * Divide polygon to triangles
      *
-     * ![Example](/media/examples/toTriangles.png)
+     * ![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()
@@ -917,7 +956,7 @@ class DPolygon {
                 .reverse()
                 .close();
             for (let i = 0; i < p.length; i++) {
-                if (p.innerAndNotIntersect(p.first, h.first)) {
+                if (innerAndNotIntersect(p, p.first, h.first)) {
                     p.insertAfter(0, ...h.points, p.first);
                     break;
                 }
@@ -926,7 +965,7 @@ class DPolygon {
         }
         const res = [];
         while (p.length > 3) {
-            const triangle = p.getTriangle();
+            const triangle = getTriangle(p);
             if (triangle) {
                 res.push(triangle);
             }
@@ -934,36 +973,6 @@ class DPolygon {
         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;
@@ -996,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);
         }
     }
@@ -1012,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/TraceMatrix.js

@@ -36,7 +36,7 @@ class TraceMatrix {
                 const marked = TraceMatrix.createMatrix(this.size, () => TraceMatrixValues.f);
                 setByPosition(marked, s, TraceMatrixValues.t);
                 while (startIndex < res.length) {
-                    const r = res.p(startIndex);
+                    const r = res.at(startIndex);
                     for (let i = -1; i < 2; i++) {
                         for (let j = -1; j < 2; j++) {
                             const t = new DPoint_1.DPoint(r.x + i, r.y + j);
@@ -90,14 +90,14 @@ class TraceMatrix {
             const left = (d) => (d + traceDirections.length + 1) % traceDirections.length;
             const right = (d) => (d + traceDirections.length - 1) % traceDirections.length;
             if (group.length < 2) {
-                const t = group.p(0).clone();
+                const t = group.at(0).clone();
                 return new DPolygon_1.DPolygon([t, t, t]);
             }
             const points = new DPolygon_1.DPolygon();
             let direction = 0;
             let prevDirection = Infinity;
-            let p = group.p(0);
-            while (!p.equal(group.p(0)) || points.length < 2) {
+            let p = group.at(0);
+            while (!p.equal(group.at(0)) || points.length < 2) {
                 // eslint-disable-next-line no-constant-condition
                 while (true) {
                     const nextValue = getByPosition(m, p.clone().move(traceDirections[direction]));

package/package.json

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