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

package/dist/esm/types/cogbitmaplayer/CogBitmapLayer.d.ts

@@ -65,9 +65,7 @@ export default class CogBitmapLayer<ExtraPropsT extends {} = {}> extends Composi
         getTileData: any;
         renderSubLayers: any;
         updateTriggers: {
-            getTileData: {
-                clampToTerrain: boolean | ClampToTerrainOptions;
-            };
+            getTileData: (boolean | GeoImageOptions | ClampToTerrainOptions)[];
         };
         extent: any;
         tileSize: any;

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

@@ -1,29 +1,115 @@
-import { Tiff, TiffImage } from '@cogeotiff/core';
-import LZWDecoder from './lzw';
+import { GeoTIFF, GeoTIFFImage } from 'geotiff';
 import GeoImage, { GeoImageOptions } from '../geoimage/geoimage.ts';
 export type Bounds = [minX: number, minY: number, maxX: number, maxY: number];
 declare class CogTiles {
-    cog: Tiff;
+    cog: GeoTIFF;
+    cogZoomLookup: number[];
+    cogResolutionLookup: number[];
+    cogOrigin: number[];
     zoomRange: number[];
     tileSize: number;
-    lowestOriginTileOffset: number[];
-    lowestOriginTileSize: number;
+    bounds: Bounds;
     loaded: boolean;
     geo: GeoImage;
-    lzw: LZWDecoder;
     options: GeoImageOptions;
     constructor(options: GeoImageOptions);
-    initializeCog(url: string): Promise<Tiff>;
-    getTileSize(cog: Tiff): number;
-    getZoomRange(cog: Tiff): number[];
-    getBoundsAsLatLon(cog: Tiff): [number, number, number, number];
-    getOriginAsLatLon(cog: Tiff): number[];
-    getImageTileIndex(img: TiffImage): number[];
-    getResolutionFromZoomLevel(tileSize: number, z: number): number;
+    initializeCog(url: string): Promise<void>;
+    getZoomRange(): number[];
+    calculateZoomRange(img: GeoTIFFImage, imgCount: number): number[];
+    calculateBoundsAsLatLon(image: GeoTIFFImage): [number, number, number, number];
     getZoomLevelFromResolution(tileSize: number, resolution: number): number;
+    getBoundsAsLatLon(): Bounds;
     getLatLon(input: number[]): number[];
-    getTile(x: number, y: number, z: number, bounds: Bounds, meshMaxError: number): Promise<string>;
-    getFormat(sampleFormat: number[] | number, bitsPerSample: number[] | number): any;
-    getNoDataValue(tags: any): number;
+    /**
+     * Builds lookup tables for zoom levels and estimated resolutions from a Cloud Optimized GeoTIFF (COG) object.
+     *
+     * It is assumed that inn web mapping, COG data is visualized in the Web Mercator coordinate system.
+     * At zoom level 0, the Web Mercator resolution is defined by the constant `webMercatorRes0`
+     * (e.g., 156543.03125 m/pixel). At each subsequent zoom level, this resolution is halved.
+     *
+     * This function calculates, for each image (overview) in the COG, its estimated resolution and
+     * corresponding zoom level based on the base image's resolution and width.
+     *
+     * @param {object} cog - A Cloud Optimized GeoTIFF object loaded via geotiff.js.
+     * @returns {Promise<[number[], number[]]>} A promise resolving to a tuple of two arrays:
+     *   - The first array (`zoomLookup`) maps each image index to its computed zoom level.
+     *   - The second array (`resolutionLookup`) maps each image index to its estimated resolution (m/pixel).
+     */
+    buildCogZoomResolutionLookup(cog: any): Promise<any[][]>;
+    /**
+     * Determines the appropriate image index from the Cloud Optimized GeoTIFF (COG)
+     * that best matches a given zoom level.
+     *
+     * This function utilizes precomputed lookup tables (`cogZoomLookup`) that map
+     * each image index in the COG to its corresponding zoom level. It ensures that
+     * the selected image index provides the closest resolution to the desired zoom level.
+     *
+     * @param {number} zoom - The target zoom level for which the image index is sought.
+     * @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): Promise<any[][] | import("geotiff").ReadRasterResult[]>;
+    getTile(x: number, y: number, z: number, bounds: Bounds, meshMaxError: number): Promise<string | {
+        loaderData: {
+            header: {};
+        };
+        header: {
+            vertexCount: any;
+            boundingBox: [[number, number, number], [number, number, number]];
+        };
+        mode: number;
+        indices: {
+            value: Uint32Array;
+            size: number;
+        };
+        attributes: {
+            POSITION: {
+                value: Float32Array;
+                size: number;
+            };
+            TEXCOORD_0: {
+                value: Float32Array;
+                size: number;
+            };
+        };
+    }>;
+    /**
+     * Determines the data type (e.g., "Int32", "Float64") of a GeoTIFF image
+     * by reading its TIFF tags.
+     *
+     * @param {GeoTIFFImage} image - A GeoTIFF.js image.
+     * @returns {Promise<string>} - A string representing the data type.
+     */
+    getDataTypeFromTags(image: any): string;
+    /**
+     * Extracts the noData value from a GeoTIFF.js image.
+     * Returns the noData value as a number if available, otherwise undefined.
+     *
+     * @param {GeoTIFFImage} image - The GeoTIFF.js image.
+     * @returns {number|undefined} The noData value as a number, or undefined if not available.
+     */
+    getNoDataValue(image: any): number;
+    /**
+     * Retrieves the number of channels (samples per pixel) in a GeoTIFF image.
+     *
+     * @param {GeoTIFFImage} image - A GeoTIFFImage object from which to extract the number of channels.
+     * @returns {number} The number of channels in the image.
+     */
+    getNumberOfChannels(image: any): any;
+    /**
+     * Retrieves the PlanarConfiguration value from a GeoTIFF image.
+     *
+     * @param {GeoTIFFImage} image - The GeoTIFF image object.
+     * @returns {number} The PlanarConfiguration value (1 for Chunky format, 2 for Planar format).
+     */
+    getPlanarConfiguration(image: any): any;
+    /**
+     * Creates a tile buffer of the specified size using a typed array corresponding to the provided data type.
+     *
+     * @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.
+     */
+    createTileBuffer(dataType: any, tileSize: any): Uint32Array | Float32Array | Uint8Array | Int8Array | Uint16Array | Int16Array | Int32Array | Float64Array;
 }
 export default CogTiles;

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

@@ -34,6 +34,7 @@ export type GeoImageOptions = {
     terrainColor?: Array<number> | chroma.Color;
     terrainSkirtHeight?: number;
     terrainMinValue?: number;
+    planarConfig?: number;
 };
 export declare const DefaultGeoImageOptions: GeoImageOptions;
 export default class GeoImage {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gisatcz/deckgl-geolib",
-  "version": "1.12.0-dev.1",
+  "version": "1.12.0-dev.3",
   "private": false,
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -29,7 +29,6 @@
   },
   "dependencies": {
     "@chunkd/source-http": "^11.1.0",
-    "@cogeotiff/core": "^9.0.3",
     "@deck.gl/core": "^9.0.33",
     "@deck.gl/extensions": "^9.0.33",
     "@deck.gl/geo-layers": "^9.0.33",

package/src/cogbitmaplayer/CogBitmapLayer.ts

@@ -181,9 +181,9 @@ export default class CogBitmapLayer<ExtraPropsT extends {} = {}> extends Composi
   }
 
   async init() {
-    const cog = await this.state.bitmapCogTiles.initializeCog(this.props.rasterData);
+    await this.state.bitmapCogTiles.initializeCog(this.props.rasterData);
 
-    const zoomRange = this.state.bitmapCogTiles.getZoomRange(cog);
+    const zoomRange = this.state.bitmapCogTiles.getZoomRange();
 
     const [minZoom, maxZoom] = zoomRange;
 
@@ -211,6 +211,15 @@ export default class CogBitmapLayer<ExtraPropsT extends {} = {}> extends Composi
       // const terrain = this.loadTerrain(props as TerrainLoadProps);
       // this.setState({ terrain });
     }
+    
+    // Update the useChannel option for bitmapCogTiles when cogBitmapOptions.useChannel changes.
+    // This ensures that the correct channel is used for rendering, but directly modifying the state
+    // object in this way is not ideal and may need refactoring in the future to follow a more
+    // declarative state management approach. Consider revisiting this if additional properties
+    // need to be synchronized or if the state structure changes.
+    if (props?.cogBitmapOptions?.useChannel && (props.cogBitmapOptions?.useChannel !== oldProps.cogBitmapOptions?.useChannel)) {
+      this.state.bitmapCogTiles.options.useChannel = props.cogBitmapOptions.useChannel;
+    }
 
     // TODO - remove in v9
     // @ts-ignore
@@ -239,6 +248,7 @@ export default class CogBitmapLayer<ExtraPropsT extends {} = {}> extends Composi
         tile: Tile2DHeader<TextureSource>;
       },
   ) {
+    
     const SubLayerClass = this.getSubLayerClass('image', BitmapLayer);
     const { blurredTexture } = this.state.bitmapCogTiles.options;
 
@@ -299,16 +309,17 @@ export default class CogBitmapLayer<ExtraPropsT extends {} = {}> extends Composi
         getTileData: this.getTiledBitmapData.bind(this),
         renderSubLayers: this.renderSubLayers.bind(this),
         updateTriggers: {
-          getTileData: {
+          getTileData: [
             // rasterData: urlTemplateToUpdateTrigger(rasterData),
             // blurredTexture,
             // opacity,
             // cogBitmapOptions,
             clampToTerrain,
-          },
+            cogBitmapOptions,
+          ],
+          // renderSubLayers: [cogBitmapOptions],
         },
-        extent: this.state.bitmapCogTiles.cog
-          ? this.state.bitmapCogTiles.getBoundsAsLatLon(this.state.bitmapCogTiles.cog) : null,
+        extent: this.state.bitmapCogTiles.getBoundsAsLatLon(),
         tileSize,
         minZoom: this.state.minZoom,
         maxZoom: this.state.maxZoom,

package/src/cogterrainlayer/CogTerrainLayer.ts

@@ -206,10 +206,10 @@ export default class TerrainLayer<ExtraPropsT extends {} = {}> extends Composite
   }
 
   async init(terrainUrl: string) {
-    const cog = await this.state.terrainCogTiles.initializeCog(this.props.elevationData);
+    await this.state.terrainCogTiles.initializeCog(this.props.elevationData);
     // this.tileSize = this.terrainCogTiles.getTileSize(cog);
 
-    const zoomRange = this.state.terrainCogTiles.getZoomRange(cog);
+    const zoomRange = this.state.terrainCogTiles.getZoomRange();
 
     const [minZoom, maxZoom] = zoomRange;