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

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

@@ -1,6 +1,6 @@
-import { GeoTIFF, GeoTIFFImage } from 'geotiff';
+import { GeoTIFF } from 'geotiff';
 import GeoImage from './GeoImage';
-import { GeoImageOptions, TileResult } from './types';
+import { GeoImageOptions, TileResult, TypedArray } from './types';
 export type Bounds = [minX: number, minY: number, maxX: number, maxY: number];
 declare class CogTiles {
     cog?: GeoTIFF;
@@ -13,63 +13,19 @@ declare class CogTiles {
     bounds: [number, number, number, number];
     geo: GeoImage;
     options: GeoImageOptions;
-    private tileResultCache;
-    private readonly tileResultCacheMaxSize;
-    private getTileResultCacheKey;
-    /** Clears the TileResult cache. Call when the COG URL or meshMaxError changes. */
-    clearTileResultCache(): void;
-    private rasterCache;
-    private readonly rasterCacheMaxSize;
-    private reliefMaskCache;
-    private readonly reliefMaskCacheMaxSize;
-    private getTileCacheKey;
-    private imageCache;
+    private cache;
+    private tileReader?;
     private initializePromise?;
     private lastInitializedUrl?;
     constructor(options: GeoImageOptions);
     initializeCog(url: string): Promise<void>;
     getZoomRange(): number[];
-    calculateZoomRange(tileSize: number, resolution: number, imgCount: number): number[];
-    calculateBoundsAsLatLon(bbox: number[]): [number, number, number, number];
-    getZoomLevelFromResolution(tileSize: number, resolution: number): number;
     getBoundsAsLatLon(): [number, number, number, number];
-    getLatLon(input: number[]): [number, number];
-    /**
-     * Calculates the error multiplier based on zoom level and COG zoom range.
-     * - z >= maxZ: multiplier = 0.5 (fine meshes at high zoom, maximum precision)
-     * - z <= minZ: multiplier = 3.0 (coarse meshes at low zoom, maximum performance)
-     * - Otherwise: linear interpolation between 3.0 and 0.5
-     */
-    private getErrorMultiplierForZoom;
-    /**
-     * Calculates dynamic meshMaxError for a given zoom level and resolution.
-     * Formula: resolution * errorMultiplier, where multiplier scales from 3.0 (low zoom) to 0.5 (high zoom).
-     * Results are clamped to 0.5–100 meters to prevent pathological tessellation:
-     * - Min 0.5m ensures simplification always happens (no rounding to 0 with sub-meter pixels)
-     * - Max 100m prevents excessive simplification at low zoom with low-resolution COGs
-     */
-    private calculateDynamicMeshMaxError;
     /**
      * Gets the auto meshMaxError for a given overview index.
      * Returns undefined if auto lookup has not been computed.
      */
     getMeshMaxErrorForImageIndex(imageIndex: number): number | undefined;
-    /**
-     * 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: GeoTIFF): Promise<number[][]>;
     /**
      * Computes dynamic meshMaxError values for each overview based on COG resolution and zoom level.
      * Called only for terrain COGs after buildCogZoomResolutionLookup() completes.
@@ -89,37 +45,11 @@ declare class CogTiles {
      * @returns {number} The index of the image in the COG that best matches the specified zoom level.
      */
     getImageIndexForZoomLevel(zoom: number): number;
-    getTileFromImage(tileX: number, tileY: number, zoom: number, fetchSize?: number, signal?: AbortSignal): Promise<(Uint8Array<ArrayBuffer> | Float32Array<ArrayBuffer> | Int8Array<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>;
+    getTileFromImage(tileX: number, tileY: number, zoom: number, fetchSize?: number, signal?: AbortSignal): Promise<TypedArray[]>;
     getTile(x: number, y: number, z: number, bounds?: Bounds, meshMaxError?: number, signal?: AbortSignal, skipTexture?: boolean): Promise<TileResult | null>;
-    /**
-     * 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(fileDirectory: any): Promise<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: GeoTIFFImage): number | undefined;
-    /**
-     * 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.
-     * @param {number} multiplier - Optional multiplier for interleaved buffers (e.g., numChannels).
-     * @returns {TypedArray} A typed array buffer of length (tileSize * tileSize * multiplier).
-     */
-    createTileBuffer(dataType: string, tileSize: number, multiplier?: number): Uint8Array<ArrayBuffer> | Float32Array<ArrayBuffer> | Int8Array<ArrayBuffer> | Int16Array<ArrayBuffer> | Uint16Array<ArrayBuffer> | Int32Array<ArrayBuffer> | Uint32Array<ArrayBuffer> | Float64Array<ArrayBuffer>;
+    private getTerrainTile;
+    private getGlazeTile;
+    private getBitmapTile;
+    clearTileResultCache(): void;
 }
 export default CogTiles;

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

@@ -0,0 +1,41 @@
+import type { GeoTIFFImage } from 'geotiff';
+import type { TileResult, TypedArray } from '../types';
+export type TileResultCacheEntry = {
+    promise: Promise<TileResult | null>;
+    controller: AbortController;
+    callerCount: number;
+    settled: boolean;
+};
+export default class TileCacheManager {
+    private tileResultCache;
+    private readonly tileResultCacheMaxSize;
+    private rasterCache;
+    private readonly rasterCacheMaxSize;
+    private reliefMaskCache;
+    private readonly reliefMaskCacheMaxSize;
+    private imageCache;
+    constructor(opts?: {
+        tileResultCacheMaxSize?: number;
+        rasterCacheMaxSize?: number;
+        reliefMaskCacheMaxSize?: number;
+    });
+    getTileResultCacheKey(x: number, y: number, z: number, meshMaxError: number, skipTexture: boolean): string;
+    getTileCacheKey(x: number, y: number, z: number): string;
+    getTileResult(key: string): TileResultCacheEntry | undefined;
+    setTileResult(key: string, entry: TileResultCacheEntry): void;
+    deleteTileResult(key: string): boolean;
+    clearTileResultCache(): void;
+    getRaster(key: string): Promise<TypedArray[]> | undefined;
+    setRaster(key: string, p: Promise<TypedArray[]>): void;
+    deleteRaster(key: string): boolean;
+    clearRasterCache(): void;
+    getReliefMask(key: string): Promise<Uint8ClampedArray> | undefined;
+    setReliefMask(key: string, p: Promise<Uint8ClampedArray>): void;
+    deleteReliefMask(key: string): boolean;
+    clearReliefMaskCache(): void;
+    getImage(index: number): Promise<GeoTIFFImage> | undefined;
+    setImage(index: number, p: Promise<GeoTIFFImage>): void;
+    deleteImage(index: number): boolean;
+    clearImageCache(): void;
+    clearAll(): void;
+}

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

@@ -0,0 +1,11 @@
+import type { TypedArray, GeoImageOptions } from '../types';
+export default class TileReader {
+    private options;
+    private tileSize;
+    constructor(params: {
+        options: GeoImageOptions;
+        tileSize: number;
+    });
+    createEmptyTile(size?: number): Float32Array<ArrayBuffer>;
+    createTileBuffer(dataType: string, tileSize: number, multiplier?: number): TypedArray;
+}

package/dist/esm/types/utils/geo.d.ts

@@ -0,0 +1,8 @@
+export declare const EARTH_CIRCUMFERENCE: number;
+export declare const EARTH_HALF_CIRCUMFERENCE: number;
+export declare const webMercatorOrigin: number[];
+export declare const webMercatorRes0 = 156543.03125;
+export declare function getLatLon(input: number[]): [number, number];
+export declare function getZoomLevelFromResolution(tileSize: number, resolution: number): number;
+export declare function calculateZoomRange(tileSize: number, resolution: number, imgCount: number): [number, number];
+export declare function calculateBoundsAsLatLon(bbox: number[]): [number, number, number, number];

package/dist/esm/types/utils/lod.d.ts

@@ -0,0 +1,8 @@
+import type { GeoTIFF } from 'geotiff';
+/**
+ * LOD (level-of-detail) helpers extracted from CogTiles.
+ */
+export declare function getErrorMultiplierForZoom(z: number, minZ: number, maxZ: number): number;
+export declare function calculateDynamicMeshMaxError(z: number, resolution: number, minZ: number, maxZ: number): number;
+export declare function buildCogZoomResolutionLookup(cog: GeoTIFF): Promise<[number[], number[]]>;
+export declare function getImageIndexForZoomLevel(zoom: number, cogZoomLookup: number[]): number;

package/dist/esm/types/utils/tiffUtils.d.ts

@@ -0,0 +1,11 @@
+import type { GeoTIFFImage } from 'geotiff';
+/**
+ * Reads TIFF tags to determine the numeric data type (e.g. "UInt8", "Int16", "Float32").
+ * The implementation mirrors the logic previously present in CogTiles.
+ */
+export declare function getDataTypeFromTags(fileDirectory: any): Promise<string>;
+/**
+ * Extracts the noData value from a GeoTIFF.js image.
+ * Returns the numeric value, NaN, or undefined if not present/parsable.
+ */
+export declare function getNoDataValue(image: GeoTIFFImage): number | undefined;

package/package.json

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