dgeoutils 2.5.0 → 2.6.1

package/README.md

@@ -23,7 +23,7 @@
   <script src="https://unpkg.com/dgeoutils@latest/dist/umd/dgeoutils.js"></script>
 ```
 
-[Sandbox](https://jsbin.com/yaxaqif/edit?js,output)
+[Sandbox](https://jsbin.com/dapakixeba/edit?html,js,output)
 
 ### For new release
 ```

package/dist/cjs/DPolygon.d.ts

@@ -46,6 +46,7 @@ export declare class DPolygon {
     get fullLength(): number;
     get fullLengthLatLon(): number;
     get perimeter(): number;
+    get pointsDistanceProportions(): number[];
     get perimeterLatLon(): number;
     get area(): number;
     get filledDeintersection(): DPolygon;
@@ -128,6 +129,8 @@ export declare class DPolygon {
     setGrowingHeight(from: number, to: number): DPolygon;
     loopPointsGenerator(): () => Generator<[DPoint, DPoint, undefined, number]>;
     loopPointsGenerator(withLine: True): () => Generator<[DPoint, DPoint, DLine, number]>;
+    cloneByDistanceProportions(proportions: number[]): DPolygon;
+    middleLinestring(line: DPolygon): DPolygon;
     private getBezierPoint;
     private simpleIncludeX;
     private simpleIncludeY;

package/dist/cjs/DPolygon.js

@@ -424,14 +424,16 @@ var DPolygon = (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(DPolygon.prototype, "perimeterLatLon", {
+    Object.defineProperty(DPolygon.prototype, "pointsDistanceProportions", {
         get: function () {
             var e_5, _a;
             var p = 0;
+            var res = [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);
+                    p += p1.distance(p2);
+                    res.push(p);
                 }
             }
             catch (e_5_1) { e_5 = { error: e_5_1 }; }
@@ -441,6 +443,28 @@ var DPolygon = (function () {
                 }
                 finally { if (e_5) throw e_5.error; }
             }
+            return res.map(function (v) { return v / p; });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DPolygon.prototype, "perimeterLatLon", {
+        get: function () {
+            var e_6, _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_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 p;
         },
         enumerable: false,
@@ -448,7 +472,7 @@ var DPolygon = (function () {
     });
     Object.defineProperty(DPolygon.prototype, "area", {
         get: function () {
-            var e_6, _a;
+            var e_7, _a;
             var sum = 0;
             try {
                 for (var _b = __values(this.deintersection.loopPointsGenerator()()), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -456,12 +480,12 @@ var DPolygon = (function () {
                     sum += x * b - y * a;
                 }
             }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            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_6) throw e_6.error; }
+                finally { if (e_7) throw e_7.error; }
             }
             return Math.abs(sum / 2) - this.holes.reduce(function (a, hole) { return a + hole.area; }, 0);
         },
@@ -504,7 +528,7 @@ var DPolygon = (function () {
     });
     Object.defineProperty(DPolygon.prototype, "deintersection", {
         get: function () {
-            var e_7, _a;
+            var e_8, _a;
             var p = this.clone().close();
             var store = {};
             for (var i = 0; i < p.length - 1; i++) {
@@ -550,12 +574,12 @@ var DPolygon = (function () {
                     }
                 }
             }
-            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_7) throw e_7.error; }
+                finally { if (e_8) throw e_8.error; }
             }
             return p;
         },
@@ -592,7 +616,7 @@ var DPolygon = (function () {
     });
     Object.defineProperty(DPolygon.prototype, "minAreaRectangle", {
         get: function () {
-            var e_8, _a, e_9, _b;
+            var e_9, _a, e_10, _b;
             var p = this.convex;
             var resultPolygon = new DPolygon();
             var resultArea = Infinity;
@@ -605,7 +629,7 @@ var DPolygon = (function () {
                     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()) {
+                        for (var _f = (e_10 = 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);
@@ -624,12 +648,12 @@ var DPolygon = (function () {
                             }
                         }
                     }
-                    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                    catch (e_10_1) { e_10 = { error: e_10_1 }; }
                     finally {
                         try {
                             if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
                         }
-                        finally { if (e_9) throw e_9.error; }
+                        finally { if (e_10) throw e_10.error; }
                     }
                     if (!maxWidthPoint1 || !maxWidthPoint2 || !maxHeightPoint) {
                         continue;
@@ -649,12 +673,12 @@ var DPolygon = (function () {
                     }
                 }
             }
-            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
             finally {
                 try {
                     if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
                 }
-                finally { if (e_8) throw e_8.error; }
+                finally { if (e_9) throw e_9.error; }
             }
             return resultPolygon;
         },
@@ -707,7 +731,7 @@ var DPolygon = (function () {
     });
     Object.defineProperty(DPolygon.prototype, "isClockwise", {
         get: function () {
-            var e_10, _a;
+            var e_11, _a;
             var sum = 0;
             try {
                 for (var _b = __values(this.clone().close()
@@ -716,12 +740,12 @@ var DPolygon = (function () {
                     sum += (a - x) * (b + y);
                 }
             }
-            catch (e_10_1) { e_10 = { error: e_10_1 }; }
+            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_10) throw e_10.error; }
+                finally { if (e_11) throw e_11.error; }
             }
             return sum < 0;
         },
@@ -751,7 +775,7 @@ var DPolygon = (function () {
         return this.pPoints.reduce(f, v);
     };
     DPolygon.prototype.intersection = function (l, includeOnly) {
-        var e_11, _a;
+        var e_12, _a;
         if (includeOnly === void 0) { includeOnly = false; }
         var res = [];
         try {
@@ -763,12 +787,12 @@ var DPolygon = (function () {
                 }
             }
         }
-        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        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_11) throw e_11.error; }
+            finally { if (e_12) throw e_12.error; }
         }
         return res;
     };
@@ -974,7 +998,7 @@ var DPolygon = (function () {
         ctx.globalCompositeOperation = old;
     };
     DPolygon.prototype.contain = function (p, isBorderInside) {
-        var e_12, _a;
+        var e_13, _a;
         if (isBorderInside === void 0) { isBorderInside = false; }
         var simpleInclude = this.simpleInclude(p);
         if (!simpleInclude) {
@@ -1000,12 +1024,12 @@ var DPolygon = (function () {
                 }
             }
         }
-        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        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_12) throw e_12.error; }
+            finally { if (e_13) throw e_13.error; }
         }
         var eps = Math.PI / 10000;
         var absTotalFi = Math.abs(totalFi);
@@ -1018,7 +1042,7 @@ var DPolygon = (function () {
         throw new Error('contains2 faild');
     };
     DPolygon.prototype.onBorder = function (p) {
-        var e_13, _a;
+        var e_14, _a;
         var simpleInclude = this.simpleInclude(p);
         if (simpleInclude) {
             var poly = this.deintersection;
@@ -1035,12 +1059,12 @@ var DPolygon = (function () {
                     }
                 }
             }
-            catch (e_13_1) { e_13 = { error: e_13_1 }; }
+            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_13) throw e_13.error; }
+                finally { if (e_14) throw e_14.error; }
             }
         }
         return false;
@@ -1164,7 +1188,7 @@ var DPolygon = (function () {
         };
     };
     DPolygon.prototype.divideToPieces = function (piecesCount, withAltitude) {
-        var e_14, _a;
+        var e_15, _a;
         if (withAltitude === void 0) { withAltitude = false; }
         var fullLength = this.fullLength;
         var pieceLength = fullLength / piecesCount;
@@ -1199,17 +1223,17 @@ var DPolygon = (function () {
                 _loop_3(p1, p2, i);
             }
         }
-        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        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_14) throw e_14.error; }
+            finally { if (e_15) throw e_15.error; }
         }
         return this;
     };
     DPolygon.prototype.prepareToFastSearch = function () {
-        var e_15, _a;
+        var e_16, _a;
         this.searchStore = {};
         try {
             for (var _b = __values(this.points), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -1223,12 +1247,12 @@ var DPolygon = (function () {
                 this.searchStore[x][y][z || 'undefined'] = true;
             }
         }
-        catch (e_15_1) { e_15 = { error: e_15_1 }; }
+        catch (e_16_1) { e_16 = { error: e_16_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_15) throw e_15.error; }
+            finally { if (e_16) throw e_16.error; }
         }
     };
     DPolygon.prototype.fastHas = function (_a) {
@@ -1248,8 +1272,8 @@ var DPolygon = (function () {
         get: function () {
             var polygon = this;
             return function () {
-                var r, _a, _b, p, e_16_1;
-                var e_16, _c;
+                var r, _a, _b, p, e_17_1;
+                var e_17, _c;
                 return __generator(this, function (_d) {
                     switch (_d.label) {
                         case 0:
@@ -1273,14 +1297,14 @@ var DPolygon = (function () {
                             return [3, 2];
                         case 5: return [3, 8];
                         case 6:
-                            e_16_1 = _d.sent();
-                            e_16 = { error: e_16_1 };
+                            e_17_1 = _d.sent();
+                            e_17 = { error: e_17_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; }
+                            finally { if (e_17) throw e_17.error; }
                             return [7];
                         case 8: return [2, r.clone()];
                     }
@@ -1312,12 +1336,12 @@ var DPolygon = (function () {
         return this.simpleLogicFunction(p, true, false);
     };
     DPolygon.prototype.smartUnion = function (p) {
-        var e_17, _a;
+        var e_18, _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 e_19, _b;
                 var _loop_5 = function (b) {
                     if (a.equal(b)) {
                         return "continue";
@@ -1329,17 +1353,17 @@ var DPolygon = (function () {
                     }
                 };
                 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()) {
+                    for (var allHoles_2 = (e_19 = 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 }; }
+                catch (e_19_1) { e_19 = { error: e_19_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; }
+                    finally { if (e_19) throw e_19.error; }
                 }
             };
             try {
@@ -1348,12 +1372,12 @@ var DPolygon = (function () {
                     _loop_4(a);
                 }
             }
-            catch (e_17_1) { e_17 = { error: e_17_1 }; }
+            catch (e_18_1) { e_18 = { error: e_18_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; }
+                finally { if (e_18) throw e_18.error; }
             }
             res.holes = allHoles;
         }
@@ -1568,8 +1592,74 @@ var DPolygon = (function () {
             });
         };
     };
+    DPolygon.prototype.cloneByDistanceProportions = function (proportions) {
+        var e_20, _a;
+        var resultedPolygon = new DPolygon();
+        var resultProportions = Array.from(new Set(__spreadArray(__spreadArray([], __read(this.pointsDistanceProportions), false), __read(proportions), false)))
+            .sort(function (a, b) { return a - b; });
+        var fullLength = this.fullLength;
+        resultedPolygon.push(this.at(0));
+        var index = 1;
+        var path = 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];
+                var p1 = p1_;
+                var _loop_6 = function () {
+                    var distance = p1.distance(p2);
+                    var currentProportion = (path + distance) / fullLength;
+                    if (Math.abs(currentProportion - resultProportions[index]) < 1e-7) {
+                        path += distance;
+                        resultedPolygon.push(p2.clone());
+                        index++;
+                        return "break";
+                    }
+                    else {
+                        var radius = (resultProportions[index] - resultProportions[index - 1]) * fullLength;
+                        var circle = new DCircle_1.DCircle(p1, radius);
+                        var line_2 = p1.findLine(p2);
+                        var intersectionPoint = line_2.intersectionWithCircle(circle)
+                            .filter(function (p) { return line_2.inRange(p, CLOSE_TO_INTERSECTION_DISTANCE); })[0];
+                        resultedPolygon.push(intersectionPoint);
+                        index++;
+                        path += p1.distance(intersectionPoint);
+                        p1 = intersectionPoint;
+                    }
+                };
+                while (true) {
+                    var state_1 = _loop_6();
+                    if (state_1 === "break")
+                        break;
+                }
+            }
+        }
+        catch (e_20_1) { e_20 = { error: e_20_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_20) throw e_20.error; }
+        }
+        return resultedPolygon;
+    };
+    DPolygon.prototype.middleLinestring = function (line) {
+        var thisClone = this.cloneByDistanceProportions(line.pointsDistanceProportions);
+        var thatClone = line.cloneByDistanceProportions(this.pointsDistanceProportions);
+        return thisClone
+            .loop()
+            .setX(function (_a, index) {
+            var x = _a.x;
+            return x + thatClone.at(index).x;
+        })
+            .setY(function (_a, index) {
+            var y = _a.y;
+            return y + thatClone.at(index).y;
+        })
+            .divide(2)
+            .run();
+    };
     DPolygon.prototype.getBezierPoint = function (v) {
-        var e_19, _a;
+        var e_21, _a;
         if (this.length === 1) {
             return this.first;
         }
@@ -1580,12 +1670,12 @@ var DPolygon = (function () {
                     .scale(v));
             }
         }
-        catch (e_19_1) { e_19 = { error: e_19_1 }; }
+        catch (e_21_1) { e_21 = { error: e_21_1 }; }
         finally {
             try {
                 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            finally { if (e_19) throw e_19.error; }
+            finally { if (e_21) throw e_21.error; }
         }
         this.pop();
         return this.getBezierPoint(v);
@@ -1644,7 +1734,7 @@ var DPolygon = (function () {
         return undefined;
     };
     DPolygon.prototype.simpleLogicFunction = function (p, unionThis, unionThat) {
-        var e_20, _a, e_21, _b, e_22, _c, e_23, _d;
+        var e_22, _a, e_23, _b, e_24, _c, e_25, _d;
         var c = this.getJSTSGeometry(p, unionThis, unionThat);
         if (c) {
             var coordinates_1 = c.getCoordinates();
@@ -1671,7 +1761,7 @@ var DPolygon = (function () {
                     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 _loop_7 = function (r) {
                                 var _e;
                                 if (q.has(r.first) && !q.equal(r)) {
                                     var index = q.findIndex(r.first);
@@ -1684,38 +1774,38 @@ var DPolygon = (function () {
                                 }
                             };
                             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()) {
+                                for (var result_2 = (e_23 = 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")
+                                    var state_2 = _loop_7(r);
+                                    if (state_2 === "break")
                                         break;
                                 }
                             }
-                            catch (e_21_1) { e_21 = { error: e_21_1 }; }
+                            catch (e_23_1) { e_23 = { error: e_23_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; }
+                                finally { if (e_23) throw e_23.error; }
                             }
                             if (result.length < 2) {
                                 break;
                             }
                         }
                     }
-                    catch (e_20_1) { e_20 = { error: e_20_1 }; }
+                    catch (e_22_1) { e_22 = { error: e_22_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; }
+                        finally { if (e_22) throw e_22.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) {
+                        var _loop_8 = function (r) {
                             if (result.length < 2) {
                                 return "break";
                             }
@@ -1727,31 +1817,31 @@ var DPolygon = (function () {
                             }
                         };
                         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()) {
+                            for (var result_4 = (e_25 = 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")
+                                var state_3 = _loop_8(r);
+                                if (state_3 === "break")
                                     break;
                             }
                         }
-                        catch (e_23_1) { e_23 = { error: e_23_1 }; }
+                        catch (e_25_1) { e_25 = { error: e_25_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; }
+                            finally { if (e_25) throw e_25.error; }
                         }
                         if (result.length < 2) {
                             break;
                         }
                     }
                 }
-                catch (e_22_1) { e_22 = { error: e_22_1 }; }
+                catch (e_24_1) { e_24 = { error: e_24_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; }
+                    finally { if (e_24) throw e_24.error; }
                 }
                 if (result.length === 0) {
                     return null;

package/dist/es2015/DPolygon.js

@@ -219,6 +219,15 @@ export class DPolygon {
         }
         return p;
     }
+    get pointsDistanceProportions() {
+        let p = 0;
+        const res = [0];
+        for (const [p1, p2] of this.loopPointsGenerator()()) {
+            p += p1.distance(p2);
+            res.push(p);
+        }
+        return res.map((v) => v / p);
+    }
     get perimeterLatLon() {
         let p = 0;
         for (const [p1, p2] of this.loopPointsGenerator()()) {
@@ -1064,6 +1073,50 @@ export class DPolygon {
             }
         };
     }
+    cloneByDistanceProportions(proportions) {
+        const resultedPolygon = new DPolygon();
+        const resultProportions = Array.from(new Set([...this.pointsDistanceProportions, ...proportions]))
+            .sort((a, b) => a - b);
+        const { fullLength } = this;
+        resultedPolygon.push(this.at(0));
+        let index = 1;
+        let path = 0;
+        for (const [p1_, p2] of this.loopPointsGenerator()()) {
+            let p1 = p1_;
+            while (true) {
+                const distance = p1.distance(p2);
+                const currentProportion = (path + distance) / fullLength;
+                if (Math.abs(currentProportion - resultProportions[index]) < 1e-7) {
+                    path += distance;
+                    resultedPolygon.push(p2.clone());
+                    index++;
+                    break;
+                }
+                else {
+                    const radius = (resultProportions[index] - resultProportions[index - 1]) * fullLength;
+                    const circle = new DCircle(p1, radius);
+                    const line = p1.findLine(p2);
+                    const intersectionPoint = line.intersectionWithCircle(circle)
+                        .filter((p) => line.inRange(p, CLOSE_TO_INTERSECTION_DISTANCE))[0];
+                    resultedPolygon.push(intersectionPoint);
+                    index++;
+                    path += p1.distance(intersectionPoint);
+                    p1 = intersectionPoint;
+                }
+            }
+        }
+        return resultedPolygon;
+    }
+    middleLinestring(line) {
+        const thisClone = this.cloneByDistanceProportions(line.pointsDistanceProportions);
+        const thatClone = line.cloneByDistanceProportions(this.pointsDistanceProportions);
+        return thisClone
+            .loop()
+            .setX(({ x }, index) => x + thatClone.at(index).x)
+            .setY(({ y }, index) => y + thatClone.at(index).y)
+            .divide(2)
+            .run();
+    }
     getBezierPoint(v) {
         if (this.length === 1) {
             return this.first;