dgeoutils 2.4.41 → 2.4.44

package/dist/es2015/DPolygon.js

@@ -1,1193 +0,0 @@
-import { DPoint } from './DPoint';
-import { DLine } from './DLine';
-import { DCircle } from './DCircle';
-import { DNumbers } from './DNumbers';
-import { io as jstsIo, operation } from 'jsts';
-import { DPolygonLoop } from './DPolygonLoop';
-import { DGeo, isDefAndNotNull } from './utils';
-const { buffer: { BufferParameters: { CAP_ROUND, CAP_FLAT, CAP_SQUARE } } } = operation;
-export const MIN_POINTS_IN_VALID_POLYGON = 3;
-const APPROXIMATION_VALUE = 0.1;
-const MAX_CONVEX_ITERATIONS = 100;
-const CLOSE_TO_INTERSECTION_DISTANCE = 0.001;
-const triangleCenter = (triangle) => {
-    const p0 = triangle.at(0);
-    const p1 = triangle.at(1);
-    const p2 = triangle.at(2);
-    return new DPoint((p0.x + p1.x + p2.x) / 3, (p0.y + p1.y + p2.y) / 3);
-};
-const containCalculator = (poly, p) => {
-    const hasSamePoint = poly.points.some((point) => point.equal(p));
-    if (hasSamePoint) {
-        return true;
-    }
-    for (const [, , polygonLine] of poly.loopPointsGenerator(true)()) {
-        const onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
-        if (onBorder) {
-            return true;
-        }
-    }
-    let totalFi = 0;
-    for (const [{ x, y }, { x: a, y: b }] of poly.loopPointsGenerator()()) {
-        const line1 = new DLine(x - p.x, y - p.y, 0);
-        const line2 = new DLine(a - p.x, b - p.y, 0);
-        const fiDif = line1.findFi(line2);
-        if (line1.vectorProduct(line2).c > 0) {
-            totalFi += fiDif;
-        }
-        else {
-            totalFi -= fiDif;
-        }
-    }
-    const eps = Math.PI / 10000;
-    let result = false;
-    const absTotalFi = Math.abs(totalFi);
-    if (absTotalFi < eps) {
-        result = false;
-    }
-    else if (Math.abs(2 * Math.PI - absTotalFi) < eps) {
-        result = true;
-    }
-    else {
-        throw new Error('contains2 faild');
-    }
-    return result;
-};
-export class DPolygon {
-    constructor(pPoints = []) {
-        this.pPoints = pPoints;
-        this.properties = {};
-        this.holes = [];
-        this.searchStore = {};
-    }
-    static arrayOfTrianglesToVertices(triangles, height) {
-        return triangles.map((v) => (isDefAndNotNull(height) ? v
-            .loop()
-            .height(height)
-            .run() : v)
-            .toArrayOfCoords())
-            .flat(2);
-    }
-    static minAreaRectangleSize(poly) {
-        const { first, second, last } = poly.clone().open();
-        return new DPoint(first.distance(second), first.distance(last));
-    }
-    static toDash(poly) {
-        let p = new DPolygon();
-        const result = [p];
-        let trigger = true;
-        for (const point of poly.points) {
-            if (trigger) {
-                p.push(point.clone());
-            }
-            if (point.properties.pieceBorder) {
-                trigger = !trigger;
-                if (trigger) {
-                    p = new DPolygon();
-                    result.push(p);
-                    p.push(point.clone());
-                }
-            }
-        }
-        return result;
-    }
-    static minAreaRectangleDirection(poly) {
-        const { first, second, last } = poly.clone().open();
-        if (!first || !second || !last) {
-            return 0;
-        }
-        if (first.distance(second) > first.distance(last)) {
-            return first.findLine(second).getFi();
-        }
-        return first.findLine(last).getFi();
-    }
-    static parseFromWKT(wkt) {
-        const data = wkt.trim().toUpperCase();
-        let res = new DPolygon();
-        if (data.indexOf('POLYGON') === 0) {
-            const regexp = /POLYGON \(\((?<data>(?:(?!\)\)$).)*?)\)\)$/miu;
-            const reg = regexp.exec(data);
-            const [path, ...holes] = reg.groups.data
-                .split('), (')
-                .map((p) => new DPolygon(p.split(', ')
-                .map((pares) => DPoint.parse(pares.split(' ').map(Number)))));
-            if (holes && holes.length) {
-                path.holes = holes;
-            }
-            res = path;
-        }
-        if (data.indexOf('LINESTRING') === 0) {
-            const regexp = /LINESTRING \((?<data>(?:(?!\)$).)*?)\)$/miu;
-            const reg = regexp.exec(data);
-            res = new DPolygon(reg.groups.data
-                .split(', ').map((t) => DPoint.parse(t.split(' ').map(Number))));
-        }
-        if (data.indexOf('POINT') === 0) {
-            res = new DPolygon([DPoint.parseFromWKT(data)]);
-        }
-        return res;
-    }
-    static createSquareBySize(size) {
-        return new DPolygon([DPoint.zero(), size.clone().setX(0), size.clone(), size.clone().setY(0)]).close();
-    }
-    loop() {
-        return new DPolygonLoop(this);
-    }
-    set points(p) {
-        this.pPoints = p;
-    }
-    get points() {
-        return this.pPoints;
-    }
-    get maxX() {
-        return this.reduce((a, r) => Math.max(a, r.x), -Infinity);
-    }
-    get minX() {
-        return this.reduce((a, r) => Math.min(a, r.x), Infinity);
-    }
-    get maxY() {
-        return this.reduce((a, r) => Math.max(a, r.y), -Infinity);
-    }
-    get minY() {
-        return this.reduce((a, r) => Math.min(a, r.y), Infinity);
-    }
-    get innerCenter() {
-        const { center } = this;
-        return this.toTriangles().map((t) => {
-            const c = triangleCenter(t);
-            c.properties.score = Math.min(c.distance(t.at(0)), c.distance(t.at(1)), c.distance(t.at(2))) + c.distance(center);
-            return c;
-        })
-            .sort((a, b) => a.properties.score - b.properties.score)[0];
-    }
-    get center() {
-        return this.leftTop.move(this.size.divide(2));
-    }
-    get h() {
-        return this.maxY - this.minY;
-    }
-    get w() {
-        return this.maxX - this.minX;
-    }
-    get dY() {
-        return this.h;
-    }
-    get dX() {
-        return this.w;
-    }
-    get extend() {
-        const { minX, minY, maxX, maxY } = this;
-        return new DPolygon([
-            new DPoint(minX, minY),
-            new DPoint(maxX, minY),
-            new DPoint(maxX, maxY),
-            new DPoint(minX, maxY),
-            new DPoint(minX, minY)
-        ]);
-    }
-    get size() {
-        const { w, h } = this;
-        return new DPoint(w, h);
-    }
-    get leftTop() {
-        const { minX, minY } = this;
-        return new DPoint(minX, minY);
-    }
-    get minPoint() {
-        return this.leftTop;
-    }
-    get rightBottom() {
-        const { maxX, maxY } = this;
-        return new DPoint(maxX, maxY);
-    }
-    get maxPoint() {
-        return this.rightBottom;
-    }
-    get length() {
-        return this.pPoints.length;
-    }
-    get fullLength() {
-        return this.clone().open().perimeter;
-    }
-    get perimeter() {
-        let p = 0;
-        for (const [p1, p2] of this.loopPointsGenerator()()) {
-            p += p1.distance(p2);
-        }
-        return p;
-    }
-    get area() {
-        let sum = 0;
-        for (const [{ x, y }, { x: a, y: b }] of this.deintersection.loopPointsGenerator()()) {
-            sum += x * b - y * a;
-        }
-        return Math.abs(sum / 2) - this.holes.reduce((a, hole) => a + hole.area, 0);
-    }
-    get filledDeintersection() {
-        const p = this.clone().deintersection.removeDuplicates().clockWise.open();
-        const findSameCorners = (startIndex = 0) => {
-            const store = {};
-            for (let i = startIndex; i < p.length; i++) {
-                const key = p.at(i).toString();
-                if (typeof store[key] === 'number') {
-                    return [store[key], i];
-                }
-                store[key] = i;
-            }
-            return undefined;
-        };
-        let indexes = findSameCorners();
-        const holes = [];
-        while (indexes) {
-            const a = new DPolygon(p.clone().removePart(indexes[0], indexes[1] - indexes[0]));
-            if (a.isClockwise) {
-                indexes = findSameCorners(indexes[0] + 1);
-            }
-            else {
-                holes.push(a.close());
-                p.removePart(indexes[0], indexes[1] - indexes[0]);
-                indexes = findSameCorners();
-            }
-        }
-        p.holes = holes;
-        return p.close();
-    }
-    get deintersection() {
-        let p = this.clone().close();
-        const store = {};
-        for (let i = 0; i < p.length - 1; i++) {
-            const k = p.at(i).toString();
-            store[k] = store[k] || [];
-            store[k].push(i);
-            for (let j = i + 2; j < p.length - 1; j++) {
-                const firstLine = p.at(i).findLine(p.at(i + 1));
-                const secondLine = p.at(j).findLine(p.at(j + 1));
-                const intersectionPoint = firstLine.intersection(secondLine);
-                if (intersectionPoint &&
-                    ![...firstLine.points, ...secondLine.points].some((t) => t.like(intersectionPoint))) {
-                    const part = p.removePart(i, j - i).reverse();
-                    p.insertAfter(i, ...part);
-                    p.insertAfter(j, intersectionPoint);
-                    p.insertAfter(i, intersectionPoint);
-                }
-            }
-        }
-        for (const key of Object.keys(store)) {
-            const record = store[key];
-            if (record.length > 1) {
-                for (let j = record.length - 1; j > 0; j--) {
-                    const origin = p.clone();
-                    const d = record[j] - record[j - 1];
-                    if (d > 1) {
-                        const part = new DPolygon(origin.removePart(record[j - 1], d));
-                        const allInside = part.reduce((a, e) => a && containCalculator(origin, e), true);
-                        if (allInside && origin.isClockwise === part.isClockwise) {
-                            origin.insertAfter(record[j - 1] - 1, ...part.reverse().points);
-                            p = origin;
-                        }
-                    }
-                }
-            }
-        }
-        return p;
-    }
-    get valid() {
-        return this.length > MIN_POINTS_IN_VALID_POLYGON;
-    }
-    get first() {
-        return this.at(0);
-    }
-    get second() {
-        return this.at(1);
-    }
-    get last() {
-        return this.at(this.length - 1);
-    }
-    get minAreaRectangle() {
-        const p = this.convex;
-        let resultPolygon = new DPolygon();
-        let resultArea = Infinity;
-        for (const [, , l] of p.loopPointsGenerator(true)()) {
-            let maxWidth = 0;
-            let maxWidthPoint1 = null;
-            let maxWidthPoint2 = null;
-            let maxHeight = 0;
-            let maxHeightPoint = null;
-            for (const [z, , , i] of p.loopPointsGenerator()()) {
-                const p1 = l.findPoint(l.findPerpendicular(z));
-                const h = p1.distance(z);
-                if (h >= maxHeight) {
-                    maxHeight = h;
-                    maxHeightPoint = z;
-                }
-                for (let j = i; j < p.length - 1; j++) {
-                    const p2 = l.findPoint(l.findPerpendicular(p.at(j)));
-                    const w = p1.distance(p2);
-                    if (w >= maxWidth) {
-                        maxWidth = w;
-                        maxWidthPoint1 = p1;
-                        maxWidthPoint2 = p2;
-                    }
-                }
-            }
-            if (!maxWidthPoint1 || !maxWidthPoint2 || !maxHeightPoint) {
-                continue;
-            }
-            const widthLine = maxWidthPoint1.findLine(maxWidthPoint2);
-            const perpendicular1 = widthLine.findPerpendicular(maxWidthPoint1);
-            const perpendicular2 = widthLine.findPerpendicular(maxWidthPoint2);
-            const tempPolygon = new DPolygon([
-                maxWidthPoint1,
-                maxWidthPoint2,
-                perpendicular2.findPoint(perpendicular2.findPerpendicular(maxHeightPoint)),
-                perpendicular1.findPoint(perpendicular1.findPerpendicular(maxHeightPoint))
-            ]).close();
-            if (tempPolygon.area < resultArea) {
-                resultPolygon = tempPolygon;
-                resultArea = tempPolygon.area;
-            }
-        }
-        return resultPolygon;
-    }
-    get convex() {
-        let p = this.clone().open();
-        const { isClockwise } = p;
-        if (!isClockwise) {
-            p.reverse();
-        }
-        let l = 0;
-        do {
-            const p1 = p.last;
-            const p2 = p.first;
-            const p3 = p.second;
-            const d = p2.findInnerAngle(p1, p3);
-            if (d > Math.PI || DNumbers.likeZero(DNumbers.rad2Deg(d)) || DNumbers.likePI(d) || DNumbers.like2PI(d)) {
-                p.removePart(-1, 1);
-            }
-            else {
-                break;
-            }
-        } while (p.length);
-        p.close();
-        let iteration = 0;
-        do {
-            p = p.deintersection;
-            l = p.length;
-            for (let i = 1; i < p.length - 1; i++) {
-                const p1 = p.at(i - 1);
-                const p2 = p.at(i);
-                const p3 = p.at(i + 1);
-                const d = p2.findInnerAngle(p1, p3);
-                if (d > Math.PI || DNumbers.likeZero(DNumbers.rad2Deg(d)) || DNumbers.likePI(d) || DNumbers.like2PI(d)) {
-                    p.removePart(--i, 1);
-                }
-            }
-            iteration++;
-        } while (p.length !== l && iteration < MAX_CONVEX_ITERATIONS);
-        if (!isClockwise) {
-            p.reverse();
-        }
-        return p;
-    }
-    get isClockwise() {
-        let sum = 0;
-        for (const [{ x, y }, { x: a, y: b }] of this.clone().close()
-            .loopPointsGenerator()()) {
-            sum += (a - x) * (b + y);
-        }
-        return sum < 0;
-    }
-    get clockWise() {
-        if (this.isClockwise) {
-            return this.clone();
-        }
-        return this.clone().reverse();
-    }
-    get noHoles() {
-        const res = this.clone();
-        res.holes = [];
-        return res;
-    }
-    reduce(f, v) {
-        return this.pPoints.reduce(f, v);
-    }
-    intersection(l, includeOnly = false) {
-        const res = [];
-        for (const [, , line] of this.loopPointsGenerator(true)()) {
-            const intersect = line.intersection(l, 0, includeOnly);
-            if (intersect) {
-                res.push(intersect);
-            }
-        }
-        return res;
-    }
-    setCenter(newCenter) {
-        return this.loop()
-            .move(newCenter.clone().move(this.center.minus()))
-            .run();
-    }
-    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.mapArray((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
-                .join(', ')})${h})`;
-        }
-        return `LINESTRING (${this.mapArray((r) => `${r.x} ${r.y}${withZ ? ` ${r.z}` : ''}`)
-            .join(', ')})`;
-    }
-    filter(f) {
-        this.pPoints = this.pPoints.filter(f);
-        return this;
-    }
-    map(f) {
-        this.pPoints = this.mapArray(f);
-        this.holes = this.holes.map((h) => h.map(f));
-        return this;
-    }
-    mapArray(f) {
-        return this.pPoints.map(f);
-    }
-    sort(f) {
-        this.points.sort(f);
-        return this;
-    }
-    at(index) {
-        const { length } = this;
-        return this.points[(index % length + length) % length];
-    }
-    pop() {
-        return this.pPoints.pop();
-    }
-    push(...args) {
-        return this.pPoints.push(...args);
-    }
-    shift() {
-        return this.pPoints.shift();
-    }
-    unshift(...args) {
-        return this.pPoints.unshift(...args);
-    }
-    reverse() {
-        this.pPoints = this.pPoints.reverse();
-        this.holes = this.holes.map((h) => h.reverse());
-        return this;
-    }
-    getValue() {
-        return (this.pPoints.map((r) => r.getValue()) + this.holes
-            .reduce((a, h) => a + h.getValue(), ''));
-    }
-    toString() {
-        return `(${this.mapArray((r) => r.toString()).join(', ')})`;
-    }
-    close() {
-        const p0 = this.first;
-        if (p0 && !this.closed) {
-            this.push(p0.clone());
-        }
-        return this;
-    }
-    open() {
-        const p = this.first;
-        if (this.length > 2 && p && this.closed) {
-            this.pop();
-        }
-        return this;
-    }
-    add(poly) {
-        const res = new DPolygon([...this.points, ...poly.points]).close();
-        res.holes = [...this.holes, ...poly.holes].map((h) => h.clone());
-        return res;
-    }
-    has(p) {
-        return this.pPoints.some((q) => q.equal(p));
-    }
-    clone() {
-        const res = new DPolygon(this.points.map((r) => r.clone()));
-        res.holes = this.holes.map((h) => h.clone());
-        res.properties = Object.assign({}, this.properties);
-        return res;
-    }
-    equal(p) {
-        if (!(p instanceof DPolygon)) {
-            return false;
-        }
-        if (this.length !== p.length || this.holes.length !== p.holes.length) {
-            return false;
-        }
-        return (this.same(p) &&
-            this.holes.reduce((a, hole) => a && p.holes.some((pHoles) => pHoles.same(hole)), true));
-    }
-    same(p) {
-        const pClone = p.clone().close();
-        const thisAsString = this.clone()
-            .close()
-            .toString();
-        for (let i = 0; i < pClone.length; i++) {
-            if (thisAsString === pClone.toString() || thisAsString === pClone.clone().reverse()
-                .toString()) {
-                return true;
-            }
-            pClone.nextStart();
-        }
-        return false;
-    }
-    findIndex(a) {
-        if (a instanceof DPoint) {
-            return this.points.findIndex((t) => t.equal(a));
-        }
-        return this.points.findIndex(a);
-    }
-    approximation(e = Math.sqrt(this.perimeter) * APPROXIMATION_VALUE) {
-        return new DPolygon(this.clone().douglasPeucker(this.pPoints, e));
-    }
-    insertAfter(index, ...points) {
-        this.pPoints.splice(index + 1, 0, ...points);
-    }
-    removePart(index, count) {
-        return this.pPoints.splice(index + 1, count);
-    }
-    hasSimpleIntersection(p) {
-        const extend1 = this.extend;
-        const extend2 = p.extend;
-        const extend1points = extend1.points;
-        const extend2points = extend2.points;
-        const in1 = extend1points.some((t) => extend2.simpleInclude(t));
-        const in2 = extend2points.some((t) => extend1.simpleInclude(t));
-        return in1 || in2;
-    }
-    simpleInclude(p) {
-        return this.simpleIncludeX(p) && this.simpleIncludeY(p);
-    }
-    drawPolygonOnCanvas(canvas, fillColor, strokeColor, shadowColor, lineWidth = 1, steps = this.length - 1) {
-        if (this.length > 1) {
-            const ctx = canvas.getContext('2d');
-            if (fillColor) {
-                ctx.fillStyle = fillColor;
-            }
-            if (strokeColor) {
-                ctx.strokeStyle = strokeColor;
-            }
-            if (lineWidth) {
-                ctx.lineWidth = lineWidth;
-            }
-            if (fillColor || strokeColor) {
-                ctx.beginPath();
-            }
-            this.goByPath(ctx, steps % this.length);
-            if (shadowColor) {
-                ctx.shadowColor = shadowColor;
-                ctx.shadowBlur = 0;
-                ctx.shadowOffsetX = 1;
-                ctx.shadowOffsetY = 1;
-            }
-            if (fillColor) {
-                ctx.closePath();
-                ctx.fill();
-            }
-            if (strokeColor) {
-                ctx.stroke();
-            }
-        }
-        return this;
-    }
-    clearPolygonOnCanvas(canvas) {
-        const ctx = canvas.getContext('2d');
-        const old = ctx.globalCompositeOperation;
-        ctx.globalCompositeOperation = 'destination-out';
-        this.goByPath(ctx);
-        ctx.fill();
-        ctx.globalCompositeOperation = old;
-    }
-    contain(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 (const [{ x, y }, { x: a, y: b }] of poly.loopPointsGenerator()()) {
-            const line1 = new DLine(x - p.x, y - p.y, 0);
-            const line2 = new DLine(a - p.x, b - p.y, 0);
-            const fiDif = line1.findFi(line2);
-            if (line1.vectorProduct(line2).c > 0) {
-                totalFi += fiDif;
-            }
-            else {
-                totalFi -= fiDif;
-            }
-        }
-        const eps = Math.PI / 10000;
-        const absTotalFi = Math.abs(totalFi);
-        if (absTotalFi < eps) {
-            return false;
-        }
-        else if (Math.abs(2 * Math.PI - absTotalFi) < eps) {
-            return true;
-        }
-        throw new Error('contains2 faild');
-    }
-    onBorder(p) {
-        const simpleInclude = this.simpleInclude(p);
-        if (simpleInclude) {
-            const poly = this.deintersection;
-            const hasSamePoint = this.points.some((point) => point.equal(p));
-            if (hasSamePoint) {
-                return true;
-            }
-            for (const [, , polygonLine] of poly.loopPointsGenerator(true)()) {
-                const onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
-                if (onBorder) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    nextStart() {
-        this.open();
-        this.push(this.shift());
-        this.close();
-        return this;
-    }
-    removeDuplicates() {
-        for (let i = 0; i < this.length - 1; i++) {
-            const p1 = this.at(i);
-            const p2 = this.at(i + 1);
-            if (p1.equal(p2)) {
-                this.removePart(i, 1);
-                i--;
-            }
-        }
-        return this;
-    }
-    static toGeoJSONFeatureCollection(polygons, format = DGeo.parseFormat) {
-        return {
-            type: 'FeatureCollection',
-            features: polygons.map((polygon) => polygon.toGeoJSONFeature(format))
-        };
-    }
-    static parse(a, format = DGeo.parseFormat) {
-        if (a.type) {
-            switch (a.type) {
-                case 'FeatureCollection':
-                    return a.features.reduce((ak, f) => {
-                        const t = DPolygon.parse(f, format);
-                        if (Array.isArray(t)) {
-                            ak.push(...t);
-                        }
-                        else {
-                            ak.push(t);
-                        }
-                        return ak;
-                    }, []);
-                case 'Feature': {
-                    const t = DPolygon.parse(a.geometry, format);
-                    const props = Object.assign(Object.assign({}, a.properties), (a.id ? ({
-                        id: a.id
-                    }) : ({})));
-                    if (Array.isArray(t)) {
-                        t.forEach((record) => {
-                            record.properties = Object.assign({}, props);
-                        });
-                    }
-                    else {
-                        t.properties = Object.assign({}, props);
-                    }
-                    return t;
-                }
-                case 'LineString':
-                case 'MultiPoint':
-                    return new DPolygon(a.coordinates.map((c) => DPoint.parse(c, format)));
-                case 'Polygon':
-                    return a.coordinates.reduce((ak, line, index) => {
-                        if (index === 0) {
-                            ak.points = line.map((c) => DPoint.parse(c, format));
-                        }
-                        else {
-                            ak.holes.push(new DPolygon(line.map((c) => DPoint.parse(c, format))));
-                        }
-                        return ak;
-                    }, new DPolygon());
-                case 'MultiLineString':
-                    return a.coordinates.reduce((ak, line) => {
-                        ak.push(new DPolygon(line.map((c) => DPoint.parse(c, format))));
-                        return ak;
-                    }, []);
-                case 'MultiPolygon':
-                    return a.coordinates.reduce((ak, coordinates) => {
-                        ak.push(DPolygon.parse({
-                            type: 'Polygon',
-                            coordinates
-                        }, format));
-                        return ak;
-                    }, []);
-                case 'GeometryCollection':
-                    return a.geometries.reduce((ak, line) => {
-                        ak.push(DPolygon.parse(line, format));
-                        return ak;
-                    }, []);
-                default:
-            }
-        }
-        return new DPolygon(a
-            .map((r) => DPoint.parse(r, format)));
-    }
-    toArrayOfCoords(format = DGeo.parseFormat) {
-        return this.mapArray((r) => r.toCoords(format));
-    }
-    toGeoJSONFeature(format = DGeo.parseFormat) {
-        return {
-            type: 'Feature',
-            properties: Object.assign({}, this.properties),
-            geometry: this.toGeoJSON(format)
-        };
-    }
-    toGeoJSON(format = DGeo.parseFormat) {
-        if (this.closed) {
-            return {
-                type: 'Polygon',
-                coordinates: [
-                    this.toArrayOfCoords(format),
-                    ...this.holes.map((h) => h.toArrayOfCoords(format))
-                ]
-            };
-        }
-        return {
-            type: 'LineString',
-            coordinates: this.toArrayOfCoords(format)
-        };
-    }
-    divideToPieces(piecesCount, withAltitude = false) {
-        const { fullLength } = this;
-        const pieceLength = fullLength / piecesCount;
-        let currentPieceLength = pieceLength;
-        for (const [p1, p2, , i] of this.loopPointsGenerator()()) {
-            const d = p1.distance(p2);
-            if (d === currentPieceLength) {
-                p2.properties.pieceBorder = true;
-                currentPieceLength = pieceLength;
-            }
-            else if (d - currentPieceLength > 0) {
-                const circle = new DCircle(p1, currentPieceLength);
-                const line = p1.findLine(p2);
-                const intersectionPoint = line.intersectionWithCircle(circle)
-                    .filter((p) => line.inRange(p, CLOSE_TO_INTERSECTION_DISTANCE))[0];
-                intersectionPoint.properties.pieceBorder = true;
-                this.insertAfter(i, intersectionPoint);
-                if (withAltitude) {
-                    const p1z = p1.z;
-                    intersectionPoint.z = p1z - (p1z - p2.z) * (p1.distance(intersectionPoint) / d);
-                }
-                currentPieceLength = pieceLength;
-            }
-            else {
-                currentPieceLength -= d;
-            }
-        }
-        return this;
-    }
-    prepareToFastSearch() {
-        this.searchStore = {};
-        for (const { x, y, z } of this.points) {
-            if (!this.searchStore[x]) {
-                this.searchStore[x] = {};
-            }
-            if (!this.searchStore[x][y]) {
-                this.searchStore[x][y] = {};
-            }
-            this.searchStore[x][y][z || 'undefined'] = true;
-        }
-    }
-    fastHas({ x, y, z }) {
-        if (!this.searchStore[x]) {
-            return false;
-        }
-        if (!this.searchStore[x][y]) {
-            return false;
-        }
-        if (!this.searchStore[x][y][z || 'undefined']) {
-            return false;
-        }
-        return this.searchStore[x][y][z || 'undefined'];
-    }
-    get growingPiecesGenerator() {
-        const polygon = this;
-        return function* () {
-            const r = new DPolygon();
-            for (const p of polygon.pPoints) {
-                r.push(p);
-                if (p.properties.pieceBorder) {
-                    yield r.clone();
-                }
-            }
-            return r.clone();
-        };
-    }
-    simpleUnion(p) {
-        try {
-            const res = this.simpleLogicFunction(p, true, true);
-            if (res === null) {
-                return null;
-            }
-            if (res instanceof DPolygon) {
-                return res;
-            }
-            return null;
-        }
-        catch (ex) {
-            return null;
-        }
-    }
-    simpleIntersection(p) {
-        return this.simpleLogicFunction(p, false, false);
-    }
-    simpleDifference(p) {
-        return this.simpleLogicFunction(p, true, false);
-    }
-    smartUnion(p) {
-        const res = this.clone().simpleUnion(p);
-        if (res) {
-            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)) {
-                        continue;
-                    }
-                    const r = a.simpleUnion(b);
-                    if (r) {
-                        allHoles = allHoles.filter((v) => !v.equal(a) && !v.equal(b));
-                        allHoles.push(r);
-                    }
-                }
-            }
-            res.holes = allHoles;
-        }
-        return res;
-    }
-    toTriangles() {
-        const q = this.clone().removeDuplicates()
-            .open();
-        if (q.length < 3) {
-            return [];
-        }
-        if (q.length === 3) {
-            return [q];
-        }
-        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 new DPolygon([
-                        p0.clone(),
-                        p1.clone(),
-                        p2.clone()
-                    ]);
-                }
-                poly.push(poly.shift());
-            }
-            return undefined;
-        };
-        const p = this.clone().removeDuplicates().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);
-        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 jstsIo.WKTReader();
-        const { noHoles, closed } = this;
-        const points = reader
-            .read(noHoles.toWKT(closed ? DPolygon.WKT_POLYGON : DPolygon.WKT_LINESTRING))
-            .buffer(v, quadrantSegments, type)
-            .getCoordinates();
-        return new DPolygon(points.map(({ x, y }) => new DPoint(x, y)));
-    }
-    sideBuffers(v, quadrantSegments = 64) {
-        const { first, last } = this;
-        const buffer = this.buffer(v, quadrantSegments, DPolygon.CAP_FLAT).open();
-        const [start0, start1] = first.sortByDistance(buffer).points.map((r) => r.properties.index);
-        const [end0, end1] = last.sortByDistance(buffer).points.map((r) => r.properties.index);
-        const fromPoint = Math.min(Math.max(start0, start1), Math.max(end0, end1));
-        const toPoint = Math.max(Math.min(start0, start1), Math.min(end0, end1));
-        const linePart = new DPolygon(buffer.removePart(fromPoint - 1, toPoint - fromPoint + 1));
-        buffer.unshift(buffer.pop());
-        return [linePart.reverse(), buffer];
-    }
-    setProperties(v) {
-        this.properties = typeof v === 'object' ? v : v(this);
-        return this;
-    }
-    bezier(step = 0.1) {
-        const res = new DPolygon();
-        for (let i = 0; i < 1; i += step) {
-            res.push(this.clone().getBezierPoint(i));
-        }
-        return res;
-    }
-    setGrowingHeight(from, to) {
-        const { fullLength } = this;
-        let { first: prevPoint } = this;
-        const d = to - from;
-        let currentDistance = 0;
-        this.loop()
-            .setZ((p) => {
-            currentDistance += prevPoint.distance(p);
-            prevPoint = p;
-            return from + currentDistance / fullLength * d;
-        })
-            .run();
-        return this;
-    }
-    loopPointsGenerator(withLine = false) {
-        const that = this;
-        return function* () {
-            for (let i = 0; i < that.length - 1; i++) {
-                const p1 = that.at(i);
-                const p2 = that.at(i + 1);
-                yield [p1, p2, withLine ? p1.findLine(p2) : undefined, i];
-            }
-        };
-    }
-    getBezierPoint(v) {
-        if (this.length === 1) {
-            return this.first;
-        }
-        for (const [p1, p2] of this.loopPointsGenerator()()) {
-            p1.move(p2.clone().move(p1.clone().minus())
-                .scale(v));
-        }
-        this.pop();
-        return this.getBezierPoint(v);
-    }
-    simpleIncludeX(p) {
-        const { x } = p;
-        return this.minX <= x && this.maxX >= x;
-    }
-    simpleIncludeY(p) {
-        const { y } = p;
-        return this.minY <= y && this.maxY >= y;
-    }
-    douglasPeucker(points, e) {
-        let dMax = 0;
-        let index = 0;
-        const end = points.length - 1;
-        const line = points[0].findLine(points[end]);
-        for (let i = 1; i < end; i++) {
-            const d = line.perpendicularDistance(points[i]);
-            if (d > dMax) {
-                index = i;
-                dMax = d;
-            }
-        }
-        if (dMax >= e) {
-            const recResult1 = this.douglasPeucker(points.slice(0, index + 1), e);
-            const recResult2 = this.douglasPeucker(points.slice(index), e);
-            recResult1.pop();
-            return [...recResult1, ...recResult2];
-        }
-        return [points[0], points[end]];
-    }
-    goByPath(ctx, steps = this.length - 1) {
-        const start = this.first;
-        ctx.moveTo(start.x, start.y);
-        for (let i = 1; i <= (steps % this.length); i++) {
-            const { x, y } = this.at(i);
-            ctx.lineTo(x, y);
-        }
-    }
-    getJSTSGeometry(p, unionThis, unionThat) {
-        const unionOrIntersection = unionThat === unionThis;
-        const reader = new jstsIo.WKTReader();
-        const a = reader.read(this.noHoles.toWKT());
-        const b = reader.read(p.noHoles.toWKT());
-        if (!unionOrIntersection) {
-            return a.difference(b);
-        }
-        else if (unionThis) {
-            return a.union(b);
-        }
-        else if (!unionThis) {
-            return a.intersection(b);
-        }
-        return undefined;
-    }
-    simpleLogicFunction(p, unionThis, unionThat) {
-        const c = this.getJSTSGeometry(p, unionThis, unionThat);
-        if (c) {
-            const coordinates = c.getCoordinates();
-            if (coordinates.length) {
-                let result = coordinates.reduce((ak, { x, y }, index) => {
-                    const lastIndex = ak.length - 1;
-                    const t = new DPoint(x, y);
-                    const { first } = ak[lastIndex];
-                    if (t.equal(first)) {
-                        if (coordinates[index + 1]) {
-                            const nextPoint = new DPoint(coordinates[index + 1].x, coordinates[index + 1].y);
-                            if (ak[lastIndex].length > 1) {
-                                ak.push(new DPolygon([nextPoint]));
-                            }
-                        }
-                    }
-                    else {
-                        ak[lastIndex].push(t);
-                    }
-                    return ak;
-                }, [new DPolygon([new DPoint(coordinates[0].x, coordinates[0].y)])]);
-                if (unionThat && unionThis && result.length > 1) {
-                    for (const q of result) {
-                        for (const r of result) {
-                            if (q.has(r.first) && !q.equal(r)) {
-                                const index = q.findIndex(r.first);
-                                q.points.splice(index, 0, ...r.points);
-                                result = result.filter((h) => !h.equal(r));
-                                continue;
-                            }
-                            if (result.length < 2) {
-                                break;
-                            }
-                        }
-                        if (result.length < 2) {
-                            break;
-                        }
-                    }
-                }
-                result = result.filter((h) => h.length > 2).map((h) => h.close());
-                for (const q of result) {
-                    for (const r of result) {
-                        if (result.length < 2) {
-                            break;
-                        }
-                        if (!q.equal(r)) {
-                            if (q.contain(r.first, true)) {
-                                q.holes.push(r);
-                                result = result.filter((h) => !h.equal(r));
-                            }
-                        }
-                    }
-                    if (result.length < 2) {
-                        break;
-                    }
-                }
-                if (result.length === 0) {
-                    return null;
-                }
-                if (result.length === 1) {
-                    return result[0].close();
-                }
-                return result.map((g) => g.close());
-            }
-        }
-        return null;
-    }
-}
-DPolygon.CAP_ROUND = CAP_ROUND;
-DPolygon.CAP_FLAT = CAP_FLAT;
-DPolygon.CAP_SQUARE = CAP_SQUARE;
-DPolygon.WKT_LINESTRING = 'LINESTRING';
-DPolygon.WKT_POLYGON = 'POLYGON';