@pirireis/webglobeplugins 1.0.2 → 1.0.4

package/util/check/typecheck.ts

@@ -1,74 +0,0 @@
-// Generic
-
-import { Color } from "../../types";
-
-interface TextFont {
-    name: string;
-    textColor: string;
-    hollowColor: string;
-    size: number;
-    bold: boolean;
-    italic: boolean;
-}
-
-const doesOwnProperties = (properties: string[], errorMessage: string) => {
-    return (object: Record<string, any>): void => {
-        properties.forEach(element => {
-            if (!object.hasOwnProperty(element)) throw new TypeError(errorMessage + ':' + element);
-        });
-    }
-}
-
-export const isHexColor = (hexColor: string): boolean => /^#[0-9A-F]{6}$/i.test(hexColor);
-export const isHexColorWithOpacity = (hexColor: string): boolean => /^#[0-9A-F]{6}[0-9a-f]{0,2}$/i.test(hexColor);
-
-export const colorCheck = (color: Color): void => {
-    if (Array.isArray(color)) {
-        if (color.length !== 4) throw new TypeError("Color must be an array 4 numbers RGBA");
-        color.forEach(c => {
-            if (typeof c !== "number") throw new TypeError("Color array must contain only numbers");
-            if (c < 0 || c > 1) throw new RangeError("Color values must be between 0 and 1");
-        });
-    }
-}
-
-export const opacityCheck = (opacity: number | any): void => {
-    if (typeof opacity !== "number") throw new TypeError("style.opacity must a number");
-    if (opacity < 0 || 1 < opacity) throw new RangeError("Opacity Range Must be 0-1");
-}
-
-// Text Related 
-
-const fontCheckTypes = doesOwnProperties(["name", "textColor", "hollowColor", "size", "bold", "italic"], "font does not have");
-const fontCheckColors = (textColor: string, hollowColor: string): boolean => isHexColor(textColor) && isHexColor(hollowColor);
-
-export const isTextFont = (textFont: TextFont): void => {
-    fontCheckTypes(textFont);
-    fontCheckColors(textFont.textColor, textFont.hollowColor);
-    if (typeof textFont.size !== "number") throw new TypeError("textFont size is not a number");
-}
-
-export const constraintFloat = (x: number, lowerBound: number | null = null, upperBound: number | null = null): void => {
-    if (typeof x !== "number") throw new Error("type must be numberic");
-    if (lowerBound === null && upperBound === null) return;
-    if (lowerBound !== null && lowerBound > x) throw new Error(`input must be greater than ${lowerBound}`);
-    if (upperBound !== null && x > upperBound) throw new Error(`input must be less than ${upperBound}`);
-}
-
-export const isBoolean = (x: any): void => {
-    if (typeof x !== "boolean") throw new TypeError("type must be boolean");
-}
-
-
-export const mapGetOrThrow = (errorNote: string) => {
-    return (mapInstance: Map<string, any>, ids: string[]) => {
-        if (!ids) throw new Error("There is no map keys to get");
-        const result = [];
-        for (let i = 0; i < ids.length; i++) {
-            const e = mapInstance.get(ids[i]);
-            if (e === undefined) throw new Error(errorNote + " " + ids[i]);
-            result.push(e);
-        }
-        return result;
-    }
-}

package/util/gl-util/buffer/attribute-loader.ts

@@ -1,84 +0,0 @@
-import { BufferAndReadInfo, AttributeLoaderOptions } from "../../../types";
-
-
-/**
- * @typedef BufferAndReadInfo Buffers can be intertwined or interleaved.
- * This object forces user to adapt generic convention of buffer and read information.
- * @type {Object}
- * @property {WebGLBuffer} buffer
- * @property {number} stride
- * @property {number} offset
- */
-
-/**
- * 
- * @param {WebGLBuffer} gl 
- * @param {BufferAndReadInfo} bufferAndReadInfo
- * @param {number} index 
- * @param {number} size 
- * @param {Object} options
- * @param {*} options.type | default gl.FLOAT, gl.UNSIGNED_BYTE, gl.SHORT, gl.UNSIGNED_SHORT, gl.INT, gl.UNSIGNED_INT
- * @param {number} options.divisor
- * @param {Array<number>} options.escapeValues 
- * @returns 
- */
-
-
-
-const attributeLoader = (
-    gl: WebGL2RenderingContext,
-    bufferAndReadInfo: BufferAndReadInfo | null | undefined,
-    index: number,
-    size: number,
-    {
-        divisor = null,
-        type = null,
-        escapeValues = null,
-        normalized = false
-    }: AttributeLoaderOptions = {}) => {
-    if (bufferAndReadInfo == null || bufferAndReadInfo.buffer == null) {
-        if (escapeValues) constantFunction(gl, index, size, escapeValues);
-        return;
-    }
-
-    const { buffer, stride, offset } = bufferAndReadInfo;
-    if (!gl || !buffer) {
-        throw new Error("Invalid WebGL context or buffer");
-    }
-    if (index < 0) {
-        throw new Error("Attribute index must be non-negative");
-    }
-    if (stride < 0 || offset < 0) {
-        throw new Error("Stride and offset must be non-negative");
-    }
-    const attribType = type === null ? gl.FLOAT : type;
-    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-    gl.enableVertexAttribArray(index);
-    gl.vertexAttribPointer(index, size, attribType, normalized, stride, offset);
-    if (divisor !== null) {
-        gl.vertexAttribDivisor(index, divisor);
-    }
-}
-
-/**
- * 
- * @param {WebGLBuffer} buffer 
- * @param {number} stride 
- * @param {number} offset 
- * @returns {BufferAndReadInfo}
- */
-const createBufferAndReadInfo = (buffer: WebGLBuffer | null, stride: number = 0, offset: number = 0): BufferAndReadInfo | null => {
-    if (buffer == null) return null;
-    return { buffer, stride, offset };
-}
-
-
-
-const constantFunction = (gl: WebGL2RenderingContext, index: number, size: number, escapeValues: Array<number>) => {
-    const func = `vertexAttrib${size}f`;
-    // @ts-ignore
-    gl[func](index, ...escapeValues);
-}
-
-
-export { attributeLoader, createBufferAndReadInfo };

package/util/interpolation/timetrack/index.js

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

package/vectorfield/wind/adapters/image-to-fields.ts

@@ -1,74 +0,0 @@
-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 };
-}

package/vectorfield/wind/adapters/types.ts

@@ -1,12 +0,0 @@
-export type WindData = {
-    image: HTMLImageElement;
-    uMin: number;
-    vMin: number;
-    uMax: number;
-    vMax: number;
-}
-
-export type LegendData = {
-    thresholds: number[];
-    values: string[];
-};