@gisatcz/deckgl-geolib 1.11.0-dev.0 → 1.11.0-dev.10

package/dist/cjs/index.js

@@ -15077,7 +15077,9 @@ class GeoImage {
         }) : undefined;
         for (let i = 0; i < arrayLength; i += 4) {
             let pixelColor = options.nullColor;
-            if (options.noDataValue === undefined || dataArray[pixel] !== options.noDataValue) {
+            // FIXME
+            // eslint-disable-next-line max-len
+            if ((!Number.isNaN(dataArray[pixel])) && (options.noDataValue === undefined || dataArray[pixel] !== options.noDataValue)) {
                 if ((options.clipLow != null && dataArray[pixel] <= options.clipLow)
                     || (options.clipHigh != null && dataArray[pixel] >= options.clipHigh)) {
                     pixelColor = options.clippedColor;
@@ -15113,10 +15115,6 @@ class GeoImage {
                         pixelColor[3] = this.scale(dataArray[pixel], options.colorScaleValueRange[0], options.colorScaleValueRange.slice(-1)[0], 0, 255);
                     }
                 }
-                // If pixel has null value
-            }
-            else if (Number.isNaN(dataArray[pixel])) {
-                pixelColor = [0, 0, 0, 0];
             }
             // FIXME
             // eslint-disable-next-line
@@ -15218,6 +15216,9 @@ function getDelatinTileMesh(meshMaxError, width, height, terrain) {
 
 const EARTH_CIRCUMFERENCE = 40075000.0;
 const EARTH_HALF_CIRCUMFERENCE = 20037500.0;
+const CogTilesGeoImageOptionsDefaults = {
+    blurredTexture: true,
+};
 class CogTiles {
     constructor(options) {
         this.zoomRange = [0, 0];
@@ -15226,7 +15227,7 @@ class CogTiles {
         this.loaded = false;
         this.geo = new GeoImage();
         this.lzw = new LZWDecoder$1();
-        this.options = options;
+        this.options = Object.assign(Object.assign({}, CogTilesGeoImageOptionsDefaults), options);
     }
     initializeCog(url) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -15471,68 +15472,174 @@ class CogTiles {
     }
 }
 
-// let needsRerender: boolean = false;
-// let extent = [0, 0, 0, 0]
+const urlType$1 = {
+    type: 'object',
+    value: null,
+    validate: (value, propType) => (propType.optional && value === null)
+        || typeof value === 'string'
+        || (Array.isArray(value) && value.every((url) => typeof url === 'string')),
+    equal: (value1, value2) => {
+        if (value1 === value2) {
+            return true;
+        }
+        if (!Array.isArray(value1) || !Array.isArray(value2)) {
+            return false;
+        }
+        const len = value1.length;
+        if (len !== value2.length) {
+            return false;
+        }
+        for (let i = 0; i < len; i++) {
+            if (value1[i] !== value2[i]) {
+                return false;
+            }
+        }
+        return true;
+    },
+};
+const defaultProps$1 = Object.assign(Object.assign({}, geoLayers.TileLayer.defaultProps), { 
+    // Image url that encodes height data
+    // elevationData: urlType,
+    // Image url to use as texture
+    // texture: { ...urlType, optional: true },
+    // Martini error tolerance in meters, smaller number -> more detailed mesh
+    // meshMaxError: { type: 'number', value: 4.0 },
+    // Bounding box of the terrain image, [minX, minY, maxX, maxY] in world coordinates
+    bounds: {
+        type: 'array', value: null, optional: true, compare: true,
+    }, rasterData: urlType$1, 
+    // Color to use if texture is unavailable
+    // color: { type: 'color', value: [255, 255, 255] },
+    blurredTexture: true, opacity: 1, clampToTerrain: false, 
+    // Object to decode height data, from (r, g, b) to height in meters
+    // elevationDecoder: {
+    //   type: 'object',
+    //   value: {
+    //     rScaler: 1,
+    //     gScaler: 0,
+    //     bScaler: 0,
+    //     offset: 0,
+    //   },
+    // },
+    // Supply url to local terrain worker bundle. Only required if running offline and cannot access CDN.
+    workerUrl: '' });
+/** Render bitmap texture from cog raster images. */
 class CogBitmapLayer extends core.CompositeLayer {
-    constructor(id, url, options) {
-        super({});
-        // private _isLoaded: boolean;
-        this.id = '';
-        this.id = id;
-        // this.state = {
-        //   initialized: false,
-        // };
-        // this._isLoaded = false;
-        this.cogTiles = new CogTiles(options);
-        this.blurredTexture = options.blurredTexture;
-        this.url = url;
-        // setTimeout(() => {
-        //   this.init(url);
-        // }, 500);
-    }
-    initializeState() {
-        this.state = {
-            initialized: false,
-        };
-        this.init(this.url);
-    }
-    init(url) {
+    // private _isLoaded: boolean;
+    // id = '';
+    // url: string;
+    // static displayName: string;
+    // cogTiles: CogTiles;
+    //
+    // tileSize: number;
+    //
+    initializeState(context) {
+        const _super = Object.create(null, {
+            initializeState: { get: () => super.initializeState }
+        });
         return __awaiter(this, void 0, void 0, function* () {
-            const cog = yield this.cogTiles.initializeCog(url);
-            this.setState({ initialized: true });
-            this.tileSize = this.cogTiles.getTileSize(cog);
-            const zoomRange = this.cogTiles.getZoomRange(cog);
-            [this.minZoom, this.maxZoom] = zoomRange;
+            _super.initializeState.call(this, context);
+            this.setState({
+                bitmapCogTiles: new CogTiles(this.props.cogBitmapOptions),
+                initialized: false,
+            });
+            yield this.init();
+        });
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cog = yield this.state.bitmapCogTiles.initializeCog(this.props.rasterData);
+            const zoomRange = this.state.bitmapCogTiles.getZoomRange(cog);
+            const [minZoom, maxZoom] = zoomRange;
+            this.setState({ initialized: true, minZoom, maxZoom });
+        });
+    }
+    updateState({ props, oldProps }) {
+        const rasterDataChanged = props.rasterData !== oldProps.rasterData;
+        if (rasterDataChanged) {
+            const { rasterData } = props;
+            const isTiled = rasterData
+                && ((Array.isArray(rasterData)
+                    || (rasterData.includes('{x}') && rasterData.includes('{y}'))) || this.props.isTiled);
+            this.setState({ isTiled });
+        }
+        // Reloading for single terrain mesh
+        const shouldReload = rasterDataChanged
+            // || props.meshMaxError !== oldProps.meshMaxError
+            // || props.elevationDecoder !== oldProps.elevationDecoder
+            || props.bounds !== oldProps.bounds;
+        if (!this.state.isTiled && shouldReload) ;
+        // TODO - remove in v9
+        // @ts-ignore
+        if (props.workerUrl) {
+            core.log.removed('workerUrl', 'loadOptions.terrain.workerUrl')();
+        }
+    }
+    getTiledBitmapData(tile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TODO - pass signal to getTile
+            // abort request if signal is aborted
+            const tileData = yield this.state.bitmapCogTiles.getTile(tile.index.x, tile.index.y, tile.index.z);
+            return tileData;
         });
     }
+    renderSubLayers(props) {
+        const SubLayerClass = this.getSubLayerClass('image', layers.BitmapLayer);
+        const { blurredTexture } = this.state.bitmapCogTiles.options;
+        const { opacity, clampToTerrain } = this.props;
+        const { data } = props;
+        if (!data) {
+            return null;
+        }
+        const { bbox: { west, south, east, north, }, } = props.tile;
+        return new SubLayerClass(Object.assign(Object.assign({}, props), { tileSize: this.state.bitmapCogTiles.tileSize }), Object.assign({ data: null, image: data, _instanced: false, bounds: [west, south, east, north], opacity, textureParameters: {
+                minFilter: blurredTexture ? 'linear' : 'nearest',
+                magFilter: blurredTexture ? 'linear' : 'nearest',
+            }, 
+            //  TODO check if works!!!
+            extensions: clampToTerrain ? [new extensions._TerrainExtension()] : [] }, ((clampToTerrain === null || clampToTerrain === void 0 ? void 0 : clampToTerrain.terrainDrawMode)
+            ? { terrainDrawMode: clampToTerrain.terrainDrawMode }
+            : {})));
+    }
     renderLayers() {
-        if (this.cogTiles.cog) {
-            const layer = new geoLayers.TileLayer({
-                id: `${this.id}-${String(performance.now())}`,
-                getTileData: (tileData) => this.cogTiles.getTile(tileData.index.x, tileData.index.y, tileData.index.z),
-                minZoom: this.minZoom,
-                maxZoom: this.maxZoom,
-                tileSize: this.tileSize,
-                maxRequests: 6,
-                extent: this.cogTiles.cog ? this.cogTiles.getBoundsAsLatLon(this.cogTiles.cog) : null,
-                renderSubLayers: (props) => {
-                    var _a, _b, _c, _d, _e, _f, _g;
-                    const { bbox: { west, south, east, north, }, } = props.tile;
-                    return new layers.BitmapLayer(props, Object.assign({ data: null, image: props.data, bounds: [west, south, east, north], opacity: 1, textureParameters: {
-                            minFilter: this.blurredTexture ? 'linear' : 'nearest',
-                            magFilter: this.blurredTexture ? 'linear' : 'nearest',
-                        }, extensions: ((_b = (_a = this.cogTiles) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.clampToTerrain) ? [new extensions._TerrainExtension()] : [] }, (((_e = (_d = (_c = this.cogTiles) === null || _c === void 0 ? void 0 : _c.options) === null || _d === void 0 ? void 0 : _d.clampToTerrain) === null || _e === void 0 ? void 0 : _e.terrainDrawMode)
-                        ? { terrainDrawMode: (_g = (_f = this.cogTiles) === null || _f === void 0 ? void 0 : _f.options) === null || _g === void 0 ? void 0 : _g.clampToTerrain.terrainDrawMode }
-                        : {})));
+        const { rasterData, blurredTexture, opacity, clampToTerrain, 
+        // tileSize,
+        maxRequests, onTileLoad, onTileUnload, onTileError, maxCacheSize, maxCacheByteSize, refinementStrategy, cogBitmapOptions, } = this.props;
+        if (this.state.isTiled && this.state.initialized) {
+            const { tileSize } = this.state.bitmapCogTiles;
+            return new geoLayers.TileLayer(this.getSubLayerProps({
+                id: 'tiles',
+            }), {
+                getTileData: this.getTiledBitmapData.bind(this),
+                renderSubLayers: this.renderSubLayers.bind(this),
+                updateTriggers: {
+                    getTileData: {
+                        // rasterData: urlTemplateToUpdateTrigger(rasterData),
+                        // blurredTexture,
+                        // opacity,
+                        // cogBitmapOptions,
+                        clampToTerrain,
+                    },
                 },
+                extent: this.state.bitmapCogTiles.cog
+                    ? this.state.bitmapCogTiles.getBoundsAsLatLon(this.state.bitmapCogTiles.cog) : null,
+                tileSize,
+                minZoom: this.state.minZoom,
+                maxZoom: this.state.maxZoom,
+                maxRequests,
+                onTileLoad,
+                onTileUnload,
+                onTileError,
+                maxCacheSize,
+                maxCacheByteSize,
+                refinementStrategy,
             });
-            return layer;
         }
         return null;
     }
 }
+CogBitmapLayer.defaultProps = defaultProps$1;
 CogBitmapLayer.layerName = 'CogBitmapLayer';
-CogBitmapLayer.displayName = 'CogBitmapLayer';
 
 // Copyright (c) 2015 - 2017 Uber Technologies, Inc.
 //