dgeoutils 2.4.41 → 2.4.44

package/dist/es2015/DPolygonLoop.js

@@ -1,430 +0,0 @@
-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["setProperties"] = 32] = "setProperties";
-    LoopFunctions[LoopFunctions["div"] = 33] = "div";
-    LoopFunctions[LoopFunctions["mod"] = 34] = "mod";
-})(LoopFunctions || (LoopFunctions = {}));
-const decodePoolRecord = (a, { functionName, pointArg, numberPointArg, numberArg, setterArg, setterArgByObject }) => {
-    let res = a;
-    switch (functionName) {
-        case LoopFunctions.getTileFromCoords:
-            res = (k, index) => a(k, index)
-                .getTileFromCoords(numberArg);
-            break;
-        case LoopFunctions.getCoordsFromTile:
-            res = (k, index) => a(k, index)
-                .getCoordsFromTile(numberArg);
-            break;
-        case LoopFunctions.height:
-            res = (k, index) => a(k, index)
-                .height(numberArg);
-            break;
-        case LoopFunctions.setX:
-            res = (k, index) => typeof setterArg === 'number' ? a(k, index)
-                .setX(setterArg) : a(k, index).setX((p) => setterArg(p, index));
-            break;
-        case LoopFunctions.setY:
-            res = (k, index) => typeof setterArg === 'number' ? a(k, index)
-                .setY(setterArg) : a(k, index).setY((p) => setterArg(p, index));
-            break;
-        case LoopFunctions.setZ:
-            res = (k, index) => typeof setterArg === 'number' ? a(k, index)
-                .setZ(setterArg) : a(k, index).setZ((p) => setterArg(p, index));
-            break;
-        case LoopFunctions.rotate:
-            res = (k, index) => a(k, index)
-                .rotate(numberArg);
-            break;
-        case LoopFunctions.rotate3dX:
-            res = (k, index) => a(k, index)
-                .rotate3dX(numberArg);
-            break;
-        case LoopFunctions.rotate3dY:
-            res = (k, index) => a(k, index)
-                .rotate3dY(numberArg);
-            break;
-        case LoopFunctions.rotate3dZ:
-            res = (k, index) => a(k, index)
-                .rotate3dZ(numberArg);
-            break;
-        case LoopFunctions.move:
-            res = (k, index) => a(k, index)
-                .move(numberPointArg, numberArg);
-            break;
-        case LoopFunctions.round:
-            res = (k, index) => a(k, index)
-                .round();
-            break;
-        case LoopFunctions.ceil:
-            res = (k, index) => a(k, index)
-                .ceil();
-            break;
-        case LoopFunctions.floor:
-            res = (k, index) => a(k, index)
-                .floor();
-            break;
-        case LoopFunctions.toFixed:
-            res = (k, index) => a(k, index)
-                .toFixed(numberArg);
-            break;
-        case LoopFunctions.abs:
-            res = (k, index) => a(k, index)
-                .abs();
-            break;
-        case LoopFunctions.scale:
-            res = (k, index) => a(k, index)
-                .scale(numberPointArg, numberArg);
-            break;
-        case LoopFunctions.divide:
-            res = (k, index) => a(k, index)
-                .divide(numberPointArg, numberArg);
-            break;
-        case LoopFunctions.div:
-            res = (k, index) => a(k, index)
-                .div(numberPointArg, numberArg);
-            break;
-        case LoopFunctions.mod:
-            res = (k, index) => a(k, index)
-                .mod(numberPointArg, numberArg);
-            break;
-        case LoopFunctions.degreeToRadians:
-            res = (k, index) => a(k, index)
-                .degreeToRadians();
-            break;
-        case LoopFunctions.radiansToDegrees:
-            res = (k, index) => a(k, index)
-                .radiansToDegrees();
-            break;
-        case LoopFunctions.radiansToMeters:
-            res = (k, index) => a(k, index)
-                .radiansToMeters();
-            break;
-        case LoopFunctions.metersToRadians:
-            res = (k, index) => a(k, index)
-                .metersToRadians();
-            break;
-        case LoopFunctions.hipPoint:
-            res = (k, index) => a(k, index)
-                .hipPoint;
-            break;
-        case LoopFunctions.xPoint:
-            res = (k, index) => a(k, index)
-                .xPoint;
-            break;
-        case LoopFunctions.yPoint:
-            res = (k, index) => a(k, index)
-                .yPoint;
-            break;
-        case LoopFunctions.wPoint:
-            res = (k, index) => a(k, index)
-                .wPoint;
-            break;
-        case LoopFunctions.hPoint:
-            res = (k, index) => a(k, index)
-                .hPoint;
-            break;
-        case LoopFunctions.setIfLessThan:
-            res = (k, index) => a(k, index)
-                .setIfLessThan(pointArg);
-            break;
-        case LoopFunctions.minus:
-            res = (k, index) => a(k, index)
-                .minus();
-            break;
-        case LoopFunctions.degreeToMeters:
-            res = (k, index) => a(k, index)
-                .degreeToMeters();
-            break;
-        case LoopFunctions.metersToDegree:
-            res = (k, index) => a(k, index)
-                .metersToDegree();
-            break;
-        case LoopFunctions.flipVertically:
-            res = (k, index) => a(k, index)
-                .flipVertically(numberPointArg);
-            break;
-        case LoopFunctions.setProperties:
-            res = (k, index) => typeof setterArgByObject === 'object' ? a(k, index)
-                .setProperties(setterArgByObject) : a(k, index).setProperties((p) => setterArgByObject(p, index));
-            break;
-    }
-    return res;
-};
-export class DPolygonLoop {
-    constructor(parent) {
-        this.parent = parent;
-        this.pool = [];
-    }
-    getLoopFunction() {
-        return this.pool.reduce(decodePoolRecord, (k) => k);
-    }
-    run() {
-        return this.parent.map(this.getLoopFunction());
-    }
-    getTileFromCoords(zoom) {
-        this.pool.push({
-            functionName: LoopFunctions.getTileFromCoords,
-            numberArg: zoom
-        });
-        return this;
-    }
-    getCoordsFromTile(zoom) {
-        this.pool.push({
-            functionName: LoopFunctions.getCoordsFromTile,
-            numberArg: zoom
-        });
-        return this;
-    }
-    height(z) {
-        this.pool.push({
-            functionName: LoopFunctions.height,
-            numberArg: z
-        });
-        return this;
-    }
-    setX(x) {
-        this.pool.push({
-            functionName: LoopFunctions.setX,
-            setterArg: x
-        });
-        return this;
-    }
-    setProperties(setterArgByObject) {
-        this.pool.push({
-            functionName: LoopFunctions.setProperties,
-            setterArgByObject
-        });
-        return this;
-    }
-    setY(y) {
-        this.pool.push({
-            functionName: LoopFunctions.setY,
-            setterArg: y
-        });
-        return this;
-    }
-    setZ(z) {
-        this.pool.push({
-            functionName: LoopFunctions.setZ,
-            setterArg: z
-        });
-        return this;
-    }
-    rotate(a) {
-        this.pool.push({
-            functionName: LoopFunctions.rotate,
-            numberArg: a
-        });
-        return this;
-    }
-    rotate3dX(a) {
-        this.pool.push({
-            functionName: LoopFunctions.rotate3dX,
-            numberArg: a
-        });
-        return this;
-    }
-    rotate3dY(a) {
-        this.pool.push({
-            functionName: LoopFunctions.rotate3dY,
-            numberArg: a
-        });
-        return this;
-    }
-    rotate3dZ(a) {
-        this.pool.push({
-            functionName: LoopFunctions.rotate3dZ,
-            numberArg: a
-        });
-        return this;
-    }
-    move(x, y = x) {
-        this.pool.push({
-            functionName: LoopFunctions.move,
-            numberPointArg: x,
-            numberArg: y
-        });
-        return this;
-    }
-    round() {
-        this.pool.push({
-            functionName: LoopFunctions.round
-        });
-        return this;
-    }
-    ceil() {
-        this.pool.push({
-            functionName: LoopFunctions.ceil
-        });
-        return this;
-    }
-    floor() {
-        this.pool.push({
-            functionName: LoopFunctions.floor
-        });
-        return this;
-    }
-    toFixed(n = 2) {
-        this.pool.push({
-            functionName: LoopFunctions.toFixed,
-            numberArg: n
-        });
-        return this;
-    }
-    abs() {
-        this.pool.push({
-            functionName: LoopFunctions.abs
-        });
-        return this;
-    }
-    scale(x, y = x) {
-        this.pool.push({
-            functionName: LoopFunctions.scale,
-            numberPointArg: x,
-            numberArg: y
-        });
-        return this;
-    }
-    divide(x, y) {
-        this.pool.push({
-            functionName: LoopFunctions.divide,
-            numberPointArg: x,
-            numberArg: y
-        });
-        return this;
-    }
-    div(x, y) {
-        this.pool.push({
-            functionName: LoopFunctions.div,
-            numberPointArg: x,
-            numberArg: y
-        });
-        return this;
-    }
-    mod(x, y) {
-        this.pool.push({
-            functionName: LoopFunctions.mod,
-            numberPointArg: x,
-            numberArg: y
-        });
-        return this;
-    }
-    degreeToRadians() {
-        this.pool.push({
-            functionName: LoopFunctions.degreeToRadians
-        });
-        return this;
-    }
-    radiansToDegrees() {
-        this.pool.push({
-            functionName: LoopFunctions.radiansToDegrees
-        });
-        return this;
-    }
-    radiansToMeters() {
-        this.pool.push({
-            functionName: LoopFunctions.radiansToMeters
-        });
-        return this;
-    }
-    metersToRadians() {
-        this.pool.push({
-            functionName: LoopFunctions.metersToRadians
-        });
-        return this;
-    }
-    getHipPoint() {
-        this.pool.push({
-            functionName: LoopFunctions.hipPoint
-        });
-        return this;
-    }
-    getXPoint() {
-        this.pool.push({
-            functionName: LoopFunctions.xPoint
-        });
-        return this;
-    }
-    getYPoint() {
-        this.pool.push({
-            functionName: LoopFunctions.yPoint
-        });
-        return this;
-    }
-    getWPoint() {
-        this.pool.push({
-            functionName: LoopFunctions.wPoint
-        });
-        return this;
-    }
-    getHPoint() {
-        this.pool.push({
-            functionName: LoopFunctions.hPoint
-        });
-        return this;
-    }
-    setIfLessThan(p) {
-        this.pool.push({
-            functionName: LoopFunctions.setIfLessThan,
-            pointArg: p
-        });
-        return this;
-    }
-    minus() {
-        this.pool.push({
-            functionName: LoopFunctions.minus
-        });
-        return this;
-    }
-    degreeToMeters() {
-        this.pool.push({
-            functionName: LoopFunctions.degreeToMeters
-        });
-        return this;
-    }
-    metersToDegree() {
-        this.pool.push({
-            functionName: LoopFunctions.metersToDegree
-        });
-        return this;
-    }
-    flipVertically(size) {
-        this.pool.push({
-            functionName: LoopFunctions.flipVertically,
-            numberPointArg: size
-        });
-        return this;
-    }
-}

package/dist/es2015/FastSearch.js

@@ -1,25 +0,0 @@
-export class FastSearch {
-    constructor() {
-        this.searchStore = {};
-    }
-    add(points) {
-        for (const { x, y, z } of points) {
-            if (!this.searchStore[x]) {
-                this.searchStore[x] = {};
-            }
-            if (!this.searchStore[x][y]) {
-                this.searchStore[x][y] = {};
-            }
-            this.searchStore[x][y][z || 'undefined'] = true;
-        }
-    }
-    find({ x, y, z }) {
-        if (!this.searchStore[x]) {
-            return false;
-        }
-        if (!this.searchStore[x][y]) {
-            return false;
-        }
-        return this.searchStore[x][y][z || 'undefined'];
-    }
-}

package/dist/es2015/InterpolationMatrix.js

@@ -1,128 +0,0 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-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.minPoint;
-        this.maxPoint = bboxLike.maxPoint;
-        this.sizePoly = DPolygon.createSquareBySize(new DPoint(this.stepSize));
-        this.size = this.maxPoint.clone().move(this.minPoint.clone().minus())
-            .divide(this.stepSize)
-            .ceil();
-        this.keys = Array.isArray(keys) ? keys : [keys];
-        this.generateCells();
-    }
-    setKnownPoints(points) {
-        this.points = points instanceof DPolygon ? points.points : points;
-        this.minPoint.setProperties(this.points.reduce((a, v) => this.keys
-            .reduce((aa, k) => {
-            var _a;
-            aa[k] = Math.min((_a = a[k]) !== null && _a !== void 0 ? _a : Infinity, v.properties[k]);
-            return aa;
-        }, a), {}));
-        this.maxPoint.setProperties(this.points.reduce((a, v) => this.keys
-            .reduce((aa, k) => {
-            var _a;
-            aa[k] = Math.max((_a = a[k]) !== null && _a !== void 0 ? _a : -Infinity, v.properties[k]);
-            return aa;
-        }, a), {}));
-        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 getCellData() {
-        return this.allCells.reduce((a, c) => {
-            const _a = c.properties, { x, y } = _a, props = __rest(_a, ["x", "y"]);
-            a[x] = a[x] || {};
-            a[x][y] = Object.assign({}, props);
-            return a;
-        }, {});
-    }
-    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);
-            }
-        }
-    }
-}