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.tsindex 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.tsindex 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.jsindex 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 filterdiff --git a/test/node/utils/gpu-filter-utils-test.js b/test/node/utils/gpu-filter-utils-test.jsindex 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();});