dgeoutils 2.2.19 → 2.3.0

package/dist/{DPolygon.js → es2015/DPolygon.js}

@@ -1,19 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DPolygon = exports.MIN_POINTS_IN_VALID_POLYGON = void 0;
-const DPoint_1 = require("./DPoint");
-const DLine_1 = require("./DLine");
-const DCircle_1 = require("./DCircle");
-const DNumbers_1 = require("./DNumbers");
-const jsts_1 = require("jsts");
-const DPolygonLoop_1 = require("./DPolygonLoop");
-const utils_1 = require("./utils");
-const { buffer: { BufferParameters: { CAP_ROUND, CAP_FLAT, CAP_SQUARE } } } = jsts_1.operation;
-exports.MIN_POINTS_IN_VALID_POLYGON = 3;
+import { DPoint } from './DPoint';
+import { DLine } from './DLine';
+import { DCircle } from './DCircle';
+import { DNumbers } from './DNumbers';
+import { io as jstsIo, operation } from 'jsts';
+import { DPolygonLoop } from './DPolygonLoop';
+import { isDefAndNotNull } from './utils';
+const { buffer: { BufferParameters: { CAP_ROUND, CAP_FLAT, CAP_SQUARE } } } = operation;
+export const MIN_POINTS_IN_VALID_POLYGON = 3;
 const APPROXIMATION_VALUE = 0.1;
 const MAX_CONVEX_ITERATIONS = 100;
 const CLOSE_TO_INTERSECTION_DISTANCE = 0.001;
-class DPolygon {
+const containCalculator = (poly, p) => {
+    const hasSamePoint = poly.points.some((point) => point.equal(p));
+    if (hasSamePoint) {
+        return true;
+    }
+    for (const [, , polygonLine] of poly.loopPointsGenerator(true)()) {
+        const onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
+        if (onBorder) {
+            return true;
+        }
+    }
+    let totalFi = 0;
+    for (const [{ x, y }, { x: a, y: b }] of poly.loopPointsGenerator()()) {
+        const line1 = new DLine(x - p.x, y - p.y, 0);
+        const line2 = new DLine(a - p.x, b - p.y, 0);
+        const fiDif = line1.findFi(line2);
+        if (line1.vectorProduct(line2).c > 0) {
+            totalFi += fiDif;
+        }
+        else {
+            totalFi -= fiDif;
+        }
+    }
+    const eps = Math.PI / 10000;
+    let result = false;
+    const absTotalFi = Math.abs(totalFi);
+    if (absTotalFi < eps) {
+        result = false;
+    }
+    else if (Math.abs(2 * Math.PI - absTotalFi) < eps) {
+        result = true;
+    }
+    else {
+        throw new Error('contains2 faild');
+    }
+    return result;
+};
+export class DPolygon {
     constructor(pPoints = []) {
         this.pPoints = pPoints;
         this.properties = {};
@@ -21,7 +55,7 @@ class DPolygon {
         this.searchStore = {};
     }
     static arrayOfTrianglesToVertices(triangles, height) {
-        return triangles.map((v) => ((0, utils_1.isDefAndNotNull)(height) ? v
+        return triangles.map((v) => (isDefAndNotNull(height) ? v
             .loop()
             .height(height)
             .run() : v)
@@ -30,7 +64,7 @@ class DPolygon {
     }
     static minAreaRectangleSize(poly) {
         const { first, second, last } = poly.clone().open();
-        return new DPoint_1.DPoint(first.distance(second), first.distance(last));
+        return new DPoint(first.distance(second), first.distance(last));
     }
     static toDash(poly) {
         let p = new DPolygon();
@@ -70,7 +104,7 @@ class DPolygon {
             const [path, ...holes] = reg.groups.data
                 .split('), (')
                 .map((p) => new DPolygon(p.split(', ')
-                .map((pares) => DPoint_1.DPoint.parse(pares.split(' ').map(Number)))));
+                .map((pares) => DPoint.parse(pares.split(' ').map(Number)))));
             if (holes && holes.length) {
                 path.holes = holes;
             }
@@ -80,18 +114,18 @@ class DPolygon {
             const regexp = /LINESTRING \((?<data>(?:(?!\)$).)*?)\)$/miu;
             const reg = regexp.exec(data);
             res = new DPolygon(reg.groups.data
-                .split(', ').map((t) => DPoint_1.DPoint.parse(t.split(' ').map(Number))));
+                .split(', ').map((t) => DPoint.parse(t.split(' ').map(Number))));
         }
         if (data.indexOf('POINT') === 0) {
-            res = new DPolygon([DPoint_1.DPoint.parseFromWKT(data)]);
+            res = new DPolygon([DPoint.parseFromWKT(data)]);
         }
         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.zero(), size.clone().setX(0), size.clone(), size.clone().setY(0)]).close();
     }
     loop() {
-        return new DPolygonLoop_1.DPolygonLoop(this);
+        return new DPolygonLoop(this);
     }
     set points(p) {
         this.pPoints = p;
@@ -100,16 +134,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));
@@ -129,24 +163,24 @@ class DPolygon {
     get extend() {
         const { minX, minY, maxX, maxY } = this;
         return new DPolygon([
-            new DPoint_1.DPoint(minX, minY),
-            new DPoint_1.DPoint(maxX, minY),
-            new DPoint_1.DPoint(maxX, maxY),
-            new DPoint_1.DPoint(minX, maxY),
-            new DPoint_1.DPoint(minX, minY)
+            new DPoint(minX, minY),
+            new DPoint(maxX, minY),
+            new DPoint(maxX, maxY),
+            new DPoint(minX, maxY),
+            new DPoint(minX, minY)
         ]);
     }
     get size() {
         const { w, h } = this;
-        return new DPoint_1.DPoint(w, h);
+        return new DPoint(w, h);
     }
     get leftTop() {
         const { minX, minY } = this;
-        return new DPoint_1.DPoint(minX, minY);
+        return new DPoint(minX, minY);
     }
     get rightBottom() {
         const { maxX, maxY } = this;
-        return new DPoint_1.DPoint(maxX, maxY);
+        return new DPoint(maxX, maxY);
     }
     get length() {
         return this.pPoints.length;
@@ -156,24 +190,25 @@ class DPolygon {
     }
     get perimeter() {
         let p = 0;
-        for (let i = 1; i < this.pPoints.length; i++) {
-            p += this.pPoints[i - 1].distance(this.pPoints[i]);
+        for (const [p1, p2] of this.loopPointsGenerator()()) {
+            p += p1.distance(p2);
         }
         return p;
     }
     get area() {
-        const closed = this.deintersection;
         let sum = 0;
-        for (let i = 1; i < closed.length; i++) {
-            const cur = closed.at(i);
-            const prev = closed.at(i - 1);
-            sum += prev.x * cur.y - prev.y * cur.x;
+        for (const [{ x, y }, { x: a, y: b }] of this.deintersection.loopPointsGenerator()()) {
+            sum += x * b - y * a;
         }
         return Math.abs(sum / 2) - this.holes.reduce((a, hole) => a + hole.area, 0);
     }
     get deintersection() {
-        const p = this.clone().close();
+        let p = this.clone().close();
+        const store = {};
         for (let i = 0; i < p.length - 1; i++) {
+            const k = p.at(i).toString();
+            store[k] = store[k] || [];
+            store[k].push(i);
             for (let j = i + 2; j < p.length - 1; j++) {
                 const firstLine = p.at(i).findLine(p.at(i + 1));
                 const secondLine = p.at(j).findLine(p.at(j + 1));
@@ -187,10 +222,27 @@ class DPolygon {
                 }
             }
         }
+        for (const key of Object.keys(store)) {
+            const record = store[key];
+            if (record.length > 1) {
+                for (let j = record.length - 1; j > 0; j--) {
+                    const origin = p.clone();
+                    const d = record[j] - record[j - 1];
+                    if (d > 1) {
+                        const part = new DPolygon(origin.removePart(record[j - 1], d));
+                        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;
+                        }
+                    }
+                }
+            }
+        }
         return p;
     }
     get valid() {
-        return this.length > exports.MIN_POINTS_IN_VALID_POLYGON;
+        return this.length > MIN_POINTS_IN_VALID_POLYGON;
     }
     get first() {
         return this.at(0);
@@ -205,19 +257,18 @@ class DPolygon {
         const p = this.convex;
         let resultPolygon = new DPolygon();
         let resultArea = Infinity;
-        for (let k = 0; k < p.length - 1; k++) {
-            const l = p.at(k).findLine(p.at(k + 1));
+        for (const [, , l] of p.loopPointsGenerator(true)()) {
             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.at(i)));
-                const h = p1.distance(p.at(i));
+            for (const [z, , , i] of p.loopPointsGenerator()()) {
+                const p1 = l.findPoint(l.findPerpendicular(z));
+                const h = p1.distance(z);
                 if (h >= maxHeight) {
                     maxHeight = h;
-                    maxHeightPoint = p.at(i);
+                    maxHeightPoint = z;
                 }
                 for (let j = i; j < p.length - 1; j++) {
                     const p2 = l.findPoint(l.findPerpendicular(p.at(j)));
@@ -260,7 +311,7 @@ class DPolygon {
             const p2 = p.first;
             const p3 = p.second;
             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)) {
+            if (d > Math.PI || DNumbers.likeZero(DNumbers.rad2Deg(d)) || DNumbers.likePI(d) || DNumbers.like2PI(d)) {
                 p.removePart(-1, 1);
             }
             else {
@@ -277,7 +328,7 @@ class DPolygon {
                 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)) {
+                if (d > Math.PI || DNumbers.likeZero(DNumbers.rad2Deg(d)) || DNumbers.likePI(d) || DNumbers.like2PI(d)) {
                     p.removePart(--i, 1);
                 }
             }
@@ -290,11 +341,9 @@ class DPolygon {
     }
     get isClockwise() {
         let sum = 0;
-        const p = this.clone().close();
-        for (let i = 1; i < p.length; i++) {
-            const p1 = p.at(i - 1);
-            const p2 = p.at(i);
-            sum += (p2.x - p1.x) * (p2.y + p1.y);
+        for (const [{ x, y }, { x: a, y: b }] of this.clone().close()
+            .loopPointsGenerator()()) {
+            sum += (a - x) * (b + y);
         }
         return sum < 0;
     }
@@ -309,12 +358,12 @@ class DPolygon {
         res.holes = [];
         return res;
     }
+    reduce(f, v) {
+        return this.pPoints.reduce(f, v);
+    }
     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);
+        for (const [, , line] of this.loopPointsGenerator(true)()) {
             const intersect = line.intersection(l, 0, includeOnly);
             if (intersect) {
                 res.push(intersect);
@@ -334,10 +383,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) {
@@ -345,10 +394,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;
@@ -379,7 +431,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;
@@ -433,8 +485,11 @@ class DPolygon {
         }
         return false;
     }
-    findIndex(p) {
-        return this.points.findIndex((t) => t.equal(p));
+    findIndex(a) {
+        if (a instanceof 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));
@@ -508,11 +563,9 @@ class DPolygon {
         }
         const poly = this.deintersection;
         let totalFi = 0;
-        for (let i = 0; i < poly.length - 1; i++) {
-            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);
+        for (const [{ x, y }, { x: a, y: b }] of poly.loopPointsGenerator()()) {
+            const line1 = new DLine(x - p.x, y - p.y, 0);
+            const line2 = new DLine(a - p.x, b - p.y, 0);
             const fiDif = line1.findFi(line2);
             if (line1.vectorProduct(line2).c > 0) {
                 totalFi += fiDif;
@@ -522,18 +575,14 @@ class DPolygon {
             }
         }
         const eps = Math.PI / 10000;
-        let result = false;
         const absTotalFi = Math.abs(totalFi);
         if (absTotalFi < eps) {
-            result = false;
+            return false;
         }
         else if (Math.abs(2 * Math.PI - absTotalFi) < eps) {
-            result = true;
-        }
-        else {
-            throw new Error('contains2 faild');
+            return true;
         }
-        return result;
+        throw new Error('contains2 faild');
     }
     onBorder(p) {
         const simpleInclude = this.simpleInclude(p);
@@ -543,10 +592,7 @@ class DPolygon {
             if (hasSamePoint) {
                 return true;
             }
-            for (let i = 0; i < poly.length - 1; i++) {
-                const p0 = poly.at(i);
-                const p1 = poly.at(i + 1);
-                const polygonLine = p0.findLine(p1);
+            for (const [, , polygonLine] of poly.loopPointsGenerator(true)()) {
                 const onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
                 if (onBorder) {
                     return true;
@@ -573,35 +619,32 @@ class DPolygon {
         return this;
     }
     static parse(a) {
-        return new DPolygon(a.map((r) => DPoint_1.DPoint.parse(r)));
+        return new DPolygon(a.map((r) => DPoint.parse(r)));
     }
     toArrayOfCoords() {
-        return this.pPoints.map((r) => r.toCoords());
+        return this.mapArray((r) => r.toCoords());
     }
     divideToPieces(piecesCount) {
         const { fullLength } = this;
         const pieceLength = fullLength / piecesCount;
         let currentPieceLength = pieceLength;
-        for (let i = 0; i < this.pPoints.length - 1; i++) {
-            const p1 = this.pPoints[i];
-            const p2 = this.pPoints[i + 1];
-            if (p1.distance(p2) === currentPieceLength) {
+        for (const [p1, p2, , i] of this.loopPointsGenerator()()) {
+            const d = p1.distance(p2);
+            if (d === currentPieceLength) {
                 p2.properties.pieceBorder = true;
                 currentPieceLength = pieceLength;
-                continue;
             }
-            if (p1.distance(p2) - currentPieceLength > 0) {
-                const circle = new DCircle_1.DCircle(p1, currentPieceLength);
+            else if (d - currentPieceLength > 0) {
+                const circle = new DCircle(p1, currentPieceLength);
                 const line = p1.findLine(p2);
                 const intersectionPoint = line.intersectionWithCircle(circle)
                     .filter((p) => line.inRange(p, CLOSE_TO_INTERSECTION_DISTANCE))[0];
                 intersectionPoint.properties.pieceBorder = true;
                 this.insertAfter(i, intersectionPoint);
                 currentPieceLength = pieceLength;
-                continue;
             }
-            if (p1.distance(p2) - currentPieceLength < 0) {
-                currentPieceLength -= p1.distance(p2);
+            else {
+                currentPieceLength -= d;
             }
         }
         return this;
@@ -804,13 +847,24 @@ class DPolygon {
         return this.first.equal(this.last);
     }
     buffer(v, quadrantSegments = 64, type = DPolygon.CAP_ROUND) {
-        const reader = new jsts_1.io.WKTReader();
+        const reader = new jstsIo.WKTReader();
         const { noHoles, closed } = this;
         const points = reader
             .read(noHoles.toWKT(closed ? DPolygon.WKT_POLYGON : DPolygon.WKT_LINESTRING))
             .buffer(v, quadrantSegments, type)
             .getCoordinates();
-        return new DPolygon(points.map(({ x, y }) => new DPoint_1.DPoint(x, y)));
+        return new DPolygon(points.map(({ x, y }) => new DPoint(x, y)));
+    }
+    sideBuffers(v, quadrantSegments = 64) {
+        const { first, last } = this;
+        const buffer = this.buffer(v, quadrantSegments, DPolygon.CAP_FLAT).open();
+        const [start0, start1] = first.sortByDistance(buffer).points.map((r) => r.properties.index);
+        const [end0, end1] = last.sortByDistance(buffer).points.map((r) => r.properties.index);
+        const fromPoint = Math.min(Math.max(start0, start1), Math.max(end0, end1));
+        const toPoint = Math.max(Math.min(start0, start1), Math.min(end0, end1));
+        const linePart = new DPolygon(buffer.removePart(fromPoint - 1, toPoint - fromPoint + 1));
+        buffer.unshift(buffer.pop());
+        return [linePart, buffer];
     }
     bezier(step = 0.1) {
         const res = new DPolygon();
@@ -833,13 +887,21 @@ class DPolygon {
             .run();
         return this;
     }
+    loopPointsGenerator(withLine = false) {
+        const that = this;
+        return function* () {
+            for (let i = 0; i < that.length - 1; i++) {
+                const p1 = that.at(i);
+                const p2 = that.at(i + 1);
+                yield [p1, p2, withLine ? p1.findLine(p2) : undefined, i];
+            }
+        };
+    }
     getBezierPoint(v) {
         if (this.length === 1) {
             return this.first;
         }
-        for (let i = 0; i < this.length - 1; i++) {
-            const p1 = this.at(i);
-            const p2 = this.at(i + 1);
+        for (const [p1, p2] of this.loopPointsGenerator()()) {
             p1.move(p2.clone().move(p1.clone().minus())
                 .scale(v));
         }
@@ -884,7 +946,7 @@ class DPolygon {
     }
     getJSTSGeometry(p, unionThis, unionThat) {
         const unionOrIntersection = unionThat === unionThis;
-        const reader = new jsts_1.io.WKTReader();
+        const reader = new jstsIo.WKTReader();
         const a = reader.read(this.noHoles.toWKT());
         const b = reader.read(p.noHoles.toWKT());
         if (!unionOrIntersection) {
@@ -905,11 +967,11 @@ class DPolygon {
             if (coordinates.length) {
                 let result = coordinates.reduce((ak, { x, y }, index) => {
                     const lastIndex = ak.length - 1;
-                    const t = new DPoint_1.DPoint(x, y);
+                    const t = new DPoint(x, y);
                     const { first } = ak[lastIndex];
                     if (t.equal(first)) {
                         if (coordinates[index + 1]) {
-                            const nextPoint = new DPoint_1.DPoint(coordinates[index + 1].x, coordinates[index + 1].y);
+                            const nextPoint = new DPoint(coordinates[index + 1].x, coordinates[index + 1].y);
                             if (ak[lastIndex].length > 1) {
                                 ak.push(new DPolygon([nextPoint]));
                             }
@@ -919,7 +981,7 @@ class DPolygon {
                         ak[lastIndex].push(t);
                     }
                     return ak;
-                }, [new DPolygon([new DPoint_1.DPoint(coordinates[0].x, coordinates[0].y)])]);
+                }, [new DPolygon([new DPoint(coordinates[0].x, coordinates[0].y)])]);
                 if (unionThat && unionThis && result.length > 1) {
                     for (const q of result) {
                         for (const r of result) {
@@ -967,7 +1029,6 @@ class DPolygon {
         return null;
     }
 }
-exports.DPolygon = DPolygon;
 DPolygon.CAP_ROUND = CAP_ROUND;
 DPolygon.CAP_FLAT = CAP_FLAT;
 DPolygon.CAP_SQUARE = CAP_SQUARE;

package/dist/{DPolygonLoop.js → es2015/DPolygonLoop.js}

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DPolygonLoop = void 0;
 var LoopFunctions;
 (function (LoopFunctions) {
     LoopFunctions[LoopFunctions["getTileFromCoords"] = 0] = "getTileFromCoords";
@@ -170,7 +167,7 @@ const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg
     }
     return res;
 };
-class DPolygonLoop {
+export class DPolygonLoop {
     constructor(parent) {
         this.parent = parent;
         this.pool = [];
@@ -393,4 +390,3 @@ class DPolygonLoop {
         return this;
     }
 }
-exports.DPolygonLoop = DPolygonLoop;

package/dist/{FastSearch.js → es2015/FastSearch.js}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FastSearch = void 0;
-class FastSearch {
+export class FastSearch {
     constructor() {
         this.searchStore = {};
     }
@@ -26,4 +23,3 @@ class FastSearch {
         return this.searchStore[x][y][z || 'undefined'];
     }
 }
-exports.FastSearch = FastSearch;