@gisatcz/deckgl-geolib 2.3.1-dev.1 → 2.4.0-dev.2

package/dist/esm/types/core/GeoImage.d.ts

@@ -9,12 +9,14 @@ export default class GeoImage {
         height: number;
         rasters: any[];
         bounds: Bounds;
+        cellSizeMeters?: number;
     }, options: GeoImageOptions, meshMaxError: any): Promise<TileResult | null>;
     getHeightmap(input: string | {
         bounds: Bounds;
         width: number;
         height: number;
         rasters: any[];
+        cellSizeMeters?: number;
     }, options: GeoImageOptions, meshMaxError: any): Promise<TileResult>;
     getBitmap(input: string | {
         width: number;

package/dist/esm/types/core/lib/BitmapGenerator.d.ts

@@ -1,15 +1,20 @@
-import chroma from 'chroma-js';
 import { GeoImageOptions, TypedArray, TileResult } from '../types';
 export declare class BitmapGenerator {
+    /**
+     * Main entry point: Generates an ImageBitmap from raw raster data.
+     */
     static generate(input: {
         width: number;
         height: number;
         rasters: TypedArray[];
     }, options: GeoImageOptions): Promise<TileResult>;
-    static getMinMax(array: TypedArray, options: GeoImageOptions, samplesPerPixel?: number): number[];
     static getColorValue(dataArray: TypedArray | any[], options: GeoImageOptions, arrayLength: number, samplesPerPixel?: number): Uint8ClampedArray<ArrayBuffer>;
-    static findClassIndex(number: number, intervals: [number, number][], bounds: [boolean, boolean][]): number;
-    static getDefaultColor(size: number, nullColor: number[]): Uint8ClampedArray<ArrayBuffer>;
-    static getColorFromChromaType(colorDefinition: number[] | chroma.Color, alpha?: number): number[];
-    static hasPixelsNoData(pixels: any[], noDataValue: any): boolean;
+    private static calculateSingleColor;
+    private static findClassIndex;
+    private static getDefaultColor;
+    private static isInvalid;
+    private static getInvalidColor;
+    static getMinMax(array: TypedArray, options: GeoImageOptions, samplesPerPixel?: number): number[];
+    static getColorFromChromaType(color: any, alpha?: number): any[];
+    static hasPixelsNoData(pixels: number[], noData: number | undefined): boolean;
 }

package/dist/esm/types/core/lib/KernelGenerator.d.ts

@@ -0,0 +1,31 @@
+/**
+ * KernelGenerator — 3×3 neighborhood kernel calculations on elevation rasters.
+ *
+ * Input contract: a Float32Array of 258×258 elevation values (row-major).
+ * Edge pixels (row/col 0 and 257) are used only as kernel neighbors and do
+ * not appear in the output.
+ * Output: Float32Array of 256×256 computed values.
+ */
+export declare class KernelGenerator {
+    /**
+     * Calculates slope (0–90 degrees) for each pixel using Horn's method.
+     *
+     * @param src         Float32Array of 258×258 elevation values (row-major)
+     * @param cellSize    Cell size in meters per pixel
+     * @param zFactor     Vertical exaggeration factor (default 1)
+     * @param noDataValue Elevation value treated as noData; output is NaN for those pixels
+     */
+    static calculateSlope(src: Float32Array, cellSize: number, zFactor?: number, noDataValue?: number): Float32Array;
+    /**
+     * Calculates hillshade (0–255 grayscale) for each pixel.
+     * Follows the ESRI hillshade algorithm convention.
+     *
+     * @param src         Float32Array of 258×258 elevation values (row-major)
+     * @param azimuth     Sun azimuth in degrees (default 315 = NW)
+     * @param altitude    Sun altitude above horizon in degrees (default 45)
+     * @param cellSize    Cell size in meters per pixel
+     * @param zFactor     Vertical exaggeration factor (default 1)
+     * @param noDataValue Elevation value treated as noData; output is NaN for those pixels
+     */
+    static calculateHillshade(src: Float32Array, cellSize: number, azimuth?: number, altitude?: number, zFactor?: number, noDataValue?: number): Float32Array;
+}

package/dist/esm/types/core/lib/TerrainGenerator.d.ts

@@ -5,7 +5,12 @@ export declare class TerrainGenerator {
         height: number;
         rasters: TypedArray[];
         bounds: Bounds;
-    }, options: GeoImageOptions, meshMaxError: number): TileResult;
+        cellSizeMeters?: number;
+    }, options: GeoImageOptions, meshMaxError: number): Promise<TileResult>;
+    /** Extracts rows 1–257, cols 1–257 from a 258×258 terrain array → 257×257 for mesh generation. */
+    private static extractMeshRaster;
+    private static hasVisualizationOptions;
+    private static cropRaster;
     /**
      * Decodes raw raster data into a Float32Array of elevation values.
      * Handles channel selection, value scaling, data type validation, and border stitching.

package/dist/esm/types/core/types.d.ts

@@ -1,4 +1,5 @@
 import chroma from 'chroma-js';
+export type ChromaColorInput = string | number[] | chroma.Color;
 import type { MeshAttributes } from '@loaders.gl/schema';
 export type Bounds = [minX: number, minY: number, maxX: number, maxY: number];
 export type ClampToTerrainOptions = {
@@ -6,38 +7,43 @@ export type ClampToTerrainOptions = {
 };
 export type GeoImageOptions = {
     type: 'image' | 'terrain';
-    tesselator?: 'martini' | 'delatin';
     format?: 'uint8' | 'uint16' | 'uint32' | 'int8' | 'int16' | 'int32' | 'float32' | 'float64';
+    /** 1-based index of the channel to visualize (e.g. 1 for the first channel). */
+    useChannel?: number | null;
+    /** 0-based index of the channel to visualize (e.g. 0 for the first channel). Alternative to useChannel. */
+    useChannelIndex?: number | null;
+    noDataValue?: number;
+    multiplier?: number;
+    numOfChannels?: number;
+    planarConfig?: number;
+    tesselator?: 'martini' | 'delatin';
+    terrainColor?: Array<number> | chroma.Color;
+    terrainSkirtHeight?: number;
+    terrainMinValue?: number;
     useHeatMap?: boolean;
     useColorsBasedOnValues?: boolean;
     useColorClasses?: boolean;
     useAutoRange?: boolean;
     useDataForOpacity?: boolean;
-    /** 1-based index of the channel to visualize (e.g. 1 for the first channel). */
-    useChannel?: number | null;
-    /** 0-based index of the channel to visualize (e.g. 0 for the first channel). Alternative to useChannel. */
-    useChannelIndex?: number | null;
     useSingleColor?: boolean;
     blurredTexture?: boolean;
     clipLow?: number | null;
     clipHigh?: number | null;
-    multiplier?: number;
-    color?: Array<number> | chroma.Color;
-    colorScale?: Array<string> | Array<chroma.Color>;
+    color?: ChromaColorInput;
+    colorScale?: ChromaColorInput[];
     colorScaleValueRange?: number[];
-    colorsBasedOnValues?: [number | undefined, chroma.Color][];
-    colorClasses?: [chroma.Color, [number, number], [boolean, boolean]?][];
+    colorsBasedOnValues?: Array<[number, ChromaColorInput]>;
+    colorClasses?: Array<[ChromaColorInput, [number, number], [boolean?, boolean?]?]>;
     alpha?: number;
-    noDataValue?: number;
-    numOfChannels?: number;
-    nullColor?: Array<number> | chroma.Color;
-    unidentifiedColor?: Array<number> | chroma.Color;
-    clippedColor?: Array<number> | chroma.Color;
+    nullColor?: ChromaColorInput;
+    unidentifiedColor?: ChromaColorInput;
+    clippedColor?: ChromaColorInput;
     clampToTerrain?: ClampToTerrainOptions | boolean;
-    terrainColor?: Array<number> | chroma.Color;
-    terrainSkirtHeight?: number;
-    terrainMinValue?: number;
-    planarConfig?: number;
+    useSlope?: boolean;
+    useHillshade?: boolean;
+    hillshadeAzimuth?: number;
+    hillshadeAltitude?: number;
+    zFactor?: number;
 };
 export declare const DefaultGeoImageOptions: GeoImageOptions;
 export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;
@@ -57,6 +63,8 @@ export type TerrainMesh = {
 export interface TileResult {
     map: ImageBitmap | TerrainMesh;
     raw: TypedArray | null;
+    rawDerived?: TypedArray | null;
     width: number;
     height: number;
+    texture?: ImageBitmap;
 }

package/dist/esm/types/layers/CogTerrainLayer.d.ts

@@ -55,6 +55,12 @@ type _CogTerrainLayerProps = {
     terrainOptions: GeoImageOptions;
     /** Pre-initialized CogTiles object for terrain */
     cogTiles?: CogTiles;
+    /**
+     * When true, suppresses any texture generated by the tile (e.g. heatmap/hillshade)
+     * and renders the mesh in the plain `color` instead.
+     * Useful for showing a neutral grey terrain during mode transitions.
+     */
+    disableTexture?: boolean;
     /**
      * @deprecated Use `loadOptions.terrain.workerUrl` instead
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gisatcz/deckgl-geolib",
-  "version": "2.3.1-dev.1",
+  "version": "2.4.0-dev.2",
   "description": "Deck.gl extension for rendering Cloud-Optimized GeoTIFF (COG) data",
   "keywords": [
     "deck.gl",