dgeoutils 2.2.2 → 2.2.6

package/dist/DPolygon.d.ts

@@ -4,13 +4,46 @@ import { DLine } from './DLine';
 import { DPolygonLoop } from './DPolygonLoop';
 export declare const MIN_POINTS_IN_VALID_POLYGON = 3;
 export declare class DPolygon {
+    private pPoints;
     properties: {
         [key: string]: any;
     };
     holes: DPolygon[];
-    private pPoints;
     private searchStore;
-    constructor(points?: DPoint[]);
+    constructor(pPoints?: DPoint[]);
+    /**
+     * Specifies a round line buffer end cap style.
+     */
+    static CAP_ROUND: number;
+    /**
+     * Specifies a flat line buffer end cap style.
+     */
+    static CAP_FLAT: number;
+    /**
+     * Specifies a square line buffer end cap style.
+     */
+    static CAP_SQUARE: number;
+    /**
+     * 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: DPolygon[], height?: number): number[];
     /**
      * Get size of min area rectangle.
      * @param poly should be `minAreaRectangle`
@@ -138,59 +171,19 @@ export declare class DPolygon {
      * @param newCenter
      */
     setCenter(newCenter: DPoint): DPolygon;
-    toWKT(): string;
+    static WKT_LINESTRING: string;
+    static WKT_POLYGON: string;
     /**
-     * Rotate polygon with center in point {0, 0}
-     * @param a Radians
-     * @deprecated Better to use loop
+     * @param [type = DPolygon.WKT_POLYGON] Available values `DPolygon.WKT_POLYGON`, `DPolygon.WKT_LINESTRING`
      */
-    rotate(a: number): DPolygon;
+    toWKT(type?: string): string;
     /**
      * Filter points
      * @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;
+    map(f: (r: DPoint) => DPoint): DPolygon;
+    map(f: (r: DPoint, index: number) => DPoint): DPolygon;
     at(index: number): DPoint;
     pop(): DPoint;
     push(...args: DPoint[]): number;
@@ -198,22 +191,6 @@ export declare class DPolygon {
     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;
     /**
      * Add to the end of polygon point equal to first point if it not exist
@@ -223,12 +200,6 @@ export declare class DPolygon {
      * Remove from the end of polygon point equal to first point if it exist
      */
     open(): DPolygon;
-    /**
-     * Set `height` (`z`)
-     * @param z
-     * @deprecated Better to use loop
-     */
-    height(z: number): DPolygon;
     add(poly: DPolygon): DPolygon;
     /**
      * Check if has point in list of points
@@ -250,7 +221,7 @@ export declare class DPolygon {
     /**
      * Get polygon approximation by
      * [Ramer–Douglas–Peucker algorithm](https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm)
-     * @param e
+     * @param [e=Math.sqrt(this.perimeter)*APPROXIMATION_VALUE]
      */
     approximation(e?: number): DPolygon;
     insertAfter(index: number, ...points: DPoint[]): void;
@@ -270,8 +241,8 @@ export declare class DPolygon {
     /**
      * Check if contain point
      * @param p
-     * @param isBorderInside
-     * @param move Ignore this parameter
+     * @param [isBorderInside=false]
+     * @param [move=(0,0)] Ignore this parameter
      */
     contain(p: DPoint, isBorderInside?: boolean, move?: DPoint): boolean;
     /**
@@ -288,11 +259,20 @@ export declare class DPolygon {
      */
     removeDuplicates(): DPolygon;
     /**
-     * Parse from [OpenLayers](https://openlayers.org/) coordinates or
-     * [GeoJSON](https://en.wikipedia.org/wiki/GeoJSON) coordinates
+     * Parse from [OpenLayers](https://openlayers.org/) coordinates
+     * @param a
+     */
+    static parse(a: LatLng[]): DPolygon;
+    /**
+     * Parse from [GeoJSON](https://en.wikipedia.org/wiki/GeoJSON) coordinates
+     * @param a
+     */
+    static parse(a: number[][]): DPolygon;
+    /**
+     * Parse from [OpenLayers](https://openlayers.org/) coordinates
      * @param a
      */
-    static parse(a: LatLng[] | number[][] | DCoord[]): DPolygon;
+    static parse(a: DCoord[]): DPolygon;
     /**
      * Transform to array of coordinates for [OpenLayers](https://openlayers.org/) or
      * [GeoJSON](https://en.wikipedia.org/wiki/GeoJSON)
@@ -319,6 +299,17 @@ export declare class DPolygon {
      * ![Example](https://edejin.github.io/DGeoUtils/media/examples/toTriangles.png)
      */
     toTriangles(): DPolygon[];
+    /**
+     * Divide polygon to triangles and return points indexes
+     */
+    getTrianglesPointIndexes(): number[];
+    get closed(): boolean;
+    /**
+     * @param v
+     * @param [quadrantSegments=64]
+     * @param [type=DPolygon.CAP_ROUND] DPolygon.CAP_ROUND || DPolygon.CAP_FLAT || DPolygon.CAP_SQUARE
+     */
+    buffer(v: number, quadrantSegments?: number, type?: number): DPolygon;
     private simpleIncludeX;
     private simpleIncludeY;
     private douglasPeucker;

package/dist/DPolygon.js

@@ -8,18 +8,47 @@ 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 {
-    constructor(points = []) {
+    // 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.pPoints = [];
         this.searchStore = {};
-        this.pPoints = points;
+    }
+    /**
+     * 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()
+            .height(height)
+            .run()
+            .toArrayOfCoords())
+            .flat(2);
     }
     /**
      * Get size of min area rectangle.
@@ -93,7 +122,7 @@ class DPolygon {
         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_1.DPoint.zero(), size.clone().setX(0), size.clone(), size.clone().setY(0)]).close();
     }
     loop() {
         return new DPolygonLoop_1.DPolygonLoop(this);
@@ -410,20 +439,21 @@ class DPolygon {
             .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(', ')}`;
-        }
-        return `POLYGON ((${this.deintersection.pPoints.map((r) => `${r.x} ${r.y}`).join(', ')})${h})`;
-    }
     /**
-     * Rotate polygon with center in point {0, 0}
-     * @param a Radians
-     * @deprecated Better to use loop
+     * @param [type = DPolygon.WKT_POLYGON] Available values `DPolygon.WKT_POLYGON`, `DPolygon.WKT_LINESTRING`
      */
-    rotate(a) {
-        return this.map((h) => h.rotate(a));
+    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 `LINESTRING (${this.pPoints.map((r) => `${r.x} ${r.y}`)
+            .join(', ')})`;
     }
     /**
      * Filter points
@@ -433,62 +463,6 @@ 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) {
-        return this.map((h) => h.move(x, y));
-    }
-    /**
-     * @deprecated Better to use loop
-     * @param [x=0]
-     * @param [y=x]
-     */
-    scale(x = 0, y) {
-        return this.map((h) => h.scale(x, y));
-    }
-    /**
-     * @deprecated Better to use loop
-     * @param [x=0]
-     * @param [y=x]
-     */
-    divide(x = 0, y) {
-        return this.map((h) => h.divide(x, y));
-    }
-    /**
-     * @deprecated Better to use loop
-     */
-    round() {
-        return this.map((h) => h.round());
-    }
-    /**
-     * @deprecated Better to use loop
-     */
-    floor() {
-        return this.map((h) => h.floor());
-    }
-    /**
-     * @deprecated Better to use loop
-     */
-    ceil() {
-        return this.map((h) => h.ceil());
-    }
-    /**
-     * @deprecated Better to use loop
-     * @param size
-     */
-    flipVertically(size) {
-        return this.map((h) => h.flipVertically(size));
-    }
-    /**
-     * @deprecated Better to use loop
-     * @param [n=2]
-     */
-    toFixed(n = 2) {
-        return this.map((h) => h.toFixed(n));
-    }
     map(f) {
         this.pPoints = this.pPoints.map(f);
         this.holes = this.holes.map((h) => h.map(f));
@@ -519,30 +493,6 @@ class DPolygon {
         return (this.pPoints.map((r) => r.getValue()) + this.holes
             .reduce((a, h) => a + h.getValue(), ''));
     }
-    /**
-     * @deprecated Better to use loop
-     */
-    degreeToMeters() {
-        return this.map((r) => r.degreeToMeters());
-    }
-    /**
-     * @deprecated Better to use loop
-     */
-    metersToDegree() {
-        return this.map((r) => r.metersToDegree());
-    }
-    /**
-     * @deprecated Better to use loop
-     */
-    radiansToMeters() {
-        return this.map((r) => r.radiansToMeters());
-    }
-    /**
-     * @deprecated Better to use loop
-     */
-    metersToRadians() {
-        return this.map((r) => r.metersToRadians());
-    }
     toString() {
         return `(${this.pPoints.map((r) => r.toString()).join(', ')})`;
     }
@@ -551,7 +501,7 @@ class DPolygon {
      */
     close() {
         const p0 = this.first;
-        if (p0 && !p0.equal(this.last)) {
+        if (p0 && !this.closed) {
             this.push(p0.clone());
         }
         return this;
@@ -561,19 +511,11 @@ class DPolygon {
      */
     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;
     }
-    /**
-     * Set `height` (`z`)
-     * @param z
-     * @deprecated Better to use loop
-     */
-    height(z) {
-        return this.map((p) => p.height(z));
-    }
     add(poly) {
         const res = new DPolygon([...this.points, ...poly.points]).close();
         res.holes = [...this.holes, ...poly.holes].map((h) => h.clone());
@@ -630,7 +572,7 @@ class DPolygon {
     /**
      * Get polygon approximation by
      * [Ramer–Douglas–Peucker algorithm](https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm)
-     * @param e
+     * @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));
@@ -704,10 +646,10 @@ class DPolygon {
     /**
      * Check if contain point
      * @param p
-     * @param isBorderInside
-     * @param move Ignore this parameter
+     * @param [isBorderInside=false]
+     * @param [move=(0,0)] Ignore this parameter
      */
-    contain(p, isBorderInside = false, move = DPoint_1.DPoint.Zero()) {
+    contain(p, isBorderInside = false, move = DPoint_1.DPoint.zero()) {
         const simpleInclude = this.simpleInclude(p);
         if (!simpleInclude) {
             return false;
@@ -779,11 +721,6 @@ class DPolygon {
         }
         return this;
     }
-    /**
-     * Parse from [OpenLayers](https://openlayers.org/) coordinates or
-     * [GeoJSON](https://en.wikipedia.org/wiki/GeoJSON) coordinates
-     * @param a
-     */
     static parse(a) {
         return new DPolygon(a.map((r) => DPoint_1.DPoint.parse(r)));
     }
@@ -890,10 +827,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)) {
@@ -902,12 +838,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);
                     }
                 }
             }
@@ -973,6 +904,89 @@ 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);
+            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);
+    }
+    /**
+     * @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;
+        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;
@@ -1134,3 +1148,17 @@ 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

@@ -10,20 +10,89 @@ export declare class DPolygonLoop {
      * 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;
-    setX(x: number | SetterFunction): DPolygonLoop;
-    setY(y: number | SetterFunction): 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;
     rotate(a: number): DPolygonLoop;
-    move(x?: number | DPoint, y?: 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;
-    scale(x?: number | DPoint, y?: number): DPolygonLoop;
-    divide(x?: number | DPoint, y?: number): 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;
     radiansToMeters(): DPolygonLoop;
@@ -37,5 +106,14 @@ export declare class DPolygonLoop {
     minus(): DPolygonLoop;
     degreeToMeters(): DPolygonLoop;
     metersToDegree(): DPolygonLoop;
-    flipVertically(size: DPoint | number): DPolygonLoop;
+    /**
+     * Flip vertically
+     * @param size canvas size
+     */
+    flipVertically(size: DPoint): DPolygonLoop;
+    /**
+     * Flip vertically
+     * @param height canvas height
+     */
+    flipVertically(height: number): DPolygonLoop;
 }