@pirireis/webglobeplugins 0.7.0 → 0.7.1

package/Math/methods.js

@@ -1,7 +1,6 @@
 
-const WORLD_RADIUS_3D = 6371.137;
-const WORLD_RADIUS_MERCATOR = 6371137;
-const POLE = 20037508.34;
+const WORLD_RADIUS_3D = 6378.137;
+const WORLD_RADIUS_MERCATOR = 6378136.99911;
 
 /**
  * @typedef {Array<number>} vec3 [x, y, z]

package/index.js

@@ -8,4 +8,5 @@ import * as compassrose from "./compassrose";
 import * as heatwave from "./heatwave";
 import * as util from "./util";
 import * as programs from "./programs";
-export { wind, waveparticles, timetracks, rangerings, compassrose, heatwave, util, programs, arrowfield, partialring };
+import * as pointheatmap from "./point-heat-map";
+export { wind, waveparticles, timetracks, rangerings, compassrose, heatwave, util, programs, arrowfield, partialring, pointheatmap };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@pirireis/webglobeplugins",
-    "version": "0.7.0",
+    "version": "0.7.1",
     "main": "index.js",
     "author": "Toprak Nihat Deniz Ozturk",
     "license": "MIT"

package/point-heat-map/index.js

@@ -0,0 +1,3 @@
+import { PointHeatmapPlugin } from "./plugin-webworker";
+import { timeTrackPluginDataToPointHeatInterpolatorAdapter } from "./adaptors/timetracksplugin-format-to-this";
+// export { PointHeatmapPlugin, timeTrackPluginDataToPointHeatInterpolatorAdapter };

package/point-heat-map/plugin-webworker.js

@@ -1,5 +1,5 @@
 import { PointHeatmapFlow } from "./point-to-heat-map-flow";
-import { TimeTrackInterpolator } from "../util/interpolation/timetrack/timetrack-interpolator";
+import { webworkerStr } from "../util/interpolation/timetrack/web-worker-str";
 import { createTexture, getColorRampModed } from "../util";
 
 class PointHeatmapPlugin {
@@ -11,21 +11,25 @@ class PointHeatmapPlugin {
         this.densityToLegendProgram = null;
         this._time = null;
 
-
         this._opacity = opacity;
         this._pointSize = pointSize;
         this._legendTexture = null;
-        // this.timeTrackInterpolator = new TimeTrackInterpolator();
-
 
         this._throttleListener = null;
 
-        this.timeTrackInterpolationWorker = new Worker(
-            new URL(
-                '../util/interpolation/timetrack/web-worker.js',
-                import.meta.url
-            ), { type: 'module' }
-        );
+        try {
+
+            this.timeTrackInterpolationWorker = new Worker(
+                new URL(
+                    '../util/interpolation/timetrack/web-worker.js',
+                    import.meta.url
+                ), { type: 'module' }
+            );
+        } catch (e) {
+            console.log(e);
+            const blob = new Blob([webworkerStr], { type: 'application/javascript' });
+            this.timeTrackInterpolationWorker = new Worker(URL.createObjectURL(blob), { type: 'module' });
+        }
         this.timeTrackInterpolationWorker.onmessage = (e) => {
             if (e.data.error) {
                 throw new Error(e.data.error);

package/util/interpolation/timetrack/index.js

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

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

@@ -0,0 +1,176 @@
+const webworkerStr = `
+
+const WORLD_RADIUS_3D = 6378.137;
+const WORLD_RADIUS_MERCATOR = 6378136.99911;
+
+const dot3 = (a, b) => {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+
+const sphericalLinearInterpolation_UnitVector = (normalizedA, normalizedB, ratio) => {
+    const theta = Math.acos(dot3(normalizedA, normalizedB));
+    if (theta < 0.000001) return normalizedA; // CALIBRATE?
+    const sinTheta = Math.sin(theta);
+    const result = [
+        (Math.sin((1.0 - ratio) * theta) * normalizedA[0] + Math.sin(ratio * theta) * normalizedB[0]) / sinTheta,
+        (Math.sin((1.0 - ratio) * theta) * normalizedA[1] + Math.sin(ratio * theta) * normalizedB[1]) / sinTheta,
+        (Math.sin((1.0 - ratio) * theta) * normalizedA[2] + Math.sin(ratio * theta) * normalizedB[2]) / sinTheta
+    ];
+    return result;
+}
+
+const radianToMercator = (xy) => {
+    return [WORLD_RADIUS_MERCATOR * xy[0], WORLD_RADIUS_MERCATOR * Math.log(Math.tan(Math.PI / 4 + xy[1] / 2))];
+}
+
+
+const cartesian3dToRadian = (cartesian) => {
+    const x = cartesian[0];
+    const y = cartesian[1];
+    const z = cartesian[2];
+    // const length = Math.sqrt(x * x + y * y + z * z);
+    const long = Math.atan2(y, x);
+    const lat = Math.asin(z)// length);
+    return [long, lat];
+}
+
+
+const sphericalLinearInterpolation_Mercator = (normalizedA, normalizedB, ratio) => {
+    const unitVector = sphericalLinearInterpolation_UnitVector(normalizedA, normalizedB, ratio);
+    const angles = cartesian3dToRadian(unitVector);
+    return radianToMercator(angles);
+}
+
+const sphericalLinearInterpolation_Cartesian3d = (a, b, ratio) => {
+    const unitVector = sphericalLinearInterpolation_UnitVector(a, b, ratio);
+    const height = a[3] + (b[3] - a[3]) * ratio;
+    return [unitVector[0] * height, unitVector[1] * height, unitVector[2] * height];
+}
+
+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;
+}
+
+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) {
+        console.log("timetracks:", 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]);
+            const interpolated = (geometry === GEOMETRY.CARTESIAN3D) ?
+                sphericalLinearInterpolation_Cartesian3d(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction) :
+                sphericalLinearInterpolation_Mercator(coordinates[timeIndex], coordinates[timeIndex + 1], timeFraction);
+            resultArray.push(...interpolated);
+        }
+        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]);
+    }
+}
+
+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);
+            /* 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);
+}
+    `;
+export { webworkerStr };