@pirireis/webglobeplugins 0.9.9 → 0.9.11

package/util/heatwavedatamanager/datamanager.js

@@ -0,0 +1,212 @@
+"use strict";
+/**
+ * todo:
+ * data must be processed before being set to the cache
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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 });
+var DataManager = /** @class */ (function () {
+    /**
+     *
+     * @param {Array<number>} timeEpocs | array of time epocs
+     * @param {Function} fetchMethod | fetchMethod(time) => Promise<data>
+     * @param {boolean} autoDownload | auto download data or not
+    */
+    function DataManager(timeEpocs, fetchMethod, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b.autoDownload, autoDownload = _c === void 0 ? true : _c;
+        this._timeEpocs = timeEpocs.sort(function (a, b) { return a - b; });
+        this._datas = [];
+        this._datas.length = timeEpocs.length;
+        // in construction
+        this._dataPromises = [];
+        this._dataPromises.length = timeEpocs.length;
+        this._fetchMethod = fetchMethod;
+        this._callbackmethods = [];
+        this._callbackmethodOwners = [];
+        this._lastTime = -1;
+        this._lastIndex = -1;
+        this.autoDownload(autoDownload);
+    }
+    DataManager.prototype.autoDownload = function (bool, time) {
+        var _this = this;
+        if (!bool) {
+            this._autoDownload = false;
+            return;
+        }
+        var index = this._lastIndex === -1 ? 0 : this._lastIndex;
+        if (time !== undefined) {
+            if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
+                this._autoDownload = bool;
+                return;
+            }
+            index = this._findIndex(time);
+        }
+        if (this._downloadStartIndex === index && this._autoDownload === bool)
+            return;
+        this._downloadStartIndex = index;
+        this._autoDownload = bool;
+        var recursion = function (startId, currentDownloadId) {
+            if (startId !== _this._downloadStartIndex)
+                return;
+            if (currentDownloadId < _this._timeEpocs.length && _this._autoDownload) {
+                _this._getData(currentDownloadId).then(function () {
+                    recursion(startId, currentDownloadId + 1);
+                });
+            }
+        };
+        recursion(index, index);
+        // save index as start index
+        //start recursive download
+        // use started id as a flag to stop the download
+    };
+    /**
+     * @param {number} time
+     * It looks like async function is not needed here. changes just overwrites the previous changes.
+     */
+    DataManager.prototype.updateTime = function (time) {
+        var _this = this;
+        if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
+            this._dontRender();
+            return;
+        }
+        this._lastTime = time;
+        var index = this._findIndex(time);
+        var ratio = this._getRatio(time, index);
+        Promise.all([this._getData(index - 1), this._getData(index)]).then(function (datas) {
+            if (_this._lastTime === time) {
+                _this._lastIndex = index;
+                _this._ratio = ratio;
+                _this._pushCallback(ratio, datas);
+            }
+        });
+    };
+    DataManager.prototype.register = function (key, callback) {
+        if (this._callbackmethodOwners.indexOf(key) !== -1) {
+            console.warn("key already registered, old one is unregistered");
+            this.unregister(key);
+        }
+        this._callbackmethods.push(callback);
+        this._callbackmethodOwners.push(key);
+        if (this._lastIndex !== -1)
+            callback(this._ratio, this._datas[this._lastIndex - 1], this._datas[this._lastIndex]);
+    };
+    /**
+     * @param {*} key | id of the owner of the callback
+     */
+    DataManager.prototype.unregister = function (key) {
+        var index = this._callbackmethodOwners.indexOf(key);
+        if (index !== -1) {
+            this._callbackmethods.splice(index, 1);
+            this._callbackmethodOwners.splice(index, 1);
+        }
+        if (this._callbackmethods.length === 0) {
+            this.free();
+        }
+    };
+    DataManager.prototype.free = function () {
+        this._callbackmethods = [];
+        this._callbackmethodOwners = [];
+        this._autoDownload = false;
+    };
+    DataManager.prototype._findIndex = function (time) {
+        var _timeEpocs = this._timeEpocs;
+        var index = this._lastIndex === -1 ? 1 : this._lastIndex;
+        if (this)
+            if (time < _timeEpocs[index - 1]) {
+                while (index > 1 && time < _timeEpocs[index - 1]) {
+                    index--;
+                }
+            }
+            else if (time > _timeEpocs[index]) {
+                while (index < _timeEpocs.length - 1 && time > _timeEpocs[index]) {
+                    index++;
+                }
+            }
+        return index;
+    };
+    DataManager.prototype._getRatio = function (time, index) {
+        return (time - this._timeEpocs[index - 1]) / (this._timeEpocs[index] - this._timeEpocs[index - 1]);
+    };
+    DataManager.prototype._pushCallback = function (ratio, datas) {
+        var _a;
+        for (var i = 0; i < this._callbackmethods.length; i++) {
+            (_a = this._callbackmethods)[i].apply(_a, __spreadArray([ratio], datas, false));
+        }
+    };
+    DataManager.prototype._getData = function (index) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (index < 0 || index >= this._timeEpocs.length) {
+                            throw new Error("Index out of range");
+                        }
+                        if (!this._datas[index]) {
+                            if (!this._dataPromises[index])
+                                this._dataPromises[index] = this._fetchMethod(this._timeEpocs[index]).then(function (data) {
+                                    _this._datas[index] = data;
+                                }, function (error) {
+                                    console.error("error", error);
+                                }).finally(function () {
+                                    _this._dataPromises[index] = null;
+                                });
+                        }
+                        return [4 /*yield*/, this._dataPromises[index]];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, this._datas[index]];
+                }
+            });
+        });
+    };
+    DataManager.prototype._dontRender = function () {
+        this._pushCallback(0, [null, null]);
+    };
+    return DataManager;
+}());
+exports.default = DataManager;

package/util/heatwavedatamanager/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PointCoordinatesDataCalculator = exports.HeatWaveDataManager = void 0;
+var pointcoordinatesdatacalculator_1 = __importDefault(require("./pointcoordinatesdatacalculator"));
+exports.PointCoordinatesDataCalculator = pointcoordinatesdatacalculator_1.default;
+var datamanager_1 = __importDefault(require("./datamanager"));
+exports.HeatWaveDataManager = datamanager_1.default;

package/util/heatwavedatamanager/pointcoordinatesdatacalculator.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var pointcoordsmeta_1 = __importDefault(require("./pointcoordsmeta"));
+var pointObject = function (long, lat, posIndex, callback) {
+    return { long: long, lat: lat, posIndex: posIndex, callback: callback };
+};
+var PointCoordinatesDataCalculator = /** @class */ (function () {
+    function PointCoordinatesDataCalculator(bbox, width, height) {
+        this._pointObjects = {};
+        this._ratio = 0.0;
+        this._bbox = bbox;
+        this._width = width;
+        this._height = height;
+        this._metaCalculater = new pointcoordsmeta_1.default(bbox, width, height);
+        this._texture0 = null;
+        this._texture1 = null;
+    }
+    /**
+     *
+     * @param {*} key
+     * @param {*} lat
+     * @param {*} long
+     * @param {*} callback | callback(data0, data1, interpolated)
+     */
+    PointCoordinatesDataCalculator.prototype.registerPoint = function (key, long, lat, callback) {
+        if (key in this._pointObjects) {
+            console.warn("key already registered, old one is unregistered");
+            this.unregisterPoint(key);
+        }
+        if (!this._isInBBox(long, lat))
+            return false;
+        var meta = this._metaCalculater.getFlooredMeta(long, lat);
+        this._pointObjects[key] = pointObject(long, lat, meta.index, callback);
+        if (this._texture0 && this._texture1) {
+            var _a = this._findAPoint(meta.index), data0 = _a.data0, data1 = _a.data1, interpolated = _a.interpolated;
+            callback(data0, data1, interpolated);
+        }
+        return true;
+    };
+    PointCoordinatesDataCalculator.prototype._isInBBox = function (long, lat) {
+        return lat >= this._bbox[1] && lat <= this._bbox[3] && long >= this._bbox[0] && long <= this._bbox[2];
+    };
+    PointCoordinatesDataCalculator.prototype.unregisterPoint = function (key) {
+        if (!(key in this._pointObjects))
+            return false;
+        delete this._pointObjects[key];
+        return true;
+    };
+    PointCoordinatesDataCalculator.prototype.updatePoint = function (key, long, lat) {
+        if (!(key in this._pointObjects))
+            return false;
+        if (!this._isInBBox(long, lat))
+            return false;
+        this._pointObjects[key].long = long;
+        this._pointObjects[key].lat = lat;
+        var meta = this._metaCalculater.getFlooredMeta(long, lat);
+        this._pointObjects[key].posIndex = meta.index;
+        var _a = this._findAPoint(meta.index), data0 = _a.data0, data1 = _a.data1, interpolated = _a.interpolated;
+        this._pointObjects[key].callback(data0, data1, interpolated);
+        return true;
+    };
+    /**
+     * @param {Number} ratio 0-1
+     * @param {} textureData0
+     * @param {*} textureData1
+     */
+    PointCoordinatesDataCalculator.prototype.updateData = function (ratio, textureData0, textureData1) {
+        if (textureData0 === void 0) { textureData0 = null; }
+        if (textureData1 === void 0) { textureData1 = null; }
+        if (!textureData0 && !textureData1) {
+            this._pushPointCallBackEmpty();
+            return;
+        }
+        if (textureData0 && textureData1) {
+            this._texture0 = textureData0;
+            this._texture1 = textureData1;
+        }
+        this._ratio = ratio;
+        this._pushPointCallbackAll();
+    };
+    PointCoordinatesDataCalculator.prototype._findAPoint = function (posIndex) {
+        var data0 = this._texture0[posIndex];
+        var data1 = this._texture1[posIndex];
+        var interpolated = data0 * (1 - this._ratio) + data1 * this._ratio;
+        return { data0: data0, data1: data1, interpolated: interpolated };
+    };
+    PointCoordinatesDataCalculator.prototype._pushPointCallbackAll = function () {
+        for (var key in this._pointObjects) {
+            var _a = this._pointObjects[key], posIndex = _a.posIndex, callback = _a.callback;
+            var _b = this._findAPoint(posIndex), data0 = _b.data0, data1 = _b.data1, interpolated = _b.interpolated;
+            callback(data0, data1, interpolated);
+        }
+    };
+    PointCoordinatesDataCalculator.prototype._pushPointCallBackEmpty = function () {
+        for (var key in this._pointObjects) {
+            var callback = this._pointObjects[key].callback;
+            callback(null, null, null);
+        }
+    };
+    PointCoordinatesDataCalculator.prototype.flush = function () {
+        this._pointObjects = {};
+    };
+    return PointCoordinatesDataCalculator;
+}());
+exports.default = PointCoordinatesDataCalculator;
+// function test() {
+//     const cp = window.plugin.getPointCoordinatesDataCalculator();
+//     const bbox = [-15, 25, 70, 60];
+//     cp.registerPoint("left up", -15, 60, (data0, data1, interpolated) => {
+//         console.log("left up", data0, data1, interpolated);
+//     });
+//     cp.registerPoint("right up", 70, 60, (data0, data1, interpolated) => {
+//         console.log("right up", data0, data1, interpolated);
+//     });
+//     cp.registerPoint("left down", -15, 25, (data0, data1, interpolated) => {
+//         console.log("right down", data0, data1, interpolated);
+//     });
+//     cp.registerPoint("right down", 70, 25, (data0, data1, interpolated) => {
+//         console.log("right down", data0, data1, interpolated);
+//     });
+//     return cp;
+// }

package/util/heatwavedatamanager/pointcoordsmeta.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var PointCoordsMeta = /** @class */ (function () {
+    function PointCoordsMeta(bbox, width, height) {
+        this._bbox = bbox;
+        this._width = width;
+        this._height = height;
+        this._xRatio = this._width / (this._bbox[2] - this._bbox[0]);
+        this._yRatio = this._height / (this._bbox[3] - this._bbox[1]);
+    }
+    PointCoordsMeta.prototype.getFlooredMeta = function (long, lat) {
+        var x = (long - this._bbox[0]) * this._xRatio;
+        var y = (this._bbox[3] - lat) * this._yRatio;
+        x = x > 0 ? x - 1 : 0;
+        y = y > 0 ? y - 1 : 0;
+        var index = Math.floor(y) * this._width + Math.floor(x);
+        return { index: index };
+    };
+    return PointCoordsMeta;
+}());
+exports.default = PointCoordsMeta;

package/util/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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.heatwavedatamanager = exports.programs = exports.webglobe = exports.geometry = exports.shaderfunctions = exports.webglobjectbuilders = void 0;
+var webglobjectbuilders = __importStar(require("./webglobjectbuilders"));
+exports.webglobjectbuilders = webglobjectbuilders;
+var shaderfunctions = __importStar(require("./shaderfunctions"));
+exports.shaderfunctions = shaderfunctions;
+var geometry = __importStar(require("./geometry"));
+exports.geometry = geometry;
+var webglobe = __importStar(require("./webglobe"));
+exports.webglobe = webglobe;
+var programs = __importStar(require("./programs"));
+exports.programs = programs;
+var heatwavedatamanager = __importStar(require("./heatwavedatamanager"));
+exports.heatwavedatamanager = heatwavedatamanager;
+__exportStar(require("./webglobe"), exports);
+__exportStar(require("./webglobjectbuilders"), exports);
+__exportStar(require("./shaderfunctions"), exports);
+__exportStar(require("./geometry"), exports);
+__exportStar(require("./programs"), exports);
+__exportStar(require("./heatwavedatamanager"), exports);

package/util/interpolation/index.js

@@ -0,0 +1 @@
+"use strict";

package/util/interpolation/timetrack/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorker = void 0;
+var createWorker = function () { return new Worker(new URL('./web-worker.js', import.meta.url), { type: 'module' }); };
+exports.createWorker = createWorker;

package/util/interpolation/timetrack/timetrack-interpolator.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GEOMETRY = exports.TimeTrackInterpolator = void 0;
+var search_binary_1 = require("../../algorithms/search-binary");
+var methods_1 = require("../../../Math/methods");
+/**
+ * @typedef {Array<number>} vec3 [x, y, z]
+ * @typedef {Array<number>} vec2 [x, y]
+ * @typedef {Array<number>} vec4 [x, y, z, w]
+ * @typedef {number} fraction a number between 0 and 1
+ * @typedef {Array<number>} wgs84 [long, lat]
+ */
+var GEOMETRY = Object.freeze({
+    CARTESIAN3D: 0,
+    MERCATOR: 1,
+});
+exports.GEOMETRY = GEOMETRY;
+var TimeTrackInterpolator = /** @class */ (function () {
+    /**
+     * @typedef Timetrack
+     * @property {Array<vec4>}} coordinates [x,y,z, length]
+     * @property {Array<Number>} times
+     * @param {Array<Timetrack>} timeTracks
+     */
+    function TimeTrackInterpolator(_a) {
+        var _b = _a === void 0 ? {} : _a, timeTracks = _b.timeTracks, _c = _b.bbox, bbox = _c === void 0 ? null : _c, _d = _b.geometry, geometry = _d === void 0 ? GEOMETRY.CARTESIAN3D : _d;
+        this.timeTracks = null;
+        this.timeTracksStartTimes = null;
+        this.geometry = geometry;
+        if (timeTracks)
+            this.setTimetracks(timeTracks);
+        if (bbox)
+            this.setBbox(bbox);
+    }
+    TimeTrackInterpolator.prototype.setGeometry = function (geometry) {
+        if (geometry !== GEOMETRY.CARTESIAN3D && geometry !== GEOMETRY.MERCATOR) {
+            throw new Error('Invalid geometry');
+        }
+        this.geometry = geometry;
+    };
+    TimeTrackInterpolator.prototype.setTimetracks = function (timeTracks) {
+        this.timeTracks = timeTracks;
+    };
+    TimeTrackInterpolator.prototype.interpolate = function (time) {
+        var _a = this, timeTracks = _a.timeTracks, geometry = _a.geometry;
+        if (!timeTracks) {
+            return null;
+        }
+        var resultArray = [];
+        var info = {
+            outOfRange: 0,
+            processed: 0,
+        };
+        for (var i = 0; i < timeTracks.length; i++) {
+            var _b = timeTracks[i], times = _b.times, coordinates = _b.coordinates;
+            if (times[times.length - 1] < time)
+                continue;
+            info.processed++;
+            var timeIndex = (0, search_binary_1.findFirstIndexInRange)(times, time);
+            if (timeIndex === null) {
+                info.outOfRange++;
+                continue;
+            }
+            var timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);
+            var interpolated = (geometry === GEOMETRY.CARTESIAN3D) ?
+                (0, methods_1.sphericalLinearInterpolation_Cartesian3d)(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction) :
+                (0, methods_1.sphericalLinearInterpolation_Mercator)(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
+            resultArray.push.apply(resultArray, interpolated);
+        }
+        return new Float32Array(resultArray);
+    };
+    // implicit methods
+    TimeTrackInterpolator.prototype._orderTimeTracks = function () {
+        this.timeTracks.sort(function (a, b) { return a.times[0] - b.times[0]; });
+    };
+    TimeTrackInterpolator.prototype._setStartTimes = function () {
+        this.timeTracksStartTimes = this.timeTracks.map(function (tt) { return tt.times[0]; });
+    };
+    return TimeTrackInterpolator;
+}());
+exports.TimeTrackInterpolator = TimeTrackInterpolator;

package/util/interpolation/timetrack/web-worker-str.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.webworkerStr = void 0;
+var webworkerStr = "\n\nconst WORLD_RADIUS_3D = 6378.137;\nconst WORLD_RADIUS_MERCATOR = 6378136.99911;\n\nconst dot3 = (a, b) => {\n    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\n}\n\nconst sphericalLinearInterpolation_UnitVector = (normalizedA, normalizedB, ratio) => {\n    const theta = Math.acos(dot3(normalizedA, normalizedB));\n    if (theta < 0.000001) return normalizedA; // CALIBRATE?\n    const sinTheta = Math.sin(theta);\n    const result = [\n        (Math.sin((1.0 - ratio) * theta) * normalizedA[0] + Math.sin(ratio * theta) * normalizedB[0]) / sinTheta,\n        (Math.sin((1.0 - ratio) * theta) * normalizedA[1] + Math.sin(ratio * theta) * normalizedB[1]) / sinTheta,\n        (Math.sin((1.0 - ratio) * theta) * normalizedA[2] + Math.sin(ratio * theta) * normalizedB[2]) / sinTheta\n    ];\n    return result;\n}\n\nconst radianToMercator = (xy) => {\n    return [WORLD_RADIUS_MERCATOR * xy[0], WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))];\n}\n\n\nconst cartesian3dToRadian = (cartesian) => {\n    const x = cartesian[0];\n    const y = cartesian[1];\n    const z = cartesian[2];\n    // const length = Math.sqrt(x * x + y * y + z * z);\n    const long = Math.atan2(y, x);\n    const lat = Math.asin(z)// length);\n    return [long, lat];\n}\n\n\nconst sphericalLinearInterpolation_Mercator = (normalizedA, normalizedB, ratio) => {\n    const unitVector = sphericalLinearInterpolation_UnitVector(normalizedA, normalizedB, ratio);\n    const angles = cartesian3dToRadian(unitVector);\n    return radianToMercator(angles);\n}\n\nconst sphericalLinearInterpolation_Cartesian3d = (a, b, ratio) => {\n    const unitVector = sphericalLinearInterpolation_UnitVector(a, b, ratio);\n    const height = a[3] + (b[3] - a[3]) * ratio;\n    return [unitVector[0] * height, unitVector[1] * height, unitVector[2] * height];\n}\n\nconst findFirstIndexInRange = (container, value) => {\n    let start = 0;\n    let end = container.length - 1;\n    let mid = 0;\n    while (start <= end) {\n        mid = Math.floor((start + end) / 2);\n        if (container[mid] <= value && value <= container[mid + 1]) return mid;\n        if (container[mid] < value) start = mid + 1;\n        else end = mid - 1;\n    }\n    return null;\n}\n\nconst GEOMETRY = Object.freeze({\n    CARTESIAN3D: 0,\n    MERCATOR: 1,\n});\n\nclass TimeTrackInterpolator {\n    /**\n     * @typedef Timetrack\n     * @property {Array<vec4>}} coordinates [x,y,z, length]\n     * @property {Array<Number>} times\n     * @param {Array<Timetrack>} timeTracks\n     */\n    constructor({ timeTracks, bbox = null, geometry = GEOMETRY.CARTESIAN3D } = {}) {\n        this.timeTracks = null;\n        this.timeTracksStartTimes = null;\n        this.geometry = geometry;\n        if (timeTracks) this.setTimetracks(timeTracks);\n        if (bbox) this.setBbox(bbox);\n    }\n\n\n    setGeometry(geometry) {\n        if (geometry !== GEOMETRY.CARTESIAN3D && geometry !== GEOMETRY.MERCATOR) {\n            throw new Error('Invalid geometry');\n        }\n        this.geometry = geometry;\n    }\n\n    setTimetracks(timeTracks) {\n        this.timeTracks = timeTracks;\n    }\n\n\n    interpolate(time) {\n        const { timeTracks, geometry } = this;\n        if (!timeTracks) { return null; }\n        const resultArray = [];\n        const info = {\n            outOfRange: 0,\n            processed: 0,\n        }\n        for (let i = 0; i < timeTracks.length; i++) {\n            const { times, coordinates } = timeTracks[i];\n\n            if (times[times.length - 1] < time) continue;\n            info.processed++;\n            const timeIndex = findFirstIndexInRange(times, time);\n            if (timeIndex === null) { info.outOfRange++; continue; }\n            const timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);\n            const interpolated = (geometry === GEOMETRY.CARTESIAN3D) ?\n                sphericalLinearInterpolation_Cartesian3d(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction) :\n                sphericalLinearInterpolation_Mercator(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);\n            resultArray.push(...interpolated);\n        }\n        return new Float32Array(resultArray);\n    }\n\n\n    // implicit methods\n\n    _orderTimeTracks() {\n        this.timeTracks.sort((a, b) => a.times[0] - b.times[0]);\n    }\n\n    _setStartTimes() {\n        this.timeTracksStartTimes = this.timeTracks.map(tt => tt.times[0]);\n    }\n}\n\nconst interpolator = new TimeTrackInterpolator({ geometry: GEOMETRY.CARTESIAN3D });\n\n/* eslint-disable-next-line no-restricted-globals */\nself.onmessage = function (e) {\n\n    const { geometry = null, timeTracks = null, time = null } = e.data;\n\n    if (geometry !== null) {\n        try {\n            interpolator.setGeometry(geometry);\n        } catch (error) {\n            /* eslint-disable-next-line no-restricted-globals */\n            self.postMessage({ error: error.message });\n            return;\n        }\n    }\n\n    if (timeTracks !== null) {\n        try {\n            interpolator.setTimetracks(timeTracks);\n        } catch (error) {\n            /* eslint-disable-next-line no-restricted-globals */\n            self.postMessage({ error: error.message });\n            return;\n        }\n    }\n\n    if (time !== null) {\n        try {\n            const result = interpolator.interpolate(time);\n            if(result === null) {\n                /* eslint-disable-next-line no-restricted-globals */\n                self.postMessage({ error: 'No TimeTracks Data' });\n                return;\n            }\n            /* eslint-disable-next-line no-restricted-globals */\n            self.postMessage(result, [result.buffer]);\n            return;\n        } catch (error) {\n            /* eslint-disable-next-line no-restricted-globals */\n            self.postMessage({ error: error.message });\n            return;\n        }\n    }\n    /* eslint-disable-next-line no-restricted-globals */\n    self.postMessage(true);\n}\n    ";
+exports.webworkerStr = webworkerStr;

package/util/interpolation/timetrack/web-worker.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var timetrack_interpolator_1 = require("./timetrack-interpolator");
+var interpolator = new timetrack_interpolator_1.TimeTrackInterpolator({ geometry: timetrack_interpolator_1.GEOMETRY.CARTESIAN3D });
+/* eslint-disable-next-line no-restricted-globals */
+self.onmessage = function (e) {
+    var _a = e.data, _b = _a.geometry, geometry = _b === void 0 ? null : _b, _c = _a.timeTracks, timeTracks = _c === void 0 ? null : _c, _d = _a.time, time = _d === void 0 ? null : _d;
+    if (geometry !== null) {
+        try {
+            interpolator.setGeometry(geometry);
+        }
+        catch (error) {
+            /* eslint-disable-next-line no-restricted-globals */
+            self.postMessage({ error: error.message });
+            return;
+        }
+    }
+    if (timeTracks !== null) {
+        try {
+            interpolator.setTimetracks(timeTracks);
+        }
+        catch (error) {
+            /* eslint-disable-next-line no-restricted-globals */
+            self.postMessage({ error: error.message });
+            return;
+        }
+    }
+    if (time !== null) {
+        try {
+            var result = interpolator.interpolate(time);
+            if (result === null) {
+                /* eslint-disable-next-line no-restricted-globals */
+                self.postMessage({ error: 'No TimeTracks Data' });
+                return;
+            }
+            /* eslint-disable-next-line no-restricted-globals */
+            self.postMessage(result, [result.buffer]);
+            return;
+        }
+        catch (error) {
+            /* eslint-disable-next-line no-restricted-globals */
+            self.postMessage({ error: error.message });
+            return;
+        }
+    }
+    /* eslint-disable-next-line no-restricted-globals */
+    self.postMessage(true);
+};

package/util/jshelpers/data-filler.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateFloat32Array = void 0;
+var populateFloat32Array = Object.freeze({
+    fillFloat32Array: function (length, data) {
+        var result = new Float32Array(length);
+        result.fill(data);
+        return result;
+    },
+    fillWithListData: function (length, listdata) {
+        var result = new Float32Array(length * listdata.length);
+        var offset = 0;
+        for (var i = 0; i < length; i++) {
+            result.set(listdata, offset);
+            offset += listdata.length;
+        }
+        return result;
+    }
+});
+exports.populateFloat32Array = populateFloat32Array;

package/util/jshelpers/equality.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arraysEqual = arraysEqual;
+function arraysEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    // If you don't care about the order of the elements inside
+    // the array, you should sort both arrays here.
+    // Please note that calling sort on an array will modify that array.
+    // you might want to clone your array first.
+    for (var i = 0; i < a.length; ++i) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}

package/util/jshelpers/index.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timefilters = void 0;
+exports.timefilters = __importStar(require("./timefilters"));