@pirireis/webglobeplugins 0.15.34 → 0.16.0

package/util/heatwavedatamanager/texture-point-sampler.ts

@@ -0,0 +1,198 @@
+import PointCoordsMeta from "./pointcoordsmeta";
+
+type BBOX = [number, number, number, number];
+type CallBackFunction = (data0: number | null, data1: number | null, interpolated: number | null) => void;
+type PointObject = {
+    long: number;
+    lat: number;
+    posIndex: number;
+    callback: CallBackFunction;
+}
+type TypedArray = Float32Array | Uint8Array | Uint16Array | Uint32Array;
+
+const pointObject = (long: number, lat: number, posIndex: number, callback: CallBackFunction): PointObject => {
+    return { long, lat, posIndex, callback };
+}
+
+
+
+
+export class TexturePointSampler {
+    _bbox: BBOX;
+    _width: number;
+    _height: number;
+    _textureCount: 1 | 2;
+    _metaCalculater: PointCoordsMeta;
+    _pointObjects: Map<string, PointObject>;
+    _textures: Array<TypedArray>;
+    _ratio: number;
+    _isReady: boolean = false;
+
+    constructor(bbox: BBOX, width: number, height: number, textureCount: 1 | 2 = 2) {
+        this._pointObjects = new Map<string, PointObject>();
+
+        this._ratio = 0.0;
+        this._bbox = bbox;
+        this._width = width;
+        this._height = height;
+        this._textureCount = textureCount;
+        this._metaCalculater = new PointCoordsMeta(bbox, width, height);
+        this._textures = new Array(textureCount).fill(null);
+        this._isReady = false;
+    }
+
+    setTextureCount(textureCount: 1 | 2) {
+        if (textureCount !== 1 && textureCount !== 2) {
+            throw new Error("Texture count must be 1 or 2");
+        }
+
+        this._textureCount = textureCount;
+        this._pushPointCallbackAll();
+    }
+
+    registerPoint(key: string, long: number, lat: number, callback: CallBackFunction): boolean {
+        if (key in this._pointObjects) {
+            console.warn("key already registered, old one is unregistered");
+            this.unregisterPoint(key);
+        }
+        if (!this._isInBBox(long, lat)) {
+            this._pointObjects.set(key, pointObject(long, lat, -1, callback));
+            this._findAndSend(key);
+
+            return false;
+        } else {
+            const index = this._metaCalculater.getFlooredIndex(long, lat)
+            this._pointObjects.set(key, pointObject(long, lat, index, callback));
+        }
+
+        this._findAndSend(key);
+        return true;
+    }
+
+
+
+    unregisterPoint(key: string): boolean {
+        return this._pointObjects.delete(key);
+    }
+
+    updatePoint(key: string, long: number, lat: number): boolean {
+        const pointObject = this._pointObjects.get(key);
+        if (!pointObject) {
+            console.warn("Point not registered, use registerPoint first");
+            return false;
+        }
+        pointObject.long = long;
+        pointObject.lat = lat;
+        if (!this._isInBBox(long, lat)) {
+            pointObject.posIndex = -1; // Mark as invalid
+            pointObject.callback(null, null, null);
+            return false
+        };
+
+        const index = this._metaCalculater.getFlooredIndex(long, lat);
+        pointObject.posIndex = index;
+        this._findAndSend(key);
+
+        return true;
+    }
+
+    updateTextureData(ratio: number, textureData0: TypedArray | null = null, textureData1: TypedArray | null = null,) {
+
+        if (this._textureCount === 1) {
+            if (textureData0 === null) {
+                this._isReady = false;
+            } else {
+                this._textures[0] = textureData0;
+                this._isReady = true;
+            }
+        } else if (this._textureCount === 2) {
+            if (textureData0 === null || textureData1 === null) {
+                this._isReady = false;
+            } else {
+                this._textures[0] = textureData0;
+                this._textures[1] = textureData1;
+                this._isReady = true;
+            }
+        } else {
+            throw new Error("Invalid texture count, must be 1 or 2");
+        }
+        this.updateRatio(ratio);
+    }
+
+
+    updateRatio(ratio: number) {
+        if (typeof ratio !== "number") {
+            throw new Error("Ratio must be a number");
+        }
+        this._ratio = ratio;
+        this._pushPointCallbackAll();
+    }
+
+    flush(callEmptyCallback: boolean = false) {
+        if (callEmptyCallback) {
+            for (const [key, { callback }] of this._pointObjects.entries()) {
+                callback(null, null, null);
+            }
+        }
+        this._pointObjects.clear();
+    }
+
+    // ------- PRIVATE METHODS -------
+
+    _isInBBox(long: number, lat: number) {
+        return lat >= this._bbox[1] && lat <= this._bbox[3] && long >= this._bbox[0] && long <= this._bbox[2];
+    }
+
+
+    _findAndSend(key: string) {
+        const pointObject = this._pointObjects.get(key);
+        if (!pointObject) {
+            console.warn("Point not registered, use registerPoint first");
+            return;
+        }
+        const { posIndex, callback } = pointObject;
+        if (posIndex === -1 || !this._isReady || this._ratio < 0 || this._ratio > 1) {
+            callback(null, null, null);
+            return;
+        }
+        const data0 = this._textures[0][posIndex];
+
+        if (this._textureCount === 1) {
+            callback(data0, data0, data0);
+        } else if (this._textureCount === 2) {
+            const data1 = this._textures[1][posIndex];
+            const interpolated = data0 * (1 - this._ratio) + data1 * this._ratio;
+            callback(data0, data1, interpolated);
+        }
+    }
+
+    _pushPointCallbackAll() {
+        if (this._isReady && this._ratio >= 0 && this._ratio <= 1) {
+            for (const key of this._pointObjects.keys()) {
+                this._findAndSend(key);
+            }
+        } else {
+            for (const [key, { callback }] of this._pointObjects.entries()) {
+                callback(null, null, null);
+            }
+        }
+    }
+}
+
+// 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/index.js

@@ -1,13 +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';
+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/util/interpolation/index.js

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

package/util/interpolation/timetrack/index.js

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

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

@@ -1,79 +1,94 @@
-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 };
+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/util/interpolation/timetrack/web-worker.js

@@ -1,46 +1,51 @@
-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);
-};
+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);
+}
+

package/util/jshelpers/data-filler.js

@@ -1,17 +1,19 @@
-const populateFloat32Array = Object.freeze({
-    fillFloat32Array: (length, data) => {
-        const result = new Float32Array(length);
-        result.fill(data);
-        return result;
-    },
-    fillWithListData: (length, listdata) => {
-        const result = new Float32Array(length * listdata.length);
-        let offset = 0;
-        for (let i = 0; i < length; i++) {
-            result.set(listdata, offset);
-            offset += listdata.length;
-        }
-        return result;
-    }
-});
-export { populateFloat32Array };
+const populateFloat32Array = Object.freeze({
+    fillFloat32Array: (length, data) => {
+        const result = new Float32Array(length);
+        result.fill(data);
+        return result;
+    },
+
+    fillWithListData: (length, listdata) => {
+        const result = new Float32Array(length * listdata.length);
+        let offset = 0;
+        for (let i = 0; i < length; i++) {
+            result.set(listdata, offset);
+            offset += listdata.length;
+        }
+        return result
+    }
+});
+
+export { populateFloat32Array };

package/util/jshelpers/equality.js

@@ -1,18 +1,17 @@
-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;
-}
-export { 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;
+}
+
+export { arraysEqual };

package/util/jshelpers/index.js

@@ -1,2 +1 @@
-import * as timefilters_1 from './timefilters';
-export { timefilters_1 as timefilters };
+export * as timefilters from './timefilters';

package/util/jshelpers/timefilters.js

@@ -1,30 +1,32 @@
-// TODO: fix logic error in instantDebounce
-function instantDebounce(func, delay) {
-    let timeout = null;
-    let lastArgs = null;
-    let runAtEnd = false;
-    const timeoutMethod = () => {
-        setTimeout(() => {
-            if (runAtEnd) {
-                func(...lastArgs);
-                lastArgs = null;
-                // console.log("processed with delay")
-                runAtEnd = false;
-            }
-            timeout = null;
-        }, delay);
-    };
-    return function () {
-        if (timeout) {
-            lastArgs = arguments;
-            runAtEnd = true;
-            return;
-        }
-        else {
-            func(...args);
-            // console.log("processed instantly")
-            timeout = timeoutMethod();
-        }
-    };
-}
-export { instantDebounce };
+// TODO: fix logic error in instantDebounce
+function instantDebounce(func, delay) {
+    let timeout = null;
+    let lastArgs = null;
+    let runAtEnd = false;
+
+    const timeoutMethod = () => {
+        setTimeout(() => {
+            if (runAtEnd) {
+                func(...lastArgs);
+                lastArgs = null;
+                // console.log("processed with delay")
+                runAtEnd = false;
+            }
+            timeout = null;
+        }, delay);
+    }
+
+    return function () {
+        if (timeout) {
+            lastArgs = arguments;
+            runAtEnd = true;
+            return;
+        } else {
+            func(...args);
+            // console.log("processed instantly")
+            timeout = timeoutMethod();
+        }
+    }
+}
+
+export { instantDebounce };