Skip to content

Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.

fix: retain zero endpoints in dynamic raster coloring (#3954)

Igor Dykhta62b88b1aad00
diff --git a/src/layers/src/raster-tile/raster-tile-utils.ts b/src/layers/src/raster-tile/raster-tile-utils.ts
index b6bb4777d..7ac9fc993 100644
--- a/src/layers/src/raster-tile/raster-tile-utils.ts
+++ b/src/layers/src/raster-tile/raster-tile-utils.ts
@@ -414,7 +414,7 @@ export function getSingleBandPresetOptions(
* @returns [minPixelValue, maxPixelValue]
*/
export function getMinMaxFromTile2DHeaders(tiles: (Tile2DHeader | null)[]): [number, number] {
- const minValues: (number | null)[] = tiles
+ const minValues: number[] = tiles
.map((tile: Tile2DHeader | null) => {
if (!tile || !tile.data) {
return null;
@@ -422,8 +422,8 @@ export function getMinMaxFromTile2DHeaders(tiles: (Tile2DHeader | null)[]): [num
const {minPixelValue} = tile.data;
return minPixelValue;
})
- .filter(value => value);
- const maxValues: (number | null)[] = tiles
+ .filter((value): value is number => Number.isFinite(value));
+ const maxValues: number[] = tiles
.map((tile: Tile2DHeader | null) => {
if (!tile || !tile.data) {
return null;
@@ -431,9 +431,8 @@ export function getMinMaxFromTile2DHeaders(tiles: (Tile2DHeader | null)[]): [num
const {maxPixelValue} = tile.data;
return maxPixelValue;
})
- .filter(value => value);
- // We can cast to number[] because we have filtered null values
- return [Math.min(...(minValues as number[])), Math.max(...(maxValues as number[]))];
+ .filter((value): value is number => Number.isFinite(value));
+ return [Math.min(...minValues), Math.max(...maxValues)];
}
/**
diff --git a/test/browser/layer-tests/raster-tile-layer-specs.js b/test/browser/layer-tests/raster-tile-layer-specs.js
index 116187bcf..7ed0dedf1 100644
--- a/test/browser/layer-tests/raster-tile-layer-specs.js
+++ b/test/browser/layer-tests/raster-tile-layer-specs.js
@@ -394,6 +394,78 @@ test('#RasterTileLayer -> pixel value tracking', t => {
t.end();
});
+test('#RasterTileLayer -> dynamic coloring keeps finite zero endpoints', t => {
+ const layer = new RasterTileLayer({id: 'dynamic-raster', dataId: 'stac-data'});
+ layer.updateLayerVisConfig({dynamicColor: true, preset: 'singleBand', singleBandName: 'red'});
+ const dataset = {
+ ...MOCK_STAC_DATASET,
+ metadata: {
+ ...MOCK_STAC_METADATA,
+ assets: Object.fromEntries(
+ Object.entries(MOCK_STAC_METADATA.assets).map(([id, asset]) => [
+ id,
+ {
+ ...asset,
+ 'raster:bands': [{data_type: 'float32', statistics: {minimum: -100, maximum: 100}}]
+ }
+ ])
+ )
+ }
+ };
+ const tile = (minPixelValue, maxPixelValue) => ({data: {minPixelValue, maxPixelValue}});
+ const cases = [
+ {name: 'zero minimum', tiles: [tile(0, 10), tile(5, 20)], range: [0, 20]},
+ {name: 'zero maximum', tiles: [tile(-10, 0), tile(-5, -2)], range: [-10, 0]},
+ {name: 'negative endpoints', tiles: [tile(-20, -10), tile(-15, -5)], range: [-20, -5]},
+ {name: 'all-zero tiles', tiles: [tile(0, 0), tile(0, 0)], range: [0, 0]},
+ {name: 'normal nonzero endpoints', tiles: [tile(5, 10), tile(8, 20)], range: [5, 20]},
+ {
+ name: 'missing and nonfinite endpoints',
+ tiles: [
+ null,
+ {},
+ {data: null},
+ {data: {}},
+ tile(null, undefined),
+ tile(NaN, NaN),
+ tile(-Infinity, Infinity),
+ tile(0, 10)
+ ],
+ range: [0, 10]
+ },
+ {
+ name: 'independent valid endpoints',
+ tiles: [tile(0, null), tile(undefined, 0)],
+ range: [0, 0]
+ },
+ {name: 'zero tile removed from viewport', tiles: [tile(5, 20)], range: [5, 20]},
+ {name: 'zero tile enters viewport again', tiles: [tile(0, 10), tile(5, 20)], range: [0, 20]},
+ {name: 'all tiles removed', tiles: [], range: [Infinity, -Infinity]},
+ {
+ name: 'only invalid statistics',
+ tiles: [null, {}, {data: {}}, tile(NaN, Infinity), tile(-Infinity, null)],
+ range: [Infinity, -Infinity]
+ }
+ ];
+
+ for (const {name, tiles, range} of cases) {
+ layer.onViewportLoad(tiles);
+ t.deepEqual(
+ [layer.minViewportPixelValue, layer.maxViewportPixelValue],
+ range,
+ `${name}: tracks the current viewport range`
+ );
+ const [rendered] = layer.renderLayer(createRenderOpts(dataset));
+ t.ok(rendered, `${name}: creates the raster TileLayer`);
+ t.deepEqual(
+ [rendered?.props.minPixelValue, rendered?.props.maxPixelValue],
+ range,
+ `${name}: forwards the range for dynamic rendering`
+ );
+ }
+ t.end();
+});
+
test('#RasterTileLayer -> findDefaultLayerProps', t => {
// Test with raster dataset
const result = RasterTileLayer.findDefaultLayerProps(MOCK_STAC_DATASET);