@pirireis/webglobeplugins 1.0.2 → 1.0.4

package/webglobeplugins/vectorfield/wind/adapters/image-to-fields.js

@@ -0,0 +1,92 @@
+/**
+ * Author: Toprak Nihat Deniz Ozturk
+ */
+export function imageToFields(data, legendData) {
+    const { image, uMin, vMin, uMax, vMax } = data;
+    const width = image.width;
+    const height = image.height;
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    ctx?.drawImage(image, 0, 0);
+    const imageData = ctx?.getImageData(0, 0, width, height);
+    if (!imageData) {
+        throw new Error("Failed to get image data from canvas.");
+    }
+    const vectorFieldData = new Float32Array(width * height * 2);
+    const speedFieldData = new Float32Array(width * height);
+    const colorFieldData = new Uint8Array(width * height * 4);
+    // Pre-parse color values for better performance
+    const parsedColors = legendData.values.map(hex => {
+        const colorValue = parseInt(hex.replace("#", ""), 16);
+        return {
+            r: (colorValue >> 16) & 0xff,
+            g: (colorValue >> 8) & 0xff,
+            b: colorValue & 0xff
+        };
+    });
+    const uDiff = uMax - uMin;
+    const vDiff = vMax - vMin;
+    const uHeight = Math.max(Math.abs(uMin), Math.abs(uMax));
+    const scaler = Math.max(Math.abs(vMin), Math.abs(vMax), uHeight);
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const index = (y * width + x) * 4;
+            const r = imageData.data[index];
+            const g = imageData.data[index + 1];
+            // Map texel [0,255] to actual speed values [uMin,uMax] and [vMin,vMax]
+            const u = uMin + (uDiff * r) / 255;
+            const v = vMin + (vDiff * g) / 255;
+            const speed = Math.sqrt(u * u + v * v);
+            speedFieldData[y * width + x] = speed;
+            vectorFieldData[(y * width + x) * 2] = u / scaler;
+            vectorFieldData[(y * width + x) * 2 + 1] = -v / scaler;
+            // Determine color via linear interpolation between thresholds
+            const thresholds = legendData.thresholds;
+            const n = Math.min(thresholds.length, parsedColors.length);
+            let outR = 0, outG = 0, outB = 0;
+            if (n === 0) {
+                outR = outG = outB = 0;
+            }
+            else if (n === 1 || speed <= thresholds[0]) {
+                outR = parsedColors[0].r;
+                outG = parsedColors[0].g;
+                outB = parsedColors[0].b;
+            }
+            else if (speed >= thresholds[n - 1]) {
+                outR = parsedColors[n - 1].r;
+                outG = parsedColors[n - 1].g;
+                outB = parsedColors[n - 1].b;
+            }
+            else {
+                let i = 0;
+                for (; i < n - 1; i++) {
+                    if (speed < thresholds[i + 1])
+                        break;
+                }
+                if (i === n - 1) {
+                    // set to last color
+                    outR = parsedColors[n - 1].r;
+                    outG = parsedColors[n - 1].g;
+                    outB = parsedColors[n - 1].b;
+                    continue;
+                }
+                const t0 = thresholds[i];
+                const t1 = thresholds[i + 1];
+                const denom = t1 - t0 || 1;
+                const t = Math.max(0, Math.min(1, (speed - t0) / denom));
+                const c0 = parsedColors[i];
+                const c1 = parsedColors[i + 1];
+                outR = Math.round(c0.r + (c1.r - c0.r) * t);
+                outG = Math.round(c0.g + (c1.g - c0.g) * t);
+                outB = Math.round(c0.b + (c1.b - c0.b) * t);
+            }
+            colorFieldData[index] = outR;
+            colorFieldData[index + 1] = outG;
+            colorFieldData[index + 2] = outB;
+            colorFieldData[index + 3] = 255; // Alpha channel
+        }
+    }
+    return { vectorFieldData, speedFieldData, colorFieldData };
+}

package/webglobeplugins/vectorfield/wind/adapters/types.js

@@ -0,0 +1 @@
+export {};

package/{vectorfield/wind/imagetovectorfieldandmagnitude.ts → webglobeplugins/vectorfield/wind/imagetovectorfieldandmagnitude.js}

@@ -1,78 +1,53 @@
-interface ImageDataInput {
-    image: HTMLImageElement;
-    uMax: number;
-    vMax: number;
-    uMin: number;
-    vMin: number;
-    height: number;
-    width: number;
-}
-
-export default function imageToMagnitude(imageData: ImageDataInput): Float32Array {
-    const { image, uMax, vMax, uMin, vMin, height, width } = imageData;
-
-
-
-    const canvas = document.createElement('canvas');
-    const ctx = canvas.getContext('2d');
-    if (!ctx) {
-        throw new Error('Failed to get 2D context');
-    }
-    canvas.width = width;
-    canvas.height = height;
-    ctx.drawImage(image, 0, 0, width, height);
-    const img = ctx.getImageData(0, 0, width, height);
-    const data = img.data;
-
-    const magnitudeArray = new Float32Array(height * width);
-
-    const uDiff = uMax - uMin;
-    const vDiff = vMax - vMin;
-
-    for (let i = 0; i < data.length; i += 4) {
-        const r = data[i];
-        const g = data[i + 1];
-        const u = uMin + (uDiff * r) / 255;
-        const v = vMin + (vDiff * g) / 255;
-        const magnitude = Math.sqrt(u * u + v * v);
-        const index = i / 4;
-        magnitudeArray[index] = magnitude;
-    }
-
-    return magnitudeArray;
-}
-
-
-export function imageToRadianAngle(imageData: ImageDataInput): Float32Array {
-    const { image, uMax, vMax, uMin, vMin, height, width } = imageData;
-
-    const canvas = document.createElement('canvas');
-    const ctx = canvas.getContext('2d');
-    if (!ctx) {
-        throw new Error('Failed to get 2D context');
-    }
-    canvas.width = width;
-    canvas.height = height;
-    ctx.drawImage(image, 0, 0, width, height);
-    const img = ctx.getImageData(0, 0, width, height);
-    const data = img.data;
-
-    const angleArray = new Float32Array(height * width);
-
-    const uDiff = uMax - uMin;
-    const vDiff = vMax - vMin;
-
-    for (let i = 0; i < data.length; i += 4) {
-        const r = data[i];
-        const g = data[i + 1];
-        const u = uMin + (uDiff * r) / 255;
-        const v = vMin + (vDiff * g) / 255;
-        // North-oriented angle: 0 = North, π/2 = East, π = South, 3π/2 = West
-        const angle = Math.atan2(u, v);
-        const index = i / 4;
-
-        angleArray[index] = angle < 0 ? (angle + 2 * Math.PI) : angle;
-    }
-
-    return angleArray;
-}
+export default function imageToMagnitude(imageData) {
+    const { image, uMax, vMax, uMin, vMin, height, width } = imageData;
+    const canvas = document.createElement('canvas');
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('Failed to get 2D context');
+    }
+    canvas.width = width;
+    canvas.height = height;
+    ctx.drawImage(image, 0, 0, width, height);
+    const img = ctx.getImageData(0, 0, width, height);
+    const data = img.data;
+    const magnitudeArray = new Float32Array(height * width);
+    const uDiff = uMax - uMin;
+    const vDiff = vMax - vMin;
+    for (let i = 0; i < data.length; i += 4) {
+        const r = data[i];
+        const g = data[i + 1];
+        const u = uMin + (uDiff * r) / 255;
+        const v = vMin + (vDiff * g) / 255;
+        const magnitude = Math.sqrt(u * u + v * v);
+        const index = i / 4;
+        magnitudeArray[index] = magnitude;
+    }
+    return magnitudeArray;
+}
+export function imageToRadianAngle(imageData) {
+    const { image, uMax, vMax, uMin, vMin, height, width } = imageData;
+    const canvas = document.createElement('canvas');
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('Failed to get 2D context');
+    }
+    canvas.width = width;
+    canvas.height = height;
+    ctx.drawImage(image, 0, 0, width, height);
+    const img = ctx.getImageData(0, 0, width, height);
+    const data = img.data;
+    const angleArray = new Float32Array(height * width);
+    const uDiff = uMax - uMin;
+    const vDiff = vMax - vMin;
+    for (let i = 0; i < data.length; i += 4) {
+        const r = data[i];
+        const g = data[i + 1];
+        const u = uMin + (uDiff * r) / 255;
+        const v = vMin + (vDiff * g) / 255;
+        // North-oriented angle: 0 = North, π/2 = East, π = South, 3π/2 = West
+        const angle = Math.atan2(u, v);
+        const index = i / 4;
+        angleArray[index] = angle < 0 ? (angle + 2 * Math.PI) : angle;
+    }
+    return angleArray;
+}

package/{vectorfield → webglobeplugins/vectorfield}/wind/index.js

@@ -1,5 +1,5 @@
-import WindPlugin from "./plugin";
-import createVectorFieldImage from "./vectorfieldimage";
-import imageToMagnitude, { imageToRadianAngle } from "./imagetovectorfieldandmagnitude";
-import { createImageFromBase64 } from "../../util/webglobjectbuilders";
-export { createVectorFieldImage, imageToMagnitude, WindPlugin, createImageFromBase64, imageToRadianAngle };
+import WindPlugin from "./plugin";
+import createVectorFieldImage from "./vectorfieldimage";
+import imageToMagnitude, { imageToRadianAngle } from "./imagetovectorfieldandmagnitude";
+import { createImageFromBase64 } from "../../util/webglobjectbuilders";
+export { createVectorFieldImage, imageToMagnitude, WindPlugin, createImageFromBase64, imageToRadianAngle };