@pirireis/webglobeplugins 1.0.2 → 1.0.3

package/vectorfield/wind/adapters/{image-to-fields.ts → image-to-fields.js}

@@ -1,74 +1,61 @@
-import { WindData, LegendData } from "./types.js";
-
-
-export function imageToFields(data: WindData, legendData: LegendData): {
-    vectorFieldData: Float32Array;
-    speedFieldData: Float32Array;
-    colorFieldData: Uint8Array;
-} {
-    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 uSpeed = uMin + (r / 255) * uDiff;
-            const vSpeed = vMin + (g / 255) * vDiff;
-            // Normalize to [-1,1] range for vector field
-            const u = uMin + (uDiff * r) / 255;
-            const v = vMin + (vDiff * g) / 255;
-            vectorFieldData[(y * width + x) * 2] = u / scaler;
-            vectorFieldData[(y * width + x) * 2 + 1] = -v / scaler;
-            const speed = Math.sqrt(uSpeed * uSpeed + vSpeed * vSpeed);
-            speedFieldData[y * width + x] = speed;
-
-            // Determine color based on speed and legendData
-            let colorIndex = legendData.thresholds.length - 1;
-            for (let i = 0; i < legendData.thresholds.length; i++) {
-                if (speed < legendData.thresholds[i]) {
-                    colorIndex = i;
-                    break;
-                }
-            }
-
-            const color = parsedColors[colorIndex];
-            colorFieldData[index] = color.r;
-            colorFieldData[index + 1] = color.g;
-            colorFieldData[index + 2] = color.b;
-            colorFieldData[index + 3] = 255; // Alpha channel
-        }
-    }
-    return { vectorFieldData, speedFieldData, colorFieldData };
-}
+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 uSpeed = uMin + (r / 255) * uDiff;
+            const vSpeed = vMin + (g / 255) * vDiff;
+            // Normalize to [-1,1] range for vector field
+            const u = uMin + (uDiff * r) / 255;
+            const v = vMin + (vDiff * g) / 255;
+            vectorFieldData[(y * width + x) * 2] = u / scaler;
+            vectorFieldData[(y * width + x) * 2 + 1] = -v / scaler;
+            const speed = Math.sqrt(uSpeed * uSpeed + vSpeed * vSpeed);
+            speedFieldData[y * width + x] = speed;
+            // Determine color based on speed and legendData
+            let colorIndex = legendData.thresholds.length - 1;
+            for (let i = 0; i < legendData.thresholds.length; i++) {
+                if (speed < legendData.thresholds[i]) {
+                    colorIndex = i;
+                    break;
+                }
+            }
+            const color = parsedColors[colorIndex];
+            colorFieldData[index] = color.r;
+            colorFieldData[index + 1] = color.g;
+            colorFieldData[index + 2] = color.b;
+            colorFieldData[index + 3] = 255; // Alpha channel
+        }
+    }
+    return { vectorFieldData, speedFieldData, colorFieldData };
+}

package/vectorfield/wind/adapters/types.js

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

package/vectorfield/wind/{imagetovectorfieldandmagnitude.ts → 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/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 };