@gisatcz/deckgl-geolib 1.12.0-dev.0 → 1.12.0-dev.11

package/dist/cjs/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: (number | boolean | ClampToTerrainOptions)[];
         };
         extent: any;
         tileSize: any;
@@ -79,7 +77,7 @@ export default class CogBitmapLayer<ExtraPropsT extends {} = {}> extends Composi
         onTileError: (err: any, tile?: any) => void;
         maxCacheSize: number;
         maxCacheByteSize: number;
-        refinementStrategy: import("node_modules/@deck.gl/geo-layers/dist/tileset-2d/tileset-2d.js").RefinementStrategy;
+        refinementStrategy: import("@deck.gl/geo-layers/dist/tileset-2d/tileset-2d").RefinementStrategy;
     }>;
 }
 export {};

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

@@ -1,29 +1,134 @@
-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<ArrayBuffer>;
+            size: number;
+        };
+        attributes: {
+            POSITION: {
+                value: Float32Array<ArrayBuffer>;
+                size: number;
+            };
+            TEXCOORD_0: {
+                value: Float32Array<ArrayBuffer>;
+                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 (including NaN) if available, otherwise undefined.
+     *
+     * @param {GeoTIFFImage} image - The GeoTIFF.js image.
+     * @returns {number|undefined} The noData value, possibly NaN, or undefined if not set or invalid.
+     */
+    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;
+    /**
+     * Calculates the intersection between a tile bounding box and a COG bounding box,
+     * returning the intersection window in image pixel space (relative to COG offsets),
+     * along with how much blank space (nodata) appears on the left and top of the tile.
+     *
+     * @param {number[]} tileBbox - Tile bounding box: [minX, minY, maxX, maxY]
+     * @param {number[]} cogBbox - COG bounding box: [minX, minY, maxX, maxY]
+     * @param {number} offsetXPixel - X offset of the COG origin in pixel space
+     * @param {number} offsetYPixel - Y offset of the COG origin in pixel space
+     * @param {number} tileSize - Size of the tile in pixels (default: 256)
+     * @returns {[number, number, number[] | null, number, number]}
+     *   An array containing:
+     *   - width of the intersection
+     *   - height of the intersection
+     *   - pixel-space window: [startX, startY, endX, endY] or null if no overlap
+     *   - missingLeft: padding pixels on the left
+     *   - missingTop: padding pixels on the top
+     */
+    getIntersectionBBox(tileBbox: any, cogBbox: any, offsetXPixel?: number, offsetYPixel?: number, tileSize?: number): 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<ArrayBuffer> | Float32Array<ArrayBuffer> | Uint8Array<ArrayBuffer> | Int8Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint16Array<ArrayBuffer> | Int32Array<ArrayBuffer> | Float64Array<ArrayBuffer>;
 }
 export default CogTiles;

package/dist/cjs/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 {
@@ -55,16 +56,16 @@ export default class GeoImage {
         };
         mode: number;
         indices: {
-            value: Uint32Array;
+            value: Uint32Array<ArrayBuffer>;
             size: number;
         };
         attributes: {
             POSITION: {
-                value: Float32Array;
+                value: Float32Array<ArrayBuffer>;
                 size: number;
             };
             TEXCOORD_0: {
-                value: Float32Array;
+                value: Float32Array<ArrayBuffer>;
                 size: number;
             };
         };
@@ -84,16 +85,16 @@ export default class GeoImage {
         };
         mode: number;
         indices: {
-            value: Uint32Array;
+            value: Uint32Array<ArrayBuffer>;
             size: number;
         };
         attributes: {
             POSITION: {
-                value: Float32Array;
+                value: Float32Array<ArrayBuffer>;
                 size: number;
             };
             TEXCOORD_0: {
-                value: Float32Array;
+                value: Float32Array<ArrayBuffer>;
                 size: number;
             };
         };