@pirireis/webglobeplugins 0.17.1 → 1.0.2

package/tracks/point-heat-map/adaptors/timetracksplugin-format-to-this.js

@@ -1,63 +1,78 @@
-/**
- * @typedef {Float32Array} TimeTrackMultiColorData  | A linestring is representation, let A{a1, a2, a3}, B{b1, b2} be the points of the line.
-     * TimeTrackMultiColorData is [
-     *  a1x, a1y, a1z, a1time, a1r, a1g, a1b, a1time, a3time,
-     *  a2x, a2y, a2z, a2time, a2r, a2g, a2b, a1time, a3time,
-     *  a3x, a3y, a3z, a3time, a3r, a3g, a3b, a1time, a3time,
-     *  0, 0, 0, 0, -1, -1, -1, 0, 0,
-     *  b1x, b1y, b1z, b1time, b1r, b1g, b1b, b1time, b2time,
-     *  b2x, b2y, b2z, b2time, b2r, b2g, b2b, BstartTime, BendTime
-     * ]
-     * there is a cutting point between A and B
-     *
-*/
-/**
- * ABOVE
- *  TO
- * BELOW
-
-/**
- * @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]
- */
-/**
- * @typedef Timetrack
- * @property {Array<vec4>}} coordinates [x,y,z, length]
- * @property {Array<Number>} times
- * @param {Array<Timetrack>} timeTracks
- */
-import { pixelXYLenghtToUnitVectorWithHeight } from "../../../Math/methods";
-const processACut = (array, offset) => {
-    // first 3 values of array
-    const v3 = array.slice(offset, offset + 3);
-    const v4 = pixelXYLenghtToUnitVectorWithHeight(v3);
-    const time = array[offset + 3];
-    return [v4, time];
-};
-const timeTrackPluginDataToPointHeatInterpolatorAdapter = (timeTrackPluginData) => {
-    const timeTracks = [];
-    let offset = 0;
-    let timeTrack = {
-        coordinates: [],
-        times: []
-    };
-    while (offset < timeTrackPluginData.length) {
-        if (!timeTrackPluginData[offset]) {
-            timeTracks.push(timeTrack);
-            timeTrack = {
-                coordinates: [],
-                times: []
-            };
-            offset += 9;
-        }
-        const point = processACut(timeTrackPluginData, offset);
-        offset += 9;
-        timeTrack.coordinates.push(point[0]);
-        timeTrack.times.push(point[1]);
-    }
-    return timeTracks;
-};
-export { timeTrackPluginDataToPointHeatInterpolatorAdapter };
+/**
+ * @typedef {Float32Array} TimeTrackMultiColorData  | A linestring is representation, let A{a1, a2, a3}, B{b1, b2} be the points of the line.
+     * TimeTrackMultiColorData is [
+     *  a1x, a1y, a1z, a1time, a1r, a1g, a1b, a1time, a3time,
+     *  a2x, a2y, a2z, a2time, a2r, a2g, a2b, a1time, a3time, 
+     *  a3x, a3y, a3z, a3time, a3r, a3g, a3b, a1time, a3time,
+     *  0, 0, 0, 0, -1, -1, -1, 0, 0,
+     *  b1x, b1y, b1z, b1time, b1r, b1g, b1b, b1time, b2time, 
+     *  b2x, b2y, b2z, b2time, b2r, b2g, b2b, BstartTime, BendTime
+     * ]
+     * there is a cutting point between A and B
+     * 
+*/
+
+/**
+ * ABOVE 
+ *  TO
+ * BELOW
+
+/**
+ * @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]
+ */
+
+
+/**
+ * @typedef Timetrack
+ * @property {Array<vec4>}} coordinates [x,y,z, length]
+ * @property {Array<Number>} times  
+ * @param {Array<Timetrack>} timeTracks 
+ */
+
+
+
+import { pixelXYLenghtToUnitVectorWithHeight } from "../../../Math/methods";
+
+
+
+const processACut = (array, offset) => {
+    // first 3 values of array
+    const v3 = array.slice(offset, offset + 3);
+    const v4 = pixelXYLenghtToUnitVectorWithHeight(v3);
+    const time = array[offset + 3];
+    return [v4, time];
+}
+
+
+const timeTrackPluginDataToPointHeatInterpolatorAdapter = (timeTrackPluginData) => {
+    const timeTracks = []
+
+    let offset = 0;
+
+    let timeTrack = {
+        coordinates: [],
+        times: []
+    }
+    while (offset < timeTrackPluginData.length) {
+        if (!timeTrackPluginData[offset]) {
+            timeTracks.push(timeTrack);
+            timeTrack = {
+                coordinates: [],
+                times: []
+            }
+            offset += 9;
+        }
+        const point = processACut(timeTrackPluginData, offset);
+        offset += 9;
+        timeTrack.coordinates.push(point[0]);
+        timeTrack.times.push(point[1]);
+    }
+    return timeTracks;
+}
+
+
+export { timeTrackPluginDataToPointHeatInterpolatorAdapter };

package/tracks/point-heat-map/index.js

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

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

@@ -1,121 +1,148 @@
-import { PointHeatmapFlow } from "./point-to-heat-map-flow";
-import { createWorker } from "../../util/interpolation/timetrack/index";
-import { createTexture, getColorRampModed } from "../../util/webglobjectbuilders";
-import { opacityCheck, constraintFloat } from "../../util/check/typecheck";
-class PointHeatmapPlugin {
-    constructor(id, { opacity = 1.0, pointSize = 5.0, onInterpolationComplete = () => { } } = {}) {
-        this.id = id;
-        this.globe = null;
-        this.gl = null;
-        this.densityToLegendProgram = null;
-        this._time = null;
-        this._opacity = opacity;
-        this._pointSize = pointSize;
-        this._legendTexture = null;
-        this._throttleListener = null;
-        this._timeTracksAreSet = false;
-        this.timeTrackInterpolationWorker = createWorker();
-        this.timeTrackInterpolationWorker.onmessage = (e) => {
-            if (e.data.error) {
-                throw new Error(e.data.error);
-            }
-            if (e.data === true) {
-                onInterpolationComplete();
-            }
-            if (e.data instanceof Float32Array) {
-                this.flow.setData(e.data);
-                this._throttleListener = null;
-                onInterpolationComplete();
-            }
-        };
-    }
-    // globe interaction
-    init(globe, gl) {
-        this.globe = globe;
-        this.gl = gl;
-        this.flow = new PointHeatmapFlow(globe);
-        this.setGeometry();
-        this.resize();
-    }
-    setPointSize(pointSize) {
-        constraintFloat(pointSize, 1);
-        this._pointSize = pointSize;
-        this.globe.DrawRender();
-    }
-    /**
-     * @param {Array<string>}
-     * @param {string} mode "interpolated" | "discrete"
-     */
-    setColorRamp(values, thresholds, mode = "interpolated") {
-        const gl = this.gl;
-        if (this.gl === null) {
-            throw new Error('Plugin not initialized');
-        }
-        ;
-        const rampData = getColorRampModed(values, thresholds, mode);
-        const texture = createTexture(gl, gl.LINEAR, rampData, 256, 1);
-        if (this._legendTexture) {
-            this.gl.deleteTexture(this._legendTexture);
-        }
-        this._legendTexture = texture;
-        this.globe.DrawRender();
-    }
-    setTime(time) {
-        // TODO: WORK ON THIS
-        this._time = time;
-        if (this.isReady() && this._throttleListener === null) {
-            if (this._isFreed)
-                return;
-            this._throttleListener = setTimeout(() => {
-                this.timeTrackInterpolationWorker?.postMessage({ time: this._time });
-            }, 0);
-        }
-    }
-    setTimetracks(timeTracks) {
-        this._timeTracksAreSet = true;
-        this.timeTrackInterpolationWorker.postMessage({ timeTracks });
-        if (this._time !== null) {
-            this.setTime(this._time);
-        }
-        this.globe.DrawRender();
-    }
-    setOpacity(opacity) {
-        opacityCheck(opacity);
-        this._opacity = opacity;
-        this.globe.DrawRender();
-    }
-    setGeometry() {
-        const geometry = this.globe.api_GetCurrentGeometry();
-        this.timeTrackInterpolationWorker.postMessage({ geometry });
-        if (this._time !== null) {
-            this.setTime(this._time);
-        }
-    }
-    draw3D() {
-        if (this.isReady()) {
-            this.flow.draw(this._legendTexture, this._pointSize, this._opacity);
-        }
-    }
-    resize() {
-        this.flow.resize();
-        if (this._time !== null) {
-            this.setTime(this._time);
-        }
-    }
-    isReady() {
-        return (this.gl !== null && this._legendTexture !== null && this._timeTracksAreSet);
-    }
-    free() {
-        if (this._isFreed)
-            return;
-        this.gl.deleteTexture(this._legendTexture);
-        this.flow.free();
-        this.flow = null;
-        this.gl = null;
-        this._isFreed = true;
-        this._legendTexture = null;
-        this.timeTrackInterpolationWorker.terminate();
-        this.timeTrackInterpolationWorker = null;
-    }
-}
-export { PointHeatmapPlugin };
+import { PointHeatmapFlow } from "./point-to-heat-map-flow";
+import { createWorker } from "../../util/interpolation/timetrack/index";
+import { createTexture, getColorRampModed } from "../../util/webglobjectbuilders";
+import { opacityCheck, constraintFloat } from "../../util/check/typecheck";
+
+class PointHeatmapPlugin {
+
+    constructor(id, { opacity = 1.0, pointSize = 5.0, onInterpolationComplete = () => { } } = {}) {
+        this.id = id;
+        this.globe = null;
+        this.gl = null;
+        this.densityToLegendProgram = null;
+        this._time = null;
+
+        this._opacity = opacity;
+        this._pointSize = pointSize;
+        this._legendTexture = null;
+
+        this._throttleListener = null;
+        this._timeTracksAreSet = false;
+        this.timeTrackInterpolationWorker = createWorker();
+        this.timeTrackInterpolationWorker.onmessage = (e) => {
+            if (e.data.error) {
+                throw new Error(e.data.error);
+            }
+            if (e.data === true) {
+                onInterpolationComplete();
+            }
+            if (e.data instanceof Float32Array) {
+                this.flow.setData(e.data);
+                this._throttleListener = null;
+                onInterpolationComplete();
+            }
+        }
+    }
+
+    // globe interaction
+
+    init(globe, gl) {
+        this.globe = globe;
+        this.gl = gl;
+        this.flow = new PointHeatmapFlow(globe);
+        this.setGeometry();
+        this.resize();
+    }
+
+
+    setPointSize(pointSize) {
+        constraintFloat(pointSize, 1);
+        this._pointSize = pointSize;
+        this.globe.DrawRender();
+    }
+
+
+    /**
+     * @param {Array<string>} 
+     * @param {string} mode "interpolated" | "discrete"
+     */
+
+    setColorRamp(values, thresholds, mode = "interpolated") {
+        const gl = this.gl
+        if (this.gl === null) {
+            throw new Error('Plugin not initialized');
+        };
+        const rampData = getColorRampModed(values, thresholds, mode);
+        const texture = createTexture(gl, gl.LINEAR, rampData, 256, 1);
+        if (this._legendTexture) {
+            this.gl.deleteTexture(this._legendTexture);
+        }
+        this._legendTexture = texture;
+        this.globe.DrawRender();
+    }
+
+
+    setTime(time) {
+        // TODO: WORK ON THIS
+        this._time = time;
+        if (this.isReady() && this._throttleListener === null) {
+            if (this._isFreed) return;
+            this._throttleListener = setTimeout(() => {
+                this.timeTrackInterpolationWorker?.postMessage({ time: this._time });
+            }, 0);
+        }
+    }
+
+
+    setTimetracks(timeTracks) {
+        this._timeTracksAreSet = true;
+        this.timeTrackInterpolationWorker.postMessage({ timeTracks });
+        if (this._time !== null) {
+            this.setTime(this._time);
+        }
+        this.globe.DrawRender();
+    }
+
+
+    setOpacity(opacity) {
+        opacityCheck(opacity);
+        this._opacity = opacity;
+        this.globe.DrawRender();
+    }
+
+
+
+    setGeometry() {
+        const geometry = this.globe.api_GetCurrentGeometry();
+        this.timeTrackInterpolationWorker.postMessage({ geometry });
+        if (this._time !== null) {
+            this.setTime(this._time);
+        }
+    }
+
+
+    draw3D() {
+        if (this.isReady()) {
+            this.flow.draw(this._legendTexture, this._pointSize, this._opacity);
+        }
+    }
+
+
+    resize() {
+        this.flow.resize();
+        if (this._time !== null) {
+            this.setTime(this._time);
+        }
+    }
+
+
+    isReady() {
+        return (this.gl !== null && this._legendTexture !== null && this._timeTracksAreSet);
+    }
+
+    free() {
+        if (this._isFreed) return;
+        this.gl.deleteTexture(this._legendTexture);
+        this.flow.free();
+        this.flow = null;
+        this.gl = null;
+        this._isFreed = true;
+        this._legendTexture = null;
+        this.timeTrackInterpolationWorker.terminate();
+        this.timeTrackInterpolationWorker = null;
+    }
+}
+
+
+export { PointHeatmapPlugin };
+