dgeoutils 2.2.23 → 2.2.24

package/dist/DPolygon.d.ts

@@ -51,6 +51,8 @@ export declare class DPolygon {
     get isClockwise(): boolean;
     get clockWise(): DPolygon;
     get noHoles(): DPolygon;
+    reduce<T>(f: (a: T, p: DPoint) => T, v: T): T;
+    reduce<T>(f: (a: T, p: DPoint, index: number) => T, v: T): T;
     intersection(l: DLine, includeOnly?: boolean): DPoint[];
     setCenter(newCenter: DPoint): DPolygon;
     static WKT_LINESTRING: string;
@@ -59,6 +61,8 @@ export declare class DPolygon {
     filter(f: (p: DPoint) => boolean): DPolygon;
     map(f: (r: DPoint) => DPoint): DPolygon;
     map(f: (r: DPoint, index: number) => DPoint): DPolygon;
+    mapArray<T>(f: (r: DPoint) => T): T[];
+    mapArray<T>(f: (r: DPoint, index: number) => T): T[];
     sort(f: (a: DPoint, b: DPoint) => number): DPolygon;
     at(index: number): DPoint;
     pop(): DPoint;
@@ -76,6 +80,8 @@ export declare class DPolygon {
     equal(p: DPolygon | null): boolean;
     same(p: DPolygon): boolean;
     findIndex(p: DPoint): number;
+    findIndex(f: (p: DPoint) => boolean): number;
+    findIndex(f: (p: DPoint, index: number) => boolean): number;
     approximation(e?: number): DPolygon;
     insertAfter(index: number, ...points: DPoint[]): void;
     removePart(index: number, count: number): DPoint[];

package/dist/DPolygon.js

@@ -137,16 +137,16 @@ class DPolygon {
         return this.pPoints;
     }
     get maxX() {
-        return this.pPoints.reduce((a, r) => Math.max(a, r.x), -Infinity);
+        return this.reduce((a, r) => Math.max(a, r.x), -Infinity);
     }
     get minX() {
-        return this.pPoints.reduce((a, r) => Math.min(a, r.x), Infinity);
+        return this.reduce((a, r) => Math.min(a, r.x), Infinity);
     }
     get maxY() {
-        return this.pPoints.reduce((a, r) => Math.max(a, r.y), -Infinity);
+        return this.reduce((a, r) => Math.max(a, r.y), -Infinity);
     }
     get minY() {
-        return this.pPoints.reduce((a, r) => Math.min(a, r.y), Infinity);
+        return this.reduce((a, r) => Math.min(a, r.y), Infinity);
     }
     get center() {
         return this.leftTop.move(this.size.divide(2));
@@ -233,8 +233,7 @@ class DPolygon {
                     const d = record[j] - record[j - 1];
                     if (d > 1) {
                         const part = new DPolygon(origin.removePart(record[j - 1], d));
-                        const allInside = part.points
-                            .reduce((a, e) => a && containCalculator(origin, e), true);
+                        const allInside = part.reduce((a, e) => a && containCalculator(origin, e), true);
                         if (allInside && origin.isClockwise === part.isClockwise) {
                             origin.insertAfter(record[j - 1] - 1, ...part.reverse().points);
                             p = origin;
@@ -362,6 +361,9 @@ class DPolygon {
         res.holes = [];
         return res;
     }
+    reduce(f, v) {
+        return this.pPoints.reduce(f, v);
+    }
     intersection(l, includeOnly = false) {
         const res = [];
         for (const [, , line] of this.loopPointsGenerator(true)()) {
@@ -384,10 +386,10 @@ class DPolygon {
                 h = `, ${this.holes.map((hole) => hole.toString())
                     .join(', ')}`;
             }
-            return `POLYGON ((${this.deintersection.pPoints.map((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
+            return `POLYGON ((${this.deintersection.mapArray((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
                 .join(', ')})${h})`;
         }
-        return `LINESTRING (${this.pPoints.map((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
+        return `LINESTRING (${this.mapArray((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
             .join(', ')})`;
     }
     filter(f) {
@@ -395,10 +397,13 @@ class DPolygon {
         return this;
     }
     map(f) {
-        this.pPoints = this.pPoints.map(f);
+        this.pPoints = this.mapArray(f);
         this.holes = this.holes.map((h) => h.map(f));
         return this;
     }
+    mapArray(f) {
+        return this.pPoints.map(f);
+    }
     sort(f) {
         this.points.sort(f);
         return this;
@@ -429,7 +434,7 @@ class DPolygon {
             .reduce((a, h) => a + h.getValue(), ''));
     }
     toString() {
-        return `(${this.pPoints.map((r) => r.toString()).join(', ')})`;
+        return `(${this.mapArray((r) => r.toString()).join(', ')})`;
     }
     close() {
         const p0 = this.first;
@@ -483,8 +488,11 @@ class DPolygon {
         }
         return false;
     }
-    findIndex(p) {
-        return this.points.findIndex((t) => t.equal(p));
+    findIndex(a) {
+        if (a instanceof DPoint_1.DPoint) {
+            return this.points.findIndex((t) => t.equal(a));
+        }
+        return this.points.findIndex(a);
     }
     approximation(e = Math.sqrt(this.perimeter) * APPROXIMATION_VALUE) {
         return new DPolygon(this.clone().douglasPeucker(this.pPoints, e));
@@ -617,7 +625,7 @@ class DPolygon {
         return new DPolygon(a.map((r) => DPoint_1.DPoint.parse(r)));
     }
     toArrayOfCoords() {
-        return this.pPoints.map((r) => r.toCoords());
+        return this.mapArray((r) => r.toCoords());
     }
     divideToPieces(piecesCount) {
         const { fullLength } = this;

package/package.json

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