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

package/dist/esm/index.js

@@ -4876,7 +4876,7 @@ const DefaultGeoImageOptions = {
     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,
@@ -5615,6 +5615,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.
      */
@@ -5795,17 +5811,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;
@@ -5817,23 +5841,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];
@@ -6510,7 +6543,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);
@@ -6520,6 +6553,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 = [];