dgeoutils 2.3.6 → 2.4.1

package/dist/cjs/TraceMatrix.js

@@ -1,81 +1,43 @@
 "use strict";
-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));
-};
-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.");
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TraceMatrix = exports.TraceMatrixValues = void 0;
-var DPoint_1 = require("./DPoint");
-var DPolygon_1 = require("./DPolygon");
-var FastSearch_1 = require("./FastSearch");
-var utils_1 = require("./utils");
+const DPoint_1 = require("./DPoint");
+const DPolygon_1 = require("./DPolygon");
+const FastSearch_1 = require("./FastSearch");
+const utils_1 = require("./utils");
 var TraceMatrixValues;
 (function (TraceMatrixValues) {
     TraceMatrixValues[TraceMatrixValues["f"] = 0] = "f";
     TraceMatrixValues[TraceMatrixValues["t"] = 1] = "t";
 })(TraceMatrixValues = exports.TraceMatrixValues || (exports.TraceMatrixValues = {}));
-var getByPosition = function (m, p, defaultValue) {
-    if (defaultValue === void 0) { defaultValue = TraceMatrixValues.f; }
+const getByPosition = (m, p, defaultValue = TraceMatrixValues.f) => {
     if (m[p.y] === undefined || m[p.y][p.x] === undefined) {
         return defaultValue;
     }
     return m[p.y][p.x];
 };
-var setByPosition = function (m, p, value) {
+const setByPosition = (m, p, value) => {
     if (m[p.y] === undefined || m[p.y][p.x] === undefined) {
         return value;
     }
     m[p.y][p.x] = value;
     return m[p.y][p.x];
 };
-var TraceMatrix = (function () {
-    function TraceMatrix(size, f) {
-        var _this = this;
+class TraceMatrix {
+    constructor(size, f) {
         this.size = size;
-        this.findGroupByIndex = function (m, s) {
-            var res = new DPolygon_1.DPolygon();
+        this.findGroupByIndex = (m, s) => {
+            const res = new DPolygon_1.DPolygon();
             if (s && getByPosition(m, s) === TraceMatrixValues.t) {
                 res.push(s);
-                var startIndex = 0;
-                var marked = TraceMatrix.createMatrix(_this.size, function () { return TraceMatrixValues.f; });
+                let startIndex = 0;
+                const marked = TraceMatrix.createMatrix(this.size, () => TraceMatrixValues.f);
                 setByPosition(marked, s, TraceMatrixValues.t);
                 while (startIndex < res.length) {
-                    var r = res.at(startIndex);
-                    for (var i = -1; i < 2; i++) {
-                        for (var j = -1; j < 2; j++) {
-                            var t = new DPoint_1.DPoint(r.x + i, r.y + j);
+                    const r = res.at(startIndex);
+                    for (let i = -1; i < 2; i++) {
+                        for (let j = -1; j < 2; j++) {
+                            const t = new DPoint_1.DPoint(r.x + i, r.y + j);
                             if (getByPosition(marked, t, TraceMatrixValues.t) === TraceMatrixValues.f &&
                                 getByPosition(m, t, TraceMatrixValues.f) === TraceMatrixValues.t) {
                                 res.push(t);
@@ -88,32 +50,32 @@ var TraceMatrix = (function () {
             }
             return res;
         };
-        this.findAllGroupsInMatrix = function (m) {
-            var firstMark = _this.findMarked(m);
+        this.findAllGroupsInMatrix = (m) => {
+            const firstMark = this.findMarked(m);
             if (!firstMark) {
                 return [];
             }
-            var group = _this.findGroupByIndex(m, firstMark);
-            var groups = [group];
-            var groupSum = group.length;
-            var allGroups = __spreadArray([], __read(group.points), false);
-            var fs = new FastSearch_1.FastSearch();
+            const group = this.findGroupByIndex(m, firstMark);
+            const groups = [group];
+            let groupSum = group.length;
+            let allGroups = [...group.points];
+            const fs = new FastSearch_1.FastSearch();
             fs.add(allGroups);
-            while (groupSum < _this.totalCountInMatrix(m)) {
-                var mark = _this.findMarked(m);
+            while (groupSum < this.totalCountInMatrix(m)) {
+                let mark = this.findMarked(m);
                 while (mark && fs.find(mark)) {
-                    mark = _this.findMarked(m, mark);
+                    mark = this.findMarked(m, mark);
                 }
-                var nextGroup = _this.findGroupByIndex(m, mark);
+                const nextGroup = this.findGroupByIndex(m, mark);
                 groupSum += nextGroup.length;
-                allGroups = __spreadArray(__spreadArray([], __read(allGroups), false), __read(nextGroup.points), false);
+                allGroups = [...allGroups, ...nextGroup.points];
                 fs.add(nextGroup.points);
                 groups.push(nextGroup);
             }
-            return groups.filter(function (g) { return g.length > 2; });
+            return groups.filter((g) => g.length > 2);
         };
-        this.traceGroup = function (m, group) {
-            var traceDirections = [
+        this.traceGroup = (m, group) => {
+            const traceDirections = [
                 new DPoint_1.DPoint(-1, -1),
                 new DPoint_1.DPoint(-1, 0),
                 new DPoint_1.DPoint(-1, 1),
@@ -123,20 +85,20 @@ var TraceMatrix = (function () {
                 new DPoint_1.DPoint(1, -1),
                 new DPoint_1.DPoint(0, -1)
             ];
-            var left = function (d) { return (d + traceDirections.length + 1) % traceDirections.length; };
-            var right = function (d) { return (d + traceDirections.length - 1) % traceDirections.length; };
+            const left = (d) => (d + traceDirections.length + 1) % traceDirections.length;
+            const right = (d) => (d + traceDirections.length - 1) % traceDirections.length;
             if (group.length < 2) {
-                var t = group.at(0).clone();
+                const t = group.at(0).clone();
                 return new DPolygon_1.DPolygon([t, t, t]);
             }
-            var points = new DPolygon_1.DPolygon();
-            var direction = 0;
-            var prevDirection = Infinity;
-            var p = group.at(0);
+            const points = new DPolygon_1.DPolygon();
+            let direction = 0;
+            let prevDirection = Infinity;
+            let p = group.at(0);
             while (!p.equal(group.at(0)) || points.length < 2) {
                 while (true) {
-                    var nextValue = getByPosition(m, p.clone().move(traceDirections[direction]));
-                    var nextNeighbourValue = getByPosition(m, p.clone().move(traceDirections[left(direction)]));
+                    const nextValue = getByPosition(m, p.clone().move(traceDirections[direction]));
+                    const nextNeighbourValue = getByPosition(m, p.clone().move(traceDirections[left(direction)]));
                     if (nextValue === TraceMatrixValues.t && nextNeighbourValue === TraceMatrixValues.f) {
                         break;
                     }
@@ -151,76 +113,64 @@ var TraceMatrix = (function () {
             }
             return points.approximation().close();
         };
-        this.createHoleMatrix = function (group) {
-            var e_1, _a;
-            var fullTraceDirections = [
+        this.createHoleMatrix = (group) => {
+            const fullTraceDirections = [
                 new DPoint_1.DPoint(-1, 0),
                 new DPoint_1.DPoint(0, 1),
                 new DPoint_1.DPoint(1, 0),
                 new DPoint_1.DPoint(0, -1)
             ];
             group.prepareToFastSearch();
-            var tmpMatrix = TraceMatrix
-                .createMatrix(_this.size, function (p) { return group.fastHas(p) ? TraceMatrixValues.t : TraceMatrixValues.f; });
-            var startCoords = new DPolygon_1.DPolygon();
-            for (var i = 0; i < _this.size.w; i++) {
+            const tmpMatrix = TraceMatrix
+                .createMatrix(this.size, (p) => group.fastHas(p) ? TraceMatrixValues.t : TraceMatrixValues.f);
+            const startCoords = new DPolygon_1.DPolygon();
+            for (let i = 0; i < this.size.w; i++) {
                 startCoords.push(new DPoint_1.DPoint(i, -1));
-                startCoords.push(new DPoint_1.DPoint(i, _this.size.h));
+                startCoords.push(new DPoint_1.DPoint(i, this.size.h));
             }
-            for (var i = 0; i < _this.size.h; i++) {
+            for (let i = 0; i < this.size.h; i++) {
                 startCoords.push(new DPoint_1.DPoint(-1, i));
-                startCoords.push(new DPoint_1.DPoint(_this.size.w, i));
+                startCoords.push(new DPoint_1.DPoint(this.size.w, i));
             }
             while (startCoords.length) {
-                var point = startCoords.pop();
-                try {
-                    for (var fullTraceDirections_1 = (e_1 = void 0, __values(fullTraceDirections)), fullTraceDirections_1_1 = fullTraceDirections_1.next(); !fullTraceDirections_1_1.done; fullTraceDirections_1_1 = fullTraceDirections_1.next()) {
-                        var direction = fullTraceDirections_1_1.value;
-                        var tmpPoint = point.clone().move(direction);
-                        var value = getByPosition(tmpMatrix, tmpPoint, TraceMatrixValues.t);
-                        if (value === TraceMatrixValues.f) {
-                            setByPosition(tmpMatrix, tmpPoint, TraceMatrixValues.t);
-                            startCoords.push(tmpPoint);
-                        }
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (fullTraceDirections_1_1 && !fullTraceDirections_1_1.done && (_a = fullTraceDirections_1.return)) _a.call(fullTraceDirections_1);
+                const point = startCoords.pop();
+                for (const direction of fullTraceDirections) {
+                    const tmpPoint = point.clone().move(direction);
+                    const value = getByPosition(tmpMatrix, tmpPoint, TraceMatrixValues.t);
+                    if (value === TraceMatrixValues.f) {
+                        setByPosition(tmpMatrix, tmpPoint, TraceMatrixValues.t);
+                        startCoords.push(tmpPoint);
                     }
-                    finally { if (e_1) throw e_1.error; }
                 }
             }
-            var t = _this.reverseMatrix(tmpMatrix);
-            return _this.totalCountInMatrix(t) ? t : null;
+            const t = this.reverseMatrix(tmpMatrix);
+            return this.totalCountInMatrix(t) ? t : null;
         };
         this.m = TraceMatrix.createMatrix(this.size, f);
     }
-    TraceMatrix.prototype.fullMatrixTrace = function () {
-        var _this = this;
-        var groups = this.findAllGroupsInMatrix(this.m);
-        var paths = groups.map(function (g) { return _this.traceGroup(_this.m, g); });
-        var holeMatrixs = groups.map(this.createHoleMatrix);
-        var holesGroups = holeMatrixs.map(function (m) { return m && _this.findAllGroupsInMatrix(m); });
-        var holesPaths = holesGroups.map(function (hg, index) { return hg && hg.map(function (g) { return _this
-            .traceGroup(holeMatrixs[index], g); }).filter(function (r) { return r.length > DPolygon_1.MIN_POINTS_IN_VALID_POLYGON; }); });
-        return groups.map(function (g, index) {
-            var res = paths[index];
+    fullMatrixTrace() {
+        const groups = this.findAllGroupsInMatrix(this.m);
+        const paths = groups.map((g) => this.traceGroup(this.m, g));
+        const holeMatrixs = groups.map(this.createHoleMatrix);
+        const holesGroups = holeMatrixs.map((m) => m && this.findAllGroupsInMatrix(m));
+        const holesPaths = holesGroups.map((hg, index) => hg && hg.map((g) => this
+            .traceGroup(holeMatrixs[index], g)).filter((r) => r.length > DPolygon_1.MIN_POINTS_IN_VALID_POLYGON));
+        return groups.map((g, index) => {
+            const res = paths[index];
             if (holesGroups[index] && holesGroups[index].length) {
                 res.holes = holesPaths[index];
             }
             return res;
         });
-    };
-    TraceMatrix.prototype.reverseMatrix = function (m) {
-        return TraceMatrix.createMatrix(this.size, function (p) { return getByPosition(m, p) === TraceMatrixValues.f ? TraceMatrixValues.t : TraceMatrixValues.f; });
-    };
-    TraceMatrix.prototype.findMarked = function (m, init) {
-        var s = this.size;
-        var ini = false;
-        for (var i = 0; i < s.w; i++) {
-            for (var j = 0; j < s.h; j++) {
+    }
+    reverseMatrix(m) {
+        return TraceMatrix.createMatrix(this.size, (p) => getByPosition(m, p) === TraceMatrixValues.f ? TraceMatrixValues.t : TraceMatrixValues.f);
+    }
+    findMarked(m, init) {
+        const s = this.size;
+        let ini = false;
+        for (let i = 0; i < s.w; i++) {
+            for (let j = 0; j < s.h; j++) {
                 if (!ini && init) {
                     i = init.x;
                     j = init.y;
@@ -233,24 +183,22 @@ var TraceMatrix = (function () {
             }
         }
         return null;
-    };
-    TraceMatrix.prototype.totalCountInMatrix = function (m) {
-        var res = 0;
-        var s = this.size;
-        for (var i = 0; i < s.w; i++) {
-            for (var j = 0; j < s.h; j++) {
+    }
+    totalCountInMatrix(m) {
+        let res = 0;
+        const s = this.size;
+        for (let i = 0; i < s.w; i++) {
+            for (let j = 0; j < s.h; j++) {
                 if (getByPosition(m, new DPoint_1.DPoint(i, j))) {
                     res++;
                 }
             }
         }
         return res;
-    };
-    TraceMatrix.createMatrix = function (size, f) {
-        if (f === void 0) { f = function () { return TraceMatrixValues.f; }; }
+    }
+    static createMatrix(size, f = () => TraceMatrixValues.f) {
         return (0, utils_1.createArray)(size.h)
-            .map(function (v, i) { return (0, utils_1.createArray)(size.w).map(function (v2, j) { return f(new DPoint_1.DPoint(j, i)); }); });
-    };
-    return TraceMatrix;
-}());
+            .map((v, i) => (0, utils_1.createArray)(size.w).map((v2, j) => f(new DPoint_1.DPoint(j, i))));
+    }
+}
 exports.TraceMatrix = TraceMatrix;

package/dist/cjs/index.d.ts

@@ -7,4 +7,4 @@ export * from './FastSearch';
 export * from './TraceMatrix';
 export * from './DPolygonLoop';
 export * from './DPlane';
-export { gaussianElimination, createCanvas, createArray, createMatrix, isDefAndNotNull, cartesianProduct, DGeo } from './utils';
+export { gaussianElimination, createCanvas, createArray, createMatrix, isDefAndNotNull, cartesianProduct, getCombinations, DGeo } from './utils';

package/dist/cjs/index.js

@@ -10,7 +10,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DGeo = exports.cartesianProduct = exports.isDefAndNotNull = exports.createMatrix = exports.createArray = exports.createCanvas = exports.gaussianElimination = void 0;
+exports.DGeo = exports.getCombinations = exports.cartesianProduct = exports.isDefAndNotNull = exports.createMatrix = exports.createArray = exports.createCanvas = exports.gaussianElimination = void 0;
 __exportStar(require("./DCircle"), exports);
 __exportStar(require("./DLine"), exports);
 __exportStar(require("./DNumbers"), exports);
@@ -27,4 +27,5 @@ Object.defineProperty(exports, "createArray", { enumerable: true, get: function
 Object.defineProperty(exports, "createMatrix", { enumerable: true, get: function () { return utils_1.createMatrix; } });
 Object.defineProperty(exports, "isDefAndNotNull", { enumerable: true, get: function () { return utils_1.isDefAndNotNull; } });
 Object.defineProperty(exports, "cartesianProduct", { enumerable: true, get: function () { return utils_1.cartesianProduct; } });
+Object.defineProperty(exports, "getCombinations", { enumerable: true, get: function () { return utils_1.getCombinations; } });
 Object.defineProperty(exports, "DGeo", { enumerable: true, get: function () { return utils_1.DGeo; } });

package/dist/cjs/utils.d.ts

@@ -36,6 +36,7 @@ export declare const createCanvas: {
     document?: Document;
 };
 export declare const cartesianProduct: {
-    <T>(...a: T[][]): T[][];
+    <T>(a: T[], ...b: T[][]): T[][];
 };
+export declare const getCombinations: <T>(arr: T[][]) => T[][];
 export {};

package/dist/cjs/utils.js

@@ -1,87 +1,58 @@
 "use strict";
-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.cartesianProduct = exports.createCanvas = exports.gaussianElimination = exports.createMatrix = exports.createArray = exports.checkFunction = exports.isDefAndNotNull = exports.warn = exports.DGeo = void 0;
-var DPoint_1 = require("./DPoint");
+exports.getCombinations = exports.cartesianProduct = exports.createCanvas = exports.gaussianElimination = exports.createMatrix = exports.createArray = exports.checkFunction = exports.isDefAndNotNull = exports.warn = exports.DGeo = void 0;
+const DPoint_1 = require("./DPoint");
 exports.DGeo = {
     DEBUG: false
 };
-var warn = function () {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
+const warn = (...args) => {
     if (exports.DGeo.DEBUG) {
-        console.warn.apply(console, __spreadArray([], __read(args), false));
+        console.warn(...args);
     }
 };
 exports.warn = warn;
-var isDefAndNotNull = function (a) { return a != undefined; };
+const isDefAndNotNull = (a) => a != undefined;
 exports.isDefAndNotNull = isDefAndNotNull;
-var hook = function (scope) { return function () { return scope; }; };
-var shouldBeInt = function (scope, funcName, argName) { return function (p) {
+const hook = (scope) => () => scope;
+const shouldBeInt = (scope, funcName, argName) => (p) => {
     if (!p.clone().round()
         .equal(p)) {
-        (0, exports.warn)("\"" + funcName + "\" -> \"" + argName + "\" should be Int!");
+        (0, exports.warn)(`"${funcName}" -> "${argName}" should be Int!`);
     }
     return scope;
-}; };
-var shouldBeUInt = function (scope, funcName, argName) { return function (p) {
+};
+const shouldBeUInt = (scope, funcName, argName) => (p) => {
     if (!p.clone().round()
         .equal(p) || !p.gtOrEqual(DPoint_1.DPoint.zero())) {
-        (0, exports.warn)("\"" + funcName + "\" -> \"" + argName + "\" should be UInt!");
+        (0, exports.warn)(`"${funcName}" -> "${argName}" should be UInt!`);
     }
     return scope;
-}; };
-var shouldBeDegree = function (scope, funcName, argName) { return function (p) {
+};
+const shouldBeDegree = (scope, funcName, argName) => (p) => {
     if (!p.likeWorldGeodeticSystem) {
-        (0, exports.warn)("\"" + funcName + "\" -> \"" + argName + "\" should be degree!");
+        (0, exports.warn)(`"${funcName}" -> "${argName}" should be degree!`);
     }
     return scope;
-}; };
-var shouldBeRadians = function (scope, funcName, argName) { return function (p) {
+};
+const shouldBeRadians = (scope, funcName, argName) => (p) => {
     if (!p.likeRadians) {
-        (0, exports.warn)("\"" + funcName + "\" -> \"" + argName + "\" should be radians!");
+        (0, exports.warn)(`"${funcName}" -> "${argName}" should be radians!`);
     }
     return scope;
-}; };
-var shouldExist = function (scope, funcName, argName) { return function (p) {
+};
+const shouldExist = (scope, funcName, argName) => (p) => {
     if (!(0, exports.isDefAndNotNull)(p)) {
-        (0, exports.warn)("\"" + funcName + "\" -> \"" + argName + "\" should exist!");
+        (0, exports.warn)(`"${funcName}" -> "${argName}" should exist!`);
     }
     return scope;
-}; };
-var shouldBeMeters = function (scope, funcName, argName) { return function (p) {
+};
+const shouldBeMeters = (scope, funcName, argName) => (p) => {
     if (!p.likePseudoMercator) {
-        (0, exports.warn)("\"" + funcName + "\" -> \"" + argName + "\" should be meters!");
+        (0, exports.warn)(`"${funcName}" -> "${argName}" should be meters!`);
     }
     return scope;
-}; };
-var checkFunction = function (funcName) { return ({
+};
+const checkFunction = (funcName) => ({
     checkArgument: function (argName) {
         if (!exports.DGeo.DEBUG) {
             return {
@@ -102,71 +73,64 @@ var checkFunction = function (funcName) { return ({
             shouldExist: shouldExist(this, funcName, argName)
         };
     }
-}); };
+});
 exports.checkFunction = checkFunction;
-var createArray = function (v, fillSymbol) {
-    if (fillSymbol === void 0) { fillSymbol = 0; }
-    return new Array(v).fill(fillSymbol);
-};
+const createArray = (v, fillSymbol = 0) => new Array(v).fill(fillSymbol);
 exports.createArray = createArray;
-var createMatrix = function (_a, fillSymbol) {
-    var h = _a.h, w = _a.w;
-    if (fillSymbol === void 0) { fillSymbol = 0; }
-    return (0, exports.createArray)(h)
-        .map(function () { return (0, exports.createArray)(w, fillSymbol); });
-};
+const createMatrix = ({ h, w }, fillSymbol = 0) => (0, exports.createArray)(h)
+    .map(() => (0, exports.createArray)(w, fillSymbol));
 exports.createMatrix = createMatrix;
-var gaussianElimination = function (matrix) {
-    var n = matrix.length;
-    var matrixClone = (0, exports.createMatrix)(new DPoint_1.DPoint(n + 1, n));
-    for (var i = 0; i < n; i++) {
-        for (var j = 0; j < n + 1; j++) {
+const gaussianElimination = (matrix) => {
+    const n = matrix.length;
+    const matrixClone = (0, exports.createMatrix)(new DPoint_1.DPoint(n + 1, n));
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n + 1; j++) {
             matrix[i][j] = matrix[i][j] === 0 ? exports.gaussianElimination.MIN : matrix[i][j];
             matrixClone[i][j] = matrix[i][j];
         }
     }
-    for (var k = 0; k < n; k++) {
-        for (var i = 0; i < n + 1; i++) {
+    for (let k = 0; k < n; k++) {
+        for (let i = 0; i < n + 1; i++) {
             matrixClone[k][i] /= matrix[k][k];
         }
-        for (var i = k + 1; i < n; i++) {
-            var K = matrixClone[i][k] / matrixClone[k][k];
-            for (var j = 0; j < n + 1; j++) {
+        for (let i = k + 1; i < n; i++) {
+            const K = matrixClone[i][k] / matrixClone[k][k];
+            for (let j = 0; j < n + 1; j++) {
                 matrixClone[i][j] -= matrixClone[k][j] * K;
             }
         }
-        for (var i = 0; i < n; i++) {
-            for (var j = 0; j < n + 1; j++) {
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < n + 1; j++) {
                 matrix[i][j] = matrixClone[i][j];
             }
         }
     }
-    for (var k = n - 1; k > -1; k--) {
-        for (var i = n; i > -1; i--) {
+    for (let k = n - 1; k > -1; k--) {
+        for (let i = n; i > -1; i--) {
             matrixClone[k][i] /= matrix[k][k];
         }
-        for (var i = k - 1; i > -1; i--) {
-            var K = matrixClone[i][k] / matrixClone[k][k];
-            for (var j = n; j > -1; j--) {
+        for (let i = k - 1; i > -1; i--) {
+            const K = matrixClone[i][k] / matrixClone[k][k];
+            for (let j = n; j > -1; j--) {
                 matrixClone[i][j] -= matrixClone[k][j] * K;
             }
         }
     }
-    var answer = (0, exports.createArray)(n);
-    for (var i = 0; i < n; i++) {
+    const answer = (0, exports.createArray)(n);
+    for (let i = 0; i < n; i++) {
         answer[i] = matrixClone[i][n];
     }
     return answer;
 };
 exports.gaussianElimination = gaussianElimination;
 exports.gaussianElimination.MIN = 1e-10;
-var createCanvas = function (a, b, c) {
+const createCanvas = (a, b, c) => {
     var _a;
-    var w = 0;
-    var h = 0;
-    var offscreen = false;
+    let w = 0;
+    let h = 0;
+    let offscreen = false;
     if (a instanceof DPoint_1.DPoint) {
-        var x = a.x, y = a.y;
+        const { x, y } = a;
         w = x;
         h = y;
     }
@@ -183,7 +147,7 @@ var createCanvas = function (a, b, c) {
     if (typeof c === 'boolean') {
         offscreen = c;
     }
-    var canvas = offscreen ? new OffscreenCanvas(w, h) : ((_a = exports.createCanvas.document) !== null && _a !== void 0 ? _a : document).createElement('canvas');
+    const canvas = offscreen ? new OffscreenCanvas(w, h) : ((_a = exports.createCanvas.document) !== null && _a !== void 0 ? _a : document).createElement('canvas');
     if (!offscreen) {
         canvas.width = w;
         canvas.height = h;
@@ -191,12 +155,20 @@ var createCanvas = function (a, b, c) {
     return [canvas, canvas.getContext('2d')];
 };
 exports.createCanvas = createCanvas;
-var f = function (a, b) { return [].concat.apply([], __spreadArray([], __read(a.map(function (c) { return b.map(function (d) { return [].concat(c, d); }); })), false)); };
-var cartesianProduct = function (a, b) {
-    var c = [];
-    for (var _i = 2; _i < arguments.length; _i++) {
-        c[_i - 2] = arguments[_i];
+const f = (a, b) => [].concat(...a.map((c) => b.map((d) => [].concat(c, d))));
+const cartesianProduct = (a, b, ...c) => b ? (0, exports.cartesianProduct)(f(a, b), ...c) : a;
+exports.cartesianProduct = cartesianProduct;
+const getCombinations = (arr) => {
+    if (arr.length === 1) {
+        return arr[0];
+    }
+    const ans = [];
+    const otherCases = (0, exports.getCombinations)(arr.slice(1));
+    for (let i = 0; i < otherCases.length; i++) {
+        for (let j = 0; j < arr[0].length; j++) {
+            ans.push([arr[0][j], ...otherCases[i]]);
+        }
     }
-    return b ? exports.cartesianProduct.apply(void 0, __spreadArray([f(a, b)], __read(c), false)) : a;
+    return ans;
 };
-exports.cartesianProduct = cartesianProduct;
+exports.getCombinations = getCombinations;

package/dist/es2015/DPolygon.js

@@ -624,7 +624,7 @@ export class DPolygon {
     toArrayOfCoords() {
         return this.mapArray((r) => r.toCoords());
     }
-    divideToPieces(piecesCount) {
+    divideToPieces(piecesCount, withAltitude = false) {
         const { fullLength } = this;
         const pieceLength = fullLength / piecesCount;
         let currentPieceLength = pieceLength;
@@ -641,6 +641,10 @@ export class DPolygon {
                     .filter((p) => line.inRange(p, CLOSE_TO_INTERSECTION_DISTANCE))[0];
                 intersectionPoint.properties.pieceBorder = true;
                 this.insertAfter(i, intersectionPoint);
+                if (withAltitude) {
+                    const p1z = p1.z;
+                    intersectionPoint.z = p1z - (p1z - p2.z) * (p1.distance(intersectionPoint) / d);
+                }
                 currentPieceLength = pieceLength;
             }
             else {

package/dist/es2015/index.js

@@ -7,4 +7,4 @@ export * from './FastSearch';
 export * from './TraceMatrix';
 export * from './DPolygonLoop';
 export * from './DPlane';
-export { gaussianElimination, createCanvas, createArray, createMatrix, isDefAndNotNull, cartesianProduct, DGeo } from './utils';
+export { gaussianElimination, createCanvas, createArray, createMatrix, isDefAndNotNull, cartesianProduct, getCombinations, DGeo } from './utils';