Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.
fix: polygon filtered index per layer, instead of per dataset (#3452)
Igor Dykhtae379e332d48b
diff --git a/src/layers/src/base-layer.ts b/src/layers/src/base-layer.tsindex c46bfa101..cdb23043c 100644--- a/src/layers/src/base-layer.ts+++ b/src/layers/src/base-layer.ts@@ -45,7 +45,7 @@ import {isArrowTable} from '@kepler.gl/utils';import {generateHashId, toArray, notNullorUndefined} from '@kepler.gl/common-utils';-import {Datasets, GpuFilter, KeplerTable} from '@kepler.gl/table';+import {Datasets, GpuFilter, KeplerTable, copyTableAndUpdate} from '@kepler.gl/table';import {AggregatedBin,ColorRange,@@ -1299,11 +1299,12 @@ class Layer implements KeplerLayer {this.meta = {...this.meta, ...meta};}- getDataUpdateTriggers({filteredIndex, id, dataContainer}: KeplerTable): any {+ getDataUpdateTriggers({filteredIndex, filteredIndexByLayer, id, dataContainer}: KeplerTable): any {const {columns} = this.config;+ const layerFilteredIndex = filteredIndexByLayer?.[this.id] ?? filteredIndex;return {- getData: {datasetId: id, dataContainer, columns, filteredIndex},+ getData: {datasetId: id, dataContainer, columns, filteredIndex: layerFilteredIndex},getMeta: {datasetId: id, dataContainer, columns},...(this.config.textLabel || []).reduce((accu, tl, i) => ({@@ -1322,12 +1323,19 @@ class Layer implements KeplerLayer {const layerDataset = datasets[this.config.dataId];const {dataContainer} = layerDataset;- const getPosition = this.getPositionAccessor(dataContainer, layerDataset);+ // Use per-layer polygon-filtered index if available+ const layerFilteredIndex = layerDataset.filteredIndexByLayer?.[this.id];+ const effectiveDataset =+ layerFilteredIndex != null+ ? copyTableAndUpdate(layerDataset, {filteredIndex: layerFilteredIndex})+ : layerDataset;++ const getPosition = this.getPositionAccessor(dataContainer, effectiveDataset);const dataUpdateTriggers = this.getDataUpdateTriggers(layerDataset);const triggerChanged = this.getChangedTriggers(dataUpdateTriggers);if (triggerChanged && (triggerChanged.getMeta || triggerChanged.getData)) {- this.updateLayerMeta(layerDataset, getPosition);+ this.updateLayerMeta(effectiveDataset, getPosition);// reset filteredItemCountthis.filteredItemCount = {};@@ -1339,7 +1347,7 @@ class Layer implements KeplerLayer {// same datadata = oldLayerData.data;} else {- data = this.calculateDataAttribute(layerDataset, getPosition);+ data = this.calculateDataAttribute(effectiveDataset, getPosition);}return {data, triggerChanged};diff --git a/src/layers/src/mapboxgl-layer.ts b/src/layers/src/mapboxgl-layer.tsindex d1b01841c..aa438b5fc 100644--- a/src/layers/src/mapboxgl-layer.ts+++ b/src/layers/src/mapboxgl-layer.ts@@ -82,8 +82,9 @@ class MapboxLayerGL extends Layer {return Array.isArray(filter) && filter.length;}- getDataUpdateTriggers({filteredIndex, gpuFilter, id}: KeplerTable): any {+ getDataUpdateTriggers({filteredIndex, filteredIndexByLayer, gpuFilter, id}: KeplerTable): any {const {columns} = this.config;+ const layerFilteredIndex = filteredIndexByLayer?.[this.id] ?? filteredIndex;const visualChannelFields = Object.values(this.visualChannels).reduce((accu, v) => ({@@ -97,7 +98,7 @@ class MapboxLayerGL extends Layer {getData: {datasetId: id,columns,- filteredIndex,+ filteredIndex: layerFilteredIndex,...visualChannelFields,...gpuFilter.filterValueUpdateTriggers},diff --git a/src/table/src/kepler-table.ts b/src/table/src/kepler-table.tsindex 9ffde6a3e..96fa4e0ec 100644--- a/src/table/src/kepler-table.ts+++ b/src/table/src/kepler-table.ts@@ -9,7 +9,8 @@ import {SORT_ORDER,ALL_FIELD_TYPES,ALTITUDE_FIELDS,- SCALE_TYPES+ SCALE_TYPES,+ FILTER_TYPES} from '@kepler.gl/constants';import {RGBColor,@@ -39,6 +40,9 @@ import {getFilterFunction,getFilterProps,getFilterRecord,+ getPolygonFilterFunctor,+ isValidFilterValue,+ mergePolygonLayerIndexes,getNumericFieldDomain,getTimestampFieldDomain,getLinearDomain,@@ -118,6 +122,67 @@ export function maybeToDate(return Array.isArray(d) ? d[fieldIdx] : dc.valueAt(d.index, fieldIdx);}+/**+ * Compute per-layer filtered indices for polygon filters.+ * Polygon filters are layer-specific: they should only affect the layers listed in filter.layerId.+ * For each layer on this dataset, compute a filtered index that applies only the polygon filters+ * targeting that specific layer. Multiple polygon filters targeting the same layer are ANDed.+ */+function computePolygonFilteredIndexByLayer(+ filters: Filter[],+ layers: Layer[],+ dataId: string,+ dataContainer: DataContainerInterface,+ baseFilteredIndex: number[]+): Record<string, number[]> {+ const polygonFilters = filters.filter(+ f =>+ f.type === FILTER_TYPES.polygon &&+ f.dataId.includes(dataId) &&+ f.enabled !== false &&+ isValidFilterValue(f.type, f.value)+ );++ if (!polygonFilters.length) {+ return {};+ }++ const layersOnDataset = layers.filter(l => l.config?.dataId === dataId);+ const result: Record<string, number[]> = {};++ for (const layer of layersOnDataset) {+ // For each polygon filter, check if this layer is targeted+ const applicableFilters = polygonFilters.filter(+ f => f.layerId && f.layerId.includes(layer.id)+ );++ if (!applicableFilters.length) {+ // This layer is not targeted by any polygon filter - use base index+ continue;+ }++ // Build polygon filter functors for this layer+ const filterFunctors = applicableFilters.map(filter =>+ getPolygonFilterFunctor(layer, filter, dataContainer)+ );++ // Filter the base filtered index: a row passes if it passes ALL polygon filters+ // (each polygon filter already uses this layer's position accessor)+ const layerFilteredIndex: number[] = [];+ const filterContext = {index: -1};+ for (let i = 0; i < baseFilteredIndex.length; i++) {+ filterContext.index = baseFilteredIndex[i];+ if (filterFunctors.every(fn => fn(filterContext))) {+ layerFilteredIndex.push(baseFilteredIndex[i]);+ }+ }++ result[layer.id] = layerFilteredIndex;+ }++ return result;+}+class KeplerTable<F extends Field = Field> {readonly id: string;@@ -134,6 +199,7 @@ class KeplerTable<F extends Field = Field> {filteredIndex: number[] = [];filteredIdxCPU?: number[];filteredIndexForDomain: number[] = [];+ filteredIndexByLayer: Record<string, number[]> = {};fieldPairs: FieldPair[] = [];gpuFilter: GpuFilter;filterRecord?: FilterRecord;@@ -230,6 +296,7 @@ class KeplerTable<F extends Field = Field> {this.allIndexes = allIndexes;this.filteredIndex = allIndexes;this.filteredIndexForDomain = allIndexes;+ this.filteredIndexByLayer = {};this.fieldPairs = findPointFieldPairs(fields);// @ts-expect-error Make sure that fields satisfies F extends Fieldthis.fields = fields;@@ -246,6 +313,7 @@ class KeplerTable<F extends Field = Field> {this.allIndexes = this.dataContainer.getPlainIndex();this.filteredIndex = this.allIndexes;this.filteredIndexForDomain = this.allIndexes;+ this.filteredIndexByLayer = {};return this;}@@ -359,6 +427,7 @@ class KeplerTable<F extends Field = Field> {if (!filters.length) {this.filteredIndex = this.allIndexes;this.filteredIndexForDomain = this.allIndexes;+ this.filteredIndexByLayer = {};return this;}@@ -393,6 +462,15 @@ class KeplerTable<F extends Field = Field> {this.filteredIndexForDomain =filterResult.filteredIndexForDomain || this.filteredIndexForDomain;+ // Compute per-layer filtered indices for polygon filters+ this.filteredIndexByLayer = computePolygonFilteredIndexByLayer(+ filters,+ layers,+ dataId,+ dataContainer,+ this.filteredIndex+ );+return this;}@@ -414,23 +492,31 @@ class KeplerTable<F extends Field = Field> {return this;}+ let baseIndex: number[];+ let indexByLayer: Record<string, number[]>;+// no gpu filterif (!filters.find(f => f.gpu)) {- this.filteredIdxCPU = this.filteredIndex;+ baseIndex = this.filteredIndex;+ indexByLayer = this.filteredIndexByLayer;this.filterRecordCPU = getFilterRecord(this.id, filters, opt);- return this;- }+ } else {+ // make a copy for cpu filtering+ const copied = copyTable(this);- // make a copy for cpu filtering- const copied = copyTable(this);+ copied.filterRecord = this.filterRecordCPU;+ copied.filteredIndex = this.filteredIdxCPU || [];- copied.filterRecord = this.filterRecordCPU;- copied.filteredIndex = this.filteredIdxCPU || [];+ const filtered = copied.filterTable(filters, layers, opt);- const filtered = copied.filterTable(filters, layers, opt);+ baseIndex = filtered.filteredIndex;+ indexByLayer = filtered.filteredIndexByLayer;+ this.filterRecordCPU = filtered.filterRecord;+ }- this.filteredIdxCPU = filtered.filteredIndex;- this.filterRecordCPU = filtered.filterRecord;+ // Polygon filters are applied per-layer (not in filteredIndex). For export, keep rows+ // visible on any polygon-targeted layer.+ this.filteredIdxCPU = mergePolygonLayerIndexes(baseIndex, indexByLayer);return this;}diff --git a/src/utils/src/filter-utils.ts b/src/utils/src/filter-utils.tsindex d2cc3c2b8..22241f419 100644--- a/src/utils/src/filter-utils.ts+++ b/src/utils/src/filter-utils.ts@@ -601,6 +601,12 @@ export function getFilterRecord(filters.forEach(f => {if (isValidFilterValue(f.type, f.value) && toArray(f.dataId).includes(dataId)) {+ // Polygon filters are layer-specific and handled per-layer, not at the dataset level+ if (f.type === FILTER_TYPES.polygon) {+ filterRecord.fixedDomain.push(f);+ return;+ }+(f.fixedDomain || opt.ignoreDomain? filterRecord.fixedDomain: filterRecord.dynamicDomaindiff --git a/src/utils/src/index.ts b/src/utils/src/index.tsindex edcb9e626..46a180b75 100644--- a/src/utils/src/index.ts+++ b/src/utils/src/index.ts@@ -40,6 +40,7 @@ export {histogramFromValues,histogramFromDomain,histogramFromOrdinal,+ mergePolygonLayerIndexes,runGpuFilterForPlot,updateTimeFilterPlotType} from './plot';diff --git a/src/utils/src/plot.ts b/src/utils/src/plot.tsindex e313a11d2..bef9d3bde 100644--- a/src/utils/src/plot.ts+++ b/src/utils/src/plot.ts@@ -40,6 +40,31 @@ import {KeplerTableModel} from './types';// TODO kepler-table module isn't accessible from utils. Add compatible interface to typestype Datasets = any;+/**+ * Merge per-layer polygon-filtered indices into a dataset-level index.+ * When any layers are polygon-filtered, take the union of their indices (a row is kept if it+ * is visible on at least one targeted layer), then intersect with the base index.+ * Used for filtered export and filter plots/histograms.+ */+export function mergePolygonLayerIndexes(+ baseIndex: number[],+ filteredIndexByLayer: Record<string, number[]> = {}+): number[] {+ const layerIndexes = Object.values(filteredIndexByLayer);+ if (!layerIndexes.length) {+ return baseIndex;+ }++ const union = new Set<number>();+ for (const indexes of layerIndexes) {+ for (const idx of indexes) {+ union.add(idx);+ }+ }++ return baseIndex.filter(i => union.has(i));+}+/**** @param thresholds@@ -242,8 +267,11 @@ export function runGpuFilterForPlot<K extends KeplerTableModel<K, L>, L>(const {gpuFilter: {filterValueUpdateTriggers, filterRange, filterValueAccessor},- filteredIndex+ filteredIndex,+ filteredIndexByLayer} = dataset;+ // Polygon filters are per-layer; plots use the union of targeted layer indices+ const plotFilteredIndex = mergePolygonLayerIndexes(filteredIndex, filteredIndexByLayer);const getFilterValue = filterValueAccessor(dataset.dataContainer)();const allChannels = Object.keys(filterValueUpdateTriggers)@@ -251,7 +279,7 @@ export function runGpuFilterForPlot<K extends KeplerTableModel<K, L>, L>(.filter(i => Object.values(filterValueUpdateTriggers)[i]);const skipAll = !allChannels.filter(i => !skipIndexes.includes(i)).length;if (skipAll) {- return filteredIndex;+ return plotFilteredIndex;}const filterData = getFilterDataFunc(@@ -261,7 +289,7 @@ export function runGpuFilterForPlot<K extends KeplerTableModel<K, L>, L>(skipIndexes);- return filteredIndex.filter(filterData);+ return plotFilteredIndex.filter(filterData);}function getSkipIndexes(dataset, filter) {diff --git a/src/utils/src/types.ts b/src/utils/src/types.tsindex 17857ca5d..43f8fe763 100644--- a/src/utils/src/types.ts+++ b/src/utils/src/types.ts@@ -25,4 +25,5 @@ export interface KeplerTableModel<K, L, F extends Field = any> {) => (d: any) => (number | number[])[];};filteredIndex: number[];+ filteredIndexByLayer?: Record<string, number[]>;}diff --git a/test/fixtures/polygon.js b/test/fixtures/polygon.jsindex 7c48c3d25..cd720ebc8 100644--- a/test/fixtures/polygon.js+++ b/test/fixtures/polygon.js@@ -179,6 +179,58 @@ export const mockPolygonData = {}};+/**+ * Closed rectangular polygon in GeoJSON [lng, lat] order.+ */+export function rectPolygonFeature(id, west, south, east, north) {+ return {+ type: 'Feature',+ geometry: {+ type: 'Polygon',+ coordinates: [+ [+ [west, south],+ [east, south],+ [east, north],+ [west, north],+ [west, south]+ ]+ ]+ },+ properties: {+ renderType: 'Polygon',+ isClosed: true+ },+ id+ };+}++/**+ * One dataset with two lon/lat pairs (start + end).+ * start (lng, lat): (10,10), (12,10), (14,10), (12,14)+ * end (lng, lat): (30,10), (32,10), (34,10), (32,14)+ * Row format: [start_lat, start_lng, end_lat, end_lng]+ */+export const mockDualLonLatRows = [+ [10, 10, 10, 30],+ [10, 12, 10, 32],+ [10, 14, 10, 34],+ [14, 12, 14, 32]+];++// Covers start rows 0 and 1; none of the end points+export const mockStartRegionPolygon = rectPolygonFeature('start-region-poly', 9, 9, 13, 11);++// Covers end rows 1 and 2; none of the start points+export const mockEndRegionPolygon = rectPolygonFeature('end-region-poly', 31, 9, 35, 11);++// Overlaps mockStartRegionPolygon on start row 1 only+export const mockEastOverlapPolygon = rectPolygonFeature('east-overlap-poly', 11, 9, 15, 11);++// Disjoint from mockWestOnlyPolygon: start row 0 vs start row 2+export const mockWestOnlyPolygon = rectPolygonFeature('west-only-poly', 9, 9, 11, 11);+export const mockEastOnlyPolygon = rectPolygonFeature('east-only-poly', 13, 9, 15, 11);+export const mockPolygonFeature2 = {type: 'Feature',geometry: {diff --git a/test/helpers/comparison-utils.js b/test/helpers/comparison-utils.jsindex d1d6a729b..def7ac223 100644--- a/test/helpers/comparison-utils.js+++ b/test/helpers/comparison-utils.js@@ -325,7 +325,20 @@ export function cmpColumns(t, expectedColumns, actualColumns, layerName) {export function cmpDataset(t, expectedDataset, actualDataset, opt = {}) {assertDatasetIsTable(t, actualDataset);- cmpObjectKeys(t, expectedDataset, actualDataset, `dataset:${expectedDataset.id}`);+ // filteredIndexByLayer is an internal optimization property, skip in key comparison if not in expected+ const actualKeysForComparison = Object.keys(actualDataset).filter(+ key => key !== 'filteredIndexByLayer' || key in expectedDataset+ );+ const expectedKeysForComparison = Object.keys(expectedDataset);+ t.deepEqual(+ actualKeysForComparison+ .filter(key => actualDataset[key] !== undefined)+ .sort(),+ expectedKeysForComparison+ .filter(key => expectedDataset[key] !== undefined)+ .sort(),+ `dataset:${expectedDataset.id} should have same keys`+ );// test everything except auto generated colorObject.keys(actualDataset)@@ -365,6 +378,15 @@ export function cmpDataset(t, expectedDataset, actualDataset, opt = {}) {);});break;+ case 'filteredIndexByLayer':+ if (key in expectedDataset) {+ t.deepEqual(+ actualDataset[key],+ expectedDataset[key],+ `dataset.${expectedDataset.id}.${key} should be correct`+ );+ }+ break;default:if (key !== 'color' || opt.color) {t.deepEqual(diff --git a/test/node/reducers/vis-state-test.js b/test/node/reducers/vis-state-test.jsindex 994659e9a..f5491b442 100644--- a/test/node/reducers/vis-state-test.js+++ b/test/node/reducers/vis-state-test.js@@ -73,7 +73,17 @@ import {} from 'test/fixtures/geojson';import tripCsvData, {tripCsvDataInfo, expectedCoordinates} from 'test/fixtures/test-trip-csv-data';import tripGeojson, {timeStampDomain, tripDataInfo} from 'test/fixtures/trip-geojson';-import {mockPolygonFeature, mockPolygonFeature2, mockPolygonData} from 'test/fixtures/polygon';+import {+ mockPolygonFeature,+ mockPolygonFeature2,+ mockPolygonData,+ mockDualLonLatRows,+ mockStartRegionPolygon,+ mockEndRegionPolygon,+ mockEastOverlapPolygon,+ mockWestOnlyPolygon,+ mockEastOnlyPolygon+} from 'test/fixtures/polygon';// test helpersimport {@@ -5026,7 +5036,7 @@ test('#visStateReducer -> POLYGON: Create polygon filter', t => {t.equal(newReducer.layerData[0].data.length, 2, 'Layer Point 1 should only show 2 points');- t.equal(newReducer.layerData[1].data.length, 2, 'Layer Point 2 should only show 2 points');+ t.equal(newReducer.layerData[1].data.length, 4, 'Layer Point 2 should show all 4 points (not targeted by filter)');const filterFeature = newReducer.filters[0].value;@@ -5040,9 +5050,9 @@ test('#visStateReducer -> POLYGON: Create polygon filter', t => {t.equal(newReducer.filters[0].layerId.length, 2, 'Should have two values in filter.layerId');- t.equal(newReducer.layerData[0].data.length, 0, 'Layer Point 1 should show 0 points');+ t.equal(newReducer.layerData[0].data.length, 2, 'Layer Point 1 should show 2 points (filtered by its own position)');- t.equal(newReducer.layerData[1].data.length, 0, 'Layer Point 2 show show 0 points');+ t.equal(newReducer.layerData[1].data.length, 0, 'Layer Point 2 should show 0 points (end positions are outside polygon)');// Adding a new dataset - creates extra 4 layersnewReducer = applyActions(reducer, newReducer, [@@ -5079,15 +5089,15 @@ test('#visStateReducer -> POLYGON: Create polygon filter', t => {t.equal(newReducer.layerData[0].data.length,2,- 'Layer Point 1 show 2 points because we removed layer 2'+ 'Layer Point 1 show 2 points because it is still filtered');t.equal(newReducer.layerData[4].data.length, 2, 'Layer Point 5 should 2 points because filtered');t.equal(- newReducer.layerData[2].data.length,- 2,- 'Layer Point 2 should still show 2 filters because layer 1 is still filtered'+ newReducer.layerData[1].data.length,+ 4,+ 'Layer Point 2 should show full data because it was removed from filter');t.end();@@ -5250,8 +5260,18 @@ test('#visStateReducer -> POLYGON: Toggle filter feature', t => {);t.deepEqual(newReducer.datasets.puppy.filteredIndex,+ [0, 1, 2, 3],+ 'The dataset filteredIndex should not be affected by polygon filters'+ );+ t.deepEqual(+ newReducer.datasets.puppy.filteredIndexByLayer[newReducer.layers[0].id],[0, 2],- 'The polygon filter should be applied'+ 'Should have per-layer polygon filtered index'+ );+ t.equal(+ newReducer.layerData[0].data.length,+ 2,+ 'Targeted layer should show polygon-filtered points');newReducer = reducer(newReducer, VisStateActions.toggleFilterFeature(0));@@ -5264,6 +5284,120 @@ test('#visStateReducer -> POLYGON: Toggle filter feature', t => {[0, 1, 2, 3],"The polygon filter shouldn't be applied");+ t.deepEqual(+ newReducer.datasets.puppy.filteredIndexByLayer,+ {},+ 'Per-layer polygon filtered index should be cleared when filter is disabled'+ );+ t.equal(+ newReducer.layerData[0].data.length,+ 4,+ 'Targeted layer should restore full data when polygon filter is disabled'+ );++ t.end();+});++test('#visStateReducer -> APPLY_CPU_FILTER with polygon filter', t => {+ const state = {+ ...INITIAL_VIS_STATE+ };++ const datasets = [+ {+ data: {+ fields: [+ {+ name: 'start_point_lat',+ format: '',+ fieldIdx: 0,+ type: 'real',+ analyzerType: 'FLOAT'+ },+ {+ name: 'start_point_lng',+ format: '',+ fieldIdx: 1,+ type: 'real',+ analyzerType: 'FLOAT'+ },+ {+ name: 'end_point_lat',+ format: '',+ fieldIdx: 2,+ type: 'real',+ analyzerType: 'FLOAT'+ },+ {+ name: 'end_point_lng',+ format: '',+ fieldIdx: 3,+ type: 'real',+ analyzerType: 'FLOAT'+ }+ ],+ rows: mockPolygonData.data+ },+ info: {+ label: 'test.csv',+ size: 144,+ id: 'puppy'+ }+ }+ ];++ let newReducer = applyActions(reducer, state, [+ {+ action: VisStateActions.updateVisData,+ payload: [datasets, {centerMap: true, keepExistingConfig: false}, {}]+ }+ ]);++ newReducer = reducer(newReducer, VisStateActions.setFeatures([mockPolygonFeature]));+ newReducer = reducer(newReducer, VisStateActions.setSelectedFeature(mockPolygonFeature));+ newReducer = reducer(+ newReducer,+ VisStateActions.setPolygonFilterLayer(newReducer.layers[0], mockPolygonFeature)+ );++ const layerId = newReducer.layers[0].id;+ t.deepEqual(+ newReducer.datasets.puppy.filteredIndex,+ [0, 1, 2, 3],+ 'dataset filteredIndex should ignore polygon filters'+ );+ t.deepEqual(+ newReducer.datasets.puppy.filteredIndexByLayer[layerId],+ [0, 2],+ 'per-layer index should keep rows inside the polygon'+ );++ newReducer = reducer(newReducer, VisStateActions.applyCPUFilter('puppy'));++ t.deepEqual(+ newReducer.datasets.puppy.filteredIdxCPU,+ [0, 2],+ 'filtered export should apply polygon filters via per-layer indices'+ );++ // Targeting a second layer whose positions are outside the polygon:+ // export should be the union of both layers' visible rows.+ newReducer = reducer(+ newReducer,+ VisStateActions.setPolygonFilterLayer(newReducer.layers[1], mockPolygonFeature)+ );+ newReducer = reducer(newReducer, VisStateActions.applyCPUFilter('puppy'));++ t.deepEqual(+ newReducer.datasets.puppy.filteredIndexByLayer[newReducer.layers[1].id],+ [],+ 'second layer should have no rows inside the polygon'+ );+ t.deepEqual(+ newReducer.datasets.puppy.filteredIdxCPU,+ [0, 2],+ 'filtered export should keep the union of polygon-visible rows across targeted layers'+ );t.end();});@@ -5412,9 +5546,9 @@ test('#visStateReducer -> POLYGON: setPolygonFilterLayer: H3', t => {const expectedFilteredIndex = [1, 3, 5, 8];t.deepEqual(- newState.datasets['190vdll3di'].filteredIndex,+ newState.datasets['190vdll3di'].filteredIndexByLayer[newState.layers[0].id],expectedFilteredIndex,- 'should filter data based on h3 layer'+ 'should have per-layer polygon filtered index for h3 layer');t.deepEqual(newState.layerData[0].data.map(d => d.index),@@ -5424,6 +5558,208 @@ test('#visStateReducer -> POLYGON: setPolygonFilterLayer: H3', t => {t.end();});+function loadDualLonLatPolygonState() {+ const datasets = [+ {+ data: {+ fields: [+ {+ name: 'start_point_lat',+ format: '',+ fieldIdx: 0,+ type: 'real',+ analyzerType: 'FLOAT'+ },+ {+ name: 'start_point_lng',+ format: '',+ fieldIdx: 1,+ type: 'real',+ analyzerType: 'FLOAT'+ },+ {+ name: 'end_point_lat',+ format: '',+ fieldIdx: 2,+ type: 'real',+ analyzerType: 'FLOAT'+ },+ {+ name: 'end_point_lng',+ format: '',+ fieldIdx: 3,+ type: 'real',+ analyzerType: 'FLOAT'+ }+ ],+ rows: mockDualLonLatRows+ },+ info: {+ label: 'trips.csv',+ size: 144,+ id: 'trips'+ }+ }+ ];++ return applyActions(reducer, {...INITIAL_VIS_STATE}, [+ {+ action: VisStateActions.updateVisData,+ payload: [datasets, {centerMap: true, keepExistingConfig: false}, {}]+ }+ ]);+}++function pointLayerByLat(state, latField) {+ return state.layers.find(+ l => l.type === 'point' && l.config.columns?.lat?.value === latField+ );+}++function layerDataIndexes(state, layer) {+ return state.layerData[state.layers.indexOf(layer)].data.map(d => d.index);+}++test('#visStateReducer -> POLYGON: independent polygons on two layers', t => {+ let state = loadDualLonLatPolygonState();+ const startLayer = pointLayerByLat(state, 'start_point_lat');+ const endLayer = pointLayerByLat(state, 'end_point_lat');++ state = reducer(+ state,+ VisStateActions.setFeatures([mockStartRegionPolygon, mockEndRegionPolygon])+ );+ state = reducer(state, VisStateActions.setSelectedFeature(mockStartRegionPolygon));+ state = reducer(+ state,+ VisStateActions.setPolygonFilterLayer(startLayer, mockStartRegionPolygon)+ );+ state = reducer(state, VisStateActions.setSelectedFeature(mockEndRegionPolygon));+ state = reducer(state, VisStateActions.setPolygonFilterLayer(endLayer, mockEndRegionPolygon));++ t.equal(state.filters.length, 2, 'Should create one polygon filter per feature');+ t.deepEqual(+ state.datasets.trips.filteredIndex,+ [0, 1, 2, 3],+ 'dataset filteredIndex should ignore polygon filters'+ );+ t.deepEqual(+ state.datasets.trips.filteredIndexByLayer[startLayer.id],+ [0, 1],+ 'start layer should keep only points inside the start-region polygon'+ );+ t.deepEqual(+ state.datasets.trips.filteredIndexByLayer[endLayer.id],+ [1, 2],+ 'end layer should keep only points inside the end-region polygon'+ );+ t.deepEqual(+ layerDataIndexes(state, startLayer),+ [0, 1],+ 'start layer data should match its per-layer polygon index'+ );+ t.deepEqual(+ layerDataIndexes(state, endLayer),+ [1, 2],+ 'end layer data should match its per-layer polygon index'+ );++ state = reducer(state, VisStateActions.applyCPUFilter('trips'));+ t.deepEqual(+ state.datasets.trips.filteredIdxCPU,+ [0, 1, 2],+ 'filtered export should be the union of independently visible rows'+ );++ t.end();+});++test('#visStateReducer -> POLYGON: intersecting polygons AND on the same layer', t => {+ let state = loadDualLonLatPolygonState();+ const startLayer = pointLayerByLat(state, 'start_point_lat');+ const endLayer = pointLayerByLat(state, 'end_point_lat');++ state = reducer(+ state,+ VisStateActions.setFeatures([mockStartRegionPolygon, mockEastOverlapPolygon])+ );+ state = reducer(state, VisStateActions.setSelectedFeature(mockStartRegionPolygon));+ state = reducer(+ state,+ VisStateActions.setPolygonFilterLayer(startLayer, mockStartRegionPolygon)+ );+ state = reducer(state, VisStateActions.setSelectedFeature(mockEastOverlapPolygon));+ state = reducer(+ state,+ VisStateActions.setPolygonFilterLayer(startLayer, mockEastOverlapPolygon)+ );++ t.equal(state.filters.length, 2, 'Should create two polygon filters on the same layer');+ t.deepEqual(+ state.filters.map(f => f.layerId),+ [[startLayer.id], [startLayer.id]],+ 'Both polygons should target only the start layer'+ );+ t.deepEqual(+ state.datasets.trips.filteredIndexByLayer[startLayer.id],+ [1],+ 'start layer should keep only the intersection of both polygons'+ );+ t.deepEqual(+ layerDataIndexes(state, startLayer),+ [1],+ 'start layer data should show only the intersecting point'+ );+ t.equal(+ state.datasets.trips.filteredIndexByLayer[endLayer.id],+ undefined,+ 'untargeted end layer should not have a per-layer polygon index'+ );+ t.deepEqual(+ layerDataIndexes(state, endLayer),+ [0, 1, 2, 3],+ 'untargeted end layer should keep all points'+ );++ state = reducer(state, VisStateActions.toggleFilterFeature(1));+ t.deepEqual(+ state.datasets.trips.filteredIndexByLayer[startLayer.id],+ [0, 1],+ 'disabling one polygon should restore the remaining polygon filter'+ );+ t.deepEqual(+ layerDataIndexes(state, startLayer),+ [0, 1],+ 'start layer data should match the remaining polygon'+ );++ t.end();+});++test('#visStateReducer -> POLYGON: disjoint polygons AND on the same layer', t => {+ let state = loadDualLonLatPolygonState();+ const startLayer = pointLayerByLat(state, 'start_point_lat');++ state = reducer(state, VisStateActions.setFeatures([mockWestOnlyPolygon, mockEastOnlyPolygon]));+ state = reducer(state, VisStateActions.setSelectedFeature(mockWestOnlyPolygon));+ state = reducer(state, VisStateActions.setPolygonFilterLayer(startLayer, mockWestOnlyPolygon));+ state = reducer(state, VisStateActions.setSelectedFeature(mockEastOnlyPolygon));+ state = reducer(state, VisStateActions.setPolygonFilterLayer(startLayer, mockEastOnlyPolygon));++ t.deepEqual(+ state.datasets.trips.filteredIndexByLayer[startLayer.id],+ [],+ 'start layer should keep no points when two polygons do not overlap'+ );+ t.deepEqual(+ layerDataIndexes(state, startLayer),+ [],+ 'start layer data should be empty when polygon filters have no intersection'+ );++ t.end();+});+test('#uiStateReducer -> SET_EDITOR_MODE', t => {const newState = reducer(INITIAL_VIS_STATE, VisStateActions.setEditorMode(EDITOR_MODES.EDIT));diff --git a/test/node/utils/plot-test.js b/test/node/utils/plot-test.jsindex 68d4d6bf2..526145dd3 100644--- a/test/node/utils/plot-test.js+++ b/test/node/utils/plot-test.js@@ -2,10 +2,73 @@// Copyright contributors to the kepler.gl projectimport test from 'tape';-import {histogramFromThreshold, histogramFromValues} from '@kepler.gl/utils';+import {+ histogramFromThreshold,+ histogramFromValues,+ mergePolygonLayerIndexes,+ runGpuFilterForPlot+} from '@kepler.gl/utils';const values1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13];+test('Utils -> mergePolygonLayerIndexes', t => {+ const baseIndex = [0, 1, 2, 3];++ t.deepEqual(+ mergePolygonLayerIndexes(baseIndex, {}),+ baseIndex,+ 'should return base index when no layers are polygon-filtered'+ );++ t.deepEqual(+ mergePolygonLayerIndexes(baseIndex, {layerA: [0, 2]}),+ [0, 2],+ 'should keep rows visible on a single targeted layer'+ );++ t.deepEqual(+ mergePolygonLayerIndexes(baseIndex, {layerA: [0, 2], layerB: [1]}),+ [0, 1, 2],+ 'should keep the union of rows visible on any targeted layer'+ );++ t.deepEqual(+ mergePolygonLayerIndexes(baseIndex, {layerA: [], layerB: []}),+ [],+ 'should export no rows when all targeted layers are empty'+ );++ t.end();+});++test('Utils -> runGpuFilterForPlot applies polygon layer indexes', t => {+ const dataset = {+ id: 'puppy',+ filteredIndex: [0, 1, 2, 3],+ filteredIndexByLayer: {layerA: [0, 2]},+ dataContainer: {},+ gpuFilter: {+ filterRange: [],+ filterValueUpdateTriggers: {},+ filterValueAccessor: () => () => () => []+ }+ };++ t.deepEqual(+ runGpuFilterForPlot(dataset),+ [0, 2],+ 'should start plots from polygon-visible rows when filteredIndexByLayer is set'+ );++ t.deepEqual(+ runGpuFilterForPlot({...dataset, filteredIndexByLayer: {}}),+ [0, 1, 2, 3],+ 'should fall back to filteredIndex when no polygon layer indexes exist'+ );++ t.end();+});+test('Utils -> histogramFromThreshold', t => {const thresholds1 = [1, 3, 6, 13];