dgeoutils 2.4.41 → 2.4.44

package/dist/cjs/DPolygonLoop.d.ts

@@ -1,60 +0,0 @@
-import { DPolygon } from './DPolygon';
-import { DPoint } from './DPoint';
-export declare type SetterFunction<T> = (t: DPoint, index: number) => T;
-export declare type LoopFunction = (k: DPoint, index: number) => DPoint;
-export declare class DPolygonLoop {
-    private readonly parent;
-    private pool;
-    constructor(parent: DPolygon);
-    private getLoopFunction;
-    run(): DPolygon;
-    getTileFromCoords(zoom?: number): DPolygonLoop;
-    getCoordsFromTile(zoom?: number): DPolygonLoop;
-    height(z: number): DPolygonLoop;
-    setX(x: number): DPolygonLoop;
-    setX(f: SetterFunction<number>): DPolygonLoop;
-    setProperties(setterArgByObject: SetterFunction<Record<string, any>> | Record<string, any>): DPolygonLoop;
-    setY(y: number): DPolygonLoop;
-    setY(f: SetterFunction<number>): DPolygonLoop;
-    setZ(z: number): DPolygonLoop;
-    setZ(f: SetterFunction<number>): DPolygonLoop;
-    rotate(a: number): DPolygonLoop;
-    rotate3dX(a: number): DPolygonLoop;
-    rotate3dY(a: number): DPolygonLoop;
-    rotate3dZ(a: number): DPolygonLoop;
-    move(v: number): DPolygonLoop;
-    move(p: DPoint): DPolygonLoop;
-    move(x: number, y: number): DPolygonLoop;
-    round(): DPolygonLoop;
-    ceil(): DPolygonLoop;
-    floor(): DPolygonLoop;
-    toFixed(n?: number): DPolygonLoop;
-    abs(): DPolygonLoop;
-    scale(v: number): DPolygonLoop;
-    scale(p: DPoint): DPolygonLoop;
-    scale(x: number, y: number): DPolygonLoop;
-    divide(v: number): DPolygonLoop;
-    divide(p: DPoint): DPolygonLoop;
-    divide(x: number, y: number): DPolygonLoop;
-    div(v: number): DPolygonLoop;
-    div(p: DPoint): DPolygonLoop;
-    div(x: number, y: number): DPolygonLoop;
-    mod(v: number): DPolygonLoop;
-    mod(p: DPoint): DPolygonLoop;
-    mod(x: number, y: number): DPolygonLoop;
-    degreeToRadians(): DPolygonLoop;
-    radiansToDegrees(): DPolygonLoop;
-    radiansToMeters(): DPolygonLoop;
-    metersToRadians(): DPolygonLoop;
-    getHipPoint(): DPolygonLoop;
-    getXPoint(): DPolygonLoop;
-    getYPoint(): DPolygonLoop;
-    getWPoint(): DPolygonLoop;
-    getHPoint(): DPolygonLoop;
-    setIfLessThan(p: DPoint): DPolygonLoop;
-    minus(): DPolygonLoop;
-    degreeToMeters(): DPolygonLoop;
-    metersToDegree(): DPolygonLoop;
-    flipVertically(size: DPoint): DPolygonLoop;
-    flipVertically(height: number): DPolygonLoop;
-}

package/dist/cjs/DPolygonLoop.js

@@ -1,439 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DPolygonLoop = void 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 = {}));
-var decodePoolRecord = function (a, _a) {
-    var functionName = _a.functionName, pointArg = _a.pointArg, numberPointArg = _a.numberPointArg, numberArg = _a.numberArg, setterArg = _a.setterArg, setterArgByObject = _a.setterArgByObject;
-    var res = a;
-    switch (functionName) {
-        case LoopFunctions.getTileFromCoords:
-            res = function (k, index) { return a(k, index)
-                .getTileFromCoords(numberArg); };
-            break;
-        case LoopFunctions.getCoordsFromTile:
-            res = function (k, index) { return a(k, index)
-                .getCoordsFromTile(numberArg); };
-            break;
-        case LoopFunctions.height:
-            res = function (k, index) { return a(k, index)
-                .height(numberArg); };
-            break;
-        case LoopFunctions.setX:
-            res = function (k, index) { return typeof setterArg === 'number' ? a(k, index)
-                .setX(setterArg) : a(k, index).setX(function (p) { return setterArg(p, index); }); };
-            break;
-        case LoopFunctions.setY:
-            res = function (k, index) { return typeof setterArg === 'number' ? a(k, index)
-                .setY(setterArg) : a(k, index).setY(function (p) { return setterArg(p, index); }); };
-            break;
-        case LoopFunctions.setZ:
-            res = function (k, index) { return typeof setterArg === 'number' ? a(k, index)
-                .setZ(setterArg) : a(k, index).setZ(function (p) { return setterArg(p, index); }); };
-            break;
-        case LoopFunctions.rotate:
-            res = function (k, index) { return a(k, index)
-                .rotate(numberArg); };
-            break;
-        case LoopFunctions.rotate3dX:
-            res = function (k, index) { return a(k, index)
-                .rotate3dX(numberArg); };
-            break;
-        case LoopFunctions.rotate3dY:
-            res = function (k, index) { return a(k, index)
-                .rotate3dY(numberArg); };
-            break;
-        case LoopFunctions.rotate3dZ:
-            res = function (k, index) { return a(k, index)
-                .rotate3dZ(numberArg); };
-            break;
-        case LoopFunctions.move:
-            res = function (k, index) { return a(k, index)
-                .move(numberPointArg, numberArg); };
-            break;
-        case LoopFunctions.round:
-            res = function (k, index) { return a(k, index)
-                .round(); };
-            break;
-        case LoopFunctions.ceil:
-            res = function (k, index) { return a(k, index)
-                .ceil(); };
-            break;
-        case LoopFunctions.floor:
-            res = function (k, index) { return a(k, index)
-                .floor(); };
-            break;
-        case LoopFunctions.toFixed:
-            res = function (k, index) { return a(k, index)
-                .toFixed(numberArg); };
-            break;
-        case LoopFunctions.abs:
-            res = function (k, index) { return a(k, index)
-                .abs(); };
-            break;
-        case LoopFunctions.scale:
-            res = function (k, index) { return a(k, index)
-                .scale(numberPointArg, numberArg); };
-            break;
-        case LoopFunctions.divide:
-            res = function (k, index) { return a(k, index)
-                .divide(numberPointArg, numberArg); };
-            break;
-        case LoopFunctions.div:
-            res = function (k, index) { return a(k, index)
-                .div(numberPointArg, numberArg); };
-            break;
-        case LoopFunctions.mod:
-            res = function (k, index) { return a(k, index)
-                .mod(numberPointArg, numberArg); };
-            break;
-        case LoopFunctions.degreeToRadians:
-            res = function (k, index) { return a(k, index)
-                .degreeToRadians(); };
-            break;
-        case LoopFunctions.radiansToDegrees:
-            res = function (k, index) { return a(k, index)
-                .radiansToDegrees(); };
-            break;
-        case LoopFunctions.radiansToMeters:
-            res = function (k, index) { return a(k, index)
-                .radiansToMeters(); };
-            break;
-        case LoopFunctions.metersToRadians:
-            res = function (k, index) { return a(k, index)
-                .metersToRadians(); };
-            break;
-        case LoopFunctions.hipPoint:
-            res = function (k, index) { return a(k, index)
-                .hipPoint; };
-            break;
-        case LoopFunctions.xPoint:
-            res = function (k, index) { return a(k, index)
-                .xPoint; };
-            break;
-        case LoopFunctions.yPoint:
-            res = function (k, index) { return a(k, index)
-                .yPoint; };
-            break;
-        case LoopFunctions.wPoint:
-            res = function (k, index) { return a(k, index)
-                .wPoint; };
-            break;
-        case LoopFunctions.hPoint:
-            res = function (k, index) { return a(k, index)
-                .hPoint; };
-            break;
-        case LoopFunctions.setIfLessThan:
-            res = function (k, index) { return a(k, index)
-                .setIfLessThan(pointArg); };
-            break;
-        case LoopFunctions.minus:
-            res = function (k, index) { return a(k, index)
-                .minus(); };
-            break;
-        case LoopFunctions.degreeToMeters:
-            res = function (k, index) { return a(k, index)
-                .degreeToMeters(); };
-            break;
-        case LoopFunctions.metersToDegree:
-            res = function (k, index) { return a(k, index)
-                .metersToDegree(); };
-            break;
-        case LoopFunctions.flipVertically:
-            res = function (k, index) { return a(k, index)
-                .flipVertically(numberPointArg); };
-            break;
-        case LoopFunctions.setProperties:
-            res = function (k, index) { return typeof setterArgByObject === 'object' ? a(k, index)
-                .setProperties(setterArgByObject) : a(k, index).setProperties(function (p) { return setterArgByObject(p, index); }); };
-            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.setProperties = function (setterArgByObject) {
-        this.pool.push({
-            functionName: LoopFunctions.setProperties,
-            setterArgByObject: setterArgByObject
-        });
-        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.div = function (x, y) {
-        this.pool.push({
-            functionName: LoopFunctions.div,
-            numberPointArg: x,
-            numberArg: y
-        });
-        return this;
-    };
-    DPolygonLoop.prototype.mod = function (x, y) {
-        this.pool.push({
-            functionName: LoopFunctions.mod,
-            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;
-}());
-exports.DPolygonLoop = DPolygonLoop;

package/dist/cjs/FastSearch.d.ts

@@ -1,6 +0,0 @@
-import { DPoint } from './DPoint';
-export declare class FastSearch {
-    private searchStore;
-    add(points: DPoint[]): void;
-    find({ x, y, z }: DPoint): boolean;
-}

package/dist/cjs/FastSearch.js

@@ -1,53 +0,0 @@
-"use strict";
-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.FastSearch = void 0;
-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;
-}());
-exports.FastSearch = FastSearch;

package/dist/cjs/InterpolationMatrix.d.ts

@@ -1,24 +0,0 @@
-import { DPolygon } from './DPolygon';
-import { DPoint } from './DPoint';
-export declare class InterpolationMatrix {
-    private readonly stepSize;
-    private readonly p;
-    readonly minPoint: DPoint;
-    readonly maxPoint: DPoint;
-    private points;
-    private cells;
-    private allCells;
-    private readonly sizePoly;
-    private readonly keys;
-    readonly size: DPoint;
-    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 getCellData(): Record<number, Record<number, Record<string, number>>>;
-    get allCellsClone(): DPolygon[];
-    private interpolateValues;
-    private setKnownValues;
-    private generateCells;
-}