@npm9912/v-map 0.1.0

package/dist/esm/geotiff-source-esnDnC-u.js

@@ -0,0 +1,1516 @@
+import { w as warn, l as log } from './messages-CMKJzsgL.js';
+
+/**
+ * ColorMap utilities for GeoTIFF visualization
+ * Extracted for testability
+ */
+/**
+ * Predefined color maps
+ */
+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
+ */
+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
+ */
+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]
+ */
+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)
+ */
+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);
+    }
+}
+
+class AABB2D {
+    min;
+    max;
+    constructor(min, max) {
+        this.min = min;
+        this.max = max;
+    }
+    contains(point) {
+        return (point.x >= this.min.x &&
+            point.x <= this.max.x &&
+            point.y >= this.min.y &&
+            point.y <= this.max.y);
+    }
+    static fromTriangle(triangle) {
+        const minX = Math.min(triangle.a.x, triangle.b.x, triangle.c.x);
+        const minY = Math.min(triangle.a.y, triangle.b.y, triangle.c.y);
+        const maxX = Math.max(triangle.a.x, triangle.b.x, triangle.c.x);
+        const maxY = Math.max(triangle.a.y, triangle.b.y, triangle.c.y);
+        return new AABB2D({ x: minX, y: minY }, { x: maxX, y: maxY });
+    }
+    static union(a, b) {
+        return new AABB2D({ x: Math.min(a.min.x, b.min.x), y: Math.min(a.min.y, b.min.y) }, { x: Math.max(a.max.x, b.max.x), y: Math.max(a.max.y, b.max.y) });
+    }
+}
+
+class BVHNode2D {
+    bbox;
+    triangles;
+    left;
+    right;
+    constructor(bbox, triangles = [], left = null, right = null) {
+        this.bbox = bbox;
+        this.triangles = triangles;
+        this.left = left;
+        this.right = right;
+    }
+    static build(triangles, depth = 0, maxDepth = 10) {
+        if (triangles.length <= 2 || depth >= maxDepth) {
+            let bbox = AABB2D.fromTriangle(triangles[0]);
+            for (let i = 1; i < triangles.length; i++) {
+                bbox = AABB2D.union(bbox, AABB2D.fromTriangle(triangles[i]));
+            }
+            return new BVHNode2D(bbox, triangles);
+        }
+        const centroids = triangles.map(t => ({
+            x: (t.a.x + t.b.x + t.c.x) / 3,
+            y: (t.a.y + t.b.y + t.c.y) / 3,
+        }));
+        const { min, max } = centroids.reduce((acc, c) => ({
+            min: { x: Math.min(acc.min.x, c.x), y: Math.min(acc.min.y, c.y) },
+            max: { x: Math.max(acc.max.x, c.x), y: Math.max(acc.max.y, c.y) },
+        }), { min: centroids[0], max: centroids[0] });
+        const axis = max.x - min.x > max.y - min.y ? 'x' : 'y';
+        centroids.sort((a, b) => a[axis] - b[axis]);
+        const mid = Math.floor(centroids.length / 2);
+        const leftTriangles = [];
+        const rightTriangles = [];
+        for (let i = 0; i < triangles.length; i++) {
+            (i < mid ? leftTriangles : rightTriangles).push(triangles[i]);
+        }
+        const left = BVHNode2D.build(leftTriangles, depth + 1, maxDepth);
+        const right = BVHNode2D.build(rightTriangles, depth + 1, maxDepth);
+        const bbox = AABB2D.union(left.bbox, right.bbox);
+        return new BVHNode2D(bbox, [], left, right);
+    }
+    /**
+     * Finds the triangle containing the given point.
+     * @param point The point to test.
+     * @returns The containing triangle or `null`.
+     */
+    findContainingTriangle(point) {
+        if (!this.bbox.contains(point)) {
+            return null;
+        }
+        if (this.triangles.length > 0) {
+            for (const triangle of this.triangles) {
+                if (BVHNode2D.punktInDreieck2D(point, triangle)) {
+                    return triangle;
+                }
+            }
+            return null;
+        }
+        return (this.left?.findContainingTriangle(point) ||
+            this.right?.findContainingTriangle(point) ||
+            null);
+    }
+    static punktInDreieck2D(p, triangle) {
+        const { a, b, c } = triangle;
+        const v0 = { x: c.x - a.x, y: c.y - a.y };
+        const v1 = { x: b.x - a.x, y: b.y - a.y };
+        const v2 = { x: p.x - a.x, y: p.y - a.y };
+        const dot00 = v0.x * v0.x + v0.y * v0.y;
+        const dot01 = v0.x * v1.x + v0.y * v1.y;
+        const dot02 = v0.x * v2.x + v0.y * v2.y;
+        const dot11 = v1.x * v1.x + v1.y * v1.y;
+        const dot12 = v1.x * v2.x + v1.y * v2.y;
+        const invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
+        const u = (dot11 * dot02 - dot01 * dot12) * invDenom;
+        const v = (dot00 * dot12 - dot01 * dot02) * invDenom;
+        return u >= 0 && v >= 0 && u + v <= 1;
+        //return u >= 0 && v >= 0 && u + v < 1;
+    }
+    static toTriangle2D(triangle) {
+        return {
+            a: { x: triangle.target[0][0], y: triangle.target[0][1] },
+            b: { x: triangle.target[1][0], y: triangle.target[1][1] },
+            c: { x: triangle.target[2][0], y: triangle.target[2][1] },
+            triangle: triangle,
+            transform: null,
+        };
+    }
+    /**
+     * Returns a string representation of the BVH tree structure
+     * @param indent - Internal parameter for recursive formatting
+     * @returns Formatted string showing tree structure
+     */
+    toString(indent = '') {
+        const isLeaf = this.triangles.length > 0;
+        const nodeType = isLeaf ? 'LEAF' : 'NODE';
+        const bboxStr = `[${this.bbox.min.x.toFixed(2)}, ${this.bbox.min.y.toFixed(2)}, ${this.bbox.max.x.toFixed(2)}, ${this.bbox.max.y.toFixed(2)}]`;
+        let result = `${indent}${nodeType} bbox=${bboxStr}`;
+        if (isLeaf) {
+            const triArray = this.triangles.map(t2D => t2D.a.x.toFixed(2) +
+                ',' +
+                t2D.a.y.toFixed(2) +
+                ' ' +
+                t2D.b.x.toFixed(2) +
+                ',' +
+                t2D.b.y.toFixed(2) +
+                ' ' +
+                t2D.c.x.toFixed(2) +
+                ',' +
+                t2D.c.y.toFixed(2));
+            const triArrayStr = triArray.toString();
+            result += ` triangles=${this.triangles.length} - ${triArrayStr}`;
+        }
+        else {
+            result += '\n';
+            if (this.left) {
+                result += `${indent}├─ left:\n${this.left.toString(indent + '│  ')}`;
+            }
+            if (this.right) {
+                result += `${indent}└─ right:\n${this.right.toString(indent + '   ')}`;
+            }
+        }
+        return result;
+    }
+    /**
+     * Get statistics about the BVH tree
+     * @returns Object with tree statistics
+     */
+    getStats() {
+        const stats = {
+            depth: 1,
+            nodeCount: 1,
+            leafCount: 0,
+            triangleCount: this.triangles.length,
+            minTrianglesPerLeaf: Infinity,
+            maxTrianglesPerLeaf: 0,
+        };
+        if (this.triangles.length > 0) {
+            // This is a leaf
+            stats.leafCount = 1;
+            stats.minTrianglesPerLeaf = this.triangles.length;
+            stats.maxTrianglesPerLeaf = this.triangles.length;
+        }
+        else {
+            // This is an internal node
+            if (this.left) {
+                const leftStats = this.left.getStats();
+                stats.depth = Math.max(stats.depth, leftStats.depth + 1);
+                stats.nodeCount += leftStats.nodeCount;
+                stats.leafCount += leftStats.leafCount;
+                stats.triangleCount += leftStats.triangleCount;
+                stats.minTrianglesPerLeaf = Math.min(stats.minTrianglesPerLeaf, leftStats.minTrianglesPerLeaf);
+                stats.maxTrianglesPerLeaf = Math.max(stats.maxTrianglesPerLeaf, leftStats.maxTrianglesPerLeaf);
+            }
+            if (this.right) {
+                const rightStats = this.right.getStats();
+                stats.depth = Math.max(stats.depth, rightStats.depth + 1);
+                stats.nodeCount += rightStats.nodeCount;
+                stats.leafCount += rightStats.leafCount;
+                stats.triangleCount += rightStats.triangleCount;
+                stats.minTrianglesPerLeaf = Math.min(stats.minTrianglesPerLeaf, rightStats.minTrianglesPerLeaf);
+                stats.maxTrianglesPerLeaf = Math.max(stats.maxTrianglesPerLeaf, rightStats.maxTrianglesPerLeaf);
+            }
+        }
+        return stats;
+    }
+}
+
+/**
+ * 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.
+ */
+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
+ */
+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,
+        ];
+    }
+}
+
+/**
+ * Normalization utilities for raster data
+ * Handles conversion of different TypedArray types to normalized 0-255 range
+ */
+/**
+ * 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
+ */
+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
+ */
+function normalizeToColorMapRange(rawValue, valueRange) {
+    {
+        // Assume already normalized or single-value range
+        return Math.max(0, Math.min(1, rawValue));
+    }
+}
+
+/**
+ * Nearest-Neighbor Sampling with window-based reading and multi-band support
+ * Returns [R, G, B, A] values (0-255)
+ */
+function sampleNearest(x, y, rasterBands, arrayType, width, height, offsetX, offsetY, colorStops) {
+    const px = Math.round(x) - offsetX;
+    const py = Math.round(y) - offsetY;
+    if (px < 0 || px >= width || py < 0 || py >= height) {
+        return null;
+    }
+    const idx = py * width + px;
+    const bandCount = rasterBands.length;
+    if (bandCount === 1) {
+        // Grayscale - apply colormap if specified
+        const rawValue = rasterBands[0][idx];
+        if (colorStops) {
+            // Apply colormap (only for Float types or when colorStops provided)
+            const normalizedValue = normalizeToColorMapRange(rawValue);
+            const [r, g, b] = applyColorMap(normalizedValue, colorStops);
+            return [r, g, b, 255];
+        }
+        else {
+            // Regular grayscale normalization
+            const gray = normalizeValue(rawValue, arrayType);
+            return [gray, gray, gray, 255];
+        }
+    }
+    else if (bandCount === 3) {
+        // RGB
+        const r = normalizeValue(rasterBands[0][idx], arrayType);
+        const g = normalizeValue(rasterBands[1][idx], arrayType);
+        const b = normalizeValue(rasterBands[2][idx], arrayType);
+        return [r, g, b, 255];
+    }
+    else if (bandCount >= 4) {
+        // RGBA
+        const r = normalizeValue(rasterBands[0][idx], arrayType);
+        const g = normalizeValue(rasterBands[1][idx], arrayType);
+        const b = normalizeValue(rasterBands[2][idx], arrayType);
+        const a = normalizeValue(rasterBands[3][idx], arrayType);
+        return [r, g, b, a];
+    }
+    return null;
+}
+/**
+ * Bilinear Interpolation with window-based reading and multi-band support
+ * Returns [R, G, B, A] values (0-255)
+ */
+function sampleBilinear(x, y, rasterBands, arrayType, width, height, offsetX, offsetY, colorStops) {
+    const localX = x - offsetX;
+    const localY = y - offsetY;
+    // Bounds-Check
+    if (localX < 0 ||
+        localX >= width - 1 ||
+        localY < 0 ||
+        localY >= height - 1) {
+        return null;
+    }
+    // Bilineare Interpolation
+    const x0 = Math.floor(localX);
+    const x1 = Math.ceil(localX);
+    const y0 = Math.floor(localY);
+    const y1 = Math.ceil(localY);
+    const fx = localX - x0;
+    const fy = localY - y0;
+    const bandCount = rasterBands.length;
+    const result = [0, 0, 0, 255];
+    if (bandCount === 1) {
+        // Grayscale - interpolate first, then apply colormap
+        const band = rasterBands[0];
+        const v00 = band[y0 * width + x0];
+        const v10 = band[y0 * width + x1];
+        const v01 = band[y1 * width + x0];
+        const v11 = band[y1 * width + x1];
+        const v0 = v00 * (1 - fx) + v10 * fx;
+        const v1 = v01 * (1 - fx) + v11 * fx;
+        const interpolated = v0 * (1 - fy) + v1 * fy;
+        if (colorStops) {
+            // Apply colormap (only for Float types or when colorStops provided)
+            const normalizedValue = normalizeToColorMapRange(interpolated);
+            const [r, g, b] = applyColorMap(normalizedValue, colorStops);
+            return [r, g, b, 255];
+        }
+        else {
+            // Regular grayscale normalization
+            const gray = normalizeValue(interpolated, arrayType);
+            return [gray, gray, gray, 255];
+        }
+    }
+    else {
+        // RGB/RGBA - interpolate each band
+        const bandsToProcess = Math.min(bandCount, 4);
+        for (let b = 0; b < bandsToProcess; b++) {
+            const band = rasterBands[b];
+            const v00 = band[y0 * width + x0];
+            const v10 = band[y0 * width + x1];
+            const v01 = band[y1 * width + x0];
+            const v11 = band[y1 * width + x1];
+            const v0 = v00 * (1 - fx) + v10 * fx;
+            const v1 = v01 * (1 - fx) + v11 * fx;
+            const interpolated = v0 * (1 - fy) + v1 * fy;
+            result[b] = normalizeValue(interpolated, arrayType);
+        }
+    }
+    return result;
+}
+
+/**
+ * Processes GeoTIFF tiles with triangulation-based reprojection
+ *
+ * This class encapsulates the tile rendering logic using triangulation
+ * for efficient reprojection from arbitrary source projections to Web Mercator.
+ */
+class GeoTIFFTileProcessor {
+    // Configuration
+    config;
+    worldSize = 40075016.686; // Earth circumference in meters (Web Mercator)
+    // Global triangulation for the entire image (created once)
+    globalTriangulation;
+    constructor(config) {
+        this.config = config;
+        if (config.worldSize) {
+            this.worldSize = config.worldSize;
+        }
+    }
+    /**
+     * Create global triangulation for the entire GeoTIFF image
+     * This is called once to avoid recreating triangulation for every tile
+     */
+    createGlobalTriangulation() {
+        const startTime = performance.now();
+        const [srcWest, srcSouth, srcEast, srcNorth] = this.config.sourceBounds;
+        // Transform source corners to target projection (Mercator)
+        const transformFnToProj = (coord) => {
+            return this.config.transformSourceMapToViewFn(coord);
+        };
+        const { source: bounds } = calculateBounds(null, null, [srcWest, srcSouth, srcEast, srcNorth], transformFnToProj);
+        const mercatorBounds = [
+            bounds.minX,
+            bounds.minY,
+            bounds.maxX,
+            bounds.maxY,
+        ];
+        log('Creating global triangulation for bounds:', {
+            source: this.config.sourceBounds,
+            mercator: mercatorBounds,
+        });
+        // Inverse transformation: from target (Mercator) back to source
+        const inverseTransformFn = (coord) => {
+            return this.config.transformViewToSourceMapFn(coord);
+        };
+        // Use adaptive error threshold based on pixel resolution
+        const errorThreshold = this.config.resolution / 2.0;
+        const step = Math.min(10, Math.max(this.config.imageWidth, this.config.imageHeight) / 256);
+        this.globalTriangulation = new Triangulation(inverseTransformFn, mercatorBounds, errorThreshold, this.config.sourceRef, this.config.resolution, step);
+        // Force indexing
+        this.globalTriangulation.findSourceTriangleForTargetPoint([0, 0]);
+        const triangles = this.globalTriangulation.getTriangles();
+        log(`Global triangulation created: ${triangles.length} triangles in ${(performance.now() - startTime).toFixed(2)}ms`);
+    }
+    /**
+     * Get the global triangulation (may be undefined if not created yet)
+     */
+    getGlobalTriangulation() {
+        return this.globalTriangulation;
+    }
+    /**
+     * Normalize terrain samples so mesh generation does not create spikes
+     * for nodata or otherwise invalid height values.
+     */
+    sanitizeElevationValue(value) {
+        if (!Number.isFinite(value)) {
+            return 0;
+        }
+        if (this.config.noDataValue !== undefined &&
+            value === this.config.noDataValue) {
+            return 0;
+        }
+        return value;
+    }
+    /**
+     * Calculate tile size in meters for a given zoom level
+     */
+    getTileSizeInMeter(z) {
+        return this.worldSize / Math.pow(2, z);
+    }
+    /**
+     * Convert tile coordinates to View projection bounds
+     * For Web Mercator (deck.gl/Leaflet/Cesium): returns bounds in meters
+     * Note: This assumes Web Mercator tiling scheme. Override for other projections.
+     */
+    getTileBounds(x, y, z) {
+        const tileSize = this.getTileSizeInMeter(z);
+        const west = -this.worldSize / 2 + x * tileSize;
+        const north = this.worldSize / 2 - y * tileSize;
+        const east = west + tileSize;
+        const south = north - tileSize;
+        return [west, south, east, north];
+    }
+    /**
+     * Select best overview image based on zoom level
+     */
+    selectOverviewImage(z, tileSize) {
+        const baseResolution = this.config.baseImage.getResolution()[0];
+        if (!this.config.overviewImages ||
+            this.config.overviewImages.length === 0) {
+            return {
+                bestImage: this.config.baseImage,
+                bestResolution: baseResolution,
+                imageLevel: 0,
+            };
+        }
+        const tileSizeInMeter = this.getTileSizeInMeter(z);
+        const tileResolution = tileSizeInMeter / tileSize;
+        // Check base image and all overviews
+        const allImages = [this.config.baseImage, ...this.config.overviewImages];
+        const maxResImage = allImages[this.config.overviewImages.length];
+        const maxResolution = baseResolution * Math.pow(2, this.config.overviewImages.length);
+        let imageLevel = this.config.overviewImages.length;
+        let bestResolution = maxResolution;
+        let bestImage = maxResImage;
+        let levelCounter = 0;
+        let resolution = baseResolution;
+        for (const img of allImages) {
+            const ratio = tileResolution / (resolution * 2.0);
+            if (ratio <= 1.0) {
+                bestImage = img;
+                bestResolution = resolution;
+                imageLevel = levelCounter;
+                break;
+            }
+            levelCounter++;
+            resolution = resolution * 2;
+        }
+        return { bestImage, bestResolution, imageLevel };
+    }
+    /**
+     * Calculate source bounds for a tile after transformation
+     * @param viewBounds - Tile bounds in View projection
+     */
+    calculateTileSourceBounds(viewBounds) {
+        const [viewWest, viewSouth, viewEast, viewNorth] = viewBounds;
+        const { source: bounds } = calculateBounds(this.config.sourceRef, this.config.resolution, [viewWest, viewSouth, viewEast, viewNorth], this.config.transformViewToSourceMapFn);
+        // Transform tile corners from View to Source projection
+        const sw = this.config.transformViewToSourceMapFn([viewWest, viewSouth]);
+        const ne = this.config.transformViewToSourceMapFn([viewEast, viewNorth]);
+        const nw = this.config.transformViewToSourceMapFn([viewWest, viewNorth]);
+        const se = this.config.transformViewToSourceMapFn([viewEast, viewSouth]);
+        // Calculate bounding box from transformed corners
+        const tileSrcWest = Math.min(bounds.minX, sw[0], ne[0], nw[0], se[0]);
+        const tileSrcEast = Math.max(bounds.maxX, sw[0], ne[0], nw[0], se[0]);
+        const tileSrcSouth = Math.min(bounds.minY, sw[1], ne[1], nw[1], se[1]);
+        const tileSrcNorth = Math.max(bounds.maxY, sw[1], ne[1], nw[1], se[1]);
+        return { tileSrcWest, tileSrcEast, tileSrcSouth, tileSrcNorth };
+    }
+    /**
+     * Calculate pixel window for reading from GeoTIFF
+     */
+    calculateReadWindow(tileSrcBounds, ovWidth, ovHeight) {
+        const [srcWest, srcSouth, srcEast, srcNorth] = this.config.sourceBounds;
+        const srcWidth = srcEast - srcWest;
+        const srcHeight = srcNorth - srcSouth;
+        const { tileSrcWest, tileSrcEast, tileSrcSouth, tileSrcNorth } = tileSrcBounds;
+        // Calculate pixel window for this tile area
+        const pixelXMin = Math.floor(((tileSrcWest - srcWest) / srcWidth) * ovWidth);
+        const pixelXMax = Math.ceil(((tileSrcEast - srcWest) / srcWidth) * ovWidth);
+        const pixelYMin = Math.floor(((srcNorth - tileSrcNorth) / srcHeight) * ovHeight);
+        const pixelYMax = Math.ceil(((srcNorth - tileSrcSouth) / srcHeight) * ovHeight);
+        // Bounds check with 2-pixel padding
+        const readXMin = Math.min(ovWidth, Math.max(0, pixelXMin - 2));
+        const readXMax = Math.max(0, Math.min(ovWidth, pixelXMax + 2));
+        const readYMin = Math.min(ovHeight, Math.max(0, pixelYMin - 2));
+        const readYMax = Math.max(0, Math.min(ovHeight, pixelYMax + 2));
+        const readWidth = readXMax - readXMin;
+        const readHeight = readYMax - readYMin;
+        if (readWidth <= 0 || readHeight <= 0) {
+            warn('Invalid read window for tile', {
+                readXMin,
+                readXMax,
+                readYMin,
+                readYMax,
+                ovWidth,
+                ovHeight,
+            });
+            return null;
+        }
+        return {
+            readXMin,
+            readXMax,
+            readYMin,
+            readYMax,
+            readWidth,
+            readHeight,
+        };
+    }
+    /**
+     * Load and convert raster data from GeoTIFF image
+     */
+    async loadAndConvertRasterData(image, readWindow) {
+        const { readXMin, readYMin, readXMax, readYMax } = readWindow;
+        let rasters = null;
+        let lasterr = null;
+        for (let i = 0; i <= 2; i++) {
+            try {
+                // Read only the needed area from GeoTIFF (COG-optimized!)
+                rasters = await image.readRasters({
+                    window: [readXMin, readYMin, readXMax, readYMax],
+                });
+            }
+            catch (err) {
+                //   warn('Error - readRasters - read window: ', readWindow);
+                lasterr = err;
+            }
+            if (rasters != null) {
+                lasterr = null;
+                break;
+            }
+        }
+        if (lasterr != null) {
+            log(lasterr);
+            warn('Error - readRasters - read window: ', readWindow);
+            throw lasterr;
+        }
+        // Convert to TypedArray array and detect type
+        const rasterBands = [];
+        let arrayType = '';
+        for (let i = 0; i < rasters.length; i++) {
+            const raster = rasters[i];
+            if (typeof raster === 'number') {
+                warn('Unexpected number in rasters array');
+                continue;
+            }
+            rasterBands.push(raster);
+            if (i === 0) {
+                arrayType = raster.constructor.name;
+            }
+        }
+        return { rasterBands, arrayType };
+    }
+    /**
+     * Render tile pixels using triangulation-based reprojection
+     */
+    renderTilePixels(params) {
+        const { sampleSize, mercatorBounds, triangulation, rasterBands, arrayType, readWindow, ovWidth, ovHeight, resampleMethod, colorStops, } = params;
+        const [mercWest, mercSouth, mercEast, mercNorth] = mercatorBounds;
+        const [srcWest, srcSouth, srcEast, srcNorth] = this.config.sourceBounds;
+        const srcWidth = srcEast - srcWest;
+        const srcHeight = srcNorth - srcSouth;
+        const outputData = new Uint8ClampedArray(sampleSize * sampleSize * 4); // RGBA
+        let tri = null;
+        for (let py = 0; py < sampleSize; py++) {
+            for (let px = 0; px < sampleSize; px++) {
+                const idx = (py * sampleSize + px) * 4; // RGBA index
+                // Pixel position in Mercator
+                const mercX = mercWest + (px / sampleSize) * (mercEast - mercWest);
+                const mercY = mercNorth - (py / sampleSize) * (mercNorth - mercSouth);
+                // Find triangle containing this pixel
+                const targetPoint = [mercX, mercY];
+                tri = triangulation.findSourceTriangleForTargetPoint(targetPoint, tri);
+                if (tri) {
+                    // Transform using affine transformation
+                    const [srcX, srcY] = triangulation.applyAffineTransform(mercX, mercY, tri.transform);
+                    // Check if point is within source bounds
+                    if (srcX < srcWest ||
+                        srcX > srcEast ||
+                        srcY < srcSouth ||
+                        srcY > srcNorth) {
+                        // Outside bounds - transparent
+                        outputData[idx] = 0;
+                        outputData[idx + 1] = 0;
+                        outputData[idx + 2] = 0;
+                        outputData[idx + 3] = 0;
+                    }
+                    else {
+                        // Convert source coordinates to pixel coordinates (in overview image)
+                        const imgX = ((srcX - srcWest) / srcWidth) * ovWidth;
+                        const imgY = ((srcNorth - srcY) / srcHeight) * ovHeight;
+                        // Sample pixel from source raster
+                        const rgba = resampleMethod === 'near'
+                            ? sampleNearest(imgX, imgY, rasterBands, arrayType, readWindow.readWidth, readWindow.readHeight, readWindow.readXMin, readWindow.readYMin, colorStops)
+                            : sampleBilinear(imgX, imgY, rasterBands, arrayType, readWindow.readWidth, readWindow.readHeight, readWindow.readXMin, readWindow.readYMin, colorStops);
+                        if (rgba) {
+                            outputData[idx] = rgba[0];
+                            outputData[idx + 1] = rgba[1];
+                            outputData[idx + 2] = rgba[2];
+                            outputData[idx + 3] = rgba[3];
+                        }
+                        else {
+                            // No data
+                            outputData[idx] = 0;
+                            outputData[idx + 1] = 0;
+                            outputData[idx + 2] = 0;
+                            outputData[idx + 3] = 0;
+                        }
+                    }
+                }
+                else {
+                    // Pixel not in any triangle (should not happen)
+                    outputData[idx] = 0;
+                    outputData[idx + 1] = 0;
+                    outputData[idx + 2] = 0;
+                    outputData[idx + 3] = 0;
+                }
+            }
+        }
+        return outputData;
+    }
+    /**
+     * Check if tile intersects with GeoTIFF source bounds
+     * @param viewBounds - Tile bounds in View projection (e.g., Web Mercator for deck.gl/Leaflet/Cesium)
+     */
+    tileIntersectsSource(viewBounds) {
+        const [viewWest, viewSouth, viewEast, viewNorth] = viewBounds;
+        const [srcWest, srcSouth, srcEast, srcNorth] = this.config.sourceBounds;
+        // Transform tile corners from View to Source projection
+        const sw = this.config.transformViewToSourceMapFn([viewWest, viewSouth]);
+        const ne = this.config.transformViewToSourceMapFn([viewEast, viewNorth]);
+        const nw = this.config.transformViewToSourceMapFn([viewWest, viewNorth]);
+        const se = this.config.transformViewToSourceMapFn([viewEast, viewSouth]);
+        // Calculate bounding box of transformed tile in source projection
+        const tileMinX = Math.min(sw[0], ne[0], nw[0], se[0]);
+        const tileMaxX = Math.max(sw[0], ne[0], nw[0], se[0]);
+        const tileMinY = Math.min(sw[1], ne[1], nw[1], se[1]);
+        const tileMaxY = Math.max(sw[1], ne[1], nw[1], se[1]);
+        // Check for intersection
+        const intersects = tileMaxX >= srcWest &&
+            tileMinX <= srcEast &&
+            tileMaxY >= srcSouth &&
+            tileMinY <= srcNorth;
+        return intersects;
+    }
+    /**
+     * Generate tile data with triangulation-based reprojection
+     *
+     * This is the main method that orchestrates the entire tile rendering process.
+     */
+    async getTileData(params) {
+        const { x, y, z, tileSize, resolution, resampleMethod, colorStops } = params;
+        // 1. Calculate View projection bounds for the tile
+        const viewBounds = this.getTileBounds(x, y, z);
+        log(`v-map - geotiff - getTileData(${x},${y},${z}): viewBounds=[${viewBounds.map(v => v.toFixed(0)).join(',')}], sourceBounds=[${this.config.sourceBounds.map(v => v.toFixed(0)).join(',')}], toProjection=${this.config.toProjection}`);
+        // 2. Early exit: Check if tile intersects with source bounds
+        if (!this.tileIntersectsSource(viewBounds)) {
+            // Tile is completely outside source bounds - return transparent tile
+            log(`v-map - geotiff - getTileData(${x},${y},${z}): no intersection, returning transparent`);
+            const sampleSize = Math.ceil(tileSize * resolution);
+            return new Uint8ClampedArray(sampleSize * sampleSize * 4);
+        }
+        // 3. Calculate sampling resolution
+        const sampleSize = Math.ceil(tileSize * resolution);
+        // 4. Get or create triangulation
+        let triangulation;
+        if (!this.globalTriangulation) {
+            warn('Global triangulation not available, creating fallback for tile');
+            triangulation = new Triangulation(this.config.transformViewToSourceMapFn, viewBounds, 0.5);
+        }
+        else {
+            triangulation = this.globalTriangulation;
+        }
+        // 5. Calculate source bounds for this tile
+        const tileSrcBounds = this.calculateTileSourceBounds(viewBounds);
+        // 6. Select best overview image based on zoom
+        const { bestImage, bestResolution, imageLevel } = this.selectOverviewImage(z, tileSize);
+        const ovWidth = bestImage.getWidth();
+        const ovHeight = bestImage.getHeight();
+        // 7. Calculate pixel window for reading
+        const readWindow = this.calculateReadWindow(tileSrcBounds, ovWidth, ovHeight);
+        if (!readWindow) {
+            return new Uint8ClampedArray(sampleSize * sampleSize * 4);
+        }
+        // 8. Load and convert raster data
+        const { rasterBands, arrayType } = await this.loadAndConvertRasterData(bestImage, readWindow);
+        const bandCount = rasterBands.length;
+        log(`Read window: [${readWindow.readXMin}, ${readWindow.readYMin}, ${readWindow.readXMax}, ${readWindow.readYMax}] (${readWindow.readWidth}x${readWindow.readHeight} pixels), ${bandCount} bands, type: ${arrayType}, imageLevel: ${imageLevel}, resolution: ${bestResolution}`);
+        // 9. Render tile pixels
+        const outputData = this.renderTilePixels({
+            sampleSize,
+            mercatorBounds: viewBounds, // Pass View bounds (kept name for backward compat)
+            triangulation,
+            rasterBands,
+            arrayType,
+            readWindow,
+            ovWidth,
+            ovHeight,
+            resampleMethod,
+            colorStops,
+        });
+        return outputData;
+    }
+    /**
+     * Get raw elevation values for a tile as Float32Array.
+     *
+     * Returns a (tileSize+1) × (tileSize+1) float array suitable for Martini
+     * terrain mesh generation. Border pixels are backfilled for Martini compatibility.
+     * Band 0 of the GeoTIFF is used as the elevation source.
+     */
+    async getElevationData(params) {
+        const { x, y, z, tileSize } = params;
+        const gridSize = tileSize + 1; // Martini requires (2^n + 1)^2 grid
+        const viewBounds = this.getTileBounds(x, y, z);
+        if (!this.tileIntersectsSource(viewBounds)) {
+            return new Float32Array(gridSize * gridSize);
+        }
+        let triangulation;
+        if (!this.globalTriangulation) {
+            warn('Global triangulation not available, creating fallback for elevation tile');
+            triangulation = new Triangulation(this.config.transformViewToSourceMapFn, viewBounds, 0.5);
+        }
+        else {
+            triangulation = this.globalTriangulation;
+        }
+        const tileSrcBounds = this.calculateTileSourceBounds(viewBounds);
+        const { bestImage } = this.selectOverviewImage(z, tileSize);
+        const ovWidth = bestImage.getWidth();
+        const ovHeight = bestImage.getHeight();
+        const readWindow = this.calculateReadWindow(tileSrcBounds, ovWidth, ovHeight);
+        if (!readWindow) {
+            return new Float32Array(gridSize * gridSize);
+        }
+        const { rasterBands } = await this.loadAndConvertRasterData(bestImage, readWindow);
+        const [mercWest, mercSouth, mercEast, mercNorth] = viewBounds;
+        const [srcWest, srcSouth, srcEast, srcNorth] = this.config.sourceBounds;
+        const srcWidth = srcEast - srcWest;
+        const srcHeight = srcNorth - srcSouth;
+        const output = new Float32Array(gridSize * gridSize);
+        let tri = null;
+        for (let py = 0; py < tileSize; py++) {
+            for (let px = 0; px < tileSize; px++) {
+                const mercX = mercWest + (px / tileSize) * (mercEast - mercWest);
+                const mercY = mercNorth - (py / tileSize) * (mercNorth - mercSouth);
+                const targetPoint = [mercX, mercY];
+                tri = triangulation.findSourceTriangleForTargetPoint(targetPoint, tri);
+                if (tri) {
+                    const [srcX, srcY] = triangulation.applyAffineTransform(mercX, mercY, tri.transform);
+                    if (srcX >= srcWest && srcX <= srcEast && srcY >= srcSouth && srcY <= srcNorth) {
+                        const imgX = ((srcX - srcWest) / srcWidth) * ovWidth;
+                        const imgY = ((srcNorth - srcY) / srcHeight) * ovHeight;
+                        const sampleX = Math.round(imgX) - readWindow.readXMin;
+                        const sampleY = Math.round(imgY) - readWindow.readYMin;
+                        if (sampleX >= 0 && sampleX < readWindow.readWidth &&
+                            sampleY >= 0 && sampleY < readWindow.readHeight) {
+                            const sampleValue = Number(rasterBands[0][sampleY * readWindow.readWidth + sampleX]);
+                            output[py * gridSize + px] =
+                                this.sanitizeElevationValue(sampleValue);
+                        }
+                    }
+                }
+            }
+        }
+        // Backfill right border column (Martini requirement)
+        for (let row = 0; row < tileSize; row++) {
+            output[row * gridSize + tileSize] = output[row * gridSize + tileSize - 1];
+        }
+        // Backfill bottom border row (Martini requirement)
+        for (let col = 0; col <= tileSize; col++) {
+            output[tileSize * gridSize + col] = output[(tileSize - 1) * gridSize + col];
+        }
+        return output;
+    }
+}
+async function getTileProcessorConfig(tiffSource, viewProjection) {
+    const { default: proj4 } = await import('./index-RpJarvr_.js');
+    // Transform from View projection to Source projection
+    const transformViewToSourceMapFn = (coord) => {
+        const result = proj4(viewProjection, tiffSource.fromProjection, coord);
+        return [Number(result[0]), Number(result[1])];
+    };
+    // Inverse: Transform from Source projection to View projection
+    const transformSourceMapToViewFn = (coord) => {
+        const result = proj4(tiffSource.fromProjection, viewProjection, coord);
+        return [Number(result[0]), Number(result[1])];
+    };
+    const config = {
+        transformViewToSourceMapFn,
+        transformSourceMapToViewFn,
+        sourceBounds: tiffSource.sourceBounds,
+        sourceRef: tiffSource.sourceRef,
+        resolution: tiffSource.resolution,
+        imageWidth: tiffSource.width,
+        imageHeight: tiffSource.height,
+        fromProjection: tiffSource.fromProjection,
+        toProjection: viewProjection,
+        baseImage: tiffSource.baseImage,
+        overviewImages: tiffSource.overviewImages ?? [],
+        noDataValue: tiffSource.noDataValue,
+    };
+    return config;
+}
+
+//const DEFAULT_TO_PROJECTION = 'EPSG:3857';
+async function loadGeoTIFFSource(url, options, deps) {
+    const { geotiff, proj4, geokeysToProj4 } = deps;
+    const { fromUrl } = geotiff;
+    const { toProj4 } = geokeysToProj4;
+    let tiff = null;
+    let lasterr = null;
+    for (let i = 0; i <= 2; i++) {
+        try {
+            tiff = await fromUrl(url, {
+                allowFullFile: true,
+                blockSize: 1024 * 1024, // 1MB blocks to reduce HTTP range-request count for non-COG files
+                cacheSize: 100,
+            });
+        }
+        catch (err) {
+            lasterr = err;
+        }
+        if (tiff != null) {
+            lasterr = null;
+            break;
+        }
+    }
+    if (lasterr != null) {
+        log(lasterr);
+        warn('Error - loadGeoTIFFSource - fromUrl: ', url);
+        throw lasterr;
+    }
+    const baseImage = await tiff.getImage(0);
+    const imageCount = await tiff.getImageCount();
+    const overviewImages = [];
+    for (let i = 1; i < imageCount; i++) {
+        overviewImages.push(await tiff.getImage(i));
+    }
+    const width = baseImage.getWidth();
+    const height = baseImage.getHeight();
+    const samplesPerPixel = Math.max(1, baseImage.getSamplesPerPixel?.() ?? 1);
+    let fromProjection = options.forceProjection && options.projection
+        ? options.projection
+        : options.projection ?? 'EPSG:4326';
+    let proj4String = null;
+    if (!options.forceProjection) {
+        const geoKeys = typeof baseImage.getGeoKeys === 'function'
+            ? baseImage.getGeoKeys() ?? null
+            : null;
+        if (geoKeys) {
+            try {
+                const projParams = toProj4(geoKeys);
+                const epsg = geoKeys.ProjectedCSTypeGeoKey ?? geoKeys.GeographicTypeGeoKey;
+                if (epsg) {
+                    fromProjection = `EPSG:${epsg}`;
+                }
+                if (projParams?.proj4) {
+                    proj4String = projParams.proj4;
+                    const numericCode = String(epsg);
+                    if (epsg && !proj4.defs(fromProjection)) {
+                        proj4.defs(fromProjection, projParams.proj4);
+                    }
+                    if (epsg && !proj4.defs(numericCode)) {
+                        proj4.defs(numericCode, projParams.proj4);
+                    }
+                }
+            }
+            catch (err) {
+                warn('v-map - geotiff - failed to parse GeoKeys', err);
+            }
+        }
+    }
+    if (!proj4String) {
+        switch (fromProjection) {
+            case 'EPSG:4326':
+                proj4String = '+proj=longlat +datum=WGS84 +no_defs';
+                break;
+            case 'EPSG:3857':
+                proj4String =
+                    '+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs';
+                break;
+            case 'EPSG:32632':
+                proj4String = '+proj=utm +zone=32 +datum=WGS84 +units=m +no_defs';
+                break;
+        }
+    }
+    if (!fromProjection || fromProjection.trim() === '') {
+        fromProjection = 'EPSG:4326';
+    }
+    if (proj4String && !proj4.defs(fromProjection)) {
+        proj4.defs(fromProjection, proj4String);
+    }
+    const sourceBounds = baseImage.getBoundingBox();
+    const sourceRef = [sourceBounds[0], sourceBounds[1]];
+    const resolution = baseImage.getResolution()[0];
+    const rawNoData = options.nodata !== undefined && options.nodata !== null
+        ? Number(options.nodata)
+        : typeof baseImage.getGDALNoData === 'function'
+            ? baseImage.getGDALNoData()
+            : undefined;
+    const noDataValue = rawNoData !== undefined && rawNoData !== null
+        ? Number(rawNoData)
+        : undefined;
+    const clampLon = (lon) => Math.max(-180, Math.min(180, Number.isFinite(lon) ? lon : 0));
+    const clampLat = (lat) => Math.max(-90, Math.min(90, Number.isFinite(lat) ? lat : 0));
+    let transformToWgs84;
+    if (!fromProjection || fromProjection === 'EPSG:4326') {
+        transformToWgs84 = coord => coord;
+    }
+    else {
+        transformToWgs84 = (coord) => {
+            try {
+                const result = proj4(fromProjection, 'EPSG:4326', coord);
+                return [Number(result[0]), Number(result[1])];
+            }
+            catch (err) {
+                warn('v-map - geotiff - transform to WGS84 failed, falling back', err);
+                return coord;
+            }
+        };
+    }
+    const [minX, minY, maxX, maxY] = sourceBounds;
+    const corners = [
+        transformToWgs84([minX, minY]),
+        transformToWgs84([maxX, minY]),
+        transformToWgs84([maxX, maxY]),
+        transformToWgs84([minX, maxY]),
+    ];
+    const west = clampLon(Math.min(...corners.map(c => c[0])));
+    const east = clampLon(Math.max(...corners.map(c => c[0])));
+    const south = clampLat(Math.min(...corners.map(c => c[1])));
+    const north = clampLat(Math.max(...corners.map(c => c[1])));
+    log('v-map - geotiff - loaded source', {
+        url,
+        width,
+        height,
+        samplesPerPixel,
+        fromProjection,
+        bounds: sourceBounds,
+    });
+    return {
+        tiff,
+        baseImage,
+        overviewImages,
+        width,
+        height,
+        samplesPerPixel,
+        fromProjection,
+        //toProjection: DEFAULT_TO_PROJECTION,
+        sourceBounds,
+        sourceRef,
+        resolution,
+        proj4,
+        noDataValue,
+        wgs84Bounds: [west, south, east, north],
+        transformToWgs84,
+    };
+}
+async function getGeoTIFFSource(url, projection, forceProjection, nodata) {
+    const [geotiffModule, { default: proj4 }, geokeysModule] = await Promise.all([
+        import('./geotiff-BEWxTIfH.js').then(function (n) { return n.g; }),
+        import('./index-RpJarvr_.js'),
+        import('./main-dist-CwnA7_Xn.js').then(function (n) { return n.m; }),
+    ]);
+    const source = await loadGeoTIFFSource(url, {
+        projection: projection,
+        forceProjection: forceProjection,
+        nodata: nodata,
+    }, {
+        geotiff: geotiffModule,
+        proj4,
+        geokeysToProj4: geokeysModule,
+    });
+    return source;
+}
+
+export { GeoTIFFTileProcessor as G, getGeoTIFFSource as a, getTileProcessorConfig as b, getColorStops as g, loadGeoTIFFSource as l };