@gisatcz/deckgl-geolib 2.5.0-dev.1 → 2.5.0-dev.3

package/dist/cjs/index.js

@@ -4874,11 +4874,12 @@ const DefaultGeoImageOptions = {
     useChannelIndex: null,
     noDataValue: undefined,
     multiplier: 1.0,
+    verticalExaggeration: 1.0,
     numOfChannels: undefined,
     planarConfig: undefined,
     // --- Mesh generation (terrain only) ---
     tesselator: 'martini',
-    terrainColor: [133, 133, 133, 255],
+    terrainColor: [200, 200, 200, 255],
     terrainSkirtHeight: 100,
     // Default fallback for invalid/nodata elevations. Should be configured based on the dataset's actual range.
     terrainMinValue: 0,
@@ -5548,25 +5549,31 @@ function addSkirt(attributes, triangles, skirtHeight, outsideIndices) {
  * @returns {number[][]} - outside edges data
  */
 function getOutsideEdgesFromTriangles(triangles) {
-    const edges = [];
-    for (let i = 0; i < triangles.length; i += 3) {
-        edges.push([triangles[i], triangles[i + 1]]);
-        edges.push([triangles[i + 1], triangles[i + 2]]);
-        edges.push([triangles[i + 2], triangles[i]]);
-    }
-    edges.sort((a, b) => Math.min(...a) - Math.min(...b) || Math.max(...a) - Math.max(...b));
-    const outsideEdges = [];
-    let index = 0;
-    while (index < edges.length) {
-        if (edges[index][0] === edges[index + 1]?.[1] && edges[index][1] === edges[index + 1]?.[0]) {
-            index += 2;
+    // Use integer keys instead of strings: min * 70000 + max is collision-free
+    // for any grid ≤ 257×257 (66,049 vertices < 70,000)
+    const edgeMap = new Map();
+    const processEdge = (a, b) => {
+        const min = Math.min(a, b);
+        const max = Math.max(a, b);
+        // Integer key: no string allocation per edge
+        const key = min * 70000 + max;
+        if (edgeMap.has(key)) {
+            edgeMap.delete(key); // Interior edge, remove
         }
         else {
-            outsideEdges.push(edges[index]);
-            index++;
+            edgeMap.set(key, [a, b]);
         }
+    };
+    for (let i = 0; i < triangles.length; i += 3) {
+        const v0 = triangles[i];
+        const v1 = triangles[i + 1];
+        const v2 = triangles[i + 2];
+        // Process each edge inline — no temporary array allocation per triangle
+        processEdge(v0, v1);
+        processEdge(v1, v2);
+        processEdge(v2, v0);
     }
-    return outsideEdges;
+    return Array.from(edgeMap.values());
 }
 /**
  * Get geometry edges that located on a border of the mesh
@@ -5617,6 +5624,22 @@ class BitmapGenerator {
      * Key: colorScale config + range, Value: pre-computed RGBA LUT
      */
     static _swissColorLUTCache = new Map();
+    /**
+     * Cache for 8-bit (256-entry) color LUTs.
+     * Shared process-wide across all tiles and datasets when options are fixed (i.e. !useAutoRange).
+     * Key: serialised coloring options, Value: pre-computed 256×RGBA LUT
+     */
+    static _8bitLUTCache = new Map();
+    /**
+     * Cache for float/16-bit (1024-entry) heatmap LUTs.
+     * Shared process-wide across all tiles and datasets when !useAutoRange.
+     * Key: serialised coloring options + range, Value: pre-computed 1024×RGBA LUT
+     */
+    static _floatLUTCache = new Map();
+    /** Build a cache key that captures all options affecting LUT colour output. */
+    static getLUTCacheKey(options, rangeMin, rangeMax, optAlpha) {
+        return `${rangeMin}_${rangeMax}_${optAlpha}_${JSON.stringify(options.colorScale)}_${options.useSingleColor}_${JSON.stringify(options.color)}_${options.useColorClasses}_${JSON.stringify(options.colorClasses)}_${options.useColorsBasedOnValues}_${JSON.stringify(options.colorsBasedOnValues)}_${options.useHeatMap}_${options.clipLow ?? ''}_${options.clipHigh ?? ''}_${JSON.stringify(options.clippedColor)}_${JSON.stringify(options.nullColor)}_${JSON.stringify(options.unidentifiedColor)}`;
+    }
     /**
      * Main entry point: Generates an ImageBitmap from raw raster data.
      */
@@ -5797,17 +5820,25 @@ class BitmapGenerator {
             return colorsArray;
         }
         // 2. 8-BIT COMPREHENSIVE LUT
-        // Single-band 8-bit (grayscale or indexed): use LUT for fast mapping
+        // Single-band 8-bit (grayscale or indexed): use LUT for fast mapping.
+        // The LUT covers all 256 possible values and is fixed for a given set of coloring options,
+        // so cache it across tiles (skip cache only when useAutoRange recomputes the range per tile).
         if (is8Bit && !options.useDataForOpacity) {
-            const lut = new Uint8ClampedArray(256 * 4);
-            for (let i = 0; i < 256; i++) {
-                if ((options.clipLow != null && i <= options.clipLow) ||
-                    (options.clipHigh != null && i >= options.clipHigh)) {
-                    lut.set(options.clippedColor, i * 4);
-                }
-                else {
-                    lut.set(this.calculateSingleColor(i, colorScale, options, optAlpha), i * 4);
+            const cacheKey = !options.useAutoRange ? this.getLUTCacheKey(options, rangeMin, rangeMax, optAlpha) : null;
+            let lut = cacheKey ? (this._8bitLUTCache.get(cacheKey) ?? null) : null;
+            if (!lut) {
+                lut = new Uint8ClampedArray(256 * 4);
+                for (let i = 0; i < 256; i++) {
+                    if ((options.clipLow != null && i <= options.clipLow) ||
+                        (options.clipHigh != null && i >= options.clipHigh)) {
+                        lut.set(options.clippedColor, i * 4);
+                    }
+                    else {
+                        lut.set(this.calculateSingleColor(i, colorScale, options, optAlpha), i * 4);
+                    }
                 }
+                if (cacheKey)
+                    this._8bitLUTCache.set(cacheKey, lut);
             }
             for (let i = 0, sampleIndex = (options.useChannelIndex ?? 0); i < arrayLength; i += 4, sampleIndex += samplesPerPixel) {
                 const lutIdx = primaryBuffer[sampleIndex] * 4;
@@ -5819,23 +5850,32 @@ class BitmapGenerator {
             return colorsArray;
         }
         // 3. FLOAT / 16-BIT LUT (HEATMAP ONLY)
-        if (isFloatOrWide && options.useHeatMap && !options.useDataForOpacity) {
+        // Guard: only activate when heatmap is the highest-priority active mode.
+        // If a more specific mode (useSingleColor, useColorClasses, useColorsBasedOnValues) is set,
+        // fall through to the general loop so calculateSingleColor can honour the priority chain.
+        if (isFloatOrWide && options.useHeatMap && !options.useSingleColor && !options.useColorClasses && !options.useColorsBasedOnValues && !options.useDataForOpacity) {
             const LUT_SIZE = 1024;
-            const lut = new Uint8ClampedArray(LUT_SIZE * 4);
             const rangeSpan = (rangeMax - rangeMin) || 1;
-            for (let i = 0; i < LUT_SIZE; i++) {
-                const domainVal = rangeMin + (i / (LUT_SIZE - 1)) * rangeSpan;
-                if ((options.clipLow != null && domainVal <= options.clipLow) ||
-                    (options.clipHigh != null && domainVal >= options.clipHigh)) {
-                    lut.set(options.clippedColor, i * 4);
-                }
-                else {
-                    const rgb = colorScale(domainVal).rgb();
-                    lut[i * 4] = rgb[0];
-                    lut[i * 4 + 1] = rgb[1];
-                    lut[i * 4 + 2] = rgb[2];
-                    lut[i * 4 + 3] = optAlpha;
+            const cacheKey = !options.useAutoRange ? this.getLUTCacheKey(options, rangeMin, rangeMax, optAlpha) : null;
+            let lut = cacheKey ? (this._floatLUTCache.get(cacheKey) ?? null) : null;
+            if (!lut) {
+                lut = new Uint8ClampedArray(LUT_SIZE * 4);
+                for (let i = 0; i < LUT_SIZE; i++) {
+                    const domainVal = rangeMin + (i / (LUT_SIZE - 1)) * rangeSpan;
+                    if ((options.clipLow != null && domainVal <= options.clipLow) ||
+                        (options.clipHigh != null && domainVal >= options.clipHigh)) {
+                        lut.set(options.clippedColor, i * 4);
+                    }
+                    else {
+                        const rgb = colorScale(domainVal).rgb();
+                        lut[i * 4] = rgb[0];
+                        lut[i * 4 + 1] = rgb[1];
+                        lut[i * 4 + 2] = rgb[2];
+                        lut[i * 4 + 3] = optAlpha;
+                    }
                 }
+                if (cacheKey)
+                    this._floatLUTCache.set(cacheKey, lut);
             }
             for (let i = 0, sampleIndex = (options.useChannelIndex ?? 0); i < arrayLength; i += 4, sampleIndex += samplesPerPixel) {
                 const val = primaryBuffer[sampleIndex];
@@ -6251,7 +6291,7 @@ class TerrainGenerator {
         const meshWidth = isKernel ? 257 : width;
         const meshHeight = isKernel ? 257 : height;
         // 2. Tesselate (Generate Mesh)
-        const { terrainSkirtHeight } = options;
+        const { terrainSkirtHeight, verticalExaggeration = 1.0 } = options;
         let mesh;
         switch (options.tesselator) {
             case 'martini':
@@ -6267,13 +6307,17 @@ class TerrainGenerator {
         }
         const { vertices } = mesh;
         let { triangles } = mesh;
-        let attributes = this.getMeshAttributes(vertices, meshTerrain, meshWidth, meshHeight, input.bounds);
+        let attributes = this.getMeshAttributes(vertices, meshTerrain, meshWidth, meshHeight, input.bounds, verticalExaggeration);
         // Compute bounding box before adding skirt so that z values are not skewed
         const boundingBox = schema.getMeshBoundingBox(attributes);
         if (terrainSkirtHeight) {
-            const { attributes: newAttributes, triangles: newTriangles } = addSkirt(attributes, triangles, terrainSkirtHeight);
-            attributes = newAttributes;
-            triangles = newTriangles;
+            const scaledSkirtHeight = terrainSkirtHeight * verticalExaggeration;
+            // Skip skirt generation if scaled height is zero (e.g., verticalExaggeration = 0)
+            if (scaledSkirtHeight > 0) {
+                const { attributes: newAttributes, triangles: newTriangles } = addSkirt(attributes, triangles, scaledSkirtHeight);
+                attributes = newAttributes;
+                triangles = newTriangles;
+            }
         }
         const map = {
             // Data return by this loader implementation
@@ -6469,10 +6513,10 @@ class TerrainGenerator {
         const vertices = coords;
         return { vertices, triangles };
     }
-    static getMeshAttributes(vertices, terrain, width, height, bounds) {
+    static getMeshAttributes(vertices, terrain, width, height, bounds, verticalExaggeration = 1.0) {
         const gridSize = width === 257 ? 257 : width + 1;
         const numOfVerticies = vertices.length / 2;
-        // vec3. x, y in pixels, z in meters
+        // vec3. x, y in pixels, z in meters (scaled by verticalExaggeration)
         const positions = new Float32Array(numOfVerticies * 3);
         // vec2. 1 to 1 relationship with position. represents the uv on the texture image. 0,0 to 1,1.
         const texCoords = new Float32Array(numOfVerticies * 2);
@@ -6489,7 +6533,7 @@ class TerrainGenerator {
             const pixelIdx = y * gridSize + x;
             positions[3 * i] = x * xScale + minX;
             positions[3 * i + 1] = -y * yScale + maxY;
-            positions[3 * i + 2] = terrain[pixelIdx];
+            positions[3 * i + 2] = terrain[pixelIdx] * verticalExaggeration;
             texCoords[2 * i] = x / effectiveWidth;
             texCoords[2 * i + 1] = y / effectiveHeight;
         }
@@ -6512,7 +6556,7 @@ class GeoImage {
         this.data = data;
     }
     async getMap(input, options, meshMaxError) {
-        const mergedOptions = { ...DefaultGeoImageOptions, ...options };
+        const mergedOptions = GeoImage.resolveVisualizationMode({ ...DefaultGeoImageOptions, ...options }, options);
         switch (mergedOptions.type) {
             case 'image':
                 return this.getBitmap(input, mergedOptions);
@@ -6522,6 +6566,56 @@ class GeoImage {
                 return null;
         }
     }
+    /**
+     * Resolves the active visualization (coloring) mode after merging user options with defaults.
+     *
+     * Solves three key issues:
+     *
+     * 1. **Mutual exclusivity**: `DefaultGeoImageOptions` sets `useHeatMap: true`. If a user
+     *    explicitly enables a coloring mode without explicitly setting `useHeatMap: false`,
+     *    enforce that only the explicitly-enabled modes are active (all others forced to false).
+     *    This prevents the default `useHeatMap: true` from interfering with user-chosen modes.
+     *
+     * 2. **Bitmap default**: for `type === 'image'` with no user-specified coloring mode,
+     *    keep `useHeatMap: true` from defaults. This provides sensible data-driven visualization.
+     *
+     * 3. **Terrain default**: for `type === 'terrain'` with no user-specified coloring mode and
+     *    no kernel-texture mode (`useSwissRelief` / `useSlope` / `useHillshade`), enable
+     *    `useSingleColor` with `color = terrainColor`. This renders the mesh in the documented
+     *    default colour (grey) without a data-driven texture overlay. When a kernel mode IS
+     *    present but no coloring mode is specified, keep `useHeatMap: true` so the kernel output
+     *    is still colourised.
+     */
+    static resolveVisualizationMode(mergedOptions, userOptions) {
+        const coloringModes = ['useSingleColor', 'useColorClasses', 'useColorsBasedOnValues', 'useHeatMap'];
+        const userExplicitColoringModes = coloringModes.filter(m => userOptions[m] === true);
+        const resolved = { ...mergedOptions };
+        if (userExplicitColoringModes.length > 0) {
+            // Enforce mutual exclusivity: disable all coloring modes, then enable only those
+            // explicitly set by the user. This prevents the default useHeatMap from interfering.
+            for (const mode of coloringModes) {
+                resolved[mode] = false;
+            }
+            for (const mode of userExplicitColoringModes) {
+                resolved[mode] = true;
+            }
+        }
+        else if (mergedOptions.type === 'terrain') {
+            // Terrain with no explicit coloring mode.
+            const hasKernelMode = userOptions.useSwissRelief || userOptions.useSlope || userOptions.useHillshade;
+            if (!hasKernelMode) {
+                // No kernel mode: enable useSingleColor with terrainColor as the default.
+                // This renders the mesh in the documented colour without a data-driven texture.
+                resolved.useHeatMap = false;
+                resolved.useSingleColor = true;
+                resolved.color = mergedOptions.terrainColor;
+            }
+            // When a kernel mode is present without an explicit coloring mode, keep
+            // useHeatMap: true from defaults so the kernel output is colourised.
+        }
+        // For 'image' with no explicit coloring mode: keep useHeatMap: true from DefaultGeoImageOptions.
+        return resolved;
+    }
     // GetHeightmap uses only "useChannel" and "multiplier" options
     async getHeightmap(input, options, meshMaxError) {
         let rasters = [];