@gisatcz/deckgl-geolib 2.1.1 → 2.1.2-dev.0

package/dist/cjs/index.js

@@ -4,7 +4,6 @@ var core = require('@deck.gl/core');
 var geoLayers = require('@deck.gl/geo-layers');
 var layers = require('@deck.gl/layers');
 var extensions = require('@deck.gl/extensions');
-var webMercator = require('@math.gl/web-mercator');
 var chroma = require('chroma-js');
 var schema = require('@loaders.gl/schema');
 var loaderUtils = require('@loaders.gl/loader-utils');
@@ -5326,17 +5325,25 @@ class GeoImage {
                 channel = rasters[optionsLocal.useChannelIndex];
             }
         }
-        const terrain = new Float32Array((width + 1) * (height + 1));
+        const terrain = new Float32Array((width === 257 ? width : width + 1) * (height === 257 ? height : height + 1));
         const numOfChannels = channel.length / (width * height);
         let pixel = options.useChannelIndex === null ? 0 : options.useChannelIndex;
-        for (let i = 0, y = 0; y < height; y++) {
-            for (let x = 0; x < width; x++, i++) {
-                const elevationValue = (options.noDataValue && channel[pixel] === options.noDataValue) ? options.terrainMinValue : channel[pixel] * options.multiplier;
-                terrain[i + y] = elevationValue;
+        const isStitched = width === 257;
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                let elevationValue = (options.noDataValue && channel[pixel] === options.noDataValue) ? options.terrainMinValue : channel[pixel] * options.multiplier;
+                // Validate that the elevation value is within the valid range for Float32.
+                // Extreme values (like -1.79e308) can become -Infinity when cast, causing WebGL errors.
+                if (Number.isNaN(elevationValue) || elevationValue < -3.4e38 || elevationValue > 3.4e38) {
+                    elevationValue = options.terrainMinValue;
+                }
+                // If stitched (257), fill linearly. If 256, fill with stride for padding.
+                const index = isStitched ? (y * width + x) : (y * (width + 1) + x);
+                terrain[index] = elevationValue;
                 pixel += numOfChannels;
             }
         }
-        if (options.tesselator === 'martini') {
+        if (!isStitched) {
             // backfill bottom border
             for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {
                 terrain[i] = terrain[i - width - 1];
@@ -5655,22 +5662,26 @@ class GeoImage {
  * @returns {{vertices: Uint16Array, triangles: Uint32Array}} vertices and triangles data
  */
 function getMartiniTileMesh(meshMaxError, width, terrain) {
-    const gridSize = width + 1;
+    const gridSize = width === 257 ? 257 : width + 1;
     const martini = new Martini(gridSize);
     const tile = martini.createTile(terrain);
     const { vertices, triangles } = tile.getMesh(meshMaxError);
     return { vertices, triangles };
 }
 function getMeshAttributes(vertices, terrain, width, height, bounds) {
-    const gridSize = width + 1;
+    const gridSize = width === 257 ? 257 : width + 1;
     const numOfVerticies = vertices.length / 2;
     // vec3. x, y in pixels, z in meters
     const positions = new Float32Array(numOfVerticies * 3);
     // vec2. 1 to 1 relationship with position. represents the uv on the texture image. 0,0 to 1,1.
     const texCoords = new Float32Array(numOfVerticies * 2);
     const [minX, minY, maxX, maxY] = bounds || [0, 0, width, height];
-    const xScale = (maxX - minX) / width;
-    const yScale = (maxY - minY) / height;
+    // If stitched (257), the spatial extent covers 0..256 pixels, so we divide by 256.
+    // If standard (256), the spatial extent covers 0..256 pixels (with backfill), so we divide by 256.
+    const effectiveWidth = width === 257 ? width - 1 : width;
+    const effectiveHeight = height === 257 ? height - 1 : height;
+    const xScale = (maxX - minX) / effectiveWidth;
+    const yScale = (maxY - minY) / effectiveHeight;
     for (let i = 0; i < numOfVerticies; i++) {
         const x = vertices[i * 2];
         const y = vertices[i * 2 + 1];
@@ -5678,8 +5689,8 @@ function getMeshAttributes(vertices, terrain, width, height, bounds) {
         positions[3 * i + 0] = x * xScale + minX;
         positions[3 * i + 1] = -y * yScale + maxY;
         positions[3 * i + 2] = terrain[pixelIdx];
-        texCoords[2 * i + 0] = x / width;
-        texCoords[2 * i + 1] = y / height;
+        texCoords[2 * i + 0] = x / effectiveWidth;
+        texCoords[2 * i + 1] = y / effectiveHeight;
     }
     return {
         POSITION: { value: positions, size: 3 },
@@ -5697,7 +5708,9 @@ function getMeshAttributes(vertices, terrain, width, height, bounds) {
  * @returns {{vertices: number[], triangles: number[]}} vertices and triangles data
  */
 function getDelatinTileMesh(meshMaxError, width, height, terrain) {
-    const tin = new Delatin(terrain, width + 1, height + 1);
+    const widthPlus = width === 257 ? 257 : width + 1;
+    const heightPlus = height === 257 ? 257 : height + 1;
+    const tin = new Delatin(terrain, widthPlus, heightPlus);
     tin.run(meshMaxError);
     // @ts-expect-error: Delatin instance properties 'coords' and 'triangles' are not explicitly typed in the library port
     const { coords, triangles } = tin;
@@ -5765,16 +5778,15 @@ class CogTiles {
         return this.bounds;
     }
     getLatLon(input) {
-        const ax = EARTH_HALF_CIRCUMFERENCE + input[0];
-        const ay = -(EARTH_HALF_CIRCUMFERENCE + (input[1] - EARTH_CIRCUMFERENCE));
-        const cartesianPosition = [
-            ax * (512 / EARTH_CIRCUMFERENCE),
-            ay * (512 / EARTH_CIRCUMFERENCE),
-        ];
-        const cartographicPosition = webMercator.worldToLngLat(cartesianPosition);
-        const cartographicPositionAdjusted = [cartographicPosition[0], -cartographicPosition[1]];
-        return cartographicPositionAdjusted;
-    }
+        const x = input[0];
+        const y = input[1];
+        const lon = (x / EARTH_HALF_CIRCUMFERENCE) * 180;
+        let lat = (y / EARTH_HALF_CIRCUMFERENCE) * 180;
+        lat = (180 / Math.PI) * (2 * Math.atan(Math.exp((lat * Math.PI) / 180)) - Math.PI / 2);
+        return [lon, lat];
+    }
+    // return cartographicPositionAdjusted;
+    // }
     /**
      * Builds lookup tables for zoom levels and estimated resolutions from a Cloud Optimized GeoTIFF (COG) object.
      *
@@ -5843,7 +5855,7 @@ class CogTiles {
         }
         return exactMatchIndex;
     }
-    async getTileFromImage(tileX, tileY, zoom) {
+    async getTileFromImage(tileX, tileY, zoom, fetchSize) {
         const imageIndex = this.getImageIndexForZoomLevel(zoom);
         const targetImage = await this.cog.getImage(imageIndex);
         // 1. Validation: Ensure the image is tiled
@@ -5877,12 +5889,11 @@ class CogTiles {
         const windowMinY = (imgOriginY - tileMaxYMeters) / imageResolution;
         // 6. Snap to Integer Grid (The "Force 256" Fix)
         // We round the start position to align with the nearest pixel.
-        // Crucially, we calculate endX/endY by adding tileSize to startX/startY.
-        // This guarantees the window is exactly 256x256, preventing "off-by-one" (257px) errors.
+        const FETCH_SIZE = fetchSize || TILE_SIZE; // Default to 256 if not provided
         const startX = Math.round(windowMinX);
         const startY = Math.round(windowMinY);
-        const endX = startX + TILE_SIZE;
-        const endY = startY + TILE_SIZE;
+        const endX = startX + FETCH_SIZE;
+        const endY = startY + FETCH_SIZE;
         // --- STEP 3: CALCULATE INTERSECTION ---
         // 7. Clamp the read window to the actual image dimensions
         // This defines the "Safe" area we can actually read from the file.
@@ -5894,7 +5905,7 @@ class CogTiles {
         const readHeight = validReadMaxY - validReadY;
         // CHECK: If no overlap, return empty
         if (readWidth <= 0 || readHeight <= 0) {
-            return [this.createEmptyTile()];
+            return [this.createEmptyTile(FETCH_SIZE)];
         }
         // 8. Calculate Offsets (Padding)
         // "missingLeft" is how many blank pixels we need to insert before the image data starts.
@@ -5906,10 +5917,11 @@ class CogTiles {
         // --- STEP 4: READ AND COMPOSITE ---
         // Case A: Partial Overlap (Padding or Cropping required)
         // If the tile is hanging off the edge, we need to manually reconstruct it.
-        if (missingLeft > 0 || missingTop > 0 || readWidth < tileWidth || readHeight < tileHeight) {
+        // We strictly compare against FETCH_SIZE because that is our target buffer dimension.
+        if (missingLeft > 0 || missingTop > 0 || readWidth < FETCH_SIZE || readHeight < FETCH_SIZE) {
             /// Initialize a temporary buffer for a single band (filled with NoData)
             // We will reuse this buffer for each band to save memory allocations.
-            const tileBuffer = this.createTileBuffer(this.options.format, tileWidth);
+            const tileBuffer = this.createTileBuffer(this.options.format, FETCH_SIZE);
             tileBuffer.fill(this.options.noDataValue);
             // if the valid window is smaller than the tile size, it gets the image size width and height, thus validRasterData.width must be used as below
             const validRasterData = await targetImage.readRasters({ window });
@@ -5919,21 +5931,26 @@ class CogTiles {
             validImageData.fill(this.options.noDataValue);
             // Place the valid pixel data into the tile buffer.
             for (let band = 0; band < validRasterData.length; band += 1) {
+                // We must reset the buffer for each band, otherwise data from previous band persists in padding areas
+                const tileBuffer = this.createTileBuffer(this.options.format, FETCH_SIZE);
+                if (this.options.noDataValue !== undefined) {
+                    tileBuffer.fill(this.options.noDataValue);
+                }
                 for (let row = 0; row < readHeight; row += 1) {
                     const destRow = missingTop + row;
-                    const destRowOffset = destRow * TILE_SIZE;
+                    const destRowOffset = destRow * FETCH_SIZE;
                     const srcRowOffset = row * validRasterData.width;
                     for (let col = 0; col < readWidth; col += 1) {
                         // Compute the destination position in the tile buffer.
                         // We shift by the number of missing pixels (if any) at the top/left.
                         const destCol = missingLeft + col;
-                        // Bounds Check: Ensure we don't write outside the 256x256 buffer
-                        if (destRow < tileWidth && destCol < tileHeight) {
+                        // Bounds Check: Ensure we don't write outside the allocated buffer
+                        if (destRow < FETCH_SIZE && destCol < FETCH_SIZE) {
                             tileBuffer[destRowOffset + destCol] = validRasterData[band][srcRowOffset + col];
                         }
                         else {
                             /* eslint-disable no-console */
-                            console.log('error in assigning data to tile buffer');
+                            console.log(`error in assigning data to tile buffer: destRow ${destRow}, destCol ${destCol}, FETCH_SIZE ${FETCH_SIZE}`);
                         }
                     }
                 }
@@ -5952,28 +5969,28 @@ class CogTiles {
     }
     /**
      * 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() {
-        // 1. Determine the size
-        // Default to 1 channel (grayscale) if not specified
+    createEmptyTile(size) {
+        const s = size || this.tileSize; // Defaults to 256
         const channels = this.options.numOfChannels || 1;
-        const size = this.tileSize * this.tileSize * channels;
-        // 2. Create the array
-        // Float32 is standard for GeoTIFF data handling in browsers
-        const tileData = new Float32Array(size);
-        // 3. Fill with "No Data" value
-        // If noDataValue is undefined, it defaults to 0
+        const totalSize = s * s * channels;
+        const tileData = new Float32Array(totalSize);
         if (this.options.noDataValue !== undefined) {
             tileData.fill(this.options.noDataValue);
         }
         return tileData;
     }
     async getTile(x, y, z, bounds, meshMaxError) {
-        const tileData = await this.getTileFromImage(x, y, z);
+        let requiredSize = this.tileSize; // Default 256 for image/bitmap
+        if (this.options.type === 'terrain') {
+            requiredSize = this.tileSize + 1; // 257 for stitching
+        }
+        const tileData = await this.getTileFromImage(x, y, z, requiredSize);
         return this.geo.getMap({
             rasters: [tileData[0]],
-            width: this.tileSize,
-            height: this.tileSize,
+            width: requiredSize,
+            height: requiredSize,
             bounds,
         }, this.options, meshMaxError);
     }
@@ -6078,7 +6095,8 @@ class CogTiles {
             case 'Float64':
                 return new Float64Array(length);
             default:
-                throw new Error(`Unsupported data type: ${dataType}`);
+                console.warn(`Unsupported data type: ${dataType}, defaulting to Float32`);
+                return new Float32Array(length);
         }
     }
 }