dgeoutils 2.4.48 → 2.5.0

package/dist/cjs/DPolygon.js

@@ -0,0 +1,1774 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DPolygon = exports.MIN_POINTS_IN_VALID_POLYGON = void 0;
+var DPoint_1 = require("./DPoint");
+var DLine_1 = require("./DLine");
+var DCircle_1 = require("./DCircle");
+var DNumbers_1 = require("./DNumbers");
+var jsts_1 = require("jsts");
+var DPolygonLoop_1 = require("./DPolygonLoop");
+var utils_1 = require("./utils");
+var _a = jsts_1.operation.buffer.BufferParameters, CAP_ROUND = _a.CAP_ROUND, CAP_FLAT = _a.CAP_FLAT, CAP_SQUARE = _a.CAP_SQUARE;
+exports.MIN_POINTS_IN_VALID_POLYGON = 3;
+var APPROXIMATION_VALUE = 0.1;
+var MAX_CONVEX_ITERATIONS = 100;
+var CLOSE_TO_INTERSECTION_DISTANCE = 0.001;
+var triangleCenter = function (triangle) {
+    var p0 = triangle.at(0);
+    var p1 = triangle.at(1);
+    var p2 = triangle.at(2);
+    return new DPoint_1.DPoint((p0.x + p1.x + p2.x) / 3, (p0.y + p1.y + p2.y) / 3);
+};
+var containCalculator = function (poly, p) {
+    var e_1, _a, e_2, _b;
+    var hasSamePoint = poly.points.some(function (point) { return point.equal(p); });
+    if (hasSamePoint) {
+        return true;
+    }
+    try {
+        for (var _c = __values(poly.loopPointsGenerator(true)()), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var _e = __read(_d.value, 3), polygonLine = _e[2];
+            var onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
+            if (onBorder) {
+                return true;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var totalFi = 0;
+    try {
+        for (var _f = __values(poly.loopPointsGenerator()()), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var _h = __read(_g.value, 2), _j = _h[0], x = _j.x, y = _j.y, _k = _h[1], a = _k.x, b = _k.y;
+            var line1 = new DLine_1.DLine(x - p.x, y - p.y, 0);
+            var line2 = new DLine_1.DLine(a - p.x, b - p.y, 0);
+            var fiDif = line1.findFi(line2);
+            if (line1.vectorProduct(line2).c > 0) {
+                totalFi += fiDif;
+            }
+            else {
+                totalFi -= fiDif;
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    var eps = Math.PI / 10000;
+    var result = false;
+    var 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;
+};
+var DPolygon = (function () {
+    function DPolygon(pPoints) {
+        if (pPoints === void 0) { pPoints = []; }
+        this.pPoints = pPoints;
+        this.properties = {};
+        this.holes = [];
+        this.searchStore = {};
+    }
+    DPolygon.arrayOfTrianglesToVertices = function (triangles, height) {
+        return triangles.map(function (v) { return ((0, utils_1.isDefAndNotNull)(height) ? v
+            .loop()
+            .height(height)
+            .run() : v)
+            .toArrayOfCoords(); })
+            .flat(2);
+    };
+    DPolygon.minAreaRectangleSize = function (poly) {
+        var _a = poly.clone().open(), first = _a.first, second = _a.second, last = _a.last;
+        return new DPoint_1.DPoint(first.distance(second), first.distance(last));
+    };
+    DPolygon.toDash = function (poly) {
+        var e_3, _a;
+        var p = new DPolygon();
+        var result = [p];
+        var trigger = true;
+        try {
+            for (var _b = __values(poly.points), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var point = _c.value;
+                if (trigger) {
+                    p.push(point.clone());
+                }
+                if (point.properties.pieceBorder) {
+                    trigger = !trigger;
+                    if (trigger) {
+                        p = new DPolygon();
+                        result.push(p);
+                        p.push(point.clone());
+                    }
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return result;
+    };
+    DPolygon.minAreaRectangleDirection = function (poly) {
+        var _a = poly.clone().open(), first = _a.first, second = _a.second, last = _a.last;
+        if (!first || !second || !last) {
+            return 0;
+        }
+        if (first.distance(second) > first.distance(last)) {
+            return first.findLine(second).getFi();
+        }
+        return first.findLine(last).getFi();
+    };
+    DPolygon.parseFromWKT = function (wkt) {
+        var data = wkt.trim().toUpperCase();
+        var res = new DPolygon();
+        if (data.indexOf('POLYGON') === 0) {
+            var regexp = /POLYGON \(\((?<data>(?:(?!\)\)$).)*?)\)\)$/miu;
+            var reg = regexp.exec(data);
+            var _a = __read(reg.groups.data
+                .split('), (')
+                .map(function (p) { return new DPolygon(p.split(', ')
+                .map(function (pares) { return DPoint_1.DPoint.parse(pares.split(' ').map(Number)); })); })), path = _a[0], holes = _a.slice(1);
+            if (holes && holes.length) {
+                path.holes = holes;
+            }
+            res = path;
+        }
+        if (data.indexOf('LINESTRING') === 0) {
+            var regexp = /LINESTRING \((?<data>(?:(?!\)$).)*?)\)$/miu;
+            var reg = regexp.exec(data);
+            res = new DPolygon(reg.groups.data
+                .split(', ').map(function (t) { return DPoint_1.DPoint.parse(t.split(' ').map(Number)); }));
+        }
+        if (data.indexOf('POINT') === 0) {
+            res = new DPolygon([DPoint_1.DPoint.parseFromWKT(data)]);
+        }
+        return res;
+    };
+    DPolygon.createSquareBySize = function (size) {
+        return new DPolygon([DPoint_1.DPoint.zero(), size.clone().setX(0), size.clone(), size.clone().setY(0)]).close();
+    };
+    DPolygon.prototype.loop = function () {
+        return new DPolygonLoop_1.DPolygonLoop(this);
+    };
+    Object.defineProperty(DPolygon.prototype, "points", {
+        get: function () {
+            return this.pPoints;
+        },
+        set: function (p) {
+            this.pPoints = p;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "maxX", {
+        get: function () {
+            return this.reduce(function (a, r) { return Math.max(a, r.x); }, -Infinity);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "minX", {
+        get: function () {
+            return this.reduce(function (a, r) { return Math.min(a, r.x); }, Infinity);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "maxY", {
+        get: function () {
+            return this.reduce(function (a, r) { return Math.max(a, r.y); }, -Infinity);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "minY", {
+        get: function () {
+            return this.reduce(function (a, r) { return Math.min(a, r.y); }, Infinity);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "innerCenter", {
+        get: function () {
+            var center = this.center;
+            return this.toTriangles().map(function (t) {
+                var 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(function (a, b) { return a.properties.score - b.properties.score; })[0];
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "center", {
+        get: function () {
+            return this.leftTop.move(this.size.divide(2));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "h", {
+        get: function () {
+            return this.maxY - this.minY;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "w", {
+        get: function () {
+            return this.maxX - this.minX;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "dY", {
+        get: function () {
+            return this.h;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "dX", {
+        get: function () {
+            return this.w;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "extend", {
+        get: function () {
+            var _a = this, minX = _a.minX, minY = _a.minY, maxX = _a.maxX, maxY = _a.maxY;
+            return new DPolygon([
+                new DPoint_1.DPoint(minX, minY),
+                new DPoint_1.DPoint(maxX, minY),
+                new DPoint_1.DPoint(maxX, maxY),
+                new DPoint_1.DPoint(minX, maxY),
+                new DPoint_1.DPoint(minX, minY)
+            ]);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "size", {
+        get: function () {
+            var _a = this, w = _a.w, h = _a.h;
+            return new DPoint_1.DPoint(w, h);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "leftTop", {
+        get: function () {
+            var _a = this, minX = _a.minX, minY = _a.minY;
+            return new DPoint_1.DPoint(minX, minY);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "minPoint", {
+        get: function () {
+            return this.leftTop;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "rightBottom", {
+        get: function () {
+            var _a = this, maxX = _a.maxX, maxY = _a.maxY;
+            return new DPoint_1.DPoint(maxX, maxY);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "maxPoint", {
+        get: function () {
+            return this.rightBottom;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "length", {
+        get: function () {
+            return this.pPoints.length;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "fullLength", {
+        get: function () {
+            return this.clone().open().perimeter;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "fullLengthLatLon", {
+        get: function () {
+            return this.clone().open().perimeterLatLon;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "perimeter", {
+        get: function () {
+            var e_4, _a;
+            var p = 0;
+            try {
+                for (var _b = __values(this.loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = __read(_c.value, 2), p1 = _d[0], p2 = _d[1];
+                    p += p1.distance(p2);
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+            return p;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "perimeterLatLon", {
+        get: function () {
+            var e_5, _a;
+            var p = 0;
+            try {
+                for (var _b = __values(this.loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = __read(_c.value, 2), p1 = _d[0], p2 = _d[1];
+                    p += p1.distanceLatLon(p2);
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            return p;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "area", {
+        get: function () {
+            var e_6, _a;
+            var sum = 0;
+            try {
+                for (var _b = __values(this.deintersection.loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = __read(_c.value, 2), _e = _d[0], x = _e.x, y = _e.y, _f = _d[1], a = _f.x, b = _f.y;
+                    sum += x * b - y * a;
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+            return Math.abs(sum / 2) - this.holes.reduce(function (a, hole) { return a + hole.area; }, 0);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "filledDeintersection", {
+        get: function () {
+            var p = this.clone().deintersection.removeDuplicates().clockWise.open();
+            var findSameCorners = function (startIndex) {
+                if (startIndex === void 0) { startIndex = 0; }
+                var store = {};
+                for (var i = startIndex; i < p.length; i++) {
+                    var key = p.at(i).toString();
+                    if (typeof store[key] === 'number') {
+                        return [store[key], i];
+                    }
+                    store[key] = i;
+                }
+                return undefined;
+            };
+            var indexes = findSameCorners();
+            var holes = [];
+            while (indexes) {
+                var 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();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "deintersection", {
+        get: function () {
+            var e_7, _a;
+            var p = this.clone().close();
+            var store = {};
+            for (var i = 0; i < p.length - 1; i++) {
+                var k = p.at(i).toString();
+                store[k] = store[k] || [];
+                store[k].push(i);
+                var _loop_1 = function (j) {
+                    var firstLine = p.at(i).findLine(p.at(i + 1));
+                    var secondLine = p.at(j).findLine(p.at(j + 1));
+                    var intersectionPoint = firstLine.intersection(secondLine);
+                    if (intersectionPoint &&
+                        !__spreadArray(__spreadArray([], __read(firstLine.points), false), __read(secondLine.points), false).some(function (t) { return t.like(intersectionPoint); })) {
+                        var part = p.removePart(i, j - i).reverse();
+                        p.insertAfter.apply(p, __spreadArray([i], __read(part), false));
+                        p.insertAfter(j, intersectionPoint);
+                        p.insertAfter(i, intersectionPoint);
+                    }
+                };
+                for (var j = i + 2; j < p.length - 1; j++) {
+                    _loop_1(j);
+                }
+            }
+            try {
+                for (var _b = __values(Object.keys(store)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var key = _c.value;
+                    var record = store[key];
+                    if (record.length > 1) {
+                        var _loop_2 = function (j) {
+                            var origin_1 = p.clone();
+                            var d = record[j] - record[j - 1];
+                            if (d > 1) {
+                                var part = new DPolygon(origin_1.removePart(record[j - 1], d));
+                                var allInside = part.reduce(function (a, e) { return a && containCalculator(origin_1, e); }, true);
+                                if (allInside && origin_1.isClockwise === part.isClockwise) {
+                                    origin_1.insertAfter.apply(origin_1, __spreadArray([record[j - 1] - 1], __read(part.reverse().points), false));
+                                    p = origin_1;
+                                }
+                            }
+                        };
+                        for (var j = record.length - 1; j > 0; j--) {
+                            _loop_2(j);
+                        }
+                    }
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+            return p;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "valid", {
+        get: function () {
+            return this.length > exports.MIN_POINTS_IN_VALID_POLYGON;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "first", {
+        get: function () {
+            return this.at(0);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "second", {
+        get: function () {
+            return this.at(1);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "last", {
+        get: function () {
+            return this.at(this.length - 1);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "minAreaRectangle", {
+        get: function () {
+            var e_8, _a, e_9, _b;
+            var p = this.convex;
+            var resultPolygon = new DPolygon();
+            var resultArea = Infinity;
+            try {
+                for (var _c = __values(p.loopPointsGenerator(true)()), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var _e = __read(_d.value, 3), l = _e[2];
+                    var maxWidth = 0;
+                    var maxWidthPoint1 = null;
+                    var maxWidthPoint2 = null;
+                    var maxHeight = 0;
+                    var maxHeightPoint = null;
+                    try {
+                        for (var _f = (e_9 = void 0, __values(p.loopPointsGenerator()())), _g = _f.next(); !_g.done; _g = _f.next()) {
+                            var _h = __read(_g.value, 4), z = _h[0], i = _h[3];
+                            var p1 = l.findPoint(l.findPerpendicular(z));
+                            var h = p1.distance(z);
+                            if (h >= maxHeight) {
+                                maxHeight = h;
+                                maxHeightPoint = z;
+                            }
+                            for (var j = i; j < p.length - 1; j++) {
+                                var p2 = l.findPoint(l.findPerpendicular(p.at(j)));
+                                var w = p1.distance(p2);
+                                if (w >= maxWidth) {
+                                    maxWidth = w;
+                                    maxWidthPoint1 = p1;
+                                    maxWidthPoint2 = p2;
+                                }
+                            }
+                        }
+                    }
+                    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                    finally {
+                        try {
+                            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                        }
+                        finally { if (e_9) throw e_9.error; }
+                    }
+                    if (!maxWidthPoint1 || !maxWidthPoint2 || !maxHeightPoint) {
+                        continue;
+                    }
+                    var widthLine = maxWidthPoint1.findLine(maxWidthPoint2);
+                    var perpendicular1 = widthLine.findPerpendicular(maxWidthPoint1);
+                    var perpendicular2 = widthLine.findPerpendicular(maxWidthPoint2);
+                    var 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;
+                    }
+                }
+            }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+            return resultPolygon;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "convex", {
+        get: function () {
+            var p = this.clone().open();
+            var isClockwise = p.isClockwise;
+            if (!isClockwise) {
+                p.reverse();
+            }
+            var l = 0;
+            do {
+                var p1 = p.last;
+                var p2 = p.first;
+                var p3 = p.second;
+                var d = p2.findInnerAngle(p1, p3);
+                if (d > Math.PI || DNumbers_1.DNumbers.likeZero(DNumbers_1.DNumbers.rad2Deg(d)) || DNumbers_1.DNumbers.likePI(d) || DNumbers_1.DNumbers.like2PI(d)) {
+                    p.removePart(-1, 1);
+                }
+                else {
+                    break;
+                }
+            } while (p.length);
+            p.close();
+            var iteration = 0;
+            do {
+                p = p.deintersection;
+                l = p.length;
+                for (var i = 1; i < p.length - 1; i++) {
+                    var p1 = p.at(i - 1);
+                    var p2 = p.at(i);
+                    var p3 = p.at(i + 1);
+                    var d = p2.findInnerAngle(p1, p3);
+                    if (d > Math.PI || DNumbers_1.DNumbers.likeZero(DNumbers_1.DNumbers.rad2Deg(d)) || DNumbers_1.DNumbers.likePI(d) || DNumbers_1.DNumbers.like2PI(d)) {
+                        p.removePart(--i, 1);
+                    }
+                }
+                iteration++;
+            } while (p.length !== l && iteration < MAX_CONVEX_ITERATIONS);
+            if (!isClockwise) {
+                p.reverse();
+            }
+            return p;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "isClockwise", {
+        get: function () {
+            var e_10, _a;
+            var sum = 0;
+            try {
+                for (var _b = __values(this.clone().close()
+                    .loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = __read(_c.value, 2), _e = _d[0], x = _e.x, y = _e.y, _f = _d[1], a = _f.x, b = _f.y;
+                    sum += (a - x) * (b + y);
+                }
+            }
+            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_10) throw e_10.error; }
+            }
+            return sum < 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "clockWise", {
+        get: function () {
+            if (this.isClockwise) {
+                return this.clone();
+            }
+            return this.clone().reverse();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "noHoles", {
+        get: function () {
+            var res = this.clone();
+            res.holes = [];
+            return res;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DPolygon.prototype.reduce = function (f, v) {
+        return this.pPoints.reduce(f, v);
+    };
+    DPolygon.prototype.intersection = function (l, includeOnly) {
+        var e_11, _a;
+        if (includeOnly === void 0) { includeOnly = false; }
+        var res = [];
+        try {
+            for (var _b = __values(this.loopPointsGenerator(true)()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 3), line = _d[2];
+                var intersect = line.intersection(l, 0, includeOnly);
+                if (intersect) {
+                    res.push(intersect);
+                }
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
+        return res;
+    };
+    DPolygon.prototype.setCenter = function (newCenter) {
+        return this.loop()
+            .move(newCenter.clone().move(this.center.minus()))
+            .run();
+    };
+    DPolygon.prototype.toWKT = function (type, withZ) {
+        if (type === void 0) { type = DPolygon.WKT_POLYGON; }
+        if (withZ === void 0) { withZ = false; }
+        if (type === DPolygon.WKT_POLYGON) {
+            var h = '';
+            if (this.holes && this.holes.length) {
+                h = ", ".concat(this.holes.map(function (hole) { return hole.toString(); })
+                    .join(', '));
+            }
+            return "POLYGON ((".concat(this.deintersection.mapArray(function (r) { return "".concat(r.x, " ").concat(r.y).concat(withZ ? " ".concat(r.z) : ''); })
+                .join(', '), ")").concat(h, ")");
+        }
+        return "LINESTRING (".concat(this.mapArray(function (r) { return "".concat(r.x, " ").concat(r.y).concat(withZ ? " ".concat(r.z) : ''); })
+            .join(', '), ")");
+    };
+    DPolygon.prototype.filter = function (f) {
+        this.pPoints = this.pPoints.filter(f);
+        return this;
+    };
+    DPolygon.prototype.map = function (f) {
+        this.pPoints = this.mapArray(f);
+        this.holes = this.holes.map(function (h) { return h.map(f); });
+        return this;
+    };
+    DPolygon.prototype.mapArray = function (f) {
+        return this.pPoints.map(f);
+    };
+    DPolygon.prototype.sort = function (f) {
+        this.points.sort(f);
+        return this;
+    };
+    DPolygon.prototype.at = function (index) {
+        var length = this.length;
+        return this.points[(index % length + length) % length];
+    };
+    DPolygon.prototype.pop = function () {
+        return this.pPoints.pop();
+    };
+    DPolygon.prototype.push = function () {
+        var _a;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return (_a = this.pPoints).push.apply(_a, __spreadArray([], __read(args), false));
+    };
+    DPolygon.prototype.shift = function () {
+        return this.pPoints.shift();
+    };
+    DPolygon.prototype.unshift = function () {
+        var _a;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        return (_a = this.pPoints).unshift.apply(_a, __spreadArray([], __read(args), false));
+    };
+    DPolygon.prototype.reverse = function () {
+        this.pPoints = this.pPoints.reverse();
+        this.holes = this.holes.map(function (h) { return h.reverse(); });
+        return this;
+    };
+    DPolygon.prototype.getValue = function () {
+        return (this.pPoints.map(function (r) { return r.getValue(); }) + this.holes
+            .reduce(function (a, h) { return a + h.getValue(); }, ''));
+    };
+    DPolygon.prototype.toString = function () {
+        return "(".concat(this.mapArray(function (r) { return r.toString(); }).join(', '), ")");
+    };
+    DPolygon.prototype.close = function () {
+        var p0 = this.first;
+        if (p0 && !this.closed) {
+            this.push(p0.clone());
+        }
+        return this;
+    };
+    DPolygon.prototype.open = function () {
+        var p = this.first;
+        if (this.length > 2 && p && this.closed) {
+            this.pop();
+        }
+        return this;
+    };
+    DPolygon.prototype.add = function (poly) {
+        var res = new DPolygon(__spreadArray(__spreadArray([], __read(this.points), false), __read(poly.points), false)).close();
+        res.holes = __spreadArray(__spreadArray([], __read(this.holes), false), __read(poly.holes), false).map(function (h) { return h.clone(); });
+        return res;
+    };
+    DPolygon.prototype.has = function (p) {
+        return this.pPoints.some(function (q) { return q.equal(p); });
+    };
+    DPolygon.prototype.clone = function () {
+        var res = new DPolygon(this.points.map(function (r) { return r.clone(); }));
+        res.holes = this.holes.map(function (h) { return h.clone(); });
+        res.properties = __assign({}, this.properties);
+        return res;
+    };
+    DPolygon.prototype.equal = function (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(function (a, hole) { return a && p.holes.some(function (pHoles) { return pHoles.same(hole); }); }, true));
+    };
+    DPolygon.prototype.same = function (p) {
+        var pClone = p.clone().close();
+        var thisAsString = this.clone()
+            .close()
+            .toString();
+        for (var i = 0; i < pClone.length; i++) {
+            if (thisAsString === pClone.toString() || thisAsString === pClone.clone().reverse()
+                .toString()) {
+                return true;
+            }
+            pClone.nextStart();
+        }
+        return false;
+    };
+    DPolygon.prototype.findIndex = function (a) {
+        if (a instanceof DPoint_1.DPoint) {
+            return this.points.findIndex(function (t) { return t.equal(a); });
+        }
+        return this.points.findIndex(a);
+    };
+    DPolygon.prototype.approximation = function (e) {
+        if (e === void 0) { e = Math.sqrt(this.perimeter) * APPROXIMATION_VALUE; }
+        return new DPolygon(this.clone().douglasPeucker(this.pPoints, e));
+    };
+    DPolygon.prototype.insertAfter = function (index) {
+        var _a;
+        var points = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            points[_i - 1] = arguments[_i];
+        }
+        (_a = this.pPoints).splice.apply(_a, __spreadArray([index + 1, 0], __read(points), false));
+    };
+    DPolygon.prototype.removePart = function (index, count) {
+        return this.pPoints.splice(index + 1, count);
+    };
+    DPolygon.prototype.hasSimpleIntersection = function (p) {
+        var extend1 = this.extend;
+        var extend2 = p.extend;
+        var extend1points = extend1.points;
+        var extend2points = extend2.points;
+        var in1 = extend1points.some(function (t) { return extend2.simpleInclude(t); });
+        var in2 = extend2points.some(function (t) { return extend1.simpleInclude(t); });
+        return in1 || in2;
+    };
+    DPolygon.prototype.simpleInclude = function (p) {
+        return this.simpleIncludeX(p) && this.simpleIncludeY(p);
+    };
+    DPolygon.prototype.drawPolygonOnCanvas = function (canvas, fillColor, strokeColor, shadowColor, lineWidth, steps) {
+        if (lineWidth === void 0) { lineWidth = 1; }
+        if (steps === void 0) { steps = this.length - 1; }
+        if (this.length > 1) {
+            var 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;
+    };
+    DPolygon.prototype.clearPolygonOnCanvas = function (canvas) {
+        var ctx = canvas.getContext('2d');
+        var old = ctx.globalCompositeOperation;
+        ctx.globalCompositeOperation = 'destination-out';
+        this.goByPath(ctx);
+        ctx.fill();
+        ctx.globalCompositeOperation = old;
+    };
+    DPolygon.prototype.contain = function (p, isBorderInside) {
+        var e_12, _a;
+        if (isBorderInside === void 0) { isBorderInside = false; }
+        var simpleInclude = this.simpleInclude(p);
+        if (!simpleInclude) {
+            return false;
+        }
+        var onBorder = this.onBorder(p);
+        if (onBorder) {
+            return isBorderInside;
+        }
+        var poly = this.deintersection;
+        var totalFi = 0;
+        try {
+            for (var _b = __values(poly.loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), _e = _d[0], x = _e.x, y = _e.y, _f = _d[1], a = _f.x, b = _f.y;
+                var line1 = new DLine_1.DLine(x - p.x, y - p.y, 0);
+                var line2 = new DLine_1.DLine(a - p.x, b - p.y, 0);
+                var fiDif = line1.findFi(line2);
+                if (line1.vectorProduct(line2).c > 0) {
+                    totalFi += fiDif;
+                }
+                else {
+                    totalFi -= fiDif;
+                }
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        var eps = Math.PI / 10000;
+        var 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');
+    };
+    DPolygon.prototype.onBorder = function (p) {
+        var e_13, _a;
+        var simpleInclude = this.simpleInclude(p);
+        if (simpleInclude) {
+            var poly = this.deintersection;
+            var hasSamePoint = this.points.some(function (point) { return point.equal(p); });
+            if (hasSamePoint) {
+                return true;
+            }
+            try {
+                for (var _b = __values(poly.loopPointsGenerator(true)()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = __read(_c.value, 3), polygonLine = _d[2];
+                    var onBorder = polygonLine.x(p).equal(p) && polygonLine.inRange(p);
+                    if (onBorder) {
+                        return true;
+                    }
+                }
+            }
+            catch (e_13_1) { e_13 = { error: e_13_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_13) throw e_13.error; }
+            }
+        }
+        return false;
+    };
+    DPolygon.prototype.nextStart = function () {
+        this.open();
+        this.push(this.shift());
+        this.close();
+        return this;
+    };
+    DPolygon.prototype.removeDuplicates = function () {
+        for (var i = 0; i < this.length - 1; i++) {
+            var p1 = this.at(i);
+            var p2 = this.at(i + 1);
+            if (p1.equal(p2)) {
+                this.removePart(i, 1);
+                i--;
+            }
+        }
+        return this;
+    };
+    DPolygon.toGeoJSONFeatureCollection = function (polygons, format) {
+        if (format === void 0) { format = utils_1.DGeo.parseFormat; }
+        return {
+            type: 'FeatureCollection',
+            features: polygons.map(function (polygon) { return polygon.toGeoJSONFeature(format); })
+        };
+    };
+    DPolygon.parse = function (a, format) {
+        if (format === void 0) { format = utils_1.DGeo.parseFormat; }
+        if (a.type) {
+            switch (a.type) {
+                case 'FeatureCollection':
+                    return a.features.reduce(function (ak, f) {
+                        var t = DPolygon.parse(f, format);
+                        if (Array.isArray(t)) {
+                            ak.push.apply(ak, __spreadArray([], __read(t), false));
+                        }
+                        else {
+                            ak.push(t);
+                        }
+                        return ak;
+                    }, []);
+                case 'Feature': {
+                    var t = DPolygon.parse(a.geometry, format);
+                    var props_1 = __assign(__assign({}, a.properties), (a.id ? ({
+                        id: a.id
+                    }) : ({})));
+                    if (Array.isArray(t)) {
+                        t.forEach(function (record) {
+                            record.properties = __assign({}, props_1);
+                        });
+                    }
+                    else {
+                        t.properties = __assign({}, props_1);
+                    }
+                    return t;
+                }
+                case 'LineString':
+                case 'MultiPoint':
+                    return new DPolygon(a.coordinates.map(function (c) { return DPoint_1.DPoint.parse(c, format); }));
+                case 'Polygon':
+                    return a.coordinates.reduce(function (ak, line, index) {
+                        if (index === 0) {
+                            ak.points = line.map(function (c) { return DPoint_1.DPoint.parse(c, format); });
+                        }
+                        else {
+                            ak.holes.push(new DPolygon(line.map(function (c) { return DPoint_1.DPoint.parse(c, format); })));
+                        }
+                        return ak;
+                    }, new DPolygon());
+                case 'MultiLineString':
+                    return a.coordinates.reduce(function (ak, line) {
+                        ak.push(new DPolygon(line.map(function (c) { return DPoint_1.DPoint.parse(c, format); })));
+                        return ak;
+                    }, []);
+                case 'MultiPolygon':
+                    return a.coordinates.reduce(function (ak, coordinates) {
+                        ak.push(DPolygon.parse({
+                            type: 'Polygon',
+                            coordinates: coordinates
+                        }, format));
+                        return ak;
+                    }, []);
+                case 'GeometryCollection':
+                    return a.geometries.reduce(function (ak, line) {
+                        ak.push(DPolygon.parse(line, format));
+                        return ak;
+                    }, []);
+                default:
+            }
+        }
+        return new DPolygon(a
+            .map(function (r) { return DPoint_1.DPoint.parse(r, format); }));
+    };
+    DPolygon.prototype.toArrayOfCoords = function (format) {
+        if (format === void 0) { format = utils_1.DGeo.parseFormat; }
+        return this.mapArray(function (r) { return r.toCoords(format); });
+    };
+    DPolygon.prototype.toGeoJSONFeature = function (format) {
+        if (format === void 0) { format = utils_1.DGeo.parseFormat; }
+        return {
+            type: 'Feature',
+            properties: __assign({}, this.properties),
+            geometry: this.toGeoJSON(format)
+        };
+    };
+    DPolygon.prototype.toGeoJSON = function (format) {
+        if (format === void 0) { format = utils_1.DGeo.parseFormat; }
+        if (this.closed) {
+            return {
+                type: 'Polygon',
+                coordinates: __spreadArray([
+                    this.toArrayOfCoords(format)
+                ], __read(this.holes.map(function (h) { return h.toArrayOfCoords(format); })), false)
+            };
+        }
+        return {
+            type: 'LineString',
+            coordinates: this.toArrayOfCoords(format)
+        };
+    };
+    DPolygon.prototype.divideToPieces = function (piecesCount, withAltitude) {
+        var e_14, _a;
+        if (withAltitude === void 0) { withAltitude = false; }
+        var fullLength = this.fullLength;
+        var pieceLength = fullLength / piecesCount;
+        var currentPieceLength = pieceLength;
+        var _loop_3 = function (p1, p2, i) {
+            var d = p1.distance(p2);
+            if (d === currentPieceLength) {
+                p2.properties.pieceBorder = true;
+                currentPieceLength = pieceLength;
+            }
+            else if (d - currentPieceLength > 0) {
+                var circle = new DCircle_1.DCircle(p1, currentPieceLength);
+                var line_1 = p1.findLine(p2);
+                var intersectionPoint = line_1.intersectionWithCircle(circle)
+                    .filter(function (p) { return line_1.inRange(p, CLOSE_TO_INTERSECTION_DISTANCE); })[0];
+                intersectionPoint.properties.pieceBorder = true;
+                this_1.insertAfter(i, intersectionPoint);
+                if (withAltitude) {
+                    var p1z = p1.z;
+                    intersectionPoint.z = p1z - (p1z - p2.z) * (p1.distance(intersectionPoint) / d);
+                }
+                currentPieceLength = pieceLength;
+            }
+            else {
+                currentPieceLength -= d;
+            }
+        };
+        var this_1 = this;
+        try {
+            for (var _b = __values(this.loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 4), p1 = _d[0], p2 = _d[1], i = _d[3];
+                _loop_3(p1, p2, i);
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+        return this;
+    };
+    DPolygon.prototype.prepareToFastSearch = function () {
+        var e_15, _a;
+        this.searchStore = {};
+        try {
+            for (var _b = __values(this.points), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = _c.value, x = _d.x, y = _d.y, z = _d.z;
+                if (!this.searchStore[x]) {
+                    this.searchStore[x] = {};
+                }
+                if (!this.searchStore[x][y]) {
+                    this.searchStore[x][y] = {};
+                }
+                this.searchStore[x][y][z || 'undefined'] = true;
+            }
+        }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_15) throw e_15.error; }
+        }
+    };
+    DPolygon.prototype.fastHas = function (_a) {
+        var x = _a.x, y = _a.y, z = _a.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'];
+    };
+    Object.defineProperty(DPolygon.prototype, "growingPiecesGenerator", {
+        get: function () {
+            var polygon = this;
+            return function () {
+                var r, _a, _b, p, e_16_1;
+                var e_16, _c;
+                return __generator(this, function (_d) {
+                    switch (_d.label) {
+                        case 0:
+                            r = new DPolygon();
+                            _d.label = 1;
+                        case 1:
+                            _d.trys.push([1, 6, 7, 8]);
+                            _a = __values(polygon.pPoints), _b = _a.next();
+                            _d.label = 2;
+                        case 2:
+                            if (!!_b.done) return [3, 5];
+                            p = _b.value;
+                            r.push(p);
+                            if (!p.properties.pieceBorder) return [3, 4];
+                            return [4, r.clone()];
+                        case 3:
+                            _d.sent();
+                            _d.label = 4;
+                        case 4:
+                            _b = _a.next();
+                            return [3, 2];
+                        case 5: return [3, 8];
+                        case 6:
+                            e_16_1 = _d.sent();
+                            e_16 = { error: e_16_1 };
+                            return [3, 8];
+                        case 7:
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_16) throw e_16.error; }
+                            return [7];
+                        case 8: return [2, r.clone()];
+                    }
+                });
+            };
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DPolygon.prototype.simpleUnion = function (p) {
+        try {
+            var res = this.simpleLogicFunction(p, true, true);
+            if (res === null) {
+                return null;
+            }
+            if (res instanceof DPolygon) {
+                return res;
+            }
+            return null;
+        }
+        catch (ex) {
+            return null;
+        }
+    };
+    DPolygon.prototype.simpleIntersection = function (p) {
+        return this.simpleLogicFunction(p, false, false);
+    };
+    DPolygon.prototype.simpleDifference = function (p) {
+        return this.simpleLogicFunction(p, true, false);
+    };
+    DPolygon.prototype.smartUnion = function (p) {
+        var e_17, _a;
+        var res = this.clone().simpleUnion(p);
+        if (res) {
+            var allHoles = __spreadArray(__spreadArray(__spreadArray([], __read(this.holes), false), __read(p.holes), false), __read(res.holes), false).map(function (h) { return h.clone(); });
+            var _loop_4 = function (a) {
+                var e_18, _b;
+                var _loop_5 = function (b) {
+                    if (a.equal(b)) {
+                        return "continue";
+                    }
+                    var r = a.simpleUnion(b);
+                    if (r) {
+                        allHoles = allHoles.filter(function (v) { return !v.equal(a) && !v.equal(b); });
+                        allHoles.push(r);
+                    }
+                };
+                try {
+                    for (var allHoles_2 = (e_18 = void 0, __values(allHoles)), allHoles_2_1 = allHoles_2.next(); !allHoles_2_1.done; allHoles_2_1 = allHoles_2.next()) {
+                        var b = allHoles_2_1.value;
+                        _loop_5(b);
+                    }
+                }
+                catch (e_18_1) { e_18 = { error: e_18_1 }; }
+                finally {
+                    try {
+                        if (allHoles_2_1 && !allHoles_2_1.done && (_b = allHoles_2.return)) _b.call(allHoles_2);
+                    }
+                    finally { if (e_18) throw e_18.error; }
+                }
+            };
+            try {
+                for (var allHoles_1 = __values(allHoles), allHoles_1_1 = allHoles_1.next(); !allHoles_1_1.done; allHoles_1_1 = allHoles_1.next()) {
+                    var a = allHoles_1_1.value;
+                    _loop_4(a);
+                }
+            }
+            catch (e_17_1) { e_17 = { error: e_17_1 }; }
+            finally {
+                try {
+                    if (allHoles_1_1 && !allHoles_1_1.done && (_a = allHoles_1.return)) _a.call(allHoles_1);
+                }
+                finally { if (e_17) throw e_17.error; }
+            }
+            res.holes = allHoles;
+        }
+        return res;
+    };
+    DPolygon.prototype.toTriangles = function () {
+        var q = this.clone().removeDuplicates()
+            .open();
+        if (q.length < 3) {
+            return [];
+        }
+        if (q.length === 3) {
+            return [q];
+        }
+        var innerAndNotIntersect = function (poly, p1, p2) {
+            var l = p1.findLine(p2);
+            var center = l.center;
+            var intersections = poly.holes.reduce(function (a, hole) { return a && Boolean(hole.clone().close()
+                .intersection(l, true).length); }, Boolean(poly.clone().close()
+                .intersection(l, true).length));
+            var contain = poly.holes.reduce(function (a, hole) { return a && !hole
+                .contain(center); }, poly.contain(center));
+            return !intersections && contain;
+        };
+        var getTriangle = function (poly) {
+            for (var i = 0; i < poly.length; i++) {
+                var p0 = poly.at(0);
+                var p1 = poly.at(1);
+                var 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;
+        };
+        var p = this.clone().removeDuplicates().clockWise.open();
+        while (p.holes.length) {
+            var h = p.holes.shift()
+                .clone()
+                .clockWise
+                .reverse()
+                .close();
+            for (var i = 0; i < p.length; i++) {
+                if (innerAndNotIntersect(p, p.first, h.first)) {
+                    p.insertAfter.apply(p, __spreadArray(__spreadArray([0], __read(h.points), false), [p.first], false));
+                    break;
+                }
+                p.push(p.shift());
+            }
+        }
+        var res = [];
+        while (p.length > 3) {
+            var triangle = getTriangle(p);
+            if (triangle) {
+                res.push(triangle);
+            }
+        }
+        res.push(p);
+        return res;
+    };
+    DPolygon.prototype.getTrianglesPointIndexes = function () {
+        var innerAndNotIntersect = function (poly, p1, p2) {
+            var l = p1.findLine(p2);
+            var center = l.center;
+            var intersections = poly.holes.reduce(function (a, hole) { return a && Boolean(hole.clone().close()
+                .intersection(l, true).length); }, Boolean(poly.clone().close()
+                .intersection(l, true).length));
+            var contain = poly.holes.reduce(function (a, hole) { return a && !hole
+                .contain(center); }, poly.contain(center));
+            return !intersections && contain;
+        };
+        var getTriangle = function (poly) {
+            for (var i = 0; i < poly.length; i++) {
+                var p0 = poly.at(0);
+                var p1 = poly.at(1);
+                var 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;
+        };
+        var p = this.clone();
+        var index = 0;
+        p.points.forEach(function (f) {
+            f.properties.index = index++;
+        });
+        p.holes.forEach(function (h) {
+            h.pPoints.forEach(function (f) {
+                f.properties.index = index++;
+            });
+        });
+        p = p.clockWise.open();
+        while (p.holes.length) {
+            var h = p.holes.shift()
+                .clone()
+                .clockWise
+                .reverse()
+                .close();
+            for (var i = 0; i < p.length; i++) {
+                if (innerAndNotIntersect(p, p.first, h.first)) {
+                    p.insertAfter.apply(p, __spreadArray(__spreadArray([0], __read(h.points), false), [p.first], false));
+                    break;
+                }
+                p.push(p.shift());
+            }
+        }
+        var res = [];
+        while (p.length > 3) {
+            var triangle = getTriangle(p);
+            if (triangle) {
+                res.push.apply(res, __spreadArray([], __read(triangle), false));
+            }
+        }
+        res.push.apply(res, __spreadArray([], __read(p.points.map(function (f) { return f.properties.index; })), false));
+        return res;
+    };
+    Object.defineProperty(DPolygon.prototype, "closed", {
+        get: function () {
+            return this.first.equal(this.last);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DPolygon.prototype.buffer = function (v, quadrantSegments, type) {
+        if (quadrantSegments === void 0) { quadrantSegments = 64; }
+        if (type === void 0) { type = DPolygon.CAP_ROUND; }
+        var reader = new jsts_1.io.WKTReader();
+        var _a = this, noHoles = _a.noHoles, closed = _a.closed;
+        var points = reader
+            .read(noHoles.toWKT(closed ? DPolygon.WKT_POLYGON : DPolygon.WKT_LINESTRING))
+            .buffer(v, quadrantSegments, type)
+            .getCoordinates();
+        return new DPolygon(points.map(function (_a) {
+            var x = _a.x, y = _a.y;
+            return new DPoint_1.DPoint(x, y);
+        }));
+    };
+    DPolygon.prototype.sideBuffers = function (v, quadrantSegments) {
+        if (quadrantSegments === void 0) { quadrantSegments = 64; }
+        var _a = this, first = _a.first, last = _a.last;
+        var buffer = this.buffer(v, quadrantSegments, DPolygon.CAP_FLAT).open();
+        var _b = __read(first.sortByDistance(buffer).points.map(function (r) { return r.properties.index; }), 2), start0 = _b[0], start1 = _b[1];
+        var _c = __read(last.sortByDistance(buffer).points.map(function (r) { return r.properties.index; }), 2), end0 = _c[0], end1 = _c[1];
+        var fromPoint = Math.min(Math.max(start0, start1), Math.max(end0, end1));
+        var toPoint = Math.max(Math.min(start0, start1), Math.min(end0, end1));
+        var linePart = new DPolygon(buffer.removePart(fromPoint - 1, toPoint - fromPoint + 1));
+        buffer.unshift(buffer.pop());
+        return [linePart.reverse(), buffer];
+    };
+    DPolygon.prototype.setProperties = function (v) {
+        this.properties = typeof v === 'object' ? v : v(this);
+        return this;
+    };
+    DPolygon.prototype.bezier = function (step) {
+        if (step === void 0) { step = 0.1; }
+        var res = new DPolygon();
+        for (var i = 0; i < 1; i += step) {
+            res.push(this.clone().getBezierPoint(i));
+        }
+        return res;
+    };
+    DPolygon.prototype.setGrowingHeight = function (from, to) {
+        var fullLength = this.fullLength;
+        var prevPoint = this.first;
+        var d = to - from;
+        var currentDistance = 0;
+        this.loop()
+            .setZ(function (p) {
+            currentDistance += prevPoint.distance(p);
+            prevPoint = p;
+            return from + currentDistance / fullLength * d;
+        })
+            .run();
+        return this;
+    };
+    DPolygon.prototype.loopPointsGenerator = function (withLine) {
+        if (withLine === void 0) { withLine = false; }
+        var that = this;
+        return function () {
+            var i, p1, p2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        i = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(i < that.length - 1)) return [3, 4];
+                        p1 = that.at(i);
+                        p2 = that.at(i + 1);
+                        return [4, [p1, p2, withLine ? p1.findLine(p2) : undefined, i]];
+                    case 2:
+                        _a.sent();
+                        _a.label = 3;
+                    case 3:
+                        i++;
+                        return [3, 1];
+                    case 4: return [2];
+                }
+            });
+        };
+    };
+    DPolygon.prototype.getBezierPoint = function (v) {
+        var e_19, _a;
+        if (this.length === 1) {
+            return this.first;
+        }
+        try {
+            for (var _b = __values(this.loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), p1 = _d[0], p2 = _d[1];
+                p1.move(p2.clone().move(p1.clone().minus())
+                    .scale(v));
+            }
+        }
+        catch (e_19_1) { e_19 = { error: e_19_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_19) throw e_19.error; }
+        }
+        this.pop();
+        return this.getBezierPoint(v);
+    };
+    DPolygon.prototype.simpleIncludeX = function (p) {
+        var x = p.x;
+        return this.minX <= x && this.maxX >= x;
+    };
+    DPolygon.prototype.simpleIncludeY = function (p) {
+        var y = p.y;
+        return this.minY <= y && this.maxY >= y;
+    };
+    DPolygon.prototype.douglasPeucker = function (points, e) {
+        var dMax = 0;
+        var index = 0;
+        var end = points.length - 1;
+        var line = points[0].findLine(points[end]);
+        for (var i = 1; i < end; i++) {
+            var d = line.perpendicularDistance(points[i]);
+            if (d > dMax) {
+                index = i;
+                dMax = d;
+            }
+        }
+        if (dMax >= e) {
+            var recResult1 = this.douglasPeucker(points.slice(0, index + 1), e);
+            var recResult2 = this.douglasPeucker(points.slice(index), e);
+            recResult1.pop();
+            return __spreadArray(__spreadArray([], __read(recResult1), false), __read(recResult2), false);
+        }
+        return [points[0], points[end]];
+    };
+    DPolygon.prototype.goByPath = function (ctx, steps) {
+        if (steps === void 0) { steps = this.length - 1; }
+        var start = this.first;
+        ctx.moveTo(start.x, start.y);
+        for (var i = 1; i <= (steps % this.length); i++) {
+            var _a = this.at(i), x = _a.x, y = _a.y;
+            ctx.lineTo(x, y);
+        }
+    };
+    DPolygon.prototype.getJSTSGeometry = function (p, unionThis, unionThat) {
+        var unionOrIntersection = unionThat === unionThis;
+        var reader = new jsts_1.io.WKTReader();
+        var a = reader.read(this.noHoles.toWKT());
+        var 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;
+    };
+    DPolygon.prototype.simpleLogicFunction = function (p, unionThis, unionThat) {
+        var e_20, _a, e_21, _b, e_22, _c, e_23, _d;
+        var c = this.getJSTSGeometry(p, unionThis, unionThat);
+        if (c) {
+            var coordinates_1 = c.getCoordinates();
+            if (coordinates_1.length) {
+                var result = coordinates_1.reduce(function (ak, _a, index) {
+                    var x = _a.x, y = _a.y;
+                    var lastIndex = ak.length - 1;
+                    var t = new DPoint_1.DPoint(x, y);
+                    var first = ak[lastIndex].first;
+                    if (t.equal(first)) {
+                        if (coordinates_1[index + 1]) {
+                            var nextPoint = new DPoint_1.DPoint(coordinates_1[index + 1].x, coordinates_1[index + 1].y);
+                            if (ak[lastIndex].length > 1) {
+                                ak.push(new DPolygon([nextPoint]));
+                            }
+                        }
+                    }
+                    else {
+                        ak[lastIndex].push(t);
+                    }
+                    return ak;
+                }, [new DPolygon([new DPoint_1.DPoint(coordinates_1[0].x, coordinates_1[0].y)])]);
+                if (unionThat && unionThis && result.length > 1) {
+                    try {
+                        for (var result_1 = __values(result), result_1_1 = result_1.next(); !result_1_1.done; result_1_1 = result_1.next()) {
+                            var q = result_1_1.value;
+                            var _loop_6 = function (r) {
+                                var _e;
+                                if (q.has(r.first) && !q.equal(r)) {
+                                    var index = q.findIndex(r.first);
+                                    (_e = q.points).splice.apply(_e, __spreadArray([index, 0], __read(r.points), false));
+                                    result = result.filter(function (h) { return !h.equal(r); });
+                                    return "continue";
+                                }
+                                if (result.length < 2) {
+                                    return "break";
+                                }
+                            };
+                            try {
+                                for (var result_2 = (e_21 = void 0, __values(result)), result_2_1 = result_2.next(); !result_2_1.done; result_2_1 = result_2.next()) {
+                                    var r = result_2_1.value;
+                                    var state_1 = _loop_6(r);
+                                    if (state_1 === "break")
+                                        break;
+                                }
+                            }
+                            catch (e_21_1) { e_21 = { error: e_21_1 }; }
+                            finally {
+                                try {
+                                    if (result_2_1 && !result_2_1.done && (_b = result_2.return)) _b.call(result_2);
+                                }
+                                finally { if (e_21) throw e_21.error; }
+                            }
+                            if (result.length < 2) {
+                                break;
+                            }
+                        }
+                    }
+                    catch (e_20_1) { e_20 = { error: e_20_1 }; }
+                    finally {
+                        try {
+                            if (result_1_1 && !result_1_1.done && (_a = result_1.return)) _a.call(result_1);
+                        }
+                        finally { if (e_20) throw e_20.error; }
+                    }
+                }
+                result = result.filter(function (h) { return h.length > 2; }).map(function (h) { return h.close(); });
+                try {
+                    for (var result_3 = __values(result), result_3_1 = result_3.next(); !result_3_1.done; result_3_1 = result_3.next()) {
+                        var q = result_3_1.value;
+                        var _loop_7 = function (r) {
+                            if (result.length < 2) {
+                                return "break";
+                            }
+                            if (!q.equal(r)) {
+                                if (q.contain(r.first, true)) {
+                                    q.holes.push(r);
+                                    result = result.filter(function (h) { return !h.equal(r); });
+                                }
+                            }
+                        };
+                        try {
+                            for (var result_4 = (e_23 = void 0, __values(result)), result_4_1 = result_4.next(); !result_4_1.done; result_4_1 = result_4.next()) {
+                                var r = result_4_1.value;
+                                var state_2 = _loop_7(r);
+                                if (state_2 === "break")
+                                    break;
+                            }
+                        }
+                        catch (e_23_1) { e_23 = { error: e_23_1 }; }
+                        finally {
+                            try {
+                                if (result_4_1 && !result_4_1.done && (_d = result_4.return)) _d.call(result_4);
+                            }
+                            finally { if (e_23) throw e_23.error; }
+                        }
+                        if (result.length < 2) {
+                            break;
+                        }
+                    }
+                }
+                catch (e_22_1) { e_22 = { error: e_22_1 }; }
+                finally {
+                    try {
+                        if (result_3_1 && !result_3_1.done && (_c = result_3.return)) _c.call(result_3);
+                    }
+                    finally { if (e_22) throw e_22.error; }
+                }
+                if (result.length === 0) {
+                    return null;
+                }
+                if (result.length === 1) {
+                    return result[0].close();
+                }
+                return result.map(function (g) { return 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';
+    return DPolygon;
+}());
+exports.DPolygon = DPolygon;