dgeoutils 2.2.7 → 2.2.11

package/dist/DPolygon.js

@@ -1,7 +1,6 @@
 "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");
@@ -14,34 +13,12 @@ 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 = {};
     }
-    /**
-     * Transform array of triangles to Three.JS vertices
-     *
-     * ```
-     * const geometry = new THREE.BufferGeometry();
-     * // create a simple square shape. We duplicate the top left and bottom right
-     * // vertices because each vertex needs to appear once per triangle.
-     * const vertices = new Float32Array( DPolygon.arrayOfTrianglesToVertices(triangles, 10) );
-     *
-     * // itemSize = 3 because there are 3 values (components) per vertex
-     * geometry.setAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
-     * const material = new THREE.MeshBasicMaterial( { color: 0xff0000 } );
-     * mesh = new THREE.Mesh( geometry, material );
-     *
-     * scene.add( mesh );
-     * ```
-     *
-     * @param triangles
-     * @param [height=0]
-     */
     static arrayOfTrianglesToVertices(triangles, height = 0) {
         return triangles.map((v) => v
             .loop()
@@ -50,18 +27,10 @@ class DPolygon {
             .toArrayOfCoords())
             .flat(2);
     }
-    /**
-     * Get size of min area rectangle.
-     * @param poly should be `minAreaRectangle`
-     */
     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];
@@ -81,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) {
@@ -145,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([
@@ -188,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++) {
@@ -231,9 +160,6 @@ class DPolygon {
         }
         return p;
     }
-    /**
-     * Get polygon area
-     */
     get area() {
         const closed = this.deintersection;
         let sum = 0;
@@ -244,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++) {
@@ -265,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();
@@ -339,9 +247,6 @@ class DPolygon {
         }
         return resultPolygon;
     }
-    /**
-     * Get convex polygon
-     */
     get convex() {
         let p = this.clone().open();
         const { isClockwise } = p;
@@ -382,9 +287,6 @@ class DPolygon {
         }
         return p;
     }
-    /**
-     * Check polygon direction
-     */
     get isClockwise() {
         let sum = 0;
         const p = this.clone().close();
@@ -395,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++) {
@@ -430,35 +321,24 @@ class DPolygon {
         }
         return res;
     }
-    /**
-     * Set polygon center
-     * @param newCenter
-     */
     setCenter(newCenter) {
         return this.loop()
             .move(newCenter.clone().move(this.center.minus()))
             .run();
     }
-    /**
-     * @param [type = DPolygon.WKT_POLYGON] Available values `DPolygon.WKT_POLYGON`, `DPolygon.WKT_LINESTRING`
-     */
-    toWKT(type = DPolygon.WKT_POLYGON) {
+    toWKT(type = DPolygon.WKT_POLYGON, withZ = false) {
         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}`)
+            return `POLYGON ((${this.deintersection.pPoints.map((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
                 .join(', ')})${h})`;
         }
-        return `LINESTRING (${this.pPoints.map((r) => `${r.x} ${r.y}`)
+        return `LINESTRING (${this.pPoints.map((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
             .join(', ')})`;
     }
-    /**
-     * Filter points
-     * @param f
-     */
     filter(f) {
         this.pPoints = this.pPoints.filter(f);
         return this;
@@ -496,9 +376,6 @@ 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 && !this.closed) {
@@ -506,9 +383,6 @@ class DPolygon {
         }
         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 && this.closed) {
@@ -521,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));
     }
@@ -534,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;
@@ -548,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()
@@ -569,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));
     }
@@ -583,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;
@@ -596,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);
     }
@@ -643,13 +492,7 @@ 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()) {
+    contain(p, isBorderInside = false) {
         const simpleInclude = this.simpleInclude(p);
         if (!simpleInclude) {
             return false;
@@ -658,26 +501,35 @@ class DPolygon {
         if (onBorder) {
             return isBorderInside;
         }
-        const line = p.findLine(this.leftTop.move(move));
         const poly = this.deintersection;
-        const intersectionPoints = [];
+        let totalFi = 0;
         for (let i = 0; i < poly.length - 1; i++) {
-            const polygonLine = poly.at(i).findLine(poly.at(i + 1));
-            const intersection = line.intersection(polygonLine, CLOSE_TO_INTERSECTION_DISTANCE);
-            if (intersection) {
-                intersectionPoints.push(intersection);
+            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);
+            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;
         }
-        const hasCorners = intersectionPoints.some((z) => poly.has(z));
-        if (hasCorners) {
-            return this.contain2(p, isBorderInside);
+        else {
+            throw new Error('contains2 faild');
         }
-        return intersectionPoints.length % 2 === 1;
+        return result;
     }
-    /**
-     * Check if point on border
-     * @param p
-     */
     onBorder(p) {
         const simpleInclude = this.simpleInclude(p);
         if (simpleInclude) {
@@ -698,18 +550,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);
@@ -724,17 +570,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;
@@ -787,13 +625,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) {
@@ -846,11 +679,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);
@@ -904,9 +732,6 @@ class DPolygon {
         res.push(p);
         return res;
     }
-    /**
-     * Divide polygon to triangles and return points indexes
-     */
     getTrianglesPointIndexes() {
         const innerAndNotIntersect = (poly, p1, p2) => {
             const l = p1.findLine(p2);
@@ -973,11 +798,6 @@ class DPolygon {
     get closed() {
         return this.first.equal(this.last);
     }
-    /**
-     * @param v
-     * @param [quadrantSegments=64]
-     * @param [type=DPolygon.CAP_ROUND] DPolygon.CAP_ROUND || DPolygon.CAP_FLAT || DPolygon.CAP_SQUARE
-     */
     buffer(v, quadrantSegments = 64, type = DPolygon.CAP_ROUND) {
         const reader = new jsts_1.io.WKTReader();
         const { noHoles, closed } = this;
@@ -1023,45 +843,6 @@ class DPolygon {
             ctx.lineTo(x, y);
         }
     }
-    contain2(p, isBorderInside = false) {
-        const simpleInclude = this.simpleInclude(p);
-        if (!simpleInclude) {
-            return false;
-        }
-        const onBorder = this.onBorder(p);
-        if (onBorder) {
-            return isBorderInside;
-        }
-        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);
-            const fiDif = line1.findFi(line2);
-            if (line1.vectorProduct(line2).c > 0) {
-                totalFi += fiDif;
-            }
-            else {
-                totalFi -= fiDif;
-            }
-        }
-        // eslint-disable-next-line no-magic-numbers
-        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;
-    }
     getJSTSGeometry(p, unionThis, unionThat) {
         const unionOrIntersection = unionThat === unionThis;
         const reader = new jsts_1.io.WKTReader();
@@ -1148,17 +929,8 @@ class DPolygon {
     }
 }
 exports.DPolygon = DPolygon;
-/**
- * Specifies a round line buffer end cap style.
- */
 DPolygon.CAP_ROUND = CAP_ROUND;
-/**
- * Specifies a flat line buffer end cap style.
- */
 DPolygon.CAP_FLAT = CAP_FLAT;
-/**
- * Specifies a square line buffer end cap style.
- */
 DPolygon.CAP_SQUARE = CAP_SQUARE;
 DPolygon.WKT_LINESTRING = 'LINESTRING';
 DPolygon.WKT_POLYGON = 'POLYGON';

package/dist/DPolygonLoop.d.ts

@@ -6,102 +6,33 @@ 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;
-    /**
-     * Set `z` value
-     * @param z
-     */
     setZ(z: number): DPolygonLoop;
-    /**
-     * Transform `z` value by function
-     * @param f
-     */
     setZ(f: SetterFunction): DPolygonLoop;
     rotate(a: number): DPolygonLoop;
-    /**
-     * Add `v` to `x` and `y`
-     * @param v
-     */
+    rotate3dX(a: number): DPolygonLoop;
+    rotate3dY(a: number): DPolygonLoop;
+    rotate3dZ(a: number): DPolygonLoop;
     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;
@@ -116,14 +47,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;
 }