dgeoutils 2.0.1 → 2.2.1

package/dist/DCircle.d.ts

@@ -12,11 +12,31 @@ export declare class DCircle {
     clone(): DCircle;
     /**
      * Find intersection points with other circle.
+     *
+     * ![Example](/media/examples/findPoints.png)
      * @param c
      */
     findPoints(c: DCircle): DPoint[] | number;
     equal({ center, r }: DCircle): boolean;
+    /**
+     * Transform circle to polygon
+     *
+     * ![Example](/media/examples/findPolygonInside.png)
+     * @param [pointCount=64]
+     */
     findPolygonInside(pointCount?: number): DPolygon;
+    /**
+     * Transform circle to polygon on sphere. It would be different for different latitude.
+     *
+     * @remarks
+     * Center should be Lng/Lat.
+     *
+     * @remarks
+     * Radius should be in meters.
+     *
+     * ![Example](/media/examples/findPolygonInsideOnSphere.png)
+     * @param [pointCount=64]
+     */
     findPolygonInsideOnSphere(pointCount?: number): DPolygon;
     private sphereOffset;
 }

package/dist/DCircle.js

@@ -23,6 +23,8 @@ class DCircle {
     }
     /**
      * Find intersection points with other circle.
+     *
+     * ![Example](/media/examples/findPoints.png)
      * @param c
      */
     findPoints(c) {
@@ -57,6 +59,12 @@ class DCircle {
     equal({ center, r }) {
         return this.center.equal(center) && this.r === r;
     }
+    /**
+     * Transform circle to polygon
+     *
+     * ![Example](/media/examples/findPolygonInside.png)
+     * @param [pointCount=64]
+     */
     findPolygonInside(pointCount = 64) {
         const preAngle = 2 * Math.PI / pointCount;
         const points = [];
@@ -68,6 +76,18 @@ class DCircle {
         }
         return new DPolygon_1.DPolygon([...points, points[0]]);
     }
+    /**
+     * Transform circle to polygon on sphere. It would be different for different latitude.
+     *
+     * @remarks
+     * Center should be Lng/Lat.
+     *
+     * @remarks
+     * Radius should be in meters.
+     *
+     * ![Example](/media/examples/findPolygonInsideOnSphere.png)
+     * @param [pointCount=64]
+     */
     findPolygonInsideOnSphere(pointCount = 64) {
         (0, utils_1.checkFunction)('findPolygonInsideOnSphere')
             .checkArgument('center')
@@ -76,7 +96,7 @@ class DCircle {
         for (let i = 0; i < pointCount; i++) {
             res.push(this.sphereOffset(2 * Math.PI * i / pointCount));
         }
-        return res;
+        return res.close();
     }
     sphereOffset(bearing, earthRadius = DPoint_1.EARTH_RADIUS_IN_METERS) {
         const lat1 = DNumbers_1.DNumbers.deg2Rad(this.center.y);

package/dist/DLine.d.ts

@@ -14,9 +14,10 @@ export declare class DLine {
      * Find intersection of two lines segments.
      * For intersection of two lines use [[findPoint]]
      * @param l
-     * @param d
+     * @param [d=0]
+     * @param [includeOnly=false]
      */
-    intersection(l: DLine, d?: number): DPoint | null;
+    intersection(l: DLine, d?: number, includeOnly?: boolean): DPoint | null;
     intersectionWithCircle(circle: DCircle): DPoint | [DPoint, DPoint] | null;
     /**
      * Check if point below to line segment
@@ -24,6 +25,13 @@ export declare class DLine {
      * @param d
      */
     inRange(p: DPoint, d?: number): boolean;
+    /**
+     * Check if point below to line segment, but not equal star or end point.
+     * @param p
+     * @param d
+     */
+    insideRange(p: DPoint, d?: number): boolean;
+    get center(): DPoint;
     get minX(): number;
     get minY(): number;
     get maxX(): number;

package/dist/DLine.js

@@ -45,11 +45,15 @@ class DLine {
      * Find intersection of two lines segments.
      * For intersection of two lines use [[findPoint]]
      * @param l
-     * @param d
+     * @param [d=0]
+     * @param [includeOnly=false]
      */
-    intersection(l, d = 0) {
+    intersection(l, d = 0, includeOnly = false) {
         const p = this.findPoint(l);
         if (p) {
+            if (includeOnly) {
+                return this.insideRange(p, d) && l.insideRange(p, d) ? p : null;
+            }
             return this.inRange(p, d) && l.inRange(p, d) ? p : null;
         }
         return null;
@@ -117,6 +121,32 @@ class DLine {
         const isInY = y >= minY - d && y <= maxY + d;
         return isInX && isInY;
     }
+    /**
+     * Check if point below to line segment, but not equal star or end point.
+     * @param p
+     * @param d
+     */
+    insideRange(p, d = 0) {
+        const { minX, minY, maxX, maxY, p1, p2 } = this;
+        const { x, y } = p;
+        return this.inRange(p, d) && !p1.like(p, 0.00001) && !p2.like(p, 0.00001);
+        const isInX = x > minX - d && x < maxX + d;
+        const isInY = y > minY - d && y < maxY + d;
+        return isInX && isInY && !p1.like(p, 0.00001) && !p2.like(p, 0.00001);
+    }
+    get center() {
+        return this.p1
+            .clone()
+            .setIfLessThan(this.p2)
+            .move(this.p2
+            .clone()
+            .move(this.p1
+            .clone()
+            .minus())
+            .abs()
+            .minus()
+            .divide(2));
+    }
     get minX() {
         return Math.min(this.p1.x, this.p2.x);
     }

package/dist/DPoint.d.ts

@@ -1,19 +1,5 @@
 import { DLine } from './DLine';
 import { DPolygon } from './DPolygon';
-/**
- * Meters
- * Projected bounds:
- * -20026376.39 -20048966.10
- * 20026376.39 20048966.10
- */
-export declare const PSEUDO_MERCATOR = "EPSG:3857";
-/**
- * Degrees
- * Projected bounds:
- * -180.0 -90.0
- * 180.0 90.0
- */
-export declare const WORLD_GEODETIC_SYSTEM = "EPSG:4326";
 export declare const EARTH_RADIUS_IN_METERS = 6371008.8;
 export declare type DCoord = [number, number] | [number, number, number];
 export interface LatLng {
@@ -45,7 +31,21 @@ export declare class DPoint {
     static isPoint(p: unknown): boolean;
     static parseFromWKT(wkt: string): DPoint;
     static Random(): DPoint;
+    /**
+     * @remark Point should be Lng/Lat.
+     *
+     * @remark `z` value default for `zoom` argument.
+     *
+     * @param [zoom=this.z]
+     */
     getTileFromCoords(zoom?: number): DPoint;
+    /**
+     * Result would be Lng/Lat.
+     *
+     * @remark `z` value default for `zoom` argument.
+     *
+     * @param [zoom=this.z]
+     */
     getCoordsFromTile(zoom?: number): DPoint;
     toCoords(): DCoord;
     /**
@@ -54,7 +54,6 @@ export declare class DPoint {
      */
     findLine(p: DPoint): DLine;
     findInnerAngle(p1: DPoint, p3: DPoint): number;
-    transform(from?: string, to?: string): DPoint;
     toString(): string;
     getValue(): [number, number];
     height(z: number): DPoint;
@@ -73,8 +72,12 @@ export declare class DPoint {
      */
     rotate(a: number): DPoint;
     move(x?: number | DPoint, y?: number): DPoint;
-    asRadians(): DPoint;
-    asDegrees(): DPoint;
+    degreeToMeters(): DPoint;
+    metersToDegree(): DPoint;
+    degreeToRadians(): DPoint;
+    radiansToDegrees(): DPoint;
+    radiansToMeters(): DPoint;
+    metersToRadians(): DPoint;
     round(): DPoint;
     ceil(): DPoint;
     floor(): DPoint;
@@ -84,6 +87,7 @@ export declare class DPoint {
     divide(x?: number | DPoint, y?: number): DPoint;
     equal(p: DPoint): boolean;
     like(p: DPoint, d?: number): boolean;
+    flipVertically(size: DPoint | number): DPoint;
     /**
      * Check if point looks like radians
      */
@@ -114,7 +118,15 @@ export declare class DPoint {
     };
     setIfLessThan(p: DPoint): DPoint;
     minus(): DPoint;
+    /**
+     * Find [orthodromic path](https://en.wikipedia.org/wiki/Great-circle_navigation) between to points.
+     *
+     * @remark Points should be Lng/Lat.
+     *
+     * ![example](/media/examples/orthodromicPath.png)
+     *
+     * @param point
+     * @param [pointsCount=360]
+     */
     orthodromicPath(point: DPoint, pointsCount?: number): DPolygon;
-    private degrees2meters;
-    private meters2degrees;
 }

package/dist/DPoint.js

@@ -1,26 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DPoint = exports.DEGREE_TO_PI = exports.PI_TO_DEGREE = exports.DOUBLE_PI_IN_DEGREE = exports.PI_IN_DEGREE = exports.HALF_PI_IN_DEGREE = exports.EARTH_RADIUS_IN_METERS = exports.WORLD_GEODETIC_SYSTEM = exports.PSEUDO_MERCATOR = void 0;
+exports.DPoint = exports.DEGREE_TO_PI = exports.PI_TO_DEGREE = exports.DOUBLE_PI_IN_DEGREE = exports.PI_IN_DEGREE = exports.HALF_PI_IN_DEGREE = exports.EARTH_RADIUS_IN_METERS = void 0;
 const DLine_1 = require("./DLine");
 const DPolygon_1 = require("./DPolygon");
 const utils_1 = require("./utils");
 const diff = 0;
 const radiansPolygon = new DPolygon_1.DPolygon();
-/**
- * Meters
- * Projected bounds:
- * -20026376.39 -20048966.10
- * 20026376.39 20048966.10
- */
-exports.PSEUDO_MERCATOR = 'EPSG:3857';
 const pseudoMercatorPolygon = new DPolygon_1.DPolygon();
-/**
- * Degrees
- * Projected bounds:
- * -180.0 -90.0
- * 180.0 90.0
- */
-exports.WORLD_GEODETIC_SYSTEM = 'EPSG:4326';
 const worldGeodeticPolygon = new DPolygon_1.DPolygon();
 exports.EARTH_RADIUS_IN_METERS = 6371008.8;
 const EARTH_IN_MITERS = 20037508.34;
@@ -72,6 +58,13 @@ class DPoint {
     static Random() {
         return new DPoint(Math.random(), Math.random());
     }
+    /**
+     * @remark Point should be Lng/Lat.
+     *
+     * @remark `z` value default for `zoom` argument.
+     *
+     * @param [zoom=this.z]
+     */
     getTileFromCoords(zoom = this.z) {
         (0, utils_1.checkFunction)('getTileFromCoords')
             .checkArgument('this')
@@ -80,6 +73,13 @@ class DPoint {
         const y = Math.floor((1 - Math.log(Math.tan(this.y * exports.PI_TO_DEGREE) + 1 / Math.cos(this.y * exports.PI_TO_DEGREE)) / Math.PI) / 2 * (Math.pow(2, zoom)));
         return new DPoint(x, y, zoom);
     }
+    /**
+     * Result would be Lng/Lat.
+     *
+     * @remark `z` value default for `zoom` argument.
+     *
+     * @param [zoom=this.z]
+     */
     getCoordsFromTile(zoom = this.z) {
         (0, utils_1.checkFunction)('getCoordsFromTile')
             .checkArgument('this')
@@ -134,18 +134,6 @@ class DPoint {
         }
         return a2 + Math.PI * 2 - a1;
     }
-    transform(from = exports.PSEUDO_MERCATOR, to = exports.WORLD_GEODETIC_SYSTEM) {
-        if (from === to && [exports.PSEUDO_MERCATOR, exports.WORLD_GEODETIC_SYSTEM].includes(from)) {
-            return this;
-        }
-        if (from === exports.PSEUDO_MERCATOR && to === exports.WORLD_GEODETIC_SYSTEM) {
-            return this.meters2degrees();
-        }
-        if (from === exports.WORLD_GEODETIC_SYSTEM && to === exports.PSEUDO_MERCATOR) {
-            return this.degrees2meters();
-        }
-        return this;
-    }
     toString() {
         return `${this.x} ${this.y}`;
     }
@@ -221,18 +209,52 @@ class DPoint {
         this.y = yV;
         return this;
     }
-    asRadians() {
-        (0, utils_1.checkFunction)('asRadians')
+    degreeToMeters() {
+        (0, utils_1.checkFunction)('degreeToMeters')
+            .checkArgument('this')
+            .shouldBeDegree(this);
+        const x = ((this.x + exports.PI_IN_DEGREE) % exports.DOUBLE_PI_IN_DEGREE - exports.PI_IN_DEGREE) * MITERS_IN_ONE_DEGREE;
+        const y = (Math.log(Math.tan(((this.y + exports.HALF_PI_IN_DEGREE) % exports.PI_IN_DEGREE) *
+            (Math.PI / exports.DOUBLE_PI_IN_DEGREE))) / exports.PI_TO_DEGREE) * MITERS_IN_ONE_DEGREE;
+        this.x = x;
+        this.y = y;
+        return this;
+    }
+    metersToDegree() {
+        (0, utils_1.checkFunction)('metersToDegree')
+            .checkArgument('this')
+            .shouldBeMeters(this);
+        const lon = this.x * DEGREES_IN_ONE_MITER;
+        const lat = Math.atan(Math.pow(Math.E, ((this.y / MITERS_IN_ONE_DEGREE) * exports.PI_TO_DEGREE))) *
+            (exports.DOUBLE_PI_IN_DEGREE / Math.PI) - exports.HALF_PI_IN_DEGREE;
+        this.x = lon;
+        this.y = lat;
+        return this;
+    }
+    degreeToRadians() {
+        (0, utils_1.checkFunction)('degreeToRadians')
             .checkArgument('this')
             .shouldBeDegree(this);
         return this.scale(exports.PI_TO_DEGREE);
     }
-    asDegrees() {
-        (0, utils_1.checkFunction)('asDegrees')
+    radiansToDegrees() {
+        (0, utils_1.checkFunction)('radiansToDegrees')
             .checkArgument('this')
             .shouldBeRadians(this);
         return this.scale(exports.DEGREE_TO_PI);
     }
+    radiansToMeters() {
+        (0, utils_1.checkFunction)('radiansToMeters')
+            .checkArgument('this')
+            .shouldBeRadians(this);
+        return this.radiansToDegrees().degreeToMeters();
+    }
+    metersToRadians() {
+        (0, utils_1.checkFunction)('metersToRadians')
+            .checkArgument('this')
+            .shouldBeMeters(this);
+        return this.metersToDegree().degreeToRadians();
+    }
     round() {
         this.x = Math.round(this.x);
         this.y = Math.round(this.y);
@@ -297,6 +319,14 @@ class DPoint {
         const likeZ = this.z === p.z || Math.abs(this.z - p.z) < d;
         return likeX && likeY && likeZ;
     }
+    flipVertically(size) {
+        let v = size;
+        if (size instanceof DPoint) {
+            v = size.y;
+        }
+        this.y = v - this.y;
+        return this;
+    }
     /**
      * Check if point looks like radians
      */
@@ -386,14 +416,24 @@ class DPoint {
     minus() {
         return this.clone().scale(-1);
     }
+    /**
+     * Find [orthodromic path](https://en.wikipedia.org/wiki/Great-circle_navigation) between to points.
+     *
+     * @remark Points should be Lng/Lat.
+     *
+     * ![example](/media/examples/orthodromicPath.png)
+     *
+     * @param point
+     * @param [pointsCount=360]
+     */
     orthodromicPath(point, pointsCount = 360) {
         (0, utils_1.checkFunction)('orthodromicPath')
             .checkArgument('this')
             .shouldBeDegree(this)
             .checkArgument('point')
             .shouldBeDegree(point);
-        const t = this.clone().asRadians();
-        const p = point.clone().asRadians();
+        const t = this.clone().degreeToRadians();
+        const p = point.clone().degreeToRadians();
         const d = Math.sin(p.x - t.x);
         const step = (p.x - t.x) / (pointsCount - 1);
         return new DPolygon_1.DPolygon(Array.from(new Array(pointsCount))
@@ -401,30 +441,8 @@ class DPoint {
             const x = t.x + step * i;
             const y = Math.atan((Math.tan(t.y) * Math.sin(p.x - x)) / d +
                 (Math.tan(p.y) * Math.sin(x - t.x)) / d);
-            return new DPoint(x, y).asDegrees();
+            return new DPoint(x, y).radiansToDegrees();
         }));
     }
-    degrees2meters() {
-        (0, utils_1.checkFunction)('degrees2meters')
-            .checkArgument('this')
-            .shouldBeDegree(this);
-        const x = ((this.x + exports.PI_IN_DEGREE) % exports.DOUBLE_PI_IN_DEGREE - exports.PI_IN_DEGREE) * MITERS_IN_ONE_DEGREE;
-        const y = (Math.log(Math.tan(((this.y + exports.HALF_PI_IN_DEGREE) % exports.PI_IN_DEGREE) *
-            (Math.PI / exports.DOUBLE_PI_IN_DEGREE))) / exports.PI_TO_DEGREE) * MITERS_IN_ONE_DEGREE;
-        this.x = x;
-        this.y = y;
-        return this;
-    }
-    meters2degrees() {
-        (0, utils_1.checkFunction)('meters2degrees')
-            .checkArgument('this')
-            .shouldBeMeters(this);
-        const lon = this.x * DEGREES_IN_ONE_MITER;
-        const lat = Math.atan(Math.pow(Math.E, ((this.y / MITERS_IN_ONE_DEGREE) * exports.PI_TO_DEGREE))) *
-            (exports.DOUBLE_PI_IN_DEGREE / Math.PI) - exports.HALF_PI_IN_DEGREE;
-        this.x = lon;
-        this.y = lat;
-        return this;
-    }
 }
 exports.DPoint = DPoint;

package/dist/DPolygon.d.ts

@@ -2,10 +2,6 @@
 import { DCoord, DPoint, LatLng } from './DPoint';
 import { DLine } from './DLine';
 import { DPolygonLoop } from './DPolygonLoop';
-interface ParseProps {
-    dataProjection: string;
-    featureProjection: string;
-}
 export declare const MIN_POINTS_IN_VALID_POLYGON = 3;
 export declare class DPolygon {
     properties: {
@@ -30,7 +26,7 @@ export declare class DPolygon {
      * @param poly should be `minAreaRectangle`
      */
     static minAreaRectangleDirection(poly: DPolygon): number;
-    static parseFromWKT(wkt: string, optProps?: ParseProps): DPolygon;
+    static parseFromWKT(wkt: string): DPolygon;
     static createSquareBySize(size: DPoint): DPolygon;
     loop(): DPolygonLoop;
     set points(p: DPoint[]);
@@ -134,8 +130,9 @@ export declare class DPolygon {
     /**
      * Check polygon intersection with line
      * @param l
+     * @param [includeOnly=false]
      */
-    intersection(l: DLine): DPoint[];
+    intersection(l: DLine, includeOnly?: boolean): DPoint[];
     /**
      * Set polygon center
      * @param newCenter
@@ -158,6 +155,7 @@ export declare class DPolygon {
     round(): DPolygon;
     floor(): DPolygon;
     ceil(): DPolygon;
+    flipVertically(size: DPoint | number): DPolygon;
     toFixed(n?: number): DPolygon;
     map(f: (r: DPoint, index?: number) => DPoint): DPolygon;
     p(index: number, divide?: boolean): DPoint;
@@ -167,7 +165,10 @@ export declare class DPolygon {
     unshift(...args: DPoint[]): number;
     reverse(): DPolygon;
     getValue(): string;
-    transform(from?: string, to?: string): DPolygon;
+    degreeToMeters(): DPolygon;
+    metersToDegree(): DPolygon;
+    radiansToMeters(): DPolygon;
+    metersToRadians(): DPolygon;
     toString(): string;
     /**
      * Add to the end of polygon point equal to first point if it not exist
@@ -266,6 +267,17 @@ export declare class DPolygon {
     simpleIntersection(p: DPolygon): DPolygon | null | DPolygon[];
     simpleDifference(p: DPolygon): DPolygon | null | DPolygon[];
     smartUnion(p: DPolygon): DPolygon | null;
+    /**
+     * Divide polygon to triangles
+     *
+     * ![Example](/media/examples/toTriangles.png)
+     */
+    toTriangles(): DPolygon[];
+    /**
+     * @internal
+     */
+    getTriangle(): DPolygon | void;
+    private innerAndNotIntersect;
     private simpleIncludeX;
     private simpleIncludeY;
     private douglasPeucker;
@@ -274,4 +286,3 @@ export declare class DPolygon {
     private getJSTSGeometry;
     private simpleLogicFunction;
 }
-export {};

package/dist/DPolygon.js

@@ -66,7 +66,7 @@ class DPolygon {
         }
         return first.findLine(last).getFi();
     }
-    static parseFromWKT(wkt, optProps) {
+    static parseFromWKT(wkt) {
         const data = wkt.trim().toUpperCase();
         let res = new DPolygon();
         if (data.indexOf('POLYGON') === 0) {
@@ -90,9 +90,6 @@ class DPolygon {
         if (data.indexOf('POINT') === 0) {
             res = new DPolygon([DPoint_1.DPoint.parseFromWKT(data)]);
         }
-        if (optProps) {
-            return res.transform(optProps.dataProjection, optProps.featureProjection);
-        }
         return res;
     }
     static createSquareBySize(size) {
@@ -389,14 +386,15 @@ class DPolygon {
     /**
      * Check polygon intersection with line
      * @param l
+     * @param [includeOnly=false]
      */
-    intersection(l) {
+    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);
-            const intersect = line.intersection(l);
+            const intersect = line.intersection(l, 0, includeOnly);
             if (intersect) {
                 res.push(intersect);
             }
@@ -464,6 +462,11 @@ class DPolygon {
         this.holes = this.holes.map((h) => h.ceil());
         return this;
     }
+    flipVertically(size) {
+        this.pPoints = this.pPoints.map((p) => p.flipVertically(size));
+        this.holes = this.holes.map((h) => h.flipVertically(size));
+        return this;
+    }
     toFixed(n = 2) {
         this.pPoints = this.pPoints.map((p) => p.toFixed(n));
         this.holes = this.holes.map((h) => h.toFixed(n));
@@ -505,9 +508,24 @@ class DPolygon {
         return (this.pPoints.map((r) => r.getValue()) + this.holes
             .reduce((a, h) => a + h.getValue(), ''));
     }
-    transform(from = DPoint_1.PSEUDO_MERCATOR, to = DPoint_1.WORLD_GEODETIC_SYSTEM) {
-        this.pPoints = this.pPoints.map((r) => r.transform(from, to));
-        this.holes = this.holes.map((h) => h.transform(from, to));
+    degreeToMeters() {
+        this.pPoints = this.pPoints.map((r) => r.degreeToMeters());
+        this.holes = this.holes.map((h) => h.degreeToMeters());
+        return this;
+    }
+    metersToDegree() {
+        this.pPoints = this.pPoints.map((r) => r.metersToDegree());
+        this.holes = this.holes.map((h) => h.metersToDegree());
+        return this;
+    }
+    radiansToMeters() {
+        this.pPoints = this.pPoints.map((r) => r.radiansToMeters());
+        this.holes = this.holes.map((h) => h.radiansToMeters());
+        return this;
+    }
+    metersToRadians() {
+        this.pPoints = this.pPoints.map((r) => r.metersToRadians());
+        this.holes = this.holes.map((h) => h.metersToRadians());
         return this;
     }
     toString() {
@@ -645,7 +663,7 @@ class DPolygon {
         if (lineWidth) {
             ctx.lineWidth = lineWidth;
         }
-        if (fillColor) {
+        if (fillColor || strokeColor) {
             ctx.beginPath();
         }
         this.goByPath(ctx, steps % this.length);
@@ -885,6 +903,67 @@ class DPolygon {
         }
         return res;
     }
+    /**
+     * Divide polygon to triangles
+     *
+     * ![Example](/media/examples/toTriangles.png)
+     */
+    toTriangles() {
+        const p = this.clone().clockWise.open();
+        while (p.holes.length) {
+            const h = p.holes.shift()
+                .clone()
+                .clockWise
+                .reverse()
+                .close();
+            for (let i = 0; i < p.length; i++) {
+                if (p.innerAndNotIntersect(p.first, h.first)) {
+                    p.insertAfter(0, ...h.points, p.first);
+                    break;
+                }
+                p.push(p.shift());
+            }
+        }
+        const res = [];
+        while (p.length > 3) {
+            const triangle = p.getTriangle();
+            if (triangle) {
+                res.push(triangle);
+            }
+        }
+        res.push(p);
+        return res;
+    }
+    /**
+     * @internal
+     */
+    getTriangle() {
+        for (let i = 0; i < this.length; i++) {
+            const p0 = this.p(0);
+            const p1 = this.p(1);
+            const p2 = this.p(2);
+            if (this.innerAndNotIntersect(p0, p2)) {
+                this.removePart(0, 1);
+                return new DPolygon([
+                    p0.clone(),
+                    p1.clone(),
+                    p2.clone()
+                ]);
+            }
+            this.push(this.shift());
+        }
+        return undefined;
+    }
+    innerAndNotIntersect(p1, p2) {
+        const l = p1.findLine(p2);
+        const { center } = l;
+        const intersections = this.holes.reduce((a, hole) => a && Boolean(hole.clone().close()
+            .intersection(l, true).length), Boolean(this.clone().close()
+            .intersection(l, true).length));
+        const contain = this.holes.reduce((a, hole) => a && !hole
+            .contain(center), this.contain(center));
+        return !intersections && contain;
+    }
     simpleIncludeX(p) {
         const { x } = p;
         return this.minX <= x && this.maxX >= x;

package/dist/DPolygonLoop.d.ts

@@ -1,12 +1,17 @@
 import { DPolygon } from './DPolygon';
 import { DPoint, SetterFunction } from './DPoint';
+export declare type LoopFunction = (k: DPoint) => DPoint;
 export declare class DPolygonLoop {
-    private f;
     private readonly parent;
+    private pool;
     constructor(parent: DPolygon);
+    private getLoopFunction;
+    /**
+     * Run loop
+     */
+    run(): DPolygon;
     getTileFromCoords(zoom?: number): DPolygonLoop;
     getCoordsFromTile(zoom?: number): DPolygonLoop;
-    transform(from?: string, to?: string): DPolygonLoop;
     height(z: number): DPolygonLoop;
     setX(x: number | SetterFunction): DPolygonLoop;
     setY(y: number | SetterFunction): DPolygonLoop;
@@ -19,8 +24,10 @@ export declare class DPolygonLoop {
     abs(): DPolygonLoop;
     scale(x?: number | DPoint, y?: number): DPolygonLoop;
     divide(x?: number | DPoint, y?: number): DPolygonLoop;
-    asRadians(): DPolygonLoop;
-    asDegrees(): DPolygonLoop;
+    degreeToRadians(): DPolygonLoop;
+    radiansToDegrees(): DPolygonLoop;
+    radiansToMeters(): DPolygonLoop;
+    metersToRadians(): DPolygonLoop;
     getHipPoint(): DPolygonLoop;
     getXPoint(): DPolygonLoop;
     getYPoint(): DPolygonLoop;
@@ -28,5 +35,7 @@ export declare class DPolygonLoop {
     getHPoint(): DPolygonLoop;
     setIfLessThan(p: DPoint): DPolygonLoop;
     minus(): DPolygonLoop;
-    run(): DPolygon;
+    degreeToMeters(): DPolygonLoop;
+    metersToDegree(): DPolygonLoop;
+    flipVertically(size: DPoint | number): DPolygonLoop;
 }

package/dist/DPolygonLoop.js

@@ -1,135 +1,353 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DPolygonLoop = void 0;
-const DPoint_1 = require("./DPoint");
+var LoopFunctions;
+(function (LoopFunctions) {
+    LoopFunctions[LoopFunctions["getTileFromCoords"] = 0] = "getTileFromCoords";
+    LoopFunctions[LoopFunctions["getCoordsFromTile"] = 1] = "getCoordsFromTile";
+    LoopFunctions[LoopFunctions["height"] = 2] = "height";
+    LoopFunctions[LoopFunctions["setX"] = 3] = "setX";
+    LoopFunctions[LoopFunctions["setY"] = 4] = "setY";
+    LoopFunctions[LoopFunctions["rotate"] = 5] = "rotate";
+    LoopFunctions[LoopFunctions["move"] = 6] = "move";
+    LoopFunctions[LoopFunctions["round"] = 7] = "round";
+    LoopFunctions[LoopFunctions["ceil"] = 8] = "ceil";
+    LoopFunctions[LoopFunctions["floor"] = 9] = "floor";
+    LoopFunctions[LoopFunctions["toFixed"] = 10] = "toFixed";
+    LoopFunctions[LoopFunctions["abs"] = 11] = "abs";
+    LoopFunctions[LoopFunctions["scale"] = 12] = "scale";
+    LoopFunctions[LoopFunctions["divide"] = 13] = "divide";
+    LoopFunctions[LoopFunctions["degreeToRadians"] = 14] = "degreeToRadians";
+    LoopFunctions[LoopFunctions["radiansToDegrees"] = 15] = "radiansToDegrees";
+    LoopFunctions[LoopFunctions["radiansToMeters"] = 16] = "radiansToMeters";
+    LoopFunctions[LoopFunctions["metersToRadians"] = 17] = "metersToRadians";
+    LoopFunctions[LoopFunctions["hipPoint"] = 18] = "hipPoint";
+    LoopFunctions[LoopFunctions["xPoint"] = 19] = "xPoint";
+    LoopFunctions[LoopFunctions["yPoint"] = 20] = "yPoint";
+    LoopFunctions[LoopFunctions["wPoint"] = 21] = "wPoint";
+    LoopFunctions[LoopFunctions["hPoint"] = 22] = "hPoint";
+    LoopFunctions[LoopFunctions["setIfLessThan"] = 23] = "setIfLessThan";
+    LoopFunctions[LoopFunctions["minus"] = 24] = "minus";
+    LoopFunctions[LoopFunctions["degreeToMeters"] = 25] = "degreeToMeters";
+    LoopFunctions[LoopFunctions["metersToDegree"] = 26] = "metersToDegree";
+    LoopFunctions[LoopFunctions["flipVertically"] = 27] = "flipVertically";
+})(LoopFunctions || (LoopFunctions = {}));
+// eslint-disable-next-line complexity
+const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg, setterArg }) => {
+    let res = a;
+    switch (functionName) {
+        case LoopFunctions.getTileFromCoords:
+            res = (k) => a(k)
+                .getTileFromCoords(numberArg);
+            break;
+        case LoopFunctions.getCoordsFromTile:
+            res = (k) => a(k)
+                .getCoordsFromTile(numberArg);
+            break;
+        case LoopFunctions.height:
+            res = (k) => a(k)
+                .height(numberArg);
+            break;
+        case LoopFunctions.setX:
+            res = (k) => a(k)
+                .setX(setterArg);
+            break;
+        case LoopFunctions.setY:
+            res = (k) => a(k)
+                .setY(setterArg);
+            break;
+        case LoopFunctions.rotate:
+            res = (k) => a(k)
+                .rotate(numberArg);
+            break;
+        case LoopFunctions.move:
+            res = (k) => a(k)
+                .move(numberPointArg, numberArg);
+            break;
+        case LoopFunctions.round:
+            res = (k) => a(k)
+                .round();
+            break;
+        case LoopFunctions.ceil:
+            res = (k) => a(k)
+                .ceil();
+            break;
+        case LoopFunctions.floor:
+            res = (k) => a(k)
+                .floor();
+            break;
+        case LoopFunctions.toFixed:
+            res = (k) => a(k)
+                .toFixed(numberArg);
+            break;
+        case LoopFunctions.abs:
+            res = (k) => a(k)
+                .abs();
+            break;
+        case LoopFunctions.scale:
+            res = (k) => a(k)
+                .scale(numberPointArg, numberArg);
+            break;
+        case LoopFunctions.divide:
+            res = (k) => a(k)
+                .divide(numberPointArg, numberArg);
+            break;
+        case LoopFunctions.degreeToRadians:
+            res = (k) => a(k)
+                .degreeToRadians();
+            break;
+        case LoopFunctions.radiansToDegrees:
+            res = (k) => a(k)
+                .radiansToDegrees();
+            break;
+        case LoopFunctions.radiansToMeters:
+            res = (k) => a(k)
+                .radiansToMeters();
+            break;
+        case LoopFunctions.metersToRadians:
+            res = (k) => a(k)
+                .metersToRadians();
+            break;
+        case LoopFunctions.hipPoint:
+            res = (k) => a(k)
+                .hipPoint;
+            break;
+        case LoopFunctions.xPoint:
+            res = (k) => a(k)
+                .xPoint;
+            break;
+        case LoopFunctions.yPoint:
+            res = (k) => a(k)
+                .yPoint;
+            break;
+        case LoopFunctions.wPoint:
+            res = (k) => a(k)
+                .wPoint;
+            break;
+        case LoopFunctions.hPoint:
+            res = (k) => a(k)
+                .hPoint;
+            break;
+        case LoopFunctions.setIfLessThan:
+            res = (k) => a(k)
+                .setIfLessThan(pointArg);
+            break;
+        case LoopFunctions.minus:
+            res = (k) => a(k)
+                .minus();
+            break;
+        case LoopFunctions.degreeToMeters:
+            res = (k) => a(k)
+                .degreeToMeters();
+            break;
+        case LoopFunctions.metersToDegree:
+            res = (k) => a(k)
+                .metersToDegree();
+            break;
+        case LoopFunctions.flipVertically:
+            res = (k) => a(k)
+                .flipVertically(numberPointArg);
+            break;
+        default:
+    }
+    return res;
+};
 class DPolygonLoop {
     constructor(parent) {
-        this.f = (k) => k;
         this.parent = parent;
+        this.pool = [];
+    }
+    getLoopFunction() {
+        return this.pool.reduce(decodePoolRecord, (k) => k);
+    }
+    /**
+     * Run loop
+     */
+    run() {
+        return this.parent.map(this.getLoopFunction());
     }
     getTileFromCoords(zoom) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).getTileFromCoords(zoom);
+        this.pool.push({
+            functionName: LoopFunctions.getTileFromCoords,
+            numberArg: zoom
+        });
         return this;
     }
     getCoordsFromTile(zoom) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).getCoordsFromTile(zoom);
-        return this;
-    }
-    transform(from = DPoint_1.PSEUDO_MERCATOR, to = DPoint_1.WORLD_GEODETIC_SYSTEM) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).transform(from, to);
+        this.pool.push({
+            functionName: LoopFunctions.getCoordsFromTile,
+            numberArg: zoom
+        });
         return this;
     }
     height(z) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).height(z);
+        this.pool.push({
+            functionName: LoopFunctions.height,
+            numberArg: z
+        });
         return this;
     }
     setX(x) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).setX(x);
+        this.pool.push({
+            functionName: LoopFunctions.setX,
+            setterArg: x
+        });
         return this;
     }
     setY(y) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).setY(y);
+        this.pool.push({
+            functionName: LoopFunctions.setY,
+            setterArg: y
+        });
         return this;
     }
     rotate(a) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).rotate(a);
+        this.pool.push({
+            functionName: LoopFunctions.rotate,
+            numberArg: a
+        });
         return this;
     }
-    move(x = 0, y) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).move(x, y);
+    move(x = 0, y = x) {
+        this.pool.push({
+            functionName: LoopFunctions.move,
+            numberPointArg: x,
+            numberArg: y
+        });
         return this;
     }
     round() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).round();
+        this.pool.push({
+            functionName: LoopFunctions.round
+        });
         return this;
     }
     ceil() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).ceil();
+        this.pool.push({
+            functionName: LoopFunctions.ceil
+        });
         return this;
     }
     floor() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).floor();
+        this.pool.push({
+            functionName: LoopFunctions.floor
+        });
         return this;
     }
     toFixed(n = 2) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).toFixed(n);
+        this.pool.push({
+            functionName: LoopFunctions.toFixed,
+            numberArg: n
+        });
         return this;
     }
     abs() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).abs();
+        this.pool.push({
+            functionName: LoopFunctions.abs
+        });
         return this;
     }
-    scale(x = 0, y) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).scale(x, y);
+    scale(x = 0, y = x) {
+        this.pool.push({
+            functionName: LoopFunctions.scale,
+            numberPointArg: x,
+            numberArg: y
+        });
         return this;
     }
     divide(x = 0, y) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).divide(x, y);
+        this.pool.push({
+            functionName: LoopFunctions.divide,
+            numberPointArg: x,
+            numberArg: y
+        });
+        return this;
+    }
+    degreeToRadians() {
+        this.pool.push({
+            functionName: LoopFunctions.degreeToRadians
+        });
         return this;
     }
-    asRadians() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).asRadians();
+    radiansToDegrees() {
+        this.pool.push({
+            functionName: LoopFunctions.radiansToDegrees
+        });
         return this;
     }
-    asDegrees() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).asDegrees();
+    radiansToMeters() {
+        this.pool.push({
+            functionName: LoopFunctions.radiansToMeters
+        });
+        return this;
+    }
+    metersToRadians() {
+        this.pool.push({
+            functionName: LoopFunctions.metersToRadians
+        });
         return this;
     }
     getHipPoint() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).hipPoint;
+        this.pool.push({
+            functionName: LoopFunctions.hipPoint
+        });
         return this;
     }
     getXPoint() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).xPoint;
+        this.pool.push({
+            functionName: LoopFunctions.xPoint
+        });
         return this;
     }
     getYPoint() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).yPoint;
+        this.pool.push({
+            functionName: LoopFunctions.yPoint
+        });
         return this;
     }
     getWPoint() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).wPoint;
+        this.pool.push({
+            functionName: LoopFunctions.wPoint
+        });
         return this;
     }
     getHPoint() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).hPoint;
+        this.pool.push({
+            functionName: LoopFunctions.hPoint
+        });
         return this;
     }
     setIfLessThan(p) {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).setIfLessThan(p);
+        this.pool.push({
+            functionName: LoopFunctions.setIfLessThan,
+            pointArg: p
+        });
         return this;
     }
     minus() {
-        const t = this.f.bind(null);
-        this.f = (k) => t(k).minus();
+        this.pool.push({
+            functionName: LoopFunctions.minus
+        });
         return this;
     }
-    run() {
-        this.parent.points = this.parent.points.map(this.f);
-        return this.parent;
+    degreeToMeters() {
+        this.pool.push({
+            functionName: LoopFunctions.degreeToMeters
+        });
+        return this;
+    }
+    metersToDegree() {
+        this.pool.push({
+            functionName: LoopFunctions.metersToDegree
+        });
+        return this;
+    }
+    flipVertically(size) {
+        this.pool.push({
+            functionName: LoopFunctions.flipVertically,
+            numberPointArg: size
+        });
+        return this;
     }
 }
 exports.DPolygonLoop = DPolygonLoop;

package/package.json

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