@pirireis/webglobeplugins 0.8.26 → 0.9.2

package/util/heatwavedatamanager/pointcoordinatesdatacalculator.js

@@ -114,20 +114,20 @@ export default class 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;
-}
+// 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/waveparticles/plugin.js

@@ -48,6 +48,7 @@ export default class Plugin {
         }
         this._stepIndex = 0;
         this._fullCycleStepCount = 3;
+        this._isFreed = false;
     }
 
     init(globe, gl) {
@@ -96,6 +97,7 @@ export default class Plugin {
     }
 
     draw3D() {
+        if (this._isFreed) return;
         const { gl, moveParticle, drawParticle, bufferManager, globeShellWiggle, waveUbo, fadeAway, _rgVectorFieldTexture } = this;
 
         gl.disable(gl.DEPTH_TEST);
@@ -168,6 +170,7 @@ export default class Plugin {
     // TODO: free all resources
     free() {
         const { gl, fadeAway, globeShellWiggle, _rgVectorFieldTexture, bufferManager, waveUbo, _drawTextures, _frameBuffer } = this;
+        this._isFreed = true;
         fadeAway.free();
         globeShellWiggle.free();
         gl.deleteTexture(_rgVectorFieldTexture);

package/wind/plugin.js

@@ -300,18 +300,6 @@ void main() {
 }`;
 
 
-const reverseDefaultRampColors = [
-    [0.0, '#d53e4f'],
-    [0.2, '#f46d43'],
-    [0.3, '#fdae61'],
-    [0.4, '#fee08b'],
-    [0.5, '#e6f598'],
-    [0.6, '#abdda4'],
-    [0.7, '#66c2a5'],
-    [0.9, '#3288bd'],
-    // 1.0 deep purple
-    [1.0, '#5e4fa2']
-];
 
 const defaultRampColors = [
     [0.0, '#5e4fa2'],
@@ -356,7 +344,11 @@ const windyLegendData = {
 export default class WindPlugin {
 
     /**
-     * @param {String} id 
+     * @param {String} id   
+     * @param {Object} windDataMeta
+     * @param {number} windDataMeta.width - image width
+     * @param {number} windDataMeta.height - image height
+     * @param {Array} windDataMeta.bbox - bounding box [minLon, minLat, maxLon, maxLat]
      * @param {Object} options 
      * @param {number} options.fadeOpacity - how fast the particle trails fade on each frame | between 0 - 1 | default 0.746
      * @param {number} options.speedFactor - how fast the particles move | between 0 - 1 | default 0.6
@@ -370,25 +362,28 @@ export default class WindPlugin {
      * @param {number} numParticles - number of particles | positive integer
      * @param {LegendData} options.legendData - legend data
      */
-    constructor(id, {
-        fadeOpacity = 0.746,
-        speedFactor = 0.6,
-        dropRate = 0.007,
-        dropRateBump = 0.001,
-        baseOpacity = 1.0,
-        pointSize = 2.0,
-        minSpeed = 0.0,
-        maxSpeed = 1000.0,
-        height = 0.0,
-        numParticles = 40000,
-        legendData = windyLegendData
-    } = {}) {
+    constructor(id,
+        windDataMeta,
+        {
+            fadeOpacity = 0.746,
+            speedFactor = 0.6,
+            dropRate = 0.007,
+            dropRateBump = 0.001,
+            baseOpacity = 1.0,
+            pointSize = 2.0,
+            minSpeed = 0.0,
+            maxSpeed = 1000.0,
+            height = 0.0,
+            numParticles = 40000,
+            legendData = windyLegendData
+        } = {}) {
 
         this.id = id;
-
+        this._windDataMeta = windDataMeta;
         this.globe = null;
         this.gl = null;
 
+
         this._screenMoved = false;
         this.projMatrix = null;
         this.modelviewMatrix = null;
@@ -485,7 +480,6 @@ export default class WindPlugin {
     }
 
     setColorRampDefault() {
-        const { gl } = this;
         const { uMax, uMin, vMax, vMin } = this.windData;
         const maxSpeed = Math.sqrt(
             uMax * uMax + vMax * vMax
@@ -509,11 +503,11 @@ export default class WindPlugin {
      */
     setLegend(legendData) {
         const { gl } = this;
-        if (gl == null) {
+        if (gl === null) {
             throw new Error("wind plugin. setColorRampFromService is called before plugin is registered.");
         }
         const { thresholds, values } = legendData;
-        if (thresholds.length == 0 || values.length == 0) {
+        if (thresholds.length === 0 || values.length === 0) {
             return;
         }
         thresholds.push(thresholds[thresholds.length - 1]);
@@ -577,30 +571,29 @@ export default class WindPlugin {
     /**
      * @param {Object} windData 
      * @param {HTMLImageElement} windData.image - image element
-     * @param {number} windData.width - image width
-     * @param {number} windData.height - image height
+     
      * @param {number} windData.uMin - minimum u value
      * @param {number} windData.vMin - minimum v value
      * @param {number} windData.uMax - maximum u value
      * @param {number} windData.vMax - maximum v value
-     * @param {Array} windData.bbox - bounding box [minLon, minLat, maxLon, maxLat]
      */
     setWind(windData) {
-        if (windData == null) {
+        if (windData === null) {
             return;
         }
+        const windDataMeta = this._windDataMeta;
         const gl = this.gl;
         this.windData = windData;
         this.windTexture = util.createTexture(gl, gl.LINEAR, windData.image);
         const currentProgram = gl.getParameter(gl.CURRENT_PROGRAM);
         gl.useProgram(this.updateProgram.program);
-        gl.uniform2f(this.updateProgram.u_wind_res, this.windData.width, this.windData.height);
+
+        gl.uniform2f(this.updateProgram.u_wind_res, windDataMeta.width, windDataMeta.height);
         gl.uniform2f(this.updateProgram.u_wind_min, this.windData.uMin, this.windData.vMin);
         gl.uniform2f(this.updateProgram.u_wind_max, this.windData.uMax, this.windData.vMax);
         this.setGeometry();
-
-        const minXY = this._latLongToPixelXY(windData.bbox[1], windData.bbox[0]);
-        const maxXY = this._latLongToPixelXY(windData.bbox[3], windData.bbox[2]);
+        const minXY = this._latLongToPixelXY(windDataMeta.bbox[1], windDataMeta.bbox[0]);
+        const maxXY = this._latLongToPixelXY(windDataMeta.bbox[3], windDataMeta.bbox[2]);
         this._loadBoundingBoxData(minXY.x, minXY.y, maxXY.x, maxXY.y);
 
         gl.useProgram(currentProgram);
@@ -630,21 +623,15 @@ export default class WindPlugin {
         }
     }
 
-    getPointCoordinatesDataCalculator({ bbox = null, width = null, height = null } = {}) {
-        if (!this.coordinatesDataCalculator) this._createPointCoordinatesDataCalculator({ bbox, width, height });
+    getPointCoordinatesDataCalculator() {
+        if (!this.coordinatesDataCalculator) this._createPointCoordinatesDataCalculator();
         return this.coordinatesDataCalculator;
     }
 
 
-    _createPointCoordinatesDataCalculator({ bbox = null, width = null, height = null } = {}) {
-        if (this.windData) {
-            this.coordinatesDataCalculator = new PointCoordinatesDataCalculator(this.windData.bbox, this.windData.width, this.windData.height);
-        } else {
-            if (!bbox || !width || !height) {
-                throw new Error("WindPlugin: windData meta info, bbox, width and height are required to create PointCoordinatesDataCalculator");
-            }
-            this.coordinatesDataCalculator = new PointCoordinatesDataCalculator(bbox, width, height);
-        }
+    _createPointCoordinatesDataCalculator() {
+        const { bbox, width, height } = this._windDataMeta;
+        this.coordinatesDataCalculator = new PointCoordinatesDataCalculator(bbox, width, height);
         this._setCoorcinatesDataCalculatorData();
     }
 
@@ -693,10 +680,10 @@ export default class WindPlugin {
 
     _doDraw() {
         const globe = this.globe;
-        if (this.windData == null) {
+        if (this.windData === null) {
             return false;
         }
-        if (globe.api_IsScreenMoving() || this._lastLOD != globe.api_GetCurrentLODWithDecimal()) {
+        if (globe.api_IsScreenMoving() || this._lastLOD !== globe.api_GetCurrentLODWithDecimal()) {
             if (!this._screenMoved) {
                 this._screenMoved = true;
             }
@@ -850,7 +837,7 @@ export default class WindPlugin {
     // globe calls `setGeometry` method on map projection change. FLAT or SPHERE
 
     setGeometry() {
-        if (this.windData == null) {
+        if (this.windData === null) {
             return;
         }
         const { globe, gl } = this;

package/Math/methodology/arc-part-on-screen.ts

@@ -1,47 +0,0 @@
-import { Plane } from "../plane";
-import { Vector3D } from "../vector3d";
-import { Arc } from "../arc";
-
-
-
-const Radians = Math.PI / 180;
-
-export class ArcPartOnScreen {
-    private _oldLookInfo: { CenterLong: number, CenterLat: number, Distance: number, Tilt: number, NorthAng: number };
-    private _boundPlane: Plane;
-
-    constructor() {
-        this._boundPlane = new Plane(new Vector3D(0, 0, 0), 0);
-        this._oldLookInfo = { CenterLong: 0, CenterLat: -190, Distance: 0, Tilt: 0, NorthAng: 0 };
-    }
-
-
-    updateBoundPlane(lookInfo): boolean {
-        if (this._oldLookInfo && this._oldLookInfo.CenterLong === lookInfo.CenterLong && this._oldLookInfo.CenterLat === lookInfo.CenterLat) {
-            return false;
-        }
-        /**
-         * lookInfo {CenterLong: 47.75355881750585, CenterLat: 42.3417076206803, Distance: 2286603.4020860917, Tilt: 0.05, NorthAng: -13.829359965098265}
-         */
-        this._oldLookInfo.CenterLong = lookInfo.CenterLong;
-        this._oldLookInfo.CenterLat = lookInfo.CenterLat;
-        this._oldLookInfo.Distance = lookInfo.Distance;
-        this._oldLookInfo.Tilt = lookInfo.Tilt;
-        this._oldLookInfo.NorthAng = lookInfo.NorthAng;
-
-        Plane.fromGlobeLookInfo(Radians * lookInfo.CenterLong, Radians * lookInfo.CenterLat, lookInfo.Distance, this._boundPlane);
-        return true;
-    }
-
-
-
-    getArcPartOnScreen(arc: Arc, target: Arc): boolean {
-        // _imaginaryPlane.set(arc.greatCirclePlaneNormalVector, arc.pointA.dot(arc.greatCirclePlaneNormalVector));
-        // const intersection = _imaginaryPlane.intersectionPlane(this._boundPlane);
-        // if (!(intersection instanceof Ray)) return false;
-        // _ray.copy(intersection as Ray);
-        // const [point1, point2] = _ray.intersectionSphere(_unitShphereCenter, _unitShphereRadius) as [Vector3D, Vector3D];
-        const result = arc.intersectionMedium(this._boundPlane, target);
-        return !(result === null);
-    }
-}

package/Math/ray.ts

@@ -1,101 +0,0 @@
-import { Vector3D } from './vector3d';
-import { Plane } from './plane';
-
-
-const _0vector = /*@__PURE__*/ new Vector3D(0, 0, 0);
-const _1vector = /*@__PURE__*/ new Vector3D(0, 0, 0);
-const _3vector = /*@__PURE__*/ new Vector3D(0, 0, 0);
-export class Ray {
-
-    origin: Vector3D;
-    direction: Vector3D;
-
-    constructor(origin: Vector3D, direction: Vector3D) {
-        this.origin = origin;
-        this.direction = direction.normalize();
-    }
-
-    copy(ray: Ray): Ray {
-        this.origin.copy(ray.origin);
-        this.direction.copy(ray.direction);
-        return this;
-    }
-
-    clone(): Ray {
-        return new Ray(this.origin.clone(), this.direction.clone());
-    }
-
-
-    at(distance: number, out: Vector3D): Vector3D {
-        return out.copy(this.direction).multiplyByScaler(distance).add(this.origin);
-    }
-
-
-    set(origin: Vector3D, direction: Vector3D): Ray {
-        this.origin.copy(origin);
-        this.direction.copy(direction).normalize();
-        return this;
-    }
-
-    intersectionSphere(sphereOrigin: Vector3D, sphereRadius: number): [Vector3D, Vector3D] | null {
-
-        const l = this.direction.clone().normalize();
-        const s = this.origin.clone().subtract(sphereOrigin);
-        const b = l.dot(s);
-
-        const c = s.dot(s) - sphereRadius * sphereRadius;
-        const d = b * b - c;
-
-        if (d < 0) {
-            return null; // no intersection
-        } else {
-            const x = Math.sqrt(d);
-            const t1 = -b - x;
-            const t2 = -b + x;
-            // l and s are used as output vectors
-            return [this.at(t1, l), this.at(t2, s)];
-        }
-    }
-
-
-    contains(point: Vector3D): boolean {
-        const x = this.origin.x - point.x;
-        const y = this.origin.y - point.y;
-        const z = this.origin.z - point.z;
-        const distance = Math.sqrt(x * x + y * y + z * z);
-        if (distance < 0.0001) {
-            return true; // point is very close to the origin
-        }
-        return Math.abs(_0vector.set(x / distance, y / distance, z / distance).dot(this.direction)) > 0.9999; // point direction  towards origin 
-        // is very close to the ray direction
-    }
-
-    // TODO: Applay this approach to other static methods on other Math classes.
-    static fromTwoPlanes(planeA: Plane, planeB: Plane, target: Ray | null = null): Ray | null {
-        const intersection = planeA.intersectionPlane(planeB);
-        if (intersection === null || intersection instanceof Plane) {
-            return null; // planes are parallel
-        }
-        if (target === null) {
-            target = new Ray(intersection.origin, intersection.direction);
-        }
-        else {
-            target.set(intersection.origin, intersection.direction);
-        }
-        return target;
-    }
-
-
-    static fromTwoPoints(pointA: Vector3D, pointB: Vector3D, target: Ray | null = null): Ray {
-        if (target === null) {
-            target = new Ray(pointA, pointB.clone().subtract(pointA).normalize());
-        } else {
-            target.set(pointA, pointB.clone().subtract(pointA).normalize());
-        }
-        return target;
-    }
-
-}
-
-
-

package/Math/vector3d.ts

@@ -1,241 +0,0 @@
-import { Vector3D as IVector3D, Radians } from "./types";
-import { Quaternion } from "./quaternion";
-
-
-
-export class Vector3D implements IVector3D {
-    x: number;
-    y: number;
-    z: number;
-
-
-    constructor(x: number = 0, y: number = 0, z: number = 0) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-    }
-
-
-
-    normalize(): Vector3D {
-        this.divideByScaler(this.length() || 1);
-        return this;
-    }
-
-
-
-    dot(other: Vector3D) {
-        return this.x * other.x + this.y * other.y + this.z * other.z;
-    }
-
-
-
-    equals(other: Vector3D, epsilon: number = 0.0000001): boolean {
-        // TODO: consider coppying other in case is true to avoid difference accumulation. 
-        return Math.abs(this.x - other.x) < epsilon &&
-            Math.abs(this.y - other.y) < epsilon &&
-            Math.abs(this.z - other.z) < epsilon;
-    }
-
-
-
-
-    static crossVectors(a: Vector3D, b: Vector3D, c: Vector3D = new Vector3D): Vector3D {
-        const x = a.y * b.z - a.z * b.y;
-        const y = a.z * b.x - a.x * b.z;
-        const z = a.x * b.y - a.y * b.x;
-
-        c.set(x, y, z);
-
-        return c;
-    }
-
-
-
-    cross(other: Vector3D): Vector3D {
-        return Vector3D.crossVectors(this, other, this);
-    }
-
-
-
-    angle(other: Vector3D): number {
-        const a = this.length();
-        const b = other.length();
-        const c = this.dot(other);
-        const angle = Math.acos(c / (a * b));
-
-        return isNaN(angle) ? 0 : angle;
-    }
-
-    lerpVectors(a: Vector3D, b: Vector3D, t: number): Vector3D {
-        this.x = a.x + (b.x - a.x) * t;
-        this.y = a.y + (b.y - a.y) * t;
-        this.z = a.z + (b.z - a.z) * t;
-
-        return this;
-    }
-
-
-
-    lerp(other: Vector3D, t: number): Vector3D {
-        return this.lerpVectors(this, other, t);
-    }
-
-
-
-    scale(scalar: number): Vector3D {
-        this.x *= scalar;
-        this.y *= scalar;
-        this.z *= scalar;
-
-        return this;
-    }
-
-    dotProduct(other: Vector3D): number {
-        return this.x * other.x + this.y * other.y + this.z * other.z;
-    }
-
-
-    dotDivide(other: Vector3D): number {
-        return this.x / other.x + this.y / other.y + this.z / other.z;
-    }
-
-
-    add(other: Vector3D): Vector3D {
-        this.x += other.x;
-        this.y += other.y;
-        this.z += other.z;
-
-        return this;
-    }
-
-
-
-    negate(): Vector3D {
-        this.x = -this.x;
-        this.y = -this.y;
-        this.z = -this.z;
-
-        return this;
-    }
-
-
-
-    length(): number {
-        return Math.sqrt(this.x ** 2 + this.y ** 2 + this.z ** 2);
-    }
-
-
-
-    subtract(other: Vector3D): Vector3D {
-        this.x -= other.x;
-        this.y -= other.y;
-        this.z -= other.z;
-
-        return this;
-    }
-
-
-
-    applyQuaternion(q: Quaternion): Vector3D {
-        const x = this.x, y = this.y, z = this.z;
-        const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
-        // calculate quat * vector
-        const ix = qw * x + qy * z - qz * y;
-        const iy = qw * y + qz * x - qx * z;
-        const iz = qw * z + qx * y - qy * x;
-        const iw = -qx * x - qy * y - qz * z;
-        // calculate result * inverse quat
-        this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
-        this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
-        this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
-        return this;
-    }
-
-
-
-    multiplyByScaler(scalar: number): Vector3D {
-        this.x *= scalar;
-        this.y *= scalar;
-        this.z *= scalar;
-
-        return this;
-    };
-
-
-
-    divideByScaler(scalar: number): Vector3D {
-        this.x /= scalar;
-        this.y /= scalar;
-        this.z /= scalar;
-
-        return this;
-    }
-
-
-
-    copy(other: Vector3D): Vector3D {
-        this.x = other.x;
-        this.y = other.y;
-        this.z = other.z;
-
-        return this
-    }
-
-
-
-    set(x: number, y: number, z: number): Vector3D {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-
-        return this
-    }
-
-
-
-    clone(): Vector3D {
-        return new Vector3D(this.x, this.y, this.z);
-    }
-
-
-
-    randomUnit(): Vector3D {
-        const x = Math.random() * 2 - 1;
-        const y = Math.random() * 2 - 1;
-        const z = Math.random() * 2 - 1;
-
-        return this.set(x, y, z).normalize();
-    }
-
-
-
-    setFromLonLat(lon: Radians, lat: Radians): Vector3D {
-        const x = Math.cos(lat) * Math.cos(lon);
-        const y = Math.cos(lat) * Math.sin(lon);
-        const z = Math.sin(lat);
-
-        return this.set(x, y, z);
-    }
-
-
-
-
-    toLonLat(): { lon: Radians, lat: Radians } {
-        const len = this.length();
-        const x = this.x / len;
-        const y = this.y / len;
-        const z = this.z / len;
-        const lon = Math.atan2(y, x);
-        const lat = Math.asin(z);
-
-        return { lon, lat };
-    }
-
-
-
-    static fromLonLatRadians(lon: Radians, lat: Radians): Vector3D {
-        return new Vector3D().setFromLonLat(lon, lat);
-    }
-
-}