@gisatcz/deckgl-geolib 2.1.2-dev.1 → 2.1.4-dev.0

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

@@ -1,5 +1,6 @@
 import { GeoTIFF, GeoTIFFImage } from 'geotiff';
-import GeoImage, { GeoImageOptions } from './GeoImage';
+import GeoImage from './GeoImage';
+import { GeoImageOptions } from './types';
 export type Bounds = [minX: number, minY: number, maxX: number, maxY: number];
 declare class CogTiles {
     cog: GeoTIFF;
@@ -47,13 +48,13 @@ declare class CogTiles {
      * @returns {number} The index of the image in the COG that best matches the specified zoom level.
      */
     getImageIndexForZoomLevel(zoom: any): number;
-    getTileFromImage(tileX: any, tileY: any, zoom: any, fetchSize?: number): Promise<any[][] | Float32Array<ArrayBuffer>[] | import("geotiff").TypedArrayWithDimensions[]>;
+    getTileFromImage(tileX: any, tileY: any, zoom: any, fetchSize?: number): Promise<(Float32Array<ArrayBuffer> | Int8Array<ArrayBuffer> | Uint8Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint16Array<ArrayBuffer> | Int32Array<ArrayBuffer> | Uint32Array<ArrayBuffer> | Float64Array<ArrayBuffer>)[] | import("geotiff").TypedArrayWithDimensions[]>;
     /**
      * Creates a blank tile buffer filled with the "No Data" value.
      * @param size The width/height of the square tile (e.g., 256 or 257)
      */
     createEmptyTile(size?: number): Float32Array<ArrayBuffer>;
-    getTile(x: number, y: number, z: number, bounds: Bounds, meshMaxError: number): Promise<string | {
+    getTile(x: number, y: number, z: number, bounds: Bounds, meshMaxError: number): Promise<{
         loaderData: {
             header: {};
         };
@@ -76,7 +77,7 @@ declare class CogTiles {
                 size: number;
             };
         };
-    }>;
+    } | ImageBitmap>;
     /**
      * Determines the data type (e.g., "Int32", "Float64") of a GeoTIFF image
      * by reading its TIFF tags.
@@ -98,8 +99,9 @@ declare class CogTiles {
      *
      * @param {string} dataType - A string specifying the data type (e.g., "Int32", "Float64", "UInt16", etc.).
      * @param {number} tileSize - The width/height of the square tile.
-     * @returns {TypedArray} A typed array buffer of length tileSize * tileSize.
+     * @param {number} multiplier - Optional multiplier for interleaved buffers (e.g., numChannels).
+     * @returns {TypedArray} A typed array buffer of length (tileSize * tileSize * multiplier).
      */
-    createTileBuffer(dataType: any, tileSize: any): Uint32Array<ArrayBuffer> | Float32Array<ArrayBuffer> | Int8Array<ArrayBuffer> | Uint8Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint16Array<ArrayBuffer> | Int32Array<ArrayBuffer> | Float64Array<ArrayBuffer>;
+    createTileBuffer(dataType: string, tileSize: number, multiplier?: number): Float32Array<ArrayBuffer> | Int8Array<ArrayBuffer> | Uint8Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint16Array<ArrayBuffer> | Int32Array<ArrayBuffer> | Uint32Array<ArrayBuffer> | Float64Array<ArrayBuffer>;
 }
 export default CogTiles;

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

@@ -1,53 +1,15 @@
 import { GeoTIFFImage } from 'geotiff';
-import chroma from 'chroma-js';
-export type Bounds = [minX: number, minY: number, maxX: number, maxY: number];
-export type ClampToTerrainOptions = {
-    terrainDrawMode?: string;
-};
-export type GeoImageOptions = {
-    type: 'image' | 'terrain';
-    tesselator?: 'martini' | 'delatin';
-    format?: 'uint8' | 'uint16' | 'uint32' | 'int8' | 'int16' | 'int32' | 'float32' | 'float64';
-    useHeatMap?: boolean;
-    useColorsBasedOnValues?: boolean;
-    useColorClasses?: boolean;
-    useAutoRange?: boolean;
-    useDataForOpacity?: boolean;
-    useChannel?: Exclude<number, 0> | null;
-    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>;
-    colorScaleValueRange?: number[];
-    colorsBasedOnValues?: [number | undefined, chroma.Color][];
-    colorClasses?: [chroma.Color, [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;
-    clampToTerrain?: ClampToTerrainOptions | boolean;
-    terrainColor?: Array<number> | chroma.Color;
-    terrainSkirtHeight?: number;
-    terrainMinValue?: number;
-    planarConfig?: number;
-};
-export declare const DefaultGeoImageOptions: GeoImageOptions;
+import { GeoImageOptions, Bounds } from './types';
+export * from './types';
 export default class GeoImage {
     data: GeoTIFFImage | undefined;
-    scale: (num: number, inMin: number, inMax: number, outMin: number, outMax: number) => number;
     setUrl(url: string): Promise<void>;
     getMap(input: string | {
         width: number;
         height: number;
         rasters: any[];
         bounds: Bounds;
-    }, options: GeoImageOptions, meshMaxError: any): Promise<string | {
+    }, options: GeoImageOptions, meshMaxError: any): Promise<{
         loaderData: {
             header: {};
         };
@@ -70,7 +32,7 @@ export default class GeoImage {
                 size: number;
             };
         };
-    }>;
+    } | ImageBitmap>;
     getHeightmap(input: string | {
         bounds: Bounds;
         width: number;
@@ -104,11 +66,5 @@ export default class GeoImage {
         width: number;
         height: number;
         rasters: any[];
-    }, options: GeoImageOptions): Promise<string>;
-    getMinMax(array: any, options: any): any[];
-    getColorValue(dataArray: [], options: GeoImageOptions, arrayLength: number, numOfChannels?: number): any[];
-    findClassIndex(number: any, intervals: any, bounds: any): number;
-    getDefaultColor(size: any, nullColor: any): any[];
-    getColorFromChromaType(colorDefinition: any): any[];
-    hasPixelsNoData(pixels: any, noDataValue: any): any;
+    }, options: GeoImageOptions): Promise<ImageBitmap>;
 }

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

@@ -0,0 +1,15 @@
+import chroma from 'chroma-js';
+import { GeoImageOptions, TypedArray } from '../types';
+export declare class BitmapGenerator {
+    static generate(input: {
+        width: number;
+        height: number;
+        rasters: TypedArray[];
+    }, options: GeoImageOptions): Promise<ImageBitmap>;
+    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;
+}

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

@@ -0,0 +1 @@
+export declare function scale(num: number, inMin: number, inMax: number, outMin: number, outMax: number): number;

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

@@ -0,0 +1,55 @@
+import { GeoImageOptions, Bounds, TypedArray } from '../types';
+export declare class TerrainGenerator {
+    static generate(input: {
+        width: number;
+        height: number;
+        rasters: TypedArray[];
+        bounds: Bounds;
+    }, options: GeoImageOptions, meshMaxError: number): {
+        loaderData: {
+            header: {};
+        };
+        header: {
+            vertexCount: any;
+            boundingBox: [[number, number, number], [number, number, number]];
+        };
+        mode: number;
+        indices: {
+            value: Uint32Array<ArrayBuffer>;
+            size: number;
+        };
+        attributes: {
+            POSITION: {
+                value: Float32Array<ArrayBuffer>;
+                size: number;
+            };
+            TEXCOORD_0: {
+                value: Float32Array<ArrayBuffer>;
+                size: number;
+            };
+        };
+    };
+    /**
+     * Decodes raw raster data into a Float32Array of elevation values.
+     * Handles channel selection, value scaling, data type validation, and border stitching.
+     */
+    private static computeTerrainData;
+    static getMartiniTileMesh(meshMaxError: number, width: number, terrain: Float32Array): {
+        vertices: any;
+        triangles: any;
+    };
+    static getDelatinTileMesh(meshMaxError: number, width: number, height: number, terrain: Float32Array): {
+        vertices: any;
+        triangles: any;
+    };
+    static getMeshAttributes(vertices: Uint16Array | Uint32Array | Float32Array | Float64Array, terrain: Float32Array, width: number, height: number, bounds: Bounds | number[]): {
+        POSITION: {
+            value: Float32Array<ArrayBuffer>;
+            size: number;
+        };
+        TEXCOORD_0: {
+            value: Float32Array<ArrayBuffer>;
+            size: number;
+        };
+    };
+}

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

@@ -0,0 +1,42 @@
+import chroma from 'chroma-js';
+export type Bounds = [minX: number, minY: number, maxX: number, maxY: number];
+export type ClampToTerrainOptions = {
+    terrainDrawMode?: string;
+};
+export type GeoImageOptions = {
+    type: 'image' | 'terrain';
+    tesselator?: 'martini' | 'delatin';
+    format?: 'uint8' | 'uint16' | 'uint32' | 'int8' | 'int16' | 'int32' | 'float32' | 'float64';
+    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>;
+    colorScaleValueRange?: number[];
+    colorsBasedOnValues?: [number | undefined, chroma.Color][];
+    colorClasses?: [chroma.Color, [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;
+    clampToTerrain?: ClampToTerrainOptions | boolean;
+    terrainColor?: Array<number> | chroma.Color;
+    terrainSkirtHeight?: number;
+    terrainMinValue?: number;
+    planarConfig?: number;
+};
+export declare const DefaultGeoImageOptions: GeoImageOptions;
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array;

package/package.json

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