dgeoutils 2.2.4 → 2.2.8

package/dist/DPolygon.js

@@ -1,38 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DPolygon = exports.MIN_POINTS_IN_VALID_POLYGON = void 0;
-/* eslint-disable max-lines */
 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 { buffer: { BufferParameters: { CAP_ROUND, CAP_FLAT, CAP_SQUARE } } } = jsts_1.operation;
 exports.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 {
-    // 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.searchStore = {};
     }
-    /**
-     * Get size of min area rectangle.
-     * @param poly should be `minAreaRectangle`
-     */
+    static arrayOfTrianglesToVertices(triangles, height = 0) {
+        return triangles.map((v) => v
+            .loop()
+            .height(height)
+            .run()
+            .toArrayOfCoords())
+            .flat(2);
+    }
     static minAreaRectangleSize(poly) {
         const { first, second, last } = poly.clone().open();
         return new DPoint_1.DPoint(first.distance(second), first.distance(last));
     }
-    /**
-     * Slice line string to dashes.
-     * @param poly should be `divideToPieces` at first
-     */
     static toDash(poly) {
         let p = new DPolygon();
         const result = [p];
@@ -52,10 +50,6 @@ class DPolygon {
         }
         return result;
     }
-    /**
-     * Get min area rectangle direction
-     * @param poly should be `minAreaRectangle`
-     */
     static minAreaRectangleDirection(poly) {
         const { first, second, last } = poly.clone().open();
         if (!first || !second || !last) {
@@ -116,39 +110,21 @@ class DPolygon {
     get minY() {
         return this.pPoints.reduce((a, r) => Math.min(a, r.y), Infinity);
     }
-    /**
-     * Get center coordinates
-     */
     get center() {
         return this.leftTop.move(this.size.divide(2));
     }
-    /**
-     * Difference between `maxY` and `minY`. Equal `ΔY` (`dY`)
-     */
     get h() {
         return this.maxY - this.minY;
     }
-    /**
-     * Difference between `maxX` and `minX`. Equal `ΔX` (`dX`)
-     */
     get w() {
         return this.maxX - this.minX;
     }
-    /**
-     * Difference between `maxY` and `minY`. Equal `height` (`h`)
-     */
     get dY() {
         return this.h;
     }
-    /**
-     * Difference between `maxX` and `minX`. Equal `width` (`w`)
-     */
     get dX() {
         return this.w;
     }
-    /**
-     * Get closed extend polygon
-     */
     get extend() {
         const { minX, minY, maxX, maxY } = this;
         return new DPolygon([
@@ -159,42 +135,24 @@ class DPolygon {
             new DPoint_1.DPoint(minX, minY)
         ]);
     }
-    /**
-     * Point with `width` value as `x` and `height` value as `y`
-     */
     get size() {
         const { w, h } = this;
         return new DPoint_1.DPoint(w, h);
     }
-    /**
-     * Point with minimal `x` and `y`
-     */
     get leftTop() {
         const { minX, minY } = this;
         return new DPoint_1.DPoint(minX, minY);
     }
-    /**
-     * Point with maximal `x` and `y`
-     */
     get rightBottom() {
         const { maxX, maxY } = this;
         return new DPoint_1.DPoint(maxX, maxY);
     }
-    /**
-     * Next point index
-     */
     get length() {
         return this.pPoints.length;
     }
-    /**
-     * Get length of line string.
-     */
     get fullLength() {
         return this.clone().open().perimeter;
     }
-    /**
-     * Get perimeter.
-     */
     get perimeter() {
         let p = 0;
         for (let i = 1; i < this.pPoints.length; i++) {
@@ -202,9 +160,6 @@ class DPolygon {
         }
         return p;
     }
-    /**
-     * Get polygon area
-     */
     get area() {
         const closed = this.deintersection;
         let sum = 0;
@@ -215,9 +170,6 @@ class DPolygon {
         }
         return Math.abs(sum / 2) - this.holes.reduce((a, hole) => a + hole.area, 0);
     }
-    /**
-     * Get deintesected polygon.
-     */
     get deintersection() {
         const p = this.clone().close();
         for (let i = 0; i < p.length - 1; i++) {
@@ -236,33 +188,18 @@ class DPolygon {
         }
         return p;
     }
-    /**
-     * Check if polygon contain more than three points
-     */
     get valid() {
         return this.length > exports.MIN_POINTS_IN_VALID_POLYGON;
     }
-    /**
-     * Get first point
-     */
     get first() {
         return this.at(0);
     }
-    /**
-     * Get second point
-     */
     get second() {
         return this.at(1);
     }
-    /**
-     * Get last point
-     */
     get last() {
         return this.at(this.length - 1);
     }
-    /**
-     * Get min area rectangle
-     */
     get minAreaRectangle() {
         const p = this.convex;
         let resultPolygon = new DPolygon();
@@ -310,9 +247,6 @@ class DPolygon {
         }
         return resultPolygon;
     }
-    /**
-     * Get convex polygon
-     */
     get convex() {
         let p = this.clone().open();
         const { isClockwise } = p;
@@ -353,9 +287,6 @@ class DPolygon {
         }
         return p;
     }
-    /**
-     * Check polygon direction
-     */
     get isClockwise() {
         let sum = 0;
         const p = this.clone().close();
@@ -366,28 +297,17 @@ class DPolygon {
         }
         return sum < 0;
     }
-    /**
-     * Get clockwise polygon
-     */
     get clockWise() {
         if (this.isClockwise) {
             return this.clone();
         }
         return this.clone().reverse();
     }
-    /**
-     * Get polygon clone without holes
-     */
     get noHoles() {
         const res = this.clone();
         res.holes = [];
         return res;
     }
-    /**
-     * Check polygon intersection with line
-     * @param l
-     * @param [includeOnly=false]
-     */
     intersection(l, includeOnly = false) {
         const res = [];
         for (let i = 0; i < this.pPoints.length - 1; i++) {
@@ -401,26 +321,24 @@ class DPolygon {
         }
         return res;
     }
-    /**
-     * Set polygon center
-     * @param newCenter
-     */
     setCenter(newCenter) {
         return this.loop()
             .move(newCenter.clone().move(this.center.minus()))
             .run();
     }
-    toWKT() {
-        let h = '';
-        if (this.holes && this.holes.length) {
-            h = `, ${this.holes.map((hole) => hole.toString()).join(', ')}`;
+    toWKT(type = DPolygon.WKT_POLYGON) {
+        if (type === DPolygon.WKT_POLYGON) {
+            let h = '';
+            if (this.holes && this.holes.length) {
+                h = `, ${this.holes.map((hole) => hole.toString())
+                    .join(', ')}`;
+            }
+            return `POLYGON ((${this.deintersection.pPoints.map((r) => `${r.x} ${r.y}`)
+                .join(', ')})${h})`;
         }
-        return `POLYGON ((${this.deintersection.pPoints.map((r) => `${r.x} ${r.y}`).join(', ')})${h})`;
+        return `LINESTRING (${this.pPoints.map((r) => `${r.x} ${r.y}`)
+            .join(', ')})`;
     }
-    /**
-     * Filter points
-     * @param f
-     */
     filter(f) {
         this.pPoints = this.pPoints.filter(f);
         return this;
@@ -458,22 +376,16 @@ class DPolygon {
     toString() {
         return `(${this.pPoints.map((r) => r.toString()).join(', ')})`;
     }
-    /**
-     * Add to the end of polygon point equal to first point if it not exist
-     */
     close() {
         const p0 = this.first;
-        if (p0 && !p0.equal(this.last)) {
+        if (p0 && !this.closed) {
             this.push(p0.clone());
         }
         return this;
     }
-    /**
-     * Remove from the end of polygon point equal to first point if it exist
-     */
     open() {
         const p = this.first;
-        if (this.length > 2 && p && p.equal(this.last)) {
+        if (this.length > 2 && p && this.closed) {
             this.pop();
         }
         return this;
@@ -483,10 +395,6 @@ class DPolygon {
         res.holes = [...this.holes, ...poly.holes].map((h) => h.clone());
         return res;
     }
-    /**
-     * Check if has point in list of points
-     * @param p
-     */
     has(p) {
         return this.pPoints.some((q) => q.equal(p));
     }
@@ -496,10 +404,6 @@ class DPolygon {
         res.properties = this.properties;
         return res;
     }
-    /**
-     * Check is it fully equal.
-     * @param p
-     */
     equal(p) {
         if (!(p instanceof DPolygon)) {
             return false;
@@ -510,10 +414,6 @@ class DPolygon {
         return (this.same(p) &&
             this.holes.reduce((a, hole) => a && p.holes.some((pHoles) => pHoles.same(hole)), true));
     }
-    /**
-     * Check is polygons are same. They can be with different directions and different start points.
-     * @param p
-     */
     same(p) {
         const pClone = p.clone().close();
         const thisAsString = this.clone()
@@ -531,11 +431,6 @@ class DPolygon {
     findIndex(p) {
         return this.points.findIndex((t) => t.equal(p));
     }
-    /**
-     * Get polygon approximation by
-     * [Ramer–Douglas–Peucker algorithm](https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm)
-     * @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));
     }
@@ -545,10 +440,6 @@ class DPolygon {
     removePart(index, count) {
         return this.pPoints.splice(index + 1, count);
     }
-    /**
-     * Check intersection with other polygon
-     * @param p
-     */
     hasSimpleIntersection(p) {
         const extend1 = this.extend;
         const extend2 = p.extend;
@@ -558,10 +449,6 @@ class DPolygon {
         const in2 = extend2points.some((t) => extend1.simpleInclude(t));
         return in1 || in2;
     }
-    /**
-     * Check if it possible to include point
-     * @param p
-     */
     simpleInclude(p) {
         return this.simpleIncludeX(p) && this.simpleIncludeY(p);
     }
@@ -605,12 +492,6 @@ class DPolygon {
         ctx.fill();
         ctx.globalCompositeOperation = old;
     }
-    /**
-     * Check if contain point
-     * @param p
-     * @param [isBorderInside=false]
-     * @param [move=(0,0)] Ignore this parameter
-     */
     contain(p, isBorderInside = false, move = DPoint_1.DPoint.zero()) {
         const simpleInclude = this.simpleInclude(p);
         if (!simpleInclude) {
@@ -636,10 +517,6 @@ class DPolygon {
         }
         return intersectionPoints.length % 2 === 1;
     }
-    /**
-     * Check if point on border
-     * @param p
-     */
     onBorder(p) {
         const simpleInclude = this.simpleInclude(p);
         if (simpleInclude) {
@@ -660,18 +537,12 @@ class DPolygon {
         }
         return false;
     }
-    /**
-     * Change start point to second point
-     */
     nextStart() {
         this.open();
         this.push(this.shift());
         this.close();
         return this;
     }
-    /**
-     * Remove duplicates points
-     */
     removeDuplicates() {
         for (let i = 0; i < this.length - 1; i++) {
             const p1 = this.at(i);
@@ -686,17 +557,9 @@ class DPolygon {
     static parse(a) {
         return new DPolygon(a.map((r) => DPoint_1.DPoint.parse(r)));
     }
-    /**
-     * Transform to array of coordinates for [OpenLayers](https://openlayers.org/) or
-     * [GeoJSON](https://en.wikipedia.org/wiki/GeoJSON)
-     */
     toArrayOfCoords() {
         return this.pPoints.map((r) => r.toCoords());
     }
-    /**
-     * Divide line string to pieces by length
-     * @param piecesCount
-     */
     divideToPieces(piecesCount) {
         const { fullLength } = this;
         const pieceLength = fullLength / piecesCount;
@@ -749,13 +612,8 @@ class DPolygon {
         }
         return this.searchStore[x][y][z || 'undefined'];
     }
-    /**
-     * Get line string as line string with growing length. For animation.
-     */
     get growingPiecesGenerator() {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias,consistent-this
         const polygon = this;
-        // eslint-disable-next-line func-names
         return function* () {
             const r = new DPolygon();
             for (const p of polygon.pPoints) {
@@ -789,10 +647,9 @@ class DPolygon {
         return this.simpleLogicFunction(p, true, false);
     }
     smartUnion(p) {
-        var _a;
         const res = this.clone().simpleUnion(p);
         if (res) {
-            let allHoles = [...this.holes, ...p.holes, ...((_a = res.holes) !== null && _a !== void 0 ? _a : [])].map((h) => h.clone());
+            let allHoles = [...this.holes, ...p.holes, ...res.holes].map((h) => h.clone());
             for (const a of allHoles) {
                 for (const b of allHoles) {
                     if (a.equal(b)) {
@@ -801,12 +658,7 @@ class DPolygon {
                     const r = a.simpleUnion(b);
                     if (r) {
                         allHoles = allHoles.filter((v) => !v.equal(a) && !v.equal(b));
-                        if (Array.isArray(r)) {
-                            allHoles = [...allHoles, ...r];
-                        }
-                        else {
-                            allHoles.push(r);
-                        }
+                        allHoles.push(r);
                     }
                 }
             }
@@ -814,11 +666,6 @@ 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);
@@ -872,6 +719,81 @@ class DPolygon {
         res.push(p);
         return res;
     }
+    getTrianglesPointIndexes() {
+        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 [
+                        p0.properties.index,
+                        p1.properties.index,
+                        p2.properties.index
+                    ];
+                }
+                poly.push(poly.shift());
+            }
+            return undefined;
+        };
+        let p = this.clone();
+        let index = 0;
+        p.points.forEach((f) => {
+            f.properties.index = index++;
+        });
+        p.holes.forEach((h) => {
+            h.pPoints.forEach((f) => {
+                f.properties.index = index++;
+            });
+        });
+        p = p.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.points.map((f) => f.properties.index));
+        return res;
+    }
+    get closed() {
+        return this.first.equal(this.last);
+    }
+    buffer(v, quadrantSegments = 64, type = DPolygon.CAP_ROUND) {
+        const reader = new jsts_1.io.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)));
+    }
     simpleIncludeX(p) {
         const { x } = p;
         return this.minX <= x && this.maxX >= x;
@@ -932,7 +854,6 @@ class DPolygon {
                 totalFi -= fiDif;
             }
         }
-        // eslint-disable-next-line no-magic-numbers
         const eps = Math.PI / 10000;
         let result = false;
         const absTotalFi = Math.abs(totalFi);
@@ -1033,3 +954,8 @@ class DPolygon {
     }
 }
 exports.DPolygon = DPolygon;
+DPolygon.CAP_ROUND = CAP_ROUND;
+DPolygon.CAP_FLAT = CAP_FLAT;
+DPolygon.CAP_SQUARE = CAP_SQUARE;
+DPolygon.WKT_LINESTRING = 'LINESTRING';
+DPolygon.WKT_POLYGON = 'POLYGON';

package/dist/DPolygonLoop.d.ts

@@ -6,92 +6,30 @@ export declare class DPolygonLoop {
     private pool;
     constructor(parent: DPolygon);
     private getLoopFunction;
-    /**
-     * Run loop
-     */
     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;
-    /**
-     * 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;
+    setZ(z: number): DPolygonLoop;
+    setZ(f: SetterFunction): DPolygonLoop;
     rotate(a: 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;
-    /**
-     * 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;
@@ -106,14 +44,6 @@ export declare class DPolygonLoop {
     minus(): DPolygonLoop;
     degreeToMeters(): DPolygonLoop;
     metersToDegree(): DPolygonLoop;
-    /**
-     * Flip vertically
-     * @param size canvas size
-     */
     flipVertically(size: DPoint): DPolygonLoop;
-    /**
-     * Flip vertically
-     * @param height canvas height
-     */
     flipVertically(height: number): DPolygonLoop;
 }