Skip to content

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

fix(table): honor disabled GPU filters (#3928)

Igor Dykhtafe92d51387b4
diff --git a/src/table/src/gpu-filter-utils.ts b/src/table/src/gpu-filter-utils.ts
index 7a6028165..00f82f0ca 100644
--- a/src/table/src/gpu-filter-utils.ts
+++ b/src/table/src/gpu-filter-utils.ts
@@ -310,6 +310,7 @@ function findFilterOnGpuChannel(
return filters.find(
f =>
f.gpu &&
+ f.enabled !== false &&
!isNumericIntervalFilter(f) &&
f.dataId.includes(dataId) &&
f.gpuChannel &&
@@ -325,6 +326,7 @@ function findFilterOnGpuEndChannel(
return filters.find(
f =>
f.gpu &&
+ f.enabled !== false &&
!isNumericIntervalFilter(f) &&
f.dataId.includes(dataId) &&
f.gpuEndChannel &&
diff --git a/src/utils/src/filter-utils.ts b/src/utils/src/filter-utils.ts
index 466974924..e1434fb15 100644
--- a/src/utils/src/filter-utils.ts
+++ b/src/utils/src/filter-utils.ts
@@ -983,7 +983,7 @@ export function diffFilters(
filterChanged = set([record, filter.id], 'added', filterChanged);
} else {
// check what has changed
- ['name', 'endName', 'value', 'dataId', 'inverted'].forEach(prop => {
+ ['name', 'endName', 'value', 'dataId', 'inverted', 'enabled'].forEach(prop => {
if (filter[prop] !== oldFilter[prop]) {
filterChanged = set([record, filter.id], `${prop}_changed`, filterChanged);
}
diff --git a/test/node/reducers/vis-state-test.js b/test/node/reducers/vis-state-test.js
index 7b3c9532f..08599df85 100644
--- a/test/node/reducers/vis-state-test.js
+++ b/test/node/reducers/vis-state-test.js
@@ -28,6 +28,7 @@ import {
setFilterAnimationWindowUpdater,
calculateLayerData
} from '@kepler.gl/reducers';
+import {formatCsv} from '../../../src/reducers/src/export-utils';
import {
processCsvData,
@@ -48,6 +49,7 @@ import {
import {copyTableAndUpdate, findPointFieldPairs, maybeToDate, KeplerTable} from '@kepler.gl/table';
import {
createDataContainer,
+ createIndexedDataContainer,
applyFilterFieldName,
getAnimatableVisibleLayers,
getBinThresholds,
@@ -7550,6 +7552,71 @@ test('#visStateReducer -> APPLY_CPU_FILTER has gpu filter', t => {
t.end();
});
+test('#visStateReducer -> SET_FILTER.enabled refreshes export rows and color domains', t => {
+ for (const gpu of [true, false]) {
+ const dataId = 'filter-enablement';
+ const rows = [0, 10, 20, 30].map((value, index) => [
+ 1 + index,
+ 30 + index,
+ value,
+ index === 3 ? 'exclude' : 'keep'
+ ]);
+ const dataset = new KeplerTable({info: {id: dataId}, color: [1, 2, 3]});
+ dataset.importData({
+ data: {
+ fields: ['lat', 'lng', 'value', 'group'].map(name => ({
+ name,
+ type: name === 'group' ? 'string' : 'real'
+ })),
+ rows
+ }
+ });
+ const {props} = PointLayer.findDefaultLayerProps(dataset);
+ const layer = new PointLayer({id: 'filtered-points', dataId, ...props[0]});
+ layer.updateLayerConfig({colorField: dataset.fields[2], colorScale: 'linear'});
+ let state = {
+ ...INITIAL_VIS_STATE,
+ datasets: {[dataId]: dataset},
+ layers: [layer],
+ layerData: []
+ };
+ const apply = action => {
+ state = reducer(state, action);
+ };
+ apply(VisStateActions.addFilter(dataId));
+ apply(VisStateActions.setFilter(0, 'name', 'value'));
+ apply(VisStateActions.setFilter(0, 'value', [5, 15]));
+ apply(VisStateActions.setFilter(0, 'gpu', gpu));
+ apply(VisStateActions.addFilter(dataId));
+ apply(VisStateActions.setFilter(1, 'name', 'group'));
+ apply(VisStateActions.setFilter(1, 'value', ['keep']));
+ t.equal(state.filters[0].gpu, gpu, 'uses the requested filter evaluation mode');
+
+ const check = (label, indexes, domain) => {
+ apply(VisStateActions.applyCPUFilter(dataId));
+ const table = state.datasets[dataId];
+ const exported = createIndexedDataContainer(table.dataContainer, table.filteredIdxCPU);
+ t.equal(
+ formatCsv(exported, table.fields),
+ ['lat,lng,value,group', ...indexes.map(index => rows[index].join(','))].join('\n'),
+ `${gpu ? 'GPU' : 'CPU'}: ${label} exports the matching rows`
+ );
+ t.deepEqual(
+ state.layers[0].config.colorDomain,
+ domain,
+ `${gpu ? 'GPU' : 'CPU'}: ${label} refreshes the color domain`
+ );
+ };
+
+ check('enabled filter populates the caches', [1], [10, 10]);
+ apply(VisStateActions.setFilter(0, 'enabled', false));
+ check('disabled filter preserves the other filter', [0, 1, 2], [0, 20]);
+ apply(VisStateActions.setFilter(0, 'enabled', true));
+ check('re-enabled filter reapplies its saved range', [1], [10, 10]);
+ }
+ t.end();
+});
+
test('#visStateReducer -> APPLY_CPU_FILTER has cpu filter', t => {
const initialState = CloneDeep(StateWFilters.visState);
// dataset has gpu filter
diff --git a/test/node/utils/gpu-filter-utils-test.js b/test/node/utils/gpu-filter-utils-test.js
index 0f297e3e4..221b4dbae 100644
--- a/test/node/utils/gpu-filter-utils-test.js
+++ b/test/node/utils/gpu-filter-utils-test.js
@@ -328,6 +328,35 @@ test('gpuFilterUtils -> getGpuFilterProps unchanged for single-channel filters',
t.equal(gpu.filterValueUpdateTriggers.gpuFilter_1, null);
t.equal(Object.prototype.hasOwnProperty.call(filters[0], 'gpuEndChannel'), false);
+ const row = {index: 1, value: 6};
+ const activeValues = gpu.filterValueAccessor(null)()(row);
+ filters.forEach((filter, index) => {
+ const channel = filter.gpuChannel[0];
+ const disabledFilters = filters.map((f, i) => (i === index ? {...f, enabled: false} : f));
+ const disabled = getGpuFilterProps(disabledFilters, 'ds', fields, gpu);
+ t.deepEqual(
+ disabled.filterRange,
+ gpu.filterRange.map((range, i) => (i === channel ? [0, 0] : range)),
+ `${filter.type}: disabling leaves the other filter range intact`
+ );
+ t.equal(disabled.filterValueUpdateTriggers[`gpuFilter_${channel}`], null);
+ t.deepEqual(
+ disabled.filterValueAccessor(null)()(row),
+ activeValues.map((value, i) => (i === channel ? 0 : value)),
+ `${filter.type}: the disabled channel passes every row`
+ );
+
+ const reenabled = getGpuFilterProps(
+ disabledFilters.map((f, i) => (i === index ? {...f, enabled: true} : f)),
+ 'ds',
+ fields,
+ disabled
+ );
+ t.deepEqual(reenabled.filterRange, gpu.filterRange, `${filter.type}: restores saved ranges`);
+ t.deepEqual(reenabled.filterValueUpdateTriggers, gpu.filterValueUpdateTriggers);
+ t.deepEqual(reenabled.filterValueAccessor(null)()(row), activeValues);
+ });
+
t.end();
});
@@ -368,5 +397,30 @@ test('gpuFilterUtils -> getGpuFilterProps interval overlap ranges', t => {
);
t.equal(gpu.filterValueUpdateTriggers.gpuFilter_1.name, 'end', 'end trigger uses end field');
+ const disabled = getGpuFilterProps([{...filters[0], enabled: false}], 'ds', fields, gpu);
+ t.deepEqual(
+ disabled.filterRange,
+ [
+ [0, 0],
+ [0, 0],
+ [0, 0],
+ [0, 0]
+ ],
+ 'disabling an interval neutralizes both start and end ranges'
+ );
+ t.equal(disabled.filterValueUpdateTriggers.gpuFilter_0, null);
+ t.equal(disabled.filterValueUpdateTriggers.gpuFilter_1, null);
+ const row = {index: 1};
+ t.deepEqual(disabled.filterValueAccessor(null)()(row), [0, 0, 0, 0]);
+
+ const reenabled = getGpuFilterProps([{...filters[0], enabled: true}], 'ds', fields, disabled);
+ t.deepEqual(reenabled.filterRange, gpu.filterRange, 're-enabling restores the interval window');
+ t.deepEqual(reenabled.filterValueUpdateTriggers, gpu.filterValueUpdateTriggers);
+ t.deepEqual(
+ reenabled.filterValueAccessor(null)()(row),
+ [1000, 3000, 0, 0],
+ 're-enabling restores both timestamp accessors'
+ );
+
t.end();
});