@pirireis/webglobeplugins 0.15.35 → 0.16.0

package/dist/timetracks/programpoint-line-strip.js

@@ -0,0 +1,151 @@
+import { createProgram, shaderfunctions } from "../util";
+import { CameraUniformBlockTotem, globeProgramCache } from "../programs";
+const vertexShader = `#version 300 es
+
+layout(std140) uniform GlobeCamera {
+    mat4 view; // 64 bytes           0
+    mat4 projection; // 64 bytes     64
+    vec3 translate; // 12 bytes      128
+    bool is3D; // 4 bytes            140
+    vec2 mapWH; // 8 bytes           144
+    vec2 screenWH; //  8 bytes       152
+    float z_level; // 4 bytes        160
+};
+
+layout(std140) uniform Globals {
+    float head_time;
+    float final_opacity;
+    float point_size;
+};
+
+in vec3 start_position;
+in float start_time;
+in vec3 start_color;
+in vec3 end_position;
+in float end_time;
+in vec3 end_color;
+out vec4 v_color;
+
+` + shaderfunctions.pixelXYToCartesian3DPoint + shaderfunctions.pixelXYToCartesian2DPoint + `
+
+void main() {
+    if (head_time < start_time || head_time > end_time) { return; }
+    if ( start_color.r < 0.0 || end_color.r < 0.0) { return; }
+    float t = (head_time - start_time) / (end_time - start_time);
+    vec3 position = mix(start_position, end_position, t);
+    if (is3D){
+        vec3 pos = pixelXYToCartesian3DPoint(position);
+        gl_Position = projection * view * vec4(pos - translate, 1.0);
+    }  else {
+        vec2 xy = pixelXYToCartesian2DPoint(position.xy, translate.xy, mapWH, screenWH);
+        gl_Position = projection * vec4(xy.x, xy.y, 0.0, 1.0);
+    }
+    v_color = vec4(mix(start_color, end_color, t), final_opacity);
+    gl_PointSize = point_size;
+}`;
+const fragmentShader = `#version 300 es
+precision highp float;
+in vec4 v_color;
+out vec4 outColor;
+void main() {
+    // circle point
+    vec2 cxy = 2.0 * gl_PointCoord - 1.0;
+    float cc = dot(cxy, cxy);
+    outColor = v_color;
+    if (cc > 0.5) {
+        outColor.a = 0.0;    
+ }
+}`;
+export default class {
+    constructor(gl, globe, attrBuffer, options) {
+        this.gl = gl;
+        this._cameraBlockBindingPoint = 0;
+        this._globalsBlockBindingPoint = 1;
+        this.cameraUniformBlockTotem = globeProgramCache.getProgram(globe, CameraUniformBlockTotem);
+        this._vao = gl.createVertexArray();
+        this._attbuffer = attrBuffer;
+        this.program = this._createProgram();
+        this._drawCount = 0;
+        this._globalsbuffer = gl.createBuffer();
+        {
+            const { gl, _globalsbuffer } = this;
+            gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+            gl.bufferData(gl.UNIFORM_BUFFER, 12, gl.STREAM_DRAW);
+            gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([0, options.opacity, options.pointSize]));
+            gl.bindBufferBase(gl.UNIFORM_BUFFER, this._globalsBlockBindingPoint, _globalsbuffer);
+            gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+        }
+    }
+    _createProgram() {
+        const gl = this.gl;
+        const program = createProgram(gl, vertexShader, fragmentShader);
+        const ubo = this.cameraUniformBlockTotem.getUBO(); // ubo bl
+        const cameraBlockIndex = gl.getUniformBlockIndex(program, "GlobeCamera");
+        gl.uniformBlockBinding(program, cameraBlockIndex, this._cameraBlockBindingPoint);
+        const globalsBlockIndex = gl.getUniformBlockIndex(program, "Globals");
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._cameraBlockBindingPoint, ubo);
+        gl.uniformBlockBinding(program, globalsBlockIndex, this._globalsBlockBindingPoint);
+        gl.bindBufferBase(gl.UNIFORM_BUFFER, this._globalsBlockBindingPoint, this._globalsbuffer);
+        // numaralarda yanlışlık olabilir
+        const start_position = gl.getAttribLocation(program, "start_position");
+        const start_time = gl.getAttribLocation(program, "start_time");
+        const start_color = gl.getAttribLocation(program, "start_color");
+        const end_position = gl.getAttribLocation(program, "end_position");
+        const end_time = gl.getAttribLocation(program, "end_time");
+        const end_color = gl.getAttribLocation(program, "end_color");
+        gl.bindVertexArray(this._vao);
+        gl.bindBuffer(gl.ARRAY_BUFFER, this._attbuffer);
+        gl.enableVertexAttribArray(start_position);
+        gl.vertexAttribPointer(start_position, 3, gl.FLOAT, false, 36, 0);
+        gl.enableVertexAttribArray(start_time);
+        gl.vertexAttribPointer(start_time, 1, gl.FLOAT, false, 36, 12);
+        gl.enableVertexAttribArray(start_color);
+        gl.vertexAttribPointer(start_color, 3, gl.FLOAT, false, 36, 16);
+        gl.enableVertexAttribArray(end_position);
+        gl.vertexAttribPointer(end_position, 3, gl.FLOAT, false, 36, 36);
+        gl.enableVertexAttribArray(end_time);
+        gl.vertexAttribPointer(end_time, 1, gl.FLOAT, false, 36, 48);
+        gl.enableVertexAttribArray(end_color);
+        gl.vertexAttribPointer(end_color, 3, gl.FLOAT, false, 36, 52);
+        gl.bindVertexArray(null);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return program;
+    }
+    setOpacity(opacity) {
+        const { gl, _globalsbuffer } = this;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 4, new Float32Array([opacity]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+    setDrawCount(count) {
+        this._drawCount = count;
+    }
+    setPointSize(size) {
+        const { gl, _globalsbuffer } = this;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 8, new Float32Array([size]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+    setHeadTime(time) {
+        const { gl, _globalsbuffer } = this;
+        gl.bindBuffer(gl.UNIFORM_BUFFER, _globalsbuffer);
+        gl.bufferSubData(gl.UNIFORM_BUFFER, 0, new Float32Array([time]));
+        gl.bindBuffer(gl.UNIFORM_BUFFER, null);
+    }
+    draw() {
+        const { gl, program, _vao, _drawCount } = this;
+        gl.useProgram(program);
+        gl.bindVertexArray(_vao);
+        gl.disable(gl.DEPTH_TEST);
+        gl.drawArrays(gl.POINTS, 0, _drawCount);
+        gl.enable(gl.DEPTH_TEST);
+        gl.bindVertexArray(null);
+    }
+    free() {
+        const { gl, _vao, _globalsbuffer, program } = this;
+        gl.deleteVertexArray(_vao);
+        // gl.deleteBuffer(_attbuffer);
+        gl.deleteBuffer(_globalsbuffer);
+        gl.deleteProgram(program);
+    }
+}

package/dist/util/account/bufferoffsetmanager.js

@@ -0,0 +1,176 @@
+/**
+ * BufferOffsetManager
+ * Purpose: To manage the offset of the buffer. Plus extend and defrag the buffer.
+ * -------------------------------------------------------------------------------------------------------------------------------------------
+ * Functions:
+ * 1. getOffet(key) : return the offset of the key if not found return false.
+ * 2. setOffset(key, offset) : set the offset of the key.
+ * 3. nextOffset() : return the next available offset if not return false.
+ * 4. delete(key) : delete the key and return true if not found return false.
+ * 5. defragBuffer(gl, buffer, bufferType, newCapacity = null) : defrag the buffer. if newCapacity is not provided the buffer is vacumed.
+ * 6. extendBuffer(gl, buffer, bufferType, newCapacity) : extend the buffer.
+ * -------------------------------------------------------------------------------------------------------------------------------------------
+ * What this class does NOT do:
+ * ADD, DELETE, READ
+ * ADD, inputs needs to be turn into a block and put into buffer. Bulk will be more performant.
+ * DELETE, might be a set to single byte to indicate the tombstone.
+ * READ, most of the time is not needed to be read, unless for defraging.
+ * This unpredicatable behavior is not handled by this class.
+ */
+export default class {
+    constructor(itemSize, { capacity = 10, bufferType = "STATIC_DRAW" } = {}) {
+        this.itemSize = itemSize;
+        this.bufferType = bufferType;
+        this.offSetMap = new Map();
+        this.tombstoneOffSet = [];
+        this._capacity = capacity;
+        this._length = 0;
+    }
+    get length() {
+        return this._length;
+    }
+    get capacity() {
+        return this._capacity;
+    }
+    getOffset(key) {
+        return this.offSetMap.get(key);
+    }
+    setOffset(key, offset) {
+        this.offSetMap.set(key, offset);
+    }
+    nextOffset() {
+        if (this.tombstoneOffSet.length > 0) {
+            const offset = this.tombstoneOffSet.pop();
+            return offset;
+        }
+        if (this._length < this._capacity) {
+            return this._length++ * this.itemSize * 4;
+        }
+        return false;
+    }
+    get spaceLeft() {
+        return this._capacity - (this._length - this.tombstoneOffSet.length);
+    }
+    get itemCount() {
+        return this._length - this.tombstoneOffSet.length;
+    }
+    deleteFromAccount(key) {
+        const offSet = this.offSetMap.get(key);
+        if (offSet !== undefined) {
+            this.tombstoneOffSet.push(offSet);
+            this.offSetMap.delete(key);
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    _deleteBulk(keys) {
+        const { gl, buffer } = this;
+        const emptyBlock = new Float32Array(this.itemSize).fill(0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        for (let key of keys) {
+            const offset = this.getOffset(key);
+            if (offset !== undefined) {
+                this.deleteFromAccount(key);
+                gl.bufferSubData(gl.ARRAY_BUFFER, offset, emptyBlock);
+            }
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+    offsetMapIterator() {
+        return this.offSetMap.entries();
+    }
+    // TODO: this is broken
+    defrag(newCapacity = null) {
+        const { gl, buffer, bufferType } = this;
+        if (gl === undefined || buffer === undefined || bufferType === undefined) {
+            throw new Error("gl, buffer, bufferType are required");
+        }
+        const itemSize = this.itemSize;
+        const itemCount = this.itemCount;
+        const capacity = (newCapacity && newCapacity > itemCount) ? newCapacity : itemCount;
+        const newArray = new Float32Array(itemCount * itemSize);
+        const bufferData = this._getBufferData();
+        let newOffSet = 0;
+        const newOffSetMap = new Map();
+        for (const [key, offSet] of this.offSetMap) {
+            const itemOffSet = offSet / 4;
+            newArray.set(bufferData.slice(itemOffSet, itemOffSet + itemSize), newOffSet);
+            // this.offSetMap.set(key, newOffSet * 4);
+            newOffSetMap.set(key, newOffSet * 4);
+            newOffSet += itemSize;
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, capacity * itemSize * 4, gl[bufferType]);
+        gl.bufferSubData(gl.ARRAY_BUFFER, 0, newArray);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this._capacity = capacity;
+        this.tombstoneOffSet = [];
+        this._length = itemCount;
+        this.offSetMap = newOffSetMap;
+    }
+    autoExtendBuffer(payloadSize) {
+        if (payloadSize <= this.spaceLeft)
+            return;
+        const newCapacity = Math.ceil((payloadSize + this.length));
+        this.extendBuffer(newCapacity);
+    }
+    extendBuffer(newCapacity) {
+        const { gl, buffer, bufferType } = this;
+        const itemSize = this.itemSize;
+        const bufferData = this._getBufferData();
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.bufferData(gl.ARRAY_BUFFER, newCapacity * itemSize * 4, gl[bufferType]);
+        gl.bufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        this._capacity = newCapacity;
+    }
+    /** implicit methods to be used by the child class */
+    /**
+     * @typedef {Float32Array} payload
+     * @param {Array<{key, payload}>} items
+     * @param {number} partOffset
+     * @returns
+     */
+    _updatePartial(items, partOffset) {
+        const { gl, buffer } = this;
+        const partStart = partOffset * 4;
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        for (let { key, payload } of items) {
+            let offset = this.getOffset(key);
+            if (offset !== undefined) {
+                gl.bufferSubData(gl.ARRAY_BUFFER, offset + partStart, payload);
+            }
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+    _getBufferData() {
+        const { gl, buffer } = this;
+        const size = new Float32Array(this.length * this.itemSize);
+        const bufferData = new Float32Array(size);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        gl.getBufferSubData(gl.ARRAY_BUFFER, 0, bufferData);
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+        return bufferData;
+    }
+    _removeFromBuffer(keys) {
+        const { gl, buffer } = this;
+        const emptyBlock = new Float32Array(this.itemSize).fill(0);
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+        for (let key of keys) {
+            let offset = this.getOffset(key);
+            if (offset !== undefined) {
+                this.deleteFromAccount(key);
+                gl.bufferSubData(gl.ARRAY_BUFFER, offset, emptyBlock);
+            }
+        }
+        gl.bindBuffer(gl.ARRAY_BUFFER, null);
+    }
+    free() {
+        this.gl.deleteBuffer(this.buffer);
+        this.buffer = null;
+        this.vao = null;
+        this.gl = null;
+    }
+}

package/dist/util/account/index.js

@@ -0,0 +1,3 @@
+// import BufferOffsetManager from './bufferoffsetmanager';
+// export { BufferOffsetManager };
+export * from './single-attribute-buffer-management/index';

package/dist/util/account/util.js

@@ -0,0 +1,18 @@
+export const vaoAttributeLoader = (gl, buffer, index, size, stride, offset, divisor = null, type = null) => {
+    if (!gl || !buffer) {
+        throw new Error("Invalid WebGL context or buffer");
+    }
+    if (index < 0) {
+        throw new Error("Attribute index must be non-negative");
+    }
+    if (stride < 0 || offset < 0) {
+        throw new Error("Stride and offset must be non-negative");
+    }
+    const attribType = type === null ? gl.FLOAT : type;
+    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+    gl.enableVertexAttribArray(index);
+    gl.vertexAttribPointer(index, size, attribType, false, stride, offset);
+    if (divisor !== null) {
+        gl.vertexAttribDivisor(index, divisor);
+    }
+};

package/dist/util/algorithms/index.js

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

package/dist/util/algorithms/search-binary.js

@@ -0,0 +1,25 @@
+/**
+ * @typedef {Array<number>} ListLike
+ * @typedef {number || null} Index
+ */
+/**
+ * @param {ListLike} container
+ * @param {number} value
+ * @returns {Index}
+ */
+const findFirstIndexInRange = (container, value) => {
+    let start = 0;
+    let end = container.length - 1;
+    let mid = 0;
+    while (start <= end) {
+        mid = Math.floor((start + end) / 2);
+        if (container[mid] <= value && value <= container[mid + 1])
+            return mid;
+        if (container[mid] < value)
+            start = mid + 1;
+        else
+            end = mid - 1;
+    }
+    return null;
+};
+export { findFirstIndexInRange };

package/dist/util/check/index.js

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

package/dist/util/gl-util/uniform-block/shader.js

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

package/dist/util/heatwavedatamanager/datamanager.js

@@ -0,0 +1,149 @@
+/**
+ * todo:
+ * data must be processed before being set to the cache
+ */
+export default class DataManager {
+    /**
+     *
+     * @param {Array<number>} timeEpocs | array of time epocs
+     * @param {Function} fetchMethod | fetchMethod(time) => Promise<data>
+     * @param {boolean} autoDownload | auto download data or not
+    */
+    constructor(timeEpocs, fetchMethod, { autoDownload = true } = {}) {
+        this._timeEpocs = timeEpocs.sort((a, b) => 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);
+    }
+    autoDownload(bool, time) {
+        if (!bool) {
+            this._autoDownload = false;
+            return;
+        }
+        let 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;
+        const recursion = (startId, currentDownloadId) => {
+            if (startId !== this._downloadStartIndex)
+                return;
+            if (currentDownloadId < this._timeEpocs.length && this._autoDownload) {
+                this._getData(currentDownloadId).then(() => {
+                    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.
+     */
+    updateTime(time) {
+        if (time < this._timeEpocs[0] || time > this._timeEpocs[this._timeEpocs.length - 1]) {
+            this._dontRender();
+            return;
+        }
+        this._lastTime = time;
+        const index = this._findIndex(time);
+        const ratio = this._getRatio(time, index);
+        Promise.all([this._getData(index - 1), this._getData(index)]).then((datas) => {
+            if (this._lastTime === time) {
+                this._lastIndex = index;
+                this._ratio = ratio;
+                this._pushCallback(ratio, datas);
+            }
+        });
+    }
+    register(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
+     */
+    unregister(key) {
+        let 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();
+        }
+    }
+    free() {
+        this._callbackmethods = [];
+        this._callbackmethodOwners = [];
+        this._autoDownload = false;
+    }
+    _findIndex(time) {
+        const { _timeEpocs } = this;
+        let 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;
+    }
+    _getRatio(time, index) {
+        return (time - this._timeEpocs[index - 1]) / (this._timeEpocs[index] - this._timeEpocs[index - 1]);
+    }
+    _pushCallback(ratio, datas) {
+        for (let i = 0; i < this._callbackmethods.length; i++) {
+            this._callbackmethods[i](ratio, ...datas);
+        }
+    }
+    async _getData(index) {
+        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((data) => {
+                    this._datas[index] = data;
+                }, (error) => {
+                    console.error("error", error);
+                }).finally(() => {
+                    this._dataPromises[index] = null;
+                });
+        }
+        await this._dataPromises[index];
+        return this._datas[index];
+    }
+    _dontRender() {
+        this._pushCallback(0, [null, null]);
+    }
+}

package/dist/util/heatwavedatamanager/index.js

@@ -0,0 +1,2 @@
+import HeatWaveDataManager from "./datamanager";
+export { HeatWaveDataManager };

package/dist/util/index.js

@@ -0,0 +1,13 @@
+import * as webglobjectbuilders from './webglobjectbuilders';
+import * as shaderfunctions from './shaderfunctions';
+import * as geometry from './geometry';
+import * as webglobe from './webglobe';
+import * as programs from './programs';
+import * as heatwavedatamanager from './heatwavedatamanager';
+export { webglobjectbuilders, shaderfunctions, geometry, webglobe, programs, heatwavedatamanager };
+export * from './webglobe';
+export * from './webglobjectbuilders';
+export * from './shaderfunctions';
+export * from './geometry';
+export * from './programs';
+export * from './heatwavedatamanager';

package/dist/util/interpolation/index.js

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

package/dist/util/interpolation/timetrack/index.js

@@ -0,0 +1,2 @@
+const createWorker = () => new Worker(new URL('./web-worker.js', import.meta.url), { type: 'module' });
+export { createWorker };

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

@@ -0,0 +1,79 @@
+import { findFirstIndexInRange } from '../../algorithms/search-binary';
+import { sphericalLinearInterpolation_Cartesian3d, sphericalLinearInterpolation_Mercator, } from '../../../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]
+ */
+const _0vec3 = [0, 0, 0];
+const GEOMETRY = Object.freeze({
+    CARTESIAN3D: 0,
+    MERCATOR: 1,
+});
+class TimeTrackInterpolator {
+    /**
+     * @typedef Timetrack
+     * @property {Array<vec4>}} coordinates [x,y,z, length]
+     * @property {Array<Number>} times
+     * @param {Array<Timetrack>} timeTracks
+     */
+    constructor({ timeTracks, bbox = null, geometry = GEOMETRY.CARTESIAN3D } = {}) {
+        this.timeTracks = null;
+        this.timeTracksStartTimes = null;
+        this.geometry = geometry;
+        if (timeTracks)
+            this.setTimetracks(timeTracks);
+        if (bbox)
+            this.setBbox(bbox);
+    }
+    setGeometry(geometry) {
+        if (geometry !== GEOMETRY.CARTESIAN3D && geometry !== GEOMETRY.MERCATOR) {
+            throw new Error('Invalid geometry');
+        }
+        this.geometry = geometry;
+    }
+    setTimetracks(timeTracks) {
+        this.timeTracks = timeTracks;
+    }
+    interpolate(time) {
+        const { timeTracks, geometry } = this;
+        if (!timeTracks) {
+            return null;
+        }
+        const resultArray = [];
+        const info = {
+            outOfRange: 0,
+            processed: 0,
+        };
+        for (let i = 0; i < timeTracks.length; i++) {
+            const { times, coordinates } = timeTracks[i];
+            if (times[times.length - 1] < time)
+                continue;
+            info.processed++;
+            const timeIndex = findFirstIndexInRange(times, time);
+            if (timeIndex === null) {
+                info.outOfRange++;
+                continue;
+            }
+            const timeFraction = (time - times[timeIndex]) / (times[timeIndex + 1] - times[timeIndex]);
+            if (geometry === GEOMETRY.CARTESIAN3D) {
+                sphericalLinearInterpolation_Cartesian3d(_0vec3, coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
+            }
+            else {
+                sphericalLinearInterpolation_Mercator(_0vec3, coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
+            }
+            resultArray.push(..._0vec3);
+        }
+        return new Float32Array(resultArray);
+    }
+    // implicit methods
+    _orderTimeTracks() {
+        this.timeTracks.sort((a, b) => a.times[0] - b.times[0]);
+    }
+    _setStartTimes() {
+        this.timeTracksStartTimes = this.timeTracks.map(tt => tt.times[0]);
+    }
+}
+export { TimeTrackInterpolator, GEOMETRY };

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

@@ -0,0 +1,46 @@
+import { TimeTrackInterpolator, GEOMETRY } from './timetrack-interpolator';
+const interpolator = new TimeTrackInterpolator({ geometry: GEOMETRY.CARTESIAN3D });
+/* eslint-disable-next-line no-restricted-globals */
+self.onmessage = function (e) {
+    const { geometry = null, timeTracks = null, time = null } = e.data;
+    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 {
+            const 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);
+};