dgeoutils 2.4.25 → 2.4.27

package/dist/cjs/InterpolationMatrix.d.ts

@@ -0,0 +1,22 @@
+import { DPolygon } from './DPolygon';
+import { DPoint } from './DPoint';
+export declare class InterpolationMatrix {
+    private readonly stepSize;
+    private readonly p;
+    private readonly minPoint;
+    private readonly maxPoint;
+    private points;
+    private cells;
+    private allCells;
+    private readonly sizePoly;
+    private readonly keys;
+    constructor(bboxLike: DPolygon, stepSize: number, keys: string[] | string, p?: number);
+    setKnownPoints(points: DPoint[] | DPolygon): InterpolationMatrix;
+    positionToCellCoords(d: DPoint): DPoint;
+    calculate(): InterpolationMatrix;
+    getCellValue({ x, y }: DPoint, key?: string | string[]): (number | Record<string, number>);
+    get allCellsClone(): DPolygon[];
+    private interpolateValues;
+    private setKnownValues;
+    private generateCells;
+}

package/dist/cjs/InterpolationMatrix.js

@@ -0,0 +1,134 @@
+"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 __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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterpolationMatrix = void 0;
+var DPolygon_1 = require("./DPolygon");
+var DPoint_1 = require("./DPoint");
+var utils_1 = require("./utils");
+var InterpolationMatrix = (function () {
+    function InterpolationMatrix(bboxLike, stepSize, keys, p) {
+        if (p === void 0) { p = 2; }
+        this.stepSize = stepSize;
+        this.p = p;
+        this.points = [];
+        this.cells = {};
+        this.allCells = [];
+        this.minPoint = bboxLike.leftTop;
+        this.maxPoint = bboxLike.rightBottom;
+        this.sizePoly = DPolygon_1.DPolygon.createSquareBySize(new DPoint_1.DPoint(this.stepSize));
+        this.keys = Array.isArray(keys) ? keys : [keys];
+        this.generateCells();
+    }
+    InterpolationMatrix.prototype.setKnownPoints = function (points) {
+        this.points = points instanceof DPolygon_1.DPolygon ? points.points : points;
+        return this;
+    };
+    InterpolationMatrix.prototype.positionToCellCoords = function (d) {
+        return d.clone()
+            .move(this.minPoint.clone().minus())
+            .divide(this.stepSize)
+            .floor();
+    };
+    InterpolationMatrix.prototype.calculate = function () {
+        this.setKnownValues();
+        this.interpolateValues();
+        return this;
+    };
+    InterpolationMatrix.prototype.getCellValue = function (_a, key) {
+        var x = _a.x, y = _a.y;
+        var cell = this.cells[x][y];
+        if (key) {
+            if (Array.isArray(key)) {
+                return key.reduce(function (a, k) {
+                    a[k] = cell.properties[k];
+                    return a;
+                }, {});
+            }
+            return cell.properties[key];
+        }
+        return __assign({}, cell.properties);
+    };
+    Object.defineProperty(InterpolationMatrix.prototype, "allCellsClone", {
+        get: function () {
+            return this.allCells.map(function (p) { return p.clone(); });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    InterpolationMatrix.prototype.interpolateValues = function () {
+        var _this = this;
+        var points = this.points.map(function (p) { return _this.positionToCellCoords(p); });
+        this.allCells.forEach(function (cell) {
+            var t = new DPoint_1.DPoint(cell.properties.x, cell.properties.y);
+            var distances = points.map(function (p) { return Math.pow(t.distance(p), _this.p); });
+            _this.keys.forEach(function (k) {
+                if ((0, utils_1.isDefAndNotNull)(cell.properties[k])) {
+                    return;
+                }
+                var _a = __read(distances.reduce(function (a, d, i) {
+                    if ((0, utils_1.isDefAndNotNull)(_this.points[i].properties[k])) {
+                        a[0] += _this.points[i].properties[k] / d;
+                        a[1] += 1 / d;
+                    }
+                    return a;
+                }, [0, 0]), 2), valueSum = _a[0], oneSum = _a[1];
+                cell.properties[k] = valueSum / oneSum;
+            });
+        });
+    };
+    InterpolationMatrix.prototype.setKnownValues = function () {
+        var _this = this;
+        this.points.forEach(function (p) {
+            var _a = _this.positionToCellCoords(p), x = _a.x, y = _a.y;
+            _this.keys.forEach(function (k) {
+                _this.cells[x][y].properties[k] = p.properties[k];
+            });
+        });
+    };
+    InterpolationMatrix.prototype.generateCells = function () {
+        for (var i = this.minPoint.x, x = 0; i < this.maxPoint.x; i += this.stepSize, x++) {
+            this.cells[x] = this.cells[x] || {};
+            for (var j = this.minPoint.y, y = 0; j < this.maxPoint.y; j += this.stepSize, y++) {
+                var t = this.sizePoly
+                    .clone()
+                    .loop()
+                    .move(i, j)
+                    .run()
+                    .setProperties({
+                    x: x,
+                    y: y
+                });
+                this.cells[x][y] = t;
+                this.allCells.push(t);
+            }
+        }
+    };
+    return InterpolationMatrix;
+}());
+exports.InterpolationMatrix = InterpolationMatrix;

package/dist/cjs/TraceMatrix.js

@@ -207,8 +207,8 @@ var TraceMatrix = (function () {
             return TraceMatrixValues.f;
         });
         this.m = TraceMatrix.createMatrix(this.size);
-        for (var i = 1; i < this.size.x - 1; i++) {
-            for (var j = 1; j < this.size.y - 1; j++) {
+        for (var i = 1; i < this.size.y - 1; i++) {
+            for (var j = 1; j < this.size.x - 1; j++) {
                 if (t[i][j] === TraceMatrixValues.t) {
                     this.m[i - 1][j - 1] = TraceMatrixValues.t;
                     this.m[i - 1][j] = TraceMatrixValues.t;

package/dist/es2015/InterpolationMatrix.js

@@ -0,0 +1,94 @@
+import { DPolygon } from './DPolygon';
+import { DPoint } from './DPoint';
+import { isDefAndNotNull } from './utils';
+export class InterpolationMatrix {
+    constructor(bboxLike, stepSize, keys, p = 2) {
+        this.stepSize = stepSize;
+        this.p = p;
+        this.points = [];
+        this.cells = {};
+        this.allCells = [];
+        this.minPoint = bboxLike.leftTop;
+        this.maxPoint = bboxLike.rightBottom;
+        this.sizePoly = DPolygon.createSquareBySize(new DPoint(this.stepSize));
+        this.keys = Array.isArray(keys) ? keys : [keys];
+        this.generateCells();
+    }
+    setKnownPoints(points) {
+        this.points = points instanceof DPolygon ? points.points : points;
+        return this;
+    }
+    positionToCellCoords(d) {
+        return d.clone()
+            .move(this.minPoint.clone().minus())
+            .divide(this.stepSize)
+            .floor();
+    }
+    calculate() {
+        this.setKnownValues();
+        this.interpolateValues();
+        return this;
+    }
+    getCellValue({ x, y }, key) {
+        const cell = this.cells[x][y];
+        if (key) {
+            if (Array.isArray(key)) {
+                return key.reduce((a, k) => {
+                    a[k] = cell.properties[k];
+                    return a;
+                }, {});
+            }
+            return cell.properties[key];
+        }
+        return Object.assign({}, cell.properties);
+    }
+    get allCellsClone() {
+        return this.allCells.map((p) => p.clone());
+    }
+    interpolateValues() {
+        const points = this.points.map((p) => this.positionToCellCoords(p));
+        this.allCells.forEach((cell) => {
+            const t = new DPoint(cell.properties.x, cell.properties.y);
+            const distances = points.map((p) => Math.pow(t.distance(p), this.p));
+            this.keys.forEach((k) => {
+                if (isDefAndNotNull(cell.properties[k])) {
+                    return;
+                }
+                const [valueSum, oneSum] = distances.reduce((a, d, i) => {
+                    if (isDefAndNotNull(this.points[i].properties[k])) {
+                        a[0] += this.points[i].properties[k] / d;
+                        a[1] += 1 / d;
+                    }
+                    return a;
+                }, [0, 0]);
+                cell.properties[k] = valueSum / oneSum;
+            });
+        });
+    }
+    setKnownValues() {
+        this.points.forEach((p) => {
+            const { x, y } = this.positionToCellCoords(p);
+            this.keys.forEach((k) => {
+                this.cells[x][y].properties[k] = p.properties[k];
+            });
+        });
+    }
+    generateCells() {
+        for (let i = this.minPoint.x, x = 0; i < this.maxPoint.x; i += this.stepSize, x++) {
+            this.cells[x] = this.cells[x] || {};
+            for (let j = this.minPoint.y, y = 0; j < this.maxPoint.y; j += this.stepSize, y++) {
+                const t = this.sizePoly
+                    .clone()
+                    .loop()
+                    .move(i, j)
+                    .run()
+                    .setProperties({
+                    x,
+                    y
+                });
+                this.cells[x][y] = t;
+                this.allCells.push(t);
+            }
+        }
+    }
+}

package/dist/es2015/TraceMatrix.js

@@ -155,8 +155,8 @@ export class TraceMatrix {
             return TraceMatrixValues.f;
         });
         this.m = TraceMatrix.createMatrix(this.size);
-        for (let i = 1; i < this.size.x - 1; i++) {
-            for (let j = 1; j < this.size.y - 1; j++) {
+        for (let i = 1; i < this.size.y - 1; i++) {
+            for (let j = 1; j < this.size.x - 1; j++) {
                 if (t[i][j] === TraceMatrixValues.t) {
                     this.m[i - 1][j - 1] = TraceMatrixValues.t;
                     this.m[i - 1][j] = TraceMatrixValues.t;

package/dist/esm/InterpolationMatrix.js

@@ -0,0 +1,131 @@
+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 __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;
+};
+import { DPolygon } from './DPolygon';
+import { DPoint } from './DPoint';
+import { isDefAndNotNull } from './utils';
+var InterpolationMatrix = (function () {
+    function InterpolationMatrix(bboxLike, stepSize, keys, p) {
+        if (p === void 0) { p = 2; }
+        this.stepSize = stepSize;
+        this.p = p;
+        this.points = [];
+        this.cells = {};
+        this.allCells = [];
+        this.minPoint = bboxLike.leftTop;
+        this.maxPoint = bboxLike.rightBottom;
+        this.sizePoly = DPolygon.createSquareBySize(new DPoint(this.stepSize));
+        this.keys = Array.isArray(keys) ? keys : [keys];
+        this.generateCells();
+    }
+    InterpolationMatrix.prototype.setKnownPoints = function (points) {
+        this.points = points instanceof DPolygon ? points.points : points;
+        return this;
+    };
+    InterpolationMatrix.prototype.positionToCellCoords = function (d) {
+        return d.clone()
+            .move(this.minPoint.clone().minus())
+            .divide(this.stepSize)
+            .floor();
+    };
+    InterpolationMatrix.prototype.calculate = function () {
+        this.setKnownValues();
+        this.interpolateValues();
+        return this;
+    };
+    InterpolationMatrix.prototype.getCellValue = function (_a, key) {
+        var x = _a.x, y = _a.y;
+        var cell = this.cells[x][y];
+        if (key) {
+            if (Array.isArray(key)) {
+                return key.reduce(function (a, k) {
+                    a[k] = cell.properties[k];
+                    return a;
+                }, {});
+            }
+            return cell.properties[key];
+        }
+        return __assign({}, cell.properties);
+    };
+    Object.defineProperty(InterpolationMatrix.prototype, "allCellsClone", {
+        get: function () {
+            return this.allCells.map(function (p) { return p.clone(); });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    InterpolationMatrix.prototype.interpolateValues = function () {
+        var _this = this;
+        var points = this.points.map(function (p) { return _this.positionToCellCoords(p); });
+        this.allCells.forEach(function (cell) {
+            var t = new DPoint(cell.properties.x, cell.properties.y);
+            var distances = points.map(function (p) { return Math.pow(t.distance(p), _this.p); });
+            _this.keys.forEach(function (k) {
+                if (isDefAndNotNull(cell.properties[k])) {
+                    return;
+                }
+                var _a = __read(distances.reduce(function (a, d, i) {
+                    if (isDefAndNotNull(_this.points[i].properties[k])) {
+                        a[0] += _this.points[i].properties[k] / d;
+                        a[1] += 1 / d;
+                    }
+                    return a;
+                }, [0, 0]), 2), valueSum = _a[0], oneSum = _a[1];
+                cell.properties[k] = valueSum / oneSum;
+            });
+        });
+    };
+    InterpolationMatrix.prototype.setKnownValues = function () {
+        var _this = this;
+        this.points.forEach(function (p) {
+            var _a = _this.positionToCellCoords(p), x = _a.x, y = _a.y;
+            _this.keys.forEach(function (k) {
+                _this.cells[x][y].properties[k] = p.properties[k];
+            });
+        });
+    };
+    InterpolationMatrix.prototype.generateCells = function () {
+        for (var i = this.minPoint.x, x = 0; i < this.maxPoint.x; i += this.stepSize, x++) {
+            this.cells[x] = this.cells[x] || {};
+            for (var j = this.minPoint.y, y = 0; j < this.maxPoint.y; j += this.stepSize, y++) {
+                var t = this.sizePoly
+                    .clone()
+                    .loop()
+                    .move(i, j)
+                    .run()
+                    .setProperties({
+                    x: x,
+                    y: y
+                });
+                this.cells[x][y] = t;
+                this.allCells.push(t);
+            }
+        }
+    };
+    return InterpolationMatrix;
+}());
+export { InterpolationMatrix };

package/dist/esm/TraceMatrix.js

@@ -204,8 +204,8 @@ var TraceMatrix = (function () {
             return TraceMatrixValues.f;
         });
         this.m = TraceMatrix.createMatrix(this.size);
-        for (var i = 1; i < this.size.x - 1; i++) {
-            for (var j = 1; j < this.size.y - 1; j++) {
+        for (var i = 1; i < this.size.y - 1; i++) {
+            for (var j = 1; j < this.size.x - 1; j++) {
                 if (t[i][j] === TraceMatrixValues.t) {
                     this.m[i - 1][j - 1] = TraceMatrixValues.t;
                     this.m[i - 1][j] = TraceMatrixValues.t;