Skip to content

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

fix(layers): synchronize sampled Zarr rescale controls (#3970)

Igor Dykhta12e14854d90b
diff --git a/src/layers/src/zarr-layer/zarr-layer.ts b/src/layers/src/zarr-layer/zarr-layer.ts
index a48fd6e65..76a4bbbf5 100644
--- a/src/layers/src/zarr-layer/zarr-layer.ts
+++ b/src/layers/src/zarr-layer/zarr-layer.ts
@@ -515,20 +515,23 @@ export default class ZarrLayer extends Layer {
// Dataset-level statistics describe its default variable, not every variable.
const advertisedRange = variable ? variable.dataRange : metadata.dataRange;
const dataRange = isUsableRange(advertisedRange) ? advertisedRange : null;
- this.visConfigSettings.rescale = {
- ...this.visConfigSettings.rescale,
- range: dataRange ?? DEFAULT_RESCALE,
- step: dataRange ? (dataRange[1] - dataRange[0]) / 100 : 0.01
- };
-
// `meta.variable` still holds the previous render's variable here.
const variableChanged =
this.meta.zarrUrl !== undefined &&
(this.meta.zarrUrl !== metadata.url || this.meta.variable !== variable?.path);
if (variableChanged) {
this._sampledRange = null;
+ // Reject old-source results even before the next render opens the new node.
+ this._getTileData = this._createTileDataLoader();
}
+ const controlRange = dataRange ?? this._sampledRange ?? DEFAULT_RESCALE;
+ this.visConfigSettings.rescale = {
+ ...this.visConfigSettings.rescale,
+ range: controlRange,
+ step: (controlRange[1] - controlRange[0]) / 100
+ };
+
const current = this.config.visConfig?.rescale;
const unset = !isUsableRange(current);
if (variableChanged || unset) {
@@ -731,6 +734,14 @@ export default class ZarrLayer extends Layer {
if (this._getTileData === getTileData && !this._sampledRange && needsSampling) {
this._sampledRange = estimateZarrDataRange(values, nodataValue);
if (this._sampledRange) {
+ // Metadata or a user choice may end automatic mode while the read is pending.
+ if (!isUsableRange(this.config.visConfig.rescale)) {
+ this.visConfigSettings.rescale = {
+ ...this.visConfigSettings.rescale,
+ range: this._sampledRange,
+ step: (this._sampledRange[1] - this._sampledRange[0]) / 100
+ };
+ }
// Earlier constant tiles may already be colored with the provisional
// range. Invalidate their rendered colors without refetching data.
this._onRedrawNeeded?.();
diff --git a/test/browser/components/side-panel/layer-configurator-test.js b/test/browser/components/side-panel/layer-configurator-test.js
index 7e5b110a5..710a46313 100644
--- a/test/browser/components/side-panel/layer-configurator-test.js
+++ b/test/browser/components/side-panel/layer-configurator-test.js
@@ -1200,19 +1200,31 @@ function mountZarrConfigurator(layer, updateLayerVisConfigSpy) {
);
}
-test('Components -> LayerConfigurator -> automatic Zarr range remains editable', t => {
+test('Components -> LayerConfigurator -> automatic Zarr range remains editable', async t => {
const layer = new LayerClasses.zarr({id: 'zarr-layer', dataId: 'zarr_data'});
+ layer.updateLayerMeta(ZARR_DATASET);
+ const variable = ZARR_DATASET.metadata.variables[0];
+ const runtime = await layer._loadRuntime();
+ layer._loadRuntime = async () => ({
+ ...runtime,
+ get: async () => ({data: new Float32Array([250, 320])})
+ });
+ layer._nodeKey = `${ZARR_DATASET.metadata.url}#${variable.path}`;
+ layer._node = {};
const updateLayerVisConfigSpy = sinon.spy();
- const {container, unmount} = renderWithTheme(
- <IntlWrapper>
- <LayerConfigurator
- {...defaultProps}
- layer={layer}
- datasets={{zarr_data: ZARR_DATASET}}
- updateLayerVisConfig={updateLayerVisConfigSpy}
- />
- </IntlWrapper>
+ const configurator = () => (
+ <ThemeProvider theme={theme}>
+ <IntlWrapper>
+ <LayerConfigurator
+ {...defaultProps}
+ layer={layer}
+ datasets={{zarr_data: ZARR_DATASET}}
+ updateLayerVisConfig={updateLayerVisConfigSpy}
+ />
+ </IntlWrapper>
+ </ThemeProvider>
);
+ const {container, unmount, rerender} = render(configurator());
try {
const [minimum, maximum] = container.querySelectorAll('.kg-range-slider__input');
t.equal(minimum.value, '0', 'shows the fallback lower bound while automatic');
@@ -1222,11 +1234,23 @@ test('Components -> LayerConfigurator -> automatic Zarr range remains editable',
null,
'displaying fallback bounds does not select them'
);
- fireEvent.change(minimum, {target: {value: '0.25'}});
+ const [deckLayer] = layer.renderLayer({
+ data: {metadata: ZARR_DATASET.metadata, variable},
+ mapState: {},
+ visible: true,
+ layerCallbacks: {onRedrawNeeded: () => rerender(configurator())}
+ });
+ await act(async () => {
+ await deckLayer.props.getTileData(layer._node, {sliceSpec: [], width: 2, height: 1});
+ });
+ t.equal(minimum.value, '250', 'shows the sampled lower bound after loading');
+ t.equal(maximum.value, '320', 'shows the sampled upper bound after loading');
+ t.equal(layer.config.visConfig.rescale, null, 'sampling keeps automatic range intent');
+ fireEvent.change(minimum, {target: {value: '264'}});
fireEvent.blur(minimum);
t.deepEqual(
updateLayerVisConfigSpy.lastCall.args[0],
- {rescale: [0.25, 1]},
+ {rescale: [264, 320]},
'editing the slider selects an explicit color range'
);
} finally {
diff --git a/test/browser/layer-tests/zarr-layer-specs.js b/test/browser/layer-tests/zarr-layer-specs.js
index eb84fa714..d03fe46f9 100644
--- a/test/browser/layer-tests/zarr-layer-specs.js
+++ b/test/browser/layer-tests/zarr-layer-specs.js
@@ -240,6 +240,19 @@ test('#ZarrLayer -> advertised and explicit 0-1 ranges are not sampled', async t
height: 1
});
const automatic = mode === 'automatic' || mode === 'invalid';
+ t.deepEqual(
+ layer.visConfigSettings.rescale.range,
+ automatic ? [0.25, 0.75] : mode === 'saved' ? [250, 320] : [0, 1],
+ `${mode}: controls follow the advertised or sampled data range`
+ );
+ layer.updateLayerMeta(dataset);
+ if (automatic) {
+ t.deepEqual(
+ layer.visConfigSettings.rescale.range,
+ [0.25, 0.75],
+ 'metadata refresh preserves the sampled control bounds'
+ );
+ }
t.deepEqual(
renderTileColors(deckLayer, tile.values),
automatic ? [0, 0, 0, 255, 255, 255, 255, 255] : expectedColors,
@@ -250,6 +263,81 @@ test('#ZarrLayer -> advertised and explicit 0-1 ranges are not sampled', async t
automatic ? null : [0, 1],
`${mode}: keeps range intent`
);
+ if (automatic) {
+ layer.updateLayerVisConfig({rescale: [0.3, 0.7]});
+ layer.updateLayerMeta(dataset);
+ t.deepEqual(
+ layer.config.visConfig.rescale,
+ [0.3, 0.7],
+ 'keeps a range chosen after sampling'
+ );
+ }
+ }
+ t.end();
+});
+
+test('#ZarrLayer -> pending tiles preserve metadata-refreshed rescale bounds', async t => {
+ for (const rerenderBeforeCompletion of [false, true]) {
+ const variable = {...TEMPERATURE, dataRange: undefined};
+ const dataset = {
+ ...MOCK_ZARR_DATASET,
+ metadata: {...MOCK_ZARR_DATASET.metadata, variables: [variable]}
+ };
+ const layer = new ZarrLayer({dataId: dataset.id});
+ layer.updateLayerMeta(dataset);
+ const runtime = await layer._loadRuntime();
+ let resolveChunk;
+ const chunk = new Promise(resolve => {
+ resolveChunk = resolve;
+ });
+ layer._loadRuntime = async () => ({...runtime, get: () => chunk});
+ layer._nodeKey = `${dataset.metadata.url}#${variable.path}`;
+ layer._node = {};
+ const options = {
+ data: {metadata: dataset.metadata, variable},
+ mapState: {},
+ visible: true
+ };
+ const [deckLayer] = layer.renderLayer(options);
+ const pending = deckLayer.props.getTileData(layer._node, {
+ sliceSpec: [],
+ width: 2,
+ height: 1
+ });
+ await Promise.resolve();
+
+ const refreshedVariable = {...variable, dataRange: [250, 320]};
+ const refreshedDataset = {
+ ...dataset,
+ metadata: {...dataset.metadata, variables: [refreshedVariable]}
+ };
+ layer.updateLayerMeta(refreshedDataset);
+ if (rerenderBeforeCompletion) {
+ layer.renderLayer({
+ ...options,
+ data: {metadata: refreshedDataset.metadata, variable: refreshedVariable}
+ });
+ }
+
+ resolveChunk({data: new Float32Array([260, 300])});
+ const tile = await pending;
+ const timing = rerenderBeforeCompletion ? 'after rerender' : 'before rerender';
+ t.deepEqual(layer.config.visConfig.rescale, [250, 320], `${timing}: keeps the metadata range`);
+ t.deepEqual(
+ layer.visConfigSettings.rescale.range,
+ [250, 320],
+ `${timing}: keeps both configured endpoints reachable`
+ );
+ t.equal(layer.visConfigSettings.rescale.step, 0.7, `${timing}: keeps the refreshed step`);
+ t.deepEqual(Array.from(tile.values), [260, 300], `${timing}: still returns the loaded tile`);
+
+ layer.updateLayerVisConfig({rescale: null});
+ layer.updateLayerMeta(dataset);
+ t.deepEqual(
+ layer.visConfigSettings.rescale.range,
+ [260, 300],
+ `${timing}: reuses loaded samples when automatic mode resumes without advertised bounds`
+ );
}
t.end();
});
@@ -377,16 +465,51 @@ test('#ZarrLayer -> stale tile requests cannot set another source opening color
const b = await render('b');
pending.shift()({data: new Float64Array([100, 200])});
await staleA;
+ t.deepEqual(
+ layer.visConfigSettings.rescale.range,
+ [0, 1],
+ 'a stale source cannot change the current control bounds'
+ );
const freshB = load(b);
await Promise.resolve();
pending.shift()({data: new Float64Array([1, 2])});
await freshB;
+ t.deepEqual(layer.visConfigSettings.rescale.range, [1, 2], 'B supplies its own control bounds');
t.deepEqual(
renderTileColors(b, [1, 2]),
[0, 0, 0, 255, 255, 255, 255, 255],
'B samples its own tiles after A finishes late'
);
+ const pendingBeforeRender = load(await render('a'));
+ await Promise.resolve();
+ layer.updateLayerVisConfig({zarrVariable: 'b'});
+ layer.updateLayerMeta(dataset);
+ pending.shift()({data: new Float64Array([100, 200])});
+ await pendingBeforeRender;
+ t.deepEqual(
+ layer.visConfigSettings.rescale.range,
+ [0, 1],
+ 'switching metadata rejects old bounds before the next render'
+ );
+ t.equal(layer.config.visConfig.rescale, null, 'the new variable stays in automatic mode');
+
+ const constantB = await render('b');
+ const pendingConstantB = load(constantB);
+ await Promise.resolve();
+ pending.shift()({data: new Float64Array([1, 1])});
+ const constantTile = await pendingConstantB;
+ t.deepEqual(
+ layer.visConfigSettings.rescale.range,
+ [0, 1],
+ 'a constant new-variable tile does not leave old-variable bounds on the controls'
+ );
+ t.deepEqual(
+ renderTileColors(constantB, constantTile.values),
+ [255, 255, 255, 255, 255, 255, 255, 255],
+ 'the new variable renders with its own provisional range'
+ );
+
const secondA = await render('a');
const staleSecondA = load(secondA);
await Promise.resolve();
@@ -399,10 +522,16 @@ test('#ZarrLayer -> stale tile requests cannot set another source opening color
await Promise.resolve();
pending.shift()({data: new Float64Array([100, 200])});
await lateInvocation;
+ t.deepEqual(
+ layer.visConfigSettings.rescale.range,
+ [0, 1],
+ 'reopening A clears previous bounds and ignores older requests'
+ );
const freshA = load(thirdA);
await Promise.resolve();
pending.shift()({data: new Float64Array([3, 4])});
await freshA;
+ t.deepEqual(layer.visConfigSettings.rescale.range, [3, 4], 'reopened A supplies fresh bounds');
t.deepEqual(
renderTileColors(thirdA, [3, 4]),
[0, 0, 0, 255, 255, 255, 255, 255],