@npm9912/v-map 0.1.0

package/dist/collection/map-provider/geotiff/utils/Triangulation.js

@@ -0,0 +1,321 @@
+/**
+ * Triangulation for raster reprojection
+ *
+ * Based on OpenLayers' triangulation approach for efficient raster reprojection.
+ * Instead of transforming every pixel, we:
+ * 1. Divide the target extent into triangles
+ * 2. Transform only triangle vertices with proj4
+ * 3. Use affine transformation to map pixels within each triangle
+ *
+ * This reduces proj4 calls from ~65,536 per tile to ~50-200 per tile.
+ */
+import { BVHNode2D } from "./BVHNode2D";
+export function calculateBounds(sourceRef, resolution, targetExtent, transformFn, step = 10) {
+    const [west, south, east, north] = targetExtent;
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let minXTarget = [0, 0];
+    let minYTarget = [0, 0];
+    let maxXTarget = [0, 0];
+    let maxYTarget = [0, 0];
+    // Funktion zum Abtasten einer Kante
+    const sampleEdge = (start, end, steps) => {
+        for (let i = 0; i <= steps; i++) {
+            const t = i / steps;
+            const x = start[0] + (end[0] - start[0]) * t;
+            const y = start[1] + (end[1] - start[1]) * t;
+            const target = [x, y];
+            const [xSrc, ySrc] = transformFn(target);
+            if (xSrc < minX) {
+                minX = xSrc;
+                minXTarget = target;
+            }
+            if (ySrc < minY) {
+                minY = ySrc;
+                minYTarget = target;
+            }
+            if (xSrc > maxX) {
+                maxX = xSrc;
+                maxXTarget = target;
+            }
+            if (ySrc > maxY) {
+                maxY = ySrc;
+                maxYTarget = target;
+            }
+        }
+    };
+    // Abtasten aller vier Kanten
+    sampleEdge([west, north], [east, north], step); // Top edge
+    sampleEdge([east, north], [east, south], step); // Right edge
+    sampleEdge([east, south], [west, south], step); // Bottom edge
+    sampleEdge([west, south], [west, north], step); // Left edge
+    if (sourceRef != null && resolution != null) {
+        const minXPix = Math.floor((minX - sourceRef[0]) / resolution);
+        minX = sourceRef[0] + minXPix * resolution;
+        const minYPix = Math.floor((minY - sourceRef[1]) / resolution);
+        minY = sourceRef[1] + minYPix * resolution;
+        const maxXPix = Math.ceil((maxX - sourceRef[0]) / resolution);
+        maxX = sourceRef[0] + maxXPix * resolution;
+        const maxYPix = Math.ceil((maxY - sourceRef[1]) / resolution);
+        maxY = sourceRef[1] + maxYPix * resolution;
+    }
+    return {
+        source: {
+            minX,
+            minY,
+            maxX,
+            maxY,
+        },
+        target: {
+            minX: minXTarget[0],
+            minY: minYTarget[1],
+            maxX: maxXTarget[0],
+            maxY: maxYTarget[1],
+        },
+    };
+}
+const MAX_SUBDIVISION = 10;
+/**
+ * Class for triangulation of the given target extent
+ * Used for determining source data and the reprojection itself
+ */
+export class Triangulation {
+    triangles_ = [];
+    transformFn_;
+    errorThresholdSquared_;
+    bvh_ = null;
+    bounds;
+    /**
+     * @param transformFn - Function that transforms [x, y] from target to source projection
+     * @param targetExtent - [west, south, east, north] in target projection
+     * @param errorThreshold - Maximum allowed error in pixels (default: 0.5)
+     */
+    constructor(transformFn, targetExtent, errorThreshold = 0.5, sourceRef = null, resolution = null, step = 10) {
+        this.transformFn_ = transformFn;
+        this.errorThresholdSquared_ = errorThreshold * errorThreshold;
+        const [west, south, east, north] = targetExtent;
+        // Transform the four corners
+        const a = [west, north]; // top-left
+        const b = [east, north]; // top-right
+        const c = [east, south]; // bottom-right
+        const d = [west, south]; // bottom-left
+        const extBounds = calculateBounds(sourceRef, resolution, targetExtent, this.transformFn_, step);
+        // const aSrc = this.transformFn_(a);
+        // const bSrc = this.transformFn_(b);
+        // const cSrc = this.transformFn_(c);
+        // const dSrc = this.transformFn_(d);
+        const aSrc = [
+            extBounds.source.minX,
+            extBounds.source.maxY,
+        ]; // top-left
+        const bSrc = [
+            extBounds.source.maxX,
+            extBounds.source.maxY,
+        ]; // top-right
+        const cSrc = [
+            extBounds.source.maxX,
+            extBounds.source.minY,
+        ]; // bottom-right
+        const dSrc = [
+            extBounds.source.minX,
+            extBounds.source.minY,
+        ]; // bottom-left
+        this.bounds = extBounds.source;
+        this.addQuad_(a, b, c, d, aSrc, bSrc, cSrc, dSrc, MAX_SUBDIVISION);
+    }
+    getBounds() {
+        return this.bounds;
+    }
+    /**
+     * Recursively subdivide a quadrilateral if needed
+     */
+    addQuad_(a, b, c, d, aSrc, bSrc, cSrc, dSrc, maxSubdivision) {
+        let needsSubdivision = false;
+        // Check if we need to subdivide based on error threshold
+        if (maxSubdivision > 0) {
+            // Calculate midpoints of all edges (linear interpolation in target space)
+            const abTarget = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+            const bcTarget = [(b[0] + c[0]) / 2, (b[1] + c[1]) / 2];
+            const cdTarget = [(c[0] + d[0]) / 2, (c[1] + d[1]) / 2];
+            const daTarget = [(d[0] + a[0]) / 2, (d[1] + a[1]) / 2];
+            // Transform midpoints to source space
+            const abSrc = this.transformFn_(abTarget);
+            const bcSrc = this.transformFn_(bcTarget);
+            const cdSrc = this.transformFn_(cdTarget);
+            const daSrc = this.transformFn_(daTarget);
+            // Calculate expected midpoints (linear interpolation in source space)
+            const abExpected = [
+                (aSrc[0] + bSrc[0]) / 2,
+                (aSrc[1] + bSrc[1]) / 2,
+            ];
+            const bcExpected = [
+                (bSrc[0] + cSrc[0]) / 2,
+                (bSrc[1] + cSrc[1]) / 2,
+            ];
+            const cdExpected = [
+                (cSrc[0] + dSrc[0]) / 2,
+                (cSrc[1] + dSrc[1]) / 2,
+            ];
+            const daExpected = [
+                (dSrc[0] + aSrc[0]) / 2,
+                (dSrc[1] + aSrc[1]) / 2,
+            ];
+            // Calculate squared errors
+            const abError = this.getSquaredError_(abSrc, abExpected);
+            const bcError = this.getSquaredError_(bcSrc, bcExpected);
+            const cdError = this.getSquaredError_(cdSrc, cdExpected);
+            const daError = this.getSquaredError_(daSrc, daExpected);
+            // Check if any edge exceeds error threshold
+            if (abError > this.errorThresholdSquared_ ||
+                bcError > this.errorThresholdSquared_ ||
+                cdError > this.errorThresholdSquared_ ||
+                daError > this.errorThresholdSquared_) {
+                needsSubdivision = true;
+            }
+        }
+        if (needsSubdivision) {
+            // Subdivide into 4 smaller quads
+            // Calculate center point
+            const eTarget = [
+                (a[0] + b[0] + c[0] + d[0]) / 4,
+                (a[1] + b[1] + c[1] + d[1]) / 4,
+            ];
+            const eSrc = this.transformFn_(eTarget);
+            // Calculate edge midpoints
+            const abTarget = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+            const bcTarget = [(b[0] + c[0]) / 2, (b[1] + c[1]) / 2];
+            const cdTarget = [(c[0] + d[0]) / 2, (c[1] + d[1]) / 2];
+            const daTarget = [(d[0] + a[0]) / 2, (d[1] + a[1]) / 2];
+            const abSrc = this.transformFn_(abTarget);
+            const bcSrc = this.transformFn_(bcTarget);
+            const cdSrc = this.transformFn_(cdTarget);
+            const daSrc = this.transformFn_(daTarget);
+            const newMaxSubdivision = maxSubdivision - 1;
+            // Recursively add 4 sub-quads
+            this.addQuad_(a, abTarget, eTarget, daTarget, aSrc, abSrc, eSrc, daSrc, newMaxSubdivision);
+            this.addQuad_(abTarget, b, bcTarget, eTarget, abSrc, bSrc, bcSrc, eSrc, newMaxSubdivision);
+            this.addQuad_(eTarget, bcTarget, c, cdTarget, eSrc, bcSrc, cSrc, cdSrc, newMaxSubdivision);
+            this.addQuad_(daTarget, eTarget, cdTarget, d, daSrc, eSrc, cdSrc, dSrc, newMaxSubdivision);
+        }
+        else {
+            // No subdivision needed - add two triangles for this quad
+            // Triangle 1: a-b-d
+            this.addTriangle_(a, b, d, aSrc, bSrc, dSrc);
+            // Triangle 2: b-c-d
+            this.addTriangle_(b, c, d, bSrc, cSrc, dSrc);
+        }
+    }
+    /**
+     * Add a single triangle
+     */
+    addTriangle_(a, b, c, aSrc, bSrc, cSrc) {
+        // Check for non-finite coordinates
+        if (!isFinite(aSrc[0]) ||
+            !isFinite(aSrc[1]) ||
+            !isFinite(bSrc[0]) ||
+            !isFinite(bSrc[1]) ||
+            !isFinite(cSrc[0]) ||
+            !isFinite(cSrc[1])) {
+            return; // Skip invalid triangles
+        }
+        this.triangles_.push({
+            source: [aSrc, bSrc, cSrc],
+            target: [a, b, c],
+        });
+    }
+    /**
+     * Calculate squared error between two points
+     */
+    getSquaredError_(actual, expected) {
+        const dx = actual[0] - expected[0];
+        const dy = actual[1] - expected[1];
+        return dx * dx + dy * dy;
+    }
+    /**
+     * Get all triangles
+     */
+    getTriangles() {
+        return this.triangles_;
+    }
+    /**
+     * Calculate the bounding extent of all source coordinates
+     */
+    calculateSourceExtent() {
+        if (this.triangles_.length === 0) {
+            return null;
+        }
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        for (const triangle of this.triangles_) {
+            for (const [x, y] of triangle.source) {
+                if (x < minX)
+                    minX = x;
+                if (x > maxX)
+                    maxX = x;
+                if (y < minY)
+                    minY = y;
+                if (y > maxY)
+                    maxY = y;
+            }
+        }
+        return [minX, minY, maxX, maxY];
+    }
+    buildBVH() {
+        const triangles2D = this.triangles_.map(BVHNode2D.toTriangle2D);
+        this.bvh_ = BVHNode2D.build(triangles2D);
+    }
+    findSourceTriangleForTargetPoint(point, extraTri = null) {
+        if (!this.bvh_)
+            this.buildBVH();
+        const point2D = { x: point[0], y: point[1] };
+        if (extraTri?.tri &&
+            BVHNode2D.punktInDreieck2D(point2D, BVHNode2D.toTriangle2D(extraTri.tri))) {
+            return extraTri;
+        }
+        const result = this.bvh_.findContainingTriangle(point2D);
+        if (result && !result.transform) {
+            result.transform = this.calculateAffineTransform(result.triangle);
+        }
+        return result
+            ? { tri: result.triangle, transform: result.transform }
+            : null;
+    }
+    /**
+     * Calculate affine transformation matrix for a triangle
+     * Maps from target triangle to source triangle
+     */
+    calculateAffineTransform(triangle) {
+        const [[x0t, y0t], [x1t, y1t], [x2t, y2t]] = triangle.target;
+        const [[x0s, y0s], [x1s, y1s], [x2s, y2s]] = triangle.source;
+        // Solve for affine transformation: [xs, ys] = [a*xt + b*yt + c, d*xt + e*yt + f]
+        // Using the three triangle vertices
+        const det = (x1t - x0t) * (y2t - y0t) - (x2t - x0t) * (y1t - y0t);
+        if (Math.abs(det) < 1e-10) {
+            // Degenerate triangle - return identity-like transform
+            return { a: 1, b: 0, c: x0s, d: 0, e: 1, f: y0s };
+        }
+        const a = ((x1s - x0s) * (y2t - y0t) - (x2s - x0s) * (y1t - y0t)) / det;
+        const b = ((x2s - x0s) * (x1t - x0t) - (x1s - x0s) * (x2t - x0t)) / det;
+        const c = x0s - a * x0t - b * y0t;
+        const d = ((y1s - y0s) * (y2t - y0t) - (y2s - y0s) * (y1t - y0t)) / det;
+        const e = ((y2s - y0s) * (x1t - x0t) - (y1s - y0s) * (x2t - x0t)) / det;
+        const f = y0s - d * x0t - e * y0t;
+        return { a, b, c, d, e, f };
+    }
+    // ============================================================================
+    // REPROJECTION METHODS
+    // ============================================================================
+    /**
+     * Apply affine transformation to a point
+     */
+    applyAffineTransform(x, y, transform) {
+        return [
+            transform.a * x + transform.b * y + transform.c,
+            transform.d * x + transform.e * y + transform.f,
+        ];
+    }
+}

package/dist/collection/map-provider/geotiff/utils/colormap-utils.js

@@ -0,0 +1,190 @@
+/**
+ * ColorMap utilities for GeoTIFF visualization
+ * Extracted for testability
+ */
+import { warn } from "../../../utils/logger";
+/**
+ * Predefined color maps
+ */
+export const PREDEFINED_COLORMAPS = {
+    grayscale: [
+        { value: 0.0, color: [0, 0, 0] },
+        { value: 1.0, color: [255, 255, 255] },
+    ],
+    viridis: [
+        { value: 0.0, color: [68, 1, 84] },
+        { value: 0.25, color: [59, 82, 139] },
+        { value: 0.5, color: [33, 145, 140] },
+        { value: 0.75, color: [94, 201, 98] },
+        { value: 1.0, color: [253, 231, 37] },
+    ],
+    terrain: [
+        { value: 0.0, color: [0, 128, 0] }, // dark green (low)
+        { value: 0.25, color: [139, 195, 74] }, // light green
+        { value: 0.5, color: [255, 235, 59] }, // yellow
+        { value: 0.75, color: [255, 152, 0] }, // orange
+        { value: 1.0, color: [255, 255, 255] }, // white (high)
+    ],
+    turbo: [
+        { value: 0.0, color: [48, 18, 59] },
+        { value: 0.2, color: [33, 102, 172] },
+        { value: 0.4, color: [68, 190, 112] },
+        { value: 0.6, color: [253, 231, 37] },
+        { value: 0.8, color: [234, 51, 35] },
+        { value: 1.0, color: [122, 4, 3] },
+    ],
+    rainbow: [
+        { value: 0.0, color: [148, 0, 211] }, // violet
+        { value: 0.2, color: [0, 0, 255] }, // blue
+        { value: 0.4, color: [0, 255, 0] }, // green
+        { value: 0.6, color: [255, 255, 0] }, // yellow
+        { value: 0.8, color: [255, 127, 0] }, // orange
+        { value: 1.0, color: [255, 0, 0] }, // red
+    ],
+};
+/**
+ * Parse a hex color string to RGB array
+ * @param hexColor - Hex color string (e.g., "#FF0000" or "#F00")
+ * @returns RGB array [r, g, b] with values 0-255
+ */
+export function parseHexColor(hexColor) {
+    let hex = hexColor.trim();
+    if (hex.startsWith('#')) {
+        hex = hex.slice(1);
+    }
+    // Handle shorthand hex (#RGB -> #RRGGBB)
+    if (hex.length === 3) {
+        hex = hex
+            .split('')
+            .map(c => c + c)
+            .join('');
+    }
+    if (hex.length !== 6) {
+        warn(`Invalid hex color: ${hexColor}, using black`);
+        return [0, 0, 0];
+    }
+    const r = parseInt(hex.slice(0, 2), 16);
+    const g = parseInt(hex.slice(2, 4), 16);
+    const b = parseInt(hex.slice(4, 6), 16);
+    if (isNaN(r) || isNaN(g) || isNaN(b)) {
+        warn(`Invalid hex color: ${hexColor}, using black`);
+        return [0, 0, 0];
+    }
+    return [r, g, b];
+}
+/**
+ * Convert GeoStyler ColorMap to internal ColorStop array
+ * @param geoStylerColorMap - GeoStyler ColorMap object
+ * @param valueRange - Optional value range [min, max] for normalization
+ * @returns Object with ColorStop array and computed range
+ */
+export function convertGeoStylerColorMap(geoStylerColorMap, valueRange) {
+    const entries = geoStylerColorMap.colorMapEntries || [];
+    if (entries.length === 0) {
+        warn('GeoStyler ColorMap has no entries, using grayscale');
+        return { stops: PREDEFINED_COLORMAPS.grayscale };
+    }
+    // Extract quantity values for normalization
+    const quantities = entries
+        .map(e => e.quantity)
+        .filter((q) => typeof q === 'number');
+    let minVal;
+    let maxVal;
+    if (valueRange) {
+        [minVal, maxVal] = valueRange;
+    }
+    else if (quantities.length > 0) {
+        minVal = Math.min(...quantities);
+        maxVal = Math.max(...quantities);
+    }
+    else {
+        // No quantities and no valueRange - assume normalized 0-1
+        minVal = 0;
+        maxVal = 1;
+    }
+    // Avoid division by zero
+    if (maxVal === minVal) {
+        maxVal = minVal + 1;
+    }
+    const stops = entries.map(entry => {
+        const quantity = typeof entry.quantity === 'number' ? entry.quantity : 0;
+        const normalizedValue = (quantity - minVal) / (maxVal - minVal);
+        // Parse color (handle both string and Expression<string>)
+        const colorStr = typeof entry.color === 'string' ? entry.color : String(entry.color);
+        const color = parseHexColor(colorStr);
+        return {
+            value: Math.max(0, Math.min(1, normalizedValue)), // Clamp to [0, 1]
+            color,
+        };
+    });
+    // Sort by value for binary search
+    stops.sort((a, b) => a.value - b.value);
+    return {
+        stops,
+        computedRange: valueRange ? undefined : [minVal, maxVal],
+    };
+}
+/**
+ * Apply colormap to a normalized value using interpolation
+ * @param normalizedValue - Value between 0 and 1
+ * @param colorStops - Array of color stops (must be sorted by value)
+ * @returns RGB color [r, g, b]
+ */
+export function applyColorMap(normalizedValue, colorStops) {
+    const v = Math.max(0, Math.min(1, normalizedValue));
+    if (colorStops.length === 0) {
+        return [0, 0, 0]; // Black fallback
+    }
+    if (colorStops.length === 1) {
+        return colorStops[0].color;
+    }
+    // Binary search for surrounding color stops
+    let left = 0;
+    let right = colorStops.length - 1;
+    // Handle edge cases
+    if (v <= colorStops[left].value) {
+        return colorStops[left].color;
+    }
+    if (v >= colorStops[right].value) {
+        return colorStops[right].color;
+    }
+    // Binary search
+    while (right - left > 1) {
+        const mid = Math.floor((left + right) / 2);
+        if (colorStops[mid].value <= v) {
+            left = mid;
+        }
+        else {
+            right = mid;
+        }
+    }
+    // Interpolate between left and right
+    const lower = colorStops[left];
+    const upper = colorStops[right];
+    const ratio = (v - lower.value) / (upper.value - lower.value);
+    const r = Math.round(lower.color[0] + ratio * (upper.color[0] - lower.color[0]));
+    const g = Math.round(lower.color[1] + ratio * (upper.color[1] - lower.color[1]));
+    const b = Math.round(lower.color[2] + ratio * (upper.color[2] - lower.color[2]));
+    return [r, g, b];
+}
+/**
+ * Get ColorStop array from ColorMapName or GeoStyler ColorMap
+ * @param colorMap - Predefined name or GeoStyler ColorMap
+ * @param valueRange - Optional value range for GeoStyler ColorMap
+ * @returns ColorStop array and computed range (if applicable)
+ */
+export function getColorStops(colorMap, valueRange) {
+    if (typeof colorMap === 'string') {
+        // Predefined colormap name
+        const stops = PREDEFINED_COLORMAPS[colorMap];
+        if (!stops) {
+            warn(`Unknown colormap: ${colorMap}, using grayscale`);
+            return { stops: PREDEFINED_COLORMAPS.grayscale };
+        }
+        return { stops };
+    }
+    else {
+        // GeoStyler ColorMap
+        return convertGeoStylerColorMap(colorMap, valueRange);
+    }
+}

package/dist/collection/map-provider/geotiff/utils/normalization-utils.js

@@ -0,0 +1,122 @@
+/**
+ * Normalization utilities for raster data
+ * Handles conversion of different TypedArray types to normalized 0-255 range
+ */
+import { warn } from "../../../utils/logger";
+/**
+ * Normalize a raw value to 0-255 range based on array type
+ * @param rawValue - The raw value from the raster
+ * @param arrayType - The TypedArray type name
+ * @returns Normalized value 0-255
+ */
+export function normalizeValue(rawValue, arrayType) {
+    switch (arrayType) {
+        case 'Uint8Array':
+            return rawValue; // Already 0-255
+        case 'Uint16Array':
+            // 0-65535 → 0-255
+            return Math.round((rawValue / 65535) * 255);
+        case 'Int16Array':
+            // -32768-32767 → 0-255
+            return Math.round(((rawValue + 32768) / 65535) * 255);
+        case 'Uint32Array':
+            // 0-4294967295 → 0-255
+            return Math.round((rawValue / 4294967295) * 255);
+        case 'Int32Array':
+            // -2147483648-2147483647 → 0-255
+            return Math.round(((rawValue + 2147483648) / 4294967295) * 255);
+        case 'Float32Array':
+        case 'Float64Array':
+            // Assume 0.0-1.0 range for Float arrays (common for normalized data)
+            // Clamp to [0, 1] first
+            const clamped = Math.max(0, Math.min(1, rawValue));
+            return Math.round(clamped * 255);
+        default:
+            warn(`Unknown array type: ${arrayType}, treating as Uint8`);
+            return rawValue;
+    }
+}
+/**
+ * Normalize a raw value to 0-1 range for colormap application
+ * @param rawValue - The raw value from the raster
+ * @param valueRange - Optional [min, max] range. If not provided, assumes normalized data.
+ * @returns Normalized value 0-1
+ */
+export function normalizeToColorMapRange(rawValue, valueRange) {
+    if (!valueRange) {
+        // Assume already normalized or single-value range
+        return Math.max(0, Math.min(1, rawValue));
+    }
+    const [minVal, maxVal] = valueRange;
+    // Avoid division by zero
+    if (maxVal === minVal) {
+        return 0.5; // Middle of range
+    }
+    const normalized = (rawValue - minVal) / (maxVal - minVal);
+    return Math.max(0, Math.min(1, normalized)); // Clamp to [0, 1]
+}
+/**
+ * Auto-detect value range from a Float32/Float64 array sample
+ * Useful when valueRange is not provided
+ * @param data - The raster data array
+ * @param sampleSize - Number of samples to analyze (default: 1000)
+ * @returns Detected [min, max] range
+ */
+export function autoDetectValueRange(data, sampleSize = 1000) {
+    if (data.length === 0) {
+        return [0, 1];
+    }
+    const step = Math.max(1, Math.floor(data.length / sampleSize));
+    let min = Infinity;
+    let max = -Infinity;
+    for (let i = 0; i < data.length; i += step) {
+        const value = data[i];
+        if (Number.isFinite(value)) {
+            if (value < min)
+                min = value;
+            if (value > max)
+                max = value;
+        }
+    }
+    // Fallback if all values were invalid
+    if (!Number.isFinite(min) || !Number.isFinite(max)) {
+        return [0, 1];
+    }
+    // Handle single-value case
+    if (min === max) {
+        return [min, min + 1];
+    }
+    return [min, max];
+}
+/**
+ * Check if a TypedArray type represents floating point data
+ * @param arrayType - The TypedArray type name
+ * @returns True if Float32Array or Float64Array
+ */
+export function isFloatType(arrayType) {
+    return arrayType === 'Float32Array' || arrayType === 'Float64Array';
+}
+/**
+ * Get the typical value range for a TypedArray type
+ * @param arrayType - The TypedArray type name
+ * @returns [min, max] range for the type
+ */
+export function getTypeRange(arrayType) {
+    switch (arrayType) {
+        case 'Uint8Array':
+            return [0, 255];
+        case 'Uint16Array':
+            return [0, 65535];
+        case 'Int16Array':
+            return [-32768, 32767];
+        case 'Uint32Array':
+            return [0, 4294967295];
+        case 'Int32Array':
+            return [-2147483648, 2147483647];
+        case 'Float32Array':
+        case 'Float64Array':
+            return [0, 1]; // Assume normalized
+        default:
+            return [0, 255];
+    }
+}