dgeoutils 2.2.22 → 2.3.1

package/dist/esm/DPolygonLoop.js

@@ -0,0 +1,398 @@
+var LoopFunctions;
+(function (LoopFunctions) {
+    LoopFunctions[LoopFunctions["getTileFromCoords"] = 0] = "getTileFromCoords";
+    LoopFunctions[LoopFunctions["getCoordsFromTile"] = 1] = "getCoordsFromTile";
+    LoopFunctions[LoopFunctions["height"] = 2] = "height";
+    LoopFunctions[LoopFunctions["setX"] = 3] = "setX";
+    LoopFunctions[LoopFunctions["setY"] = 4] = "setY";
+    LoopFunctions[LoopFunctions["setZ"] = 5] = "setZ";
+    LoopFunctions[LoopFunctions["rotate"] = 6] = "rotate";
+    LoopFunctions[LoopFunctions["rotate3dX"] = 7] = "rotate3dX";
+    LoopFunctions[LoopFunctions["rotate3dY"] = 8] = "rotate3dY";
+    LoopFunctions[LoopFunctions["rotate3dZ"] = 9] = "rotate3dZ";
+    LoopFunctions[LoopFunctions["move"] = 10] = "move";
+    LoopFunctions[LoopFunctions["round"] = 11] = "round";
+    LoopFunctions[LoopFunctions["ceil"] = 12] = "ceil";
+    LoopFunctions[LoopFunctions["floor"] = 13] = "floor";
+    LoopFunctions[LoopFunctions["toFixed"] = 14] = "toFixed";
+    LoopFunctions[LoopFunctions["abs"] = 15] = "abs";
+    LoopFunctions[LoopFunctions["scale"] = 16] = "scale";
+    LoopFunctions[LoopFunctions["divide"] = 17] = "divide";
+    LoopFunctions[LoopFunctions["degreeToRadians"] = 18] = "degreeToRadians";
+    LoopFunctions[LoopFunctions["radiansToDegrees"] = 19] = "radiansToDegrees";
+    LoopFunctions[LoopFunctions["radiansToMeters"] = 20] = "radiansToMeters";
+    LoopFunctions[LoopFunctions["metersToRadians"] = 21] = "metersToRadians";
+    LoopFunctions[LoopFunctions["hipPoint"] = 22] = "hipPoint";
+    LoopFunctions[LoopFunctions["xPoint"] = 23] = "xPoint";
+    LoopFunctions[LoopFunctions["yPoint"] = 24] = "yPoint";
+    LoopFunctions[LoopFunctions["wPoint"] = 25] = "wPoint";
+    LoopFunctions[LoopFunctions["hPoint"] = 26] = "hPoint";
+    LoopFunctions[LoopFunctions["setIfLessThan"] = 27] = "setIfLessThan";
+    LoopFunctions[LoopFunctions["minus"] = 28] = "minus";
+    LoopFunctions[LoopFunctions["degreeToMeters"] = 29] = "degreeToMeters";
+    LoopFunctions[LoopFunctions["metersToDegree"] = 30] = "metersToDegree";
+    LoopFunctions[LoopFunctions["flipVertically"] = 31] = "flipVertically";
+})(LoopFunctions || (LoopFunctions = {}));
+var decodePoolRecord = function (a, _a) {
+    var functionName = _a.functionName, pointArg = _a.pointArg, numberPointArg = _a.numberPointArg, numberArg = _a.numberArg, setterArg = _a.setterArg;
+    var res = a;
+    switch (functionName) {
+        case LoopFunctions.getTileFromCoords:
+            res = function (k) { return a(k)
+                .getTileFromCoords(numberArg); };
+            break;
+        case LoopFunctions.getCoordsFromTile:
+            res = function (k) { return a(k)
+                .getCoordsFromTile(numberArg); };
+            break;
+        case LoopFunctions.height:
+            res = function (k) { return a(k)
+                .height(numberArg); };
+            break;
+        case LoopFunctions.setX:
+            res = function (k) { return a(k)
+                .setX(setterArg); };
+            break;
+        case LoopFunctions.setY:
+            res = function (k) { return a(k)
+                .setY(setterArg); };
+            break;
+        case LoopFunctions.setZ:
+            res = function (k) { return a(k)
+                .setZ(setterArg); };
+            break;
+        case LoopFunctions.rotate:
+            res = function (k) { return a(k)
+                .rotate(numberArg); };
+            break;
+        case LoopFunctions.rotate3dX:
+            res = function (k) { return a(k)
+                .rotate3dX(numberArg); };
+            break;
+        case LoopFunctions.rotate3dY:
+            res = function (k) { return a(k)
+                .rotate3dY(numberArg); };
+            break;
+        case LoopFunctions.rotate3dZ:
+            res = function (k) { return a(k)
+                .rotate3dZ(numberArg); };
+            break;
+        case LoopFunctions.move:
+            res = function (k) { return a(k)
+                .move(numberPointArg, numberArg); };
+            break;
+        case LoopFunctions.round:
+            res = function (k) { return a(k)
+                .round(); };
+            break;
+        case LoopFunctions.ceil:
+            res = function (k) { return a(k)
+                .ceil(); };
+            break;
+        case LoopFunctions.floor:
+            res = function (k) { return a(k)
+                .floor(); };
+            break;
+        case LoopFunctions.toFixed:
+            res = function (k) { return a(k)
+                .toFixed(numberArg); };
+            break;
+        case LoopFunctions.abs:
+            res = function (k) { return a(k)
+                .abs(); };
+            break;
+        case LoopFunctions.scale:
+            res = function (k) { return a(k)
+                .scale(numberPointArg, numberArg); };
+            break;
+        case LoopFunctions.divide:
+            res = function (k) { return a(k)
+                .divide(numberPointArg, numberArg); };
+            break;
+        case LoopFunctions.degreeToRadians:
+            res = function (k) { return a(k)
+                .degreeToRadians(); };
+            break;
+        case LoopFunctions.radiansToDegrees:
+            res = function (k) { return a(k)
+                .radiansToDegrees(); };
+            break;
+        case LoopFunctions.radiansToMeters:
+            res = function (k) { return a(k)
+                .radiansToMeters(); };
+            break;
+        case LoopFunctions.metersToRadians:
+            res = function (k) { return a(k)
+                .metersToRadians(); };
+            break;
+        case LoopFunctions.hipPoint:
+            res = function (k) { return a(k)
+                .hipPoint; };
+            break;
+        case LoopFunctions.xPoint:
+            res = function (k) { return a(k)
+                .xPoint; };
+            break;
+        case LoopFunctions.yPoint:
+            res = function (k) { return a(k)
+                .yPoint; };
+            break;
+        case LoopFunctions.wPoint:
+            res = function (k) { return a(k)
+                .wPoint; };
+            break;
+        case LoopFunctions.hPoint:
+            res = function (k) { return a(k)
+                .hPoint; };
+            break;
+        case LoopFunctions.setIfLessThan:
+            res = function (k) { return a(k)
+                .setIfLessThan(pointArg); };
+            break;
+        case LoopFunctions.minus:
+            res = function (k) { return a(k)
+                .minus(); };
+            break;
+        case LoopFunctions.degreeToMeters:
+            res = function (k) { return a(k)
+                .degreeToMeters(); };
+            break;
+        case LoopFunctions.metersToDegree:
+            res = function (k) { return a(k)
+                .metersToDegree(); };
+            break;
+        case LoopFunctions.flipVertically:
+            res = function (k) { return a(k)
+                .flipVertically(numberPointArg); };
+            break;
+    }
+    return res;
+};
+var DPolygonLoop = (function () {
+    function DPolygonLoop(parent) {
+        this.parent = parent;
+        this.pool = [];
+    }
+    DPolygonLoop.prototype.getLoopFunction = function () {
+        return this.pool.reduce(decodePoolRecord, function (k) { return k; });
+    };
+    DPolygonLoop.prototype.run = function () {
+        return this.parent.map(this.getLoopFunction());
+    };
+    DPolygonLoop.prototype.getTileFromCoords = function (zoom) {
+        this.pool.push({
+            functionName: LoopFunctions.getTileFromCoords,
+            numberArg: zoom
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.getCoordsFromTile = function (zoom) {
+        this.pool.push({
+            functionName: LoopFunctions.getCoordsFromTile,
+            numberArg: zoom
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.height = function (z) {
+        this.pool.push({
+            functionName: LoopFunctions.height,
+            numberArg: z
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.setX = function (x) {
+        this.pool.push({
+            functionName: LoopFunctions.setX,
+            setterArg: x
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.setY = function (y) {
+        this.pool.push({
+            functionName: LoopFunctions.setY,
+            setterArg: y
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.setZ = function (z) {
+        this.pool.push({
+            functionName: LoopFunctions.setZ,
+            setterArg: z
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.rotate = function (a) {
+        this.pool.push({
+            functionName: LoopFunctions.rotate,
+            numberArg: a
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.rotate3dX = function (a) {
+        this.pool.push({
+            functionName: LoopFunctions.rotate3dX,
+            numberArg: a
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.rotate3dY = function (a) {
+        this.pool.push({
+            functionName: LoopFunctions.rotate3dY,
+            numberArg: a
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.rotate3dZ = function (a) {
+        this.pool.push({
+            functionName: LoopFunctions.rotate3dZ,
+            numberArg: a
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.move = function (x, y) {
+        if (y === void 0) { y = x; }
+        this.pool.push({
+            functionName: LoopFunctions.move,
+            numberPointArg: x,
+            numberArg: y
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.round = function () {
+        this.pool.push({
+            functionName: LoopFunctions.round
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.ceil = function () {
+        this.pool.push({
+            functionName: LoopFunctions.ceil
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.floor = function () {
+        this.pool.push({
+            functionName: LoopFunctions.floor
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.toFixed = function (n) {
+        if (n === void 0) { n = 2; }
+        this.pool.push({
+            functionName: LoopFunctions.toFixed,
+            numberArg: n
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.abs = function () {
+        this.pool.push({
+            functionName: LoopFunctions.abs
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.scale = function (x, y) {
+        if (y === void 0) { y = x; }
+        this.pool.push({
+            functionName: LoopFunctions.scale,
+            numberPointArg: x,
+            numberArg: y
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.divide = function (x, y) {
+        this.pool.push({
+            functionName: LoopFunctions.divide,
+            numberPointArg: x,
+            numberArg: y
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.degreeToRadians = function () {
+        this.pool.push({
+            functionName: LoopFunctions.degreeToRadians
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.radiansToDegrees = function () {
+        this.pool.push({
+            functionName: LoopFunctions.radiansToDegrees
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.radiansToMeters = function () {
+        this.pool.push({
+            functionName: LoopFunctions.radiansToMeters
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.metersToRadians = function () {
+        this.pool.push({
+            functionName: LoopFunctions.metersToRadians
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.getHipPoint = function () {
+        this.pool.push({
+            functionName: LoopFunctions.hipPoint
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.getXPoint = function () {
+        this.pool.push({
+            functionName: LoopFunctions.xPoint
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.getYPoint = function () {
+        this.pool.push({
+            functionName: LoopFunctions.yPoint
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.getWPoint = function () {
+        this.pool.push({
+            functionName: LoopFunctions.wPoint
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.getHPoint = function () {
+        this.pool.push({
+            functionName: LoopFunctions.hPoint
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.setIfLessThan = function (p) {
+        this.pool.push({
+            functionName: LoopFunctions.setIfLessThan,
+            pointArg: p
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.minus = function () {
+        this.pool.push({
+            functionName: LoopFunctions.minus
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.degreeToMeters = function () {
+        this.pool.push({
+            functionName: LoopFunctions.degreeToMeters
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.metersToDegree = function () {
+        this.pool.push({
+            functionName: LoopFunctions.metersToDegree
+        });
+        return this;
+    };
+    DPolygonLoop.prototype.flipVertically = function (size) {
+        this.pool.push({
+            functionName: LoopFunctions.flipVertically,
+            numberPointArg: size
+        });
+        return this;
+    };
+    return DPolygonLoop;
+}());
+export { DPolygonLoop };

package/dist/esm/FastSearch.js

@@ -0,0 +1,50 @@
+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 FastSearch = (function () {
+    function FastSearch() {
+        this.searchStore = {};
+    }
+    FastSearch.prototype.add = function (points) {
+        var e_1, _a;
+        try {
+            for (var points_1 = __values(points), points_1_1 = points_1.next(); !points_1_1.done; points_1_1 = points_1.next()) {
+                var _b = points_1_1.value, x = _b.x, y = _b.y, z = _b.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_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (points_1_1 && !points_1_1.done && (_a = points_1.return)) _a.call(points_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    FastSearch.prototype.find = 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;
+        }
+        return this.searchStore[x][y][z || 'undefined'];
+    };
+    return FastSearch;
+}());
+export { FastSearch };

package/dist/esm/TraceMatrix.js

@@ -0,0 +1,253 @@
+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.");
+};
+import { DPoint } from './DPoint';
+import { DPolygon, MIN_POINTS_IN_VALID_POLYGON } from './DPolygon';
+import { FastSearch } from './FastSearch';
+import { createArray } from './utils';
+export var TraceMatrixValues;
+(function (TraceMatrixValues) {
+    TraceMatrixValues[TraceMatrixValues["f"] = 0] = "f";
+    TraceMatrixValues[TraceMatrixValues["t"] = 1] = "t";
+})(TraceMatrixValues || (TraceMatrixValues = {}));
+var getByPosition = function (m, p, defaultValue) {
+    if (defaultValue === void 0) { 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) {
+    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;
+        this.size = size;
+        this.findGroupByIndex = function (m, s) {
+            var res = new DPolygon();
+            if (s && getByPosition(m, s) === TraceMatrixValues.t) {
+                res.push(s);
+                var startIndex = 0;
+                var marked = TraceMatrix.createMatrix(_this.size, function () { return 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(r.x + i, r.y + j);
+                            if (getByPosition(marked, t, TraceMatrixValues.t) === TraceMatrixValues.f &&
+                                getByPosition(m, t, TraceMatrixValues.f) === TraceMatrixValues.t) {
+                                res.push(t);
+                                setByPosition(marked, t, TraceMatrixValues.t);
+                            }
+                        }
+                    }
+                    startIndex++;
+                }
+            }
+            return res;
+        };
+        this.findAllGroupsInMatrix = function (m) {
+            var 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();
+            fs.add(allGroups);
+            while (groupSum < _this.totalCountInMatrix(m)) {
+                var mark = _this.findMarked(m);
+                while (mark && fs.find(mark)) {
+                    mark = _this.findMarked(m, mark);
+                }
+                var nextGroup = _this.findGroupByIndex(m, mark);
+                groupSum += nextGroup.length;
+                allGroups = __spreadArray(__spreadArray([], __read(allGroups), false), __read(nextGroup.points), false);
+                fs.add(nextGroup.points);
+                groups.push(nextGroup);
+            }
+            return groups.filter(function (g) { return g.length > 2; });
+        };
+        this.traceGroup = function (m, group) {
+            var traceDirections = [
+                new DPoint(-1, -1),
+                new DPoint(-1, 0),
+                new DPoint(-1, 1),
+                new DPoint(0, 1),
+                new DPoint(1, 1),
+                new DPoint(1, 0),
+                new DPoint(1, -1),
+                new 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; };
+            if (group.length < 2) {
+                var t = group.at(0).clone();
+                return new DPolygon([t, t, t]);
+            }
+            var points = new DPolygon();
+            var direction = 0;
+            var prevDirection = Infinity;
+            var 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)]));
+                    if (nextValue === TraceMatrixValues.t && nextNeighbourValue === TraceMatrixValues.f) {
+                        break;
+                    }
+                    direction = right(direction);
+                }
+                if (prevDirection !== direction) {
+                    points.push(p);
+                    prevDirection = direction;
+                }
+                p = p.clone().move(traceDirections[direction]);
+                direction = left(left(direction));
+            }
+            return points.approximation().close();
+        };
+        this.createHoleMatrix = function (group) {
+            var e_1, _a;
+            var fullTraceDirections = [
+                new DPoint(-1, 0),
+                new DPoint(0, 1),
+                new DPoint(1, 0),
+                new 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();
+            for (var i = 0; i < _this.size.w; i++) {
+                startCoords.push(new DPoint(i, -1));
+                startCoords.push(new DPoint(i, _this.size.h));
+            }
+            for (var i = 0; i < _this.size.h; i++) {
+                startCoords.push(new DPoint(-1, i));
+                startCoords.push(new 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);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            var 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 > MIN_POINTS_IN_VALID_POLYGON; }); });
+        return groups.map(function (g, index) {
+            var 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++) {
+                if (!ini && init) {
+                    i = init.x;
+                    j = init.y;
+                    ini = true;
+                    continue;
+                }
+                if (getByPosition(m, new DPoint(i, j)) === TraceMatrixValues.t) {
+                    return new DPoint(i, j);
+                }
+            }
+        }
+        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++) {
+                if (getByPosition(m, new DPoint(i, j))) {
+                    res++;
+                }
+            }
+        }
+        return res;
+    };
+    TraceMatrix.createMatrix = function (size, f) {
+        if (f === void 0) { f = function () { return TraceMatrixValues.f; }; }
+        return createArray(size.h)
+            .map(function (v, i) { return createArray(size.w).map(function (v2, j) { return f(new DPoint(j, i)); }); });
+    };
+    return TraceMatrix;
+}());
+export { TraceMatrix };