Kepler.gl is a powerful open source geospatial analysis tool for large-scale data sets.
feat(filters): add a filter out option (#3817)
Igor Dykhta6a51220150f3
diff --git a/src/components/src/filters/filter-invert-toggle.spec.tsx b/src/components/src/filters/filter-invert-toggle.spec.tsxnew file mode 100644index 000000000..93cd8eace--- /dev/null+++ b/src/components/src/filters/filter-invert-toggle.spec.tsx@@ -0,0 +1,73 @@+// SPDX-License-Identifier: MIT+// Copyright contributors to the kepler.gl project++import React from 'react';+import {act, fireEvent, screen} from '@testing-library/react';++import {renderWithTheme} from 'test/helpers/component-jest-utils';++import FilterInvertToggle from './filter-invert-toggle';++describe('FilterInvertToggle', () => {+ const filter = {+ id: 'rate',+ type: 'multiSelect',+ inverted: false+ };++ test('turns filter out on', () => {+ const setFilter = jest.fn();+ renderWithTheme(<FilterInvertToggle filter={filter as any} idx={1} setFilter={setFilter} />);++ expect(screen.getByRole('checkbox', {name: 'filterManager.filterOut'})).toBeInTheDocument();+ const helpButton = screen.getByRole('button', {+ name: 'Filter out help'+ });+ expect(helpButton).toHaveAttribute('aria-describedby', 'filter-out-hint-rate');+ act(() => helpButton.focus());+ expect(helpButton).toHaveFocus();+ expect(document.getElementById('filter-out-hint-rate')).toHaveTextContent(+ 'filterManager.filterOutHint'+ );+ fireEvent.click(screen.getByRole('checkbox'));++ expect(setFilter).toHaveBeenCalledWith(1, 'inverted', true);+ });++ test('turns filter out off', () => {+ const setFilter = jest.fn();+ renderWithTheme(+ <FilterInvertToggle+ filter={{...filter, inverted: true} as any}+ idx={2}+ setFilter={setFilter}+ />+ );++ fireEvent.click(screen.getByRole('checkbox'));+ expect(setFilter).toHaveBeenCalledWith(2, 'inverted', false);+ });++ test('stays hidden until a field is chosen', () => {+ const setFilter = jest.fn();+ const {container} = renderWithTheme(+ <FilterInvertToggle filter={{id: 'new', type: null} as any} idx={0} setFilter={setFilter} />+ );++ expect(container).toBeEmptyDOMElement();+ });++ test('stays hidden when the dataset cannot run CPU filters', () => {+ const setFilter = jest.fn();+ const {container} = renderWithTheme(+ <FilterInvertToggle+ filter={filter as any}+ idx={0}+ setFilter={setFilter}+ isSupported={false}+ />+ );++ expect(container).toBeEmptyDOMElement();+ });+});diff --git a/src/components/src/filters/filter-invert-toggle.tsx b/src/components/src/filters/filter-invert-toggle.tsxnew file mode 100644index 000000000..54810f5da--- /dev/null+++ b/src/components/src/filters/filter-invert-toggle.tsx@@ -0,0 +1,97 @@+// SPDX-License-Identifier: MIT+// Copyright contributors to the kepler.gl project++import React, {useCallback} from 'react';+import styled from 'styled-components';+import {useIntl} from 'react-intl';+import {FormattedMessage} from '@kepler.gl/localization';+import {Filter} from '@kepler.gl/types';++import Switch from '../common/switch';+import {Help} from '../common/icons';+import {Tooltip} from '../common/styled-components';++const FilterOutRow = styled.div`+ display: flex;+ align-items: center;+ margin-bottom: 4px;+`;++const FilterOutHelp = styled.button.attrs({type: 'button'})`+ display: flex;+ align-items: center;+ margin-left: 6px;+ padding: 0;+ border: 0;+ background: transparent;+ color: ${props => props.theme.labelColor};+ cursor: help;++ &:hover,+ &:focus {+ color: ${props => props.theme.textColorHl};+ }+`;++const FilterOutHelpContent = styled.div`+ width: 220px;+`;++type FilterInvertToggleProps = {+ filter: Filter;+ idx: number;+ setFilter: (idx: number, prop: string, value: boolean) => void;+ isSupported?: boolean;+};++const FilterInvertToggle: React.FC<FilterInvertToggleProps> = ({+ filter,+ idx,+ setFilter,+ isSupported = true+}) => {+ const intl = useIntl();+ const onChange = useCallback(+ (event: React.ChangeEvent<HTMLInputElement>) => {+ setFilter(idx, 'inverted', event.target.checked);+ },+ [idx, setFilter]+ );++ if (!filter.type || !isSupported) {+ return null;+ }++ const tooltipId = `filter-out-hint-${filter.id}`;++ return (+ <FilterOutRow className="filter-panel__filter-out">+ <Switch+ checked={Boolean(filter.inverted)}+ id={`filter-out-${filter.id}`}+ secondary+ label={<FormattedMessage id="filterManager.filterOut" />}+ onChange={onChange}+ />+ <FilterOutHelp+ data-testid="filter-out-help"+ data-tip+ data-for={tooltipId}+ aria-label={intl.formatMessage({+ id: 'filterManager.filterOutHelp',+ defaultMessage: 'Filter out help'+ })}+ aria-describedby={tooltipId}+ >+ <Help height="14px" />+ <Tooltip id={tooltipId} effect="solid" place="top">+ <FilterOutHelpContent>+ <FormattedMessage id="filterManager.filterOutHint" />+ </FilterOutHelpContent>+ </Tooltip>+ </FilterOutHelp>+ </FilterOutRow>+ );+};++export default FilterInvertToggle;diff --git a/src/components/src/filters/filter-panels/filter-panel-with-field-select.tsx b/src/components/src/filters/filter-panels/filter-panel-with-field-select.tsxindex cb6ffa79e..0b3a91823 100644--- a/src/components/src/filters/filter-panels/filter-panel-with-field-select.tsx+++ b/src/components/src/filters/filter-panels/filter-panel-with-field-select.tsx@@ -10,6 +10,7 @@ import FieldSelectorFactory from '../../common/field-selector';import {getSupportedFilterFields} from './new-filter-panel';import {FilterPanelWithFieldSelectComponent} from './types';import {KeplerTable} from '@kepler.gl/table';+import FilterInvertToggle from '../filter-invert-toggle';FieldPanelWithFieldSelectFactory.deps = [FilterPanelHeaderFactory,@@ -85,6 +86,12 @@ function FieldPanelWithFieldSelectFactory(onSelect={onSourceDataSelector}/>)}+ <FilterInvertToggle+ filter={filter}+ idx={idx}+ setFilter={setFilter}+ isSupported={!dataset.disableDataOperation}+ />{children}</StyledFilterContent></>diff --git a/src/components/src/filters/filter-panels/filter-synced-dataset-panel.tsx b/src/components/src/filters/filter-panels/filter-synced-dataset-panel.tsxindex 31a131570..23826f01d 100644--- a/src/components/src/filters/filter-panels/filter-synced-dataset-panel.tsx+++ b/src/components/src/filters/filter-panels/filter-synced-dataset-panel.tsx@@ -23,6 +23,8 @@ const TrashIcon = styled(Trash)``;const SyncedDatasetsArea = styled.div`+ margin-bottom: 12px;+.side-panel-section {margin-bottom: 0;}diff --git a/src/components/src/filters/filter-panels/polygon-filter-panel.tsx b/src/components/src/filters/filter-panels/polygon-filter-panel.tsxindex 3f2164028..7e0ef915f 100644--- a/src/components/src/filters/filter-panels/polygon-filter-panel.tsx+++ b/src/components/src/filters/filter-panels/polygon-filter-panel.tsx@@ -13,6 +13,7 @@ import {StyledFilterPanel} from '../components';import get from 'es-toolkit/compat/get';import {PolygonFilterPanelComponent} from './types';import {KeplerTable} from '@kepler.gl/table';+import FilterInvertToggle from '../filter-invert-toggle';PolygonFilterPanelFactory.deps = [FilterPanelHeaderFactory,@@ -50,6 +51,12 @@ function PolygonFilterPanelFactory(/></FilterPanelHeader><StyledFilterContent className="filter-panel__content">+ <FilterInvertToggle+ filter={filter}+ idx={idx}+ setFilter={setFilter}+ isSupported={filterDatasets.every(dataset => !dataset?.disableDataOperation)}+ /><div className="filter-panel__filter"><PolygonFilter filter={filter} layers={layers} setLayers={onSetLayers} /></div>diff --git a/src/components/src/filters/filter-panels/time-range-filter-panel.tsx b/src/components/src/filters/filter-panels/time-range-filter-panel.tsxindex 1443f6848..7053e4d1f 100644--- a/src/components/src/filters/filter-panels/time-range-filter-panel.tsx+++ b/src/components/src/filters/filter-panels/time-range-filter-panel.tsx@@ -21,6 +21,7 @@ import {ALL_FIELD_TYPES, FILTER_TYPES} from '@kepler.gl/constants';import TimeSyncedFieldSelectorFactory from './time-synced-field-selector';import FilterSyncedDatasetPanelFactory from './filter-synced-dataset-panel';import {FormattedMessage} from '@kepler.gl/localization';+import FilterInvertToggle from '../filter-invert-toggle';const SYNC_FILTER_ID_LENGTH = 2;@@ -120,6 +121,9 @@ function TimeRangeFilterPanelFactory(() => filter.type && !isEnlarged,[filter.type, isEnlarged]);+ const isInversionSupported = filter.dataId.every(+ dataId => !datasets[dataId]?.disableDataOperation+ );const timeline = getTimelineFromFilter(filter);@@ -188,6 +192,12 @@ function TimeRangeFilterPanelFactory(/></SidePanelSection>) : null}+ <FilterInvertToggle+ filter={filter}+ idx={idx}+ setFilter={setFilter}+ isSupported={isInversionSupported}+ />{isHistogramVisible && (<div className="filter-panel__filter"><TimeRangeFilterdiff --git a/src/localization/src/translations/en.ts b/src/localization/src/translations/en.tsindex 7ad9771d9..3e8c5b05d 100644--- a/src/localization/src/translations/en.ts+++ b/src/localization/src/translations/en.ts@@ -407,6 +407,9 @@ export default {timeIntervalEndField: 'End time',timeIntervalEndFieldHint:'Optional. Features stay visible while the playback window overlaps this time span.',+ filterOut: 'Filter out',+ filterOutHelp: 'Filter out help',+ filterOutHint: 'Hide rows that match this filter and keep the rest.',timezone: 'Time Zone',selectTimezone: 'Select display timezone',groupBy: 'Group By',diff --git a/src/reducers/src/vis-state-updaters.ts b/src/reducers/src/vis-state-updaters.tsindex b244a5bd2..b9dba751c 100644--- a/src/reducers/src/vis-state-updaters.ts+++ b/src/reducers/src/vis-state-updaters.ts@@ -69,6 +69,9 @@ import {combineSplitMapsByIndex,computeSplitMapLayers,adjustValueToFilterDomain,+ disableGpuIfInverted,+ filterTypeUsesGpu,+ getPlotBaseIndexByDataId,errorNotification,successNotification,editorFeaturesToFeatureCollection,@@ -1441,7 +1444,11 @@ export function setFilterAnimationWindowUpdater<S extends VisState>(filter.type === FILTER_TYPES.timeRange &&(previousWindow === ANIMATION_WINDOW.interval || animationWindow === ANIMATION_WINDOW.interval)) {- const adjusted = adjustValueToAnimationWindow(state, nextFilter as TimeRangeFilter);+ const adjusted = adjustValueToAnimationWindow(+ state,+ nextFilter as TimeRangeFilter,+ getPlotBaseIndexByDataId(state.datasets, nextFilter, state.layers)+ );if (Array.isArray(adjusted.value) && adjusted.value.every(v => Number.isFinite(v))) {nextFilter = adjusted;}@@ -1558,7 +1565,12 @@ export function setFilterUpdater<S extends VisState>(newState = set(['datasets'], filteredDatasets, newState);// need to update filterPlot after filter Dataset for plot to update on filtered result- const filterWithPLot = updateFilterPlot(newState.datasets, newState.filters[idx]);+ const filterWithPLot = updateFilterPlot(+ newState.datasets,+ newState.filters[idx],+ undefined,+ newState.layers+ );newState = set(['filters', idx], filterWithPLot, newState);@@ -1699,6 +1711,27 @@ function _updateFilterProp(state, filter, prop, value, valueIndex, datasetIds?)break;}+ case 'inverted': {+ const supportsInversion = filter.dataId.every(+ datasetId => !state.datasets[datasetId]?.disableDataOperation+ );+ filter = {+ ...filter,+ inverted: supportsInversion && Boolean(value)+ };+ if (filter.inverted) {+ // GPU range tests can only keep values inside the window.+ filter = disableGpuIfInverted(filter);+ } else if (filterTypeUsesGpu(filter.type)) {+ filter = assignGpuChannel(+ setFilterGpuMode({...filter, gpu: true}, state.filters),+ state.filters+ );+ }+ datasetIdsToFilter = [...filter.dataId];+ break;+ }+case FILTER_UPDATER_PROPS.layerId: {// We need to update only datasetId/s if we have added/removed layers// - check for layerId changes (XOR works because of string values)@@ -1782,7 +1815,7 @@ export const setFilterPlotUpdater = (}}- newFilter = updateFilterPlot(state.datasets, newFilter);+ newFilter = updateFilterPlot(state.datasets, newFilter, undefined, state.layers);return {...state,@@ -6535,8 +6568,15 @@ function adjustTimeFilterInterval(state, filter) {// adjust filterconst timeFormat = getDefaultTimeFormat(interval);const updatedPlotType = {...filter.plotType, interval, timeFormat};- const newFilter = updateTimeFilterPlotType(filter, updatedPlotType, state.datasets);- return adjustValueToAnimationWindow(state, newFilter);+ const plotBaseIndexByDataId = getPlotBaseIndexByDataId(state.datasets, filter, state.layers);+ const newFilter = updateTimeFilterPlotType(+ filter,+ updatedPlotType,+ state.datasets,+ undefined,+ plotBaseIndexByDataId+ );+ return adjustValueToAnimationWindow(state, newFilter, plotBaseIndexByDataId);}// Find dataId from a saved visState property:diff --git a/src/schemas/src/vis-state-schema.ts b/src/schemas/src/vis-state-schema.tsindex a99d7267b..4e8f9ae02 100644--- a/src/schemas/src/vis-state-schema.ts+++ b/src/schemas/src/vis-state-schema.ts@@ -1022,6 +1022,7 @@ export const filterPropsV1 = {syncTimelineMode: null,enabled: null,+ inverted: null,invertTrendColor: null,timezone: null,diff --git a/src/table/src/kepler-table.ts b/src/table/src/kepler-table.tsindex 8295f918f..b629fece8 100644--- a/src/table/src/kepler-table.ts+++ b/src/table/src/kepler-table.ts@@ -9,8 +9,7 @@ import {SORT_ORDER,ALL_FIELD_TYPES,ALTITUDE_FIELDS,- SCALE_TYPES,- FILTER_TYPES+ SCALE_TYPES} from '@kepler.gl/constants';import {RGBColor,@@ -41,8 +40,7 @@ import {getFilterFunction,getFilterProps,getFilterRecord,- getPolygonFilterFunctor,- isValidFilterValue,+ computePolygonFilteredIndexByLayer,mergePolygonLayerIndexes,getNumericFieldDomain,getTimestampFieldDomain,@@ -136,65 +134,6 @@ export function maybeToDate(return isTime ? timeToUnixMilli(value, format) : value;}-/**- * 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;diff --git a/src/types/reducers.d.ts b/src/types/reducers.d.tsindex 096b66e59..b89faad03 100644--- a/src/types/reducers.d.ts+++ b/src/types/reducers.d.ts@@ -171,6 +171,11 @@ export type FilterBase<L extends LineChart> = {dataId: string[];id: string;enabled: boolean;+ /**+ * When true, rows that match the filter are hidden and the rest are kept.+ * Undefined is treated as false so older saved maps stay unchanged.+ */+ inverted?: boolean;// time range filter specificfixedDomain: boolean;diff --git a/src/types/schemas.d.ts b/src/types/schemas.d.tsindex b6863c540..bca249111 100644--- a/src/types/schemas.d.ts+++ b/src/types/schemas.d.ts@@ -27,6 +27,8 @@ export type SavedFilter = {layerId: Filter['layerId'];syncedWithLayerTimeline: Filter['syncedWithLayerTimeline'];syncTimelineMode: Filter['syncTimelineMode'];+ /** Hide rows that match the filter instead of keeping them. */+ inverted?: boolean;};export type MinSavedFilter = RequireFrom<SavedFilter, 'dataId' | 'id' | 'name' | 'type' | 'value'>;export type ParsedFilter = SavedFilter | MinSavedFilter;diff --git a/src/utils/src/filter-utils.ts b/src/utils/src/filter-utils.tsindex 5373a1237..fda2f69ae 100644--- a/src/utils/src/filter-utils.ts+++ b/src/utils/src/filter-utils.ts@@ -45,7 +45,11 @@ import {generateHashId, toArray, notNullorUndefined, getCentroid} from '@kepler.import {DataContainerInterface} from './data-container-interface';import {set} from './utils';import {timeToUnixMilli, unique} from './data-utils';-import {updateTimeFilterPlotType, updateRangeFilterPlotType} from './plot';+import {+ mergePolygonLayerIndexes,+ updateTimeFilterPlotType,+ updateRangeFilterPlotType+} from './plot';import {KeplerTableModel} from './types';export const durationSecond = 1000;@@ -66,7 +70,13 @@ export type FilterResult = {export type FilterChanged = {// eslint-disable-next-line no-unused-vars[key in keyof FilterRecord]: {- [key: string]: 'added' | 'deleted' | 'name_changed' | 'value_changed' | 'dataId_changed';+ [key: string]:+ | 'added'+ | 'deleted'+ | 'name_changed'+ | 'value_changed'+ | 'dataId_changed'+ | 'inverted_changed';} | null;};@@ -386,9 +396,23 @@ export function validateFilterWithData<K extends KeplerTableModel<K, L>, L>(filter: ParsedFilter,layers: L[]): {filter: Filter; dataset: K} {- return filter.type && Object.prototype.hasOwnProperty.call(filterValidators, filter.type)- ? filterValidators[filter.type](datasets[datasetId], filter, layers)- : validateFilter(datasets, datasetId, filter);+ const validated =+ filter.type && Object.prototype.hasOwnProperty.call(filterValidators, filter.type)+ ? filterValidators[filter.type](datasets[datasetId], filter, layers)+ : validateFilter(datasets, datasetId, filter);++ if (validated.filter?.inverted && validated.dataset.disableDataOperation) {+ return {+ ...validated,+ filter: {+ ...validated.filter,+ inverted: false,+ ...(filterTypeUsesGpu(validated.filter.type) ? {gpu: true} : {})+ }+ };+ }++ return validated;}/**@@ -585,6 +609,54 @@ export const getPolygonFilterFunctor = (layer, filter, dataContainer) => {}};+/**+ * Compute the polygon-filtered indexes for each layer on a dataset. Keeping this+ * independent of KeplerTable lets filter plots work with custom table classes.+ */+export function computePolygonFilteredIndexByLayer(+ filters: Filter[],+ layers: any[],+ dataId: string,+ dataContainer: DataContainerInterface,+ baseFilteredIndex: number[]+): Record<string, number[]> {+ const polygonFilters = filters.filter(+ filter =>+ filter.type === FILTER_TYPES.polygon &&+ filter.dataId.includes(dataId) &&+ filter.enabled !== false &&+ isValidFilterValue(filter.type, filter.value)+ );++ if (!polygonFilters.length) {+ return {};+ }++ const result: Record<string, number[]> = {};+ for (const layer of layers.filter(candidate => candidate.config?.dataId === dataId)) {+ const applicableFilters = polygonFilters.filter(+ filter => filter.layerId && filter.layerId.includes(layer.id)+ );++ if (!applicableFilters.length) {+ continue;+ }++ const filterFunctors = applicableFilters.map(filter => {+ const matches = getPolygonFilterFunctor(layer, filter, dataContainer);+ return filter.inverted ? (data: {index: number}) => !matches(data) : matches;+ });+ const filterContext = {index: -1};++ result[layer.id] = baseFilteredIndex.filter(index => {+ filterContext.index = index;+ return filterFunctors.every(fn => fn(filterContext));+ });+ }++ return result;+}+/*** Check if a GeoJSON feature filter can be applied to a layer*/@@ -623,6 +695,22 @@ export function getFilterFunction<L extends {config: {dataId: string | null}; idreturn defaultFunc;}+ const matches = getFilterPredicate(field, dataId, filter, layers, dataContainer, valueAccessor);+ if (!matches) {+ return defaultFunc;+ }+ // Filter out: hide rows the predicate would have kept.+ return filter.inverted ? data => !matches(data) : matches;+}++function getFilterPredicate<L extends {config: {dataId: string | null}; id: string}>(+ field: Field | null,+ dataId: string,+ filter: Filter,+ layers: L[],+ dataContainer: DataContainerInterface,+ valueAccessor: (data: {index: number}) => any+): filterFunction | null {switch (filter.type) {case FILTER_TYPES.range:return data => isInRange(valueAccessor(data), filter.value);@@ -632,7 +720,7 @@ export function getFilterFunction<L extends {config: {dataId: string | null}; idreturn data => valueAccessor(data) === filter.value;case FILTER_TYPES.timeRange: {if (!field) {- return defaultFunc;+ return null;}const mappedValue = get(field, ['filterProps', 'mappedValue']);const accessor = Array.isArray(mappedValue)@@ -650,7 +738,7 @@ export function getFilterFunction<L extends {config: {dataId: string | null}; id}case FILTER_TYPES.polygon: {if (!layers || !layers.length || !filter.layerId) {- return defaultFunc;+ return null;}const layerFilterFunctions = filter.layerId.map(id => layers.find(l => l.id === id))@@ -660,8 +748,24 @@ export function getFilterFunction<L extends {config: {dataId: string | null}; idreturn data => layerFilterFunctions.every(filterFunc => filterFunc(data));}default:- return defaultFunc;+ return null;+ }+}++/**+ * Range and time filters normally run on the GPU, which can only keep values+ * inside a range. An inverted filter has to run on the CPU instead.+ */+export function filterTypeUsesGpu(type: Filter['type']): boolean {+ return type === FILTER_TYPES.range || type === FILTER_TYPES.timeRange;+}++export function disableGpuIfInverted<T extends Filter>(filter: T): T {+ if (!filter?.inverted || (!filter.gpu && !filter.gpuChannel && !filter.gpuEndChannel)) {+ return filter;}+ const {gpuChannel: _gpuChannel, gpuEndChannel: _gpuEndChannel, ...rest} = filter;+ return {...rest, gpu: false} as T;}export function updateFilterDataId(dataId: string | string[]): FilterBase<LineChart> {@@ -709,6 +813,64 @@ export function filterDataByFilterTypes(};}+/**+ * Histogram bins must not include the filter being plotted. GPU filters are+ * already absent from filteredIndex. An inverted filter is on the CPU, so+ * rebuild the index from the other CPU filters.+ */+export function getPlotBaseIndexByDataId(+ datasets: {[id: string]: any},+ filter: Filter,+ layers: any[] = []+): Record<string, number[]> | undefined {+ if (!filter?.id) {+ return undefined;+ }++ const result: Record<string, number[]> = {};+ toArray(filter.dataId).forEach(dataId => {+ const dataset = datasets[dataId];+ const base = dataset ? plotBaseIndexExcludingFilter(dataset, filter) : undefined;+ if (base) {+ const filteredIndexByLayer = computePolygonFilteredIndexByLayer(+ dataset.filterRecord?.fixedDomain || [],+ layers,+ dataset.id,+ dataset.dataContainer,+ base+ );+ result[dataId] = mergePolygonLayerIndexes(base, filteredIndexByLayer);+ }+ });++ return Object.keys(result).length ? result : undefined;+}++function plotBaseIndexExcludingFilter(dataset: any, filter: Filter): number[] | undefined {+ const cpuFilters = dataset.filterRecord?.cpu;+ if (!cpuFilters?.some(f => f.id === filter.id)) {+ return undefined;+ }++ const others = cpuFilters.filter(f => f.id !== filter.id);+ if (!others.length) {+ return dataset.allIndexes || dataset.filteredIndex || [];+ }++ const filterFuncs = others.reduce((acc: {[id: string]: filterFunction}, f) => {+ const datasetIndex = toArray(f.dataId).indexOf(dataset.id);+ const fieldIdx = toArray(f.fieldIdx)[datasetIndex];+ const field = notNullorUndefined(fieldIdx) ? dataset.fields[fieldIdx] : null;+ acc[f.id] = getFilterFunction(field, dataset.id, f, [], dataset.dataContainer);+ return acc;+ }, {});++ return filterDataByFilterTypes(+ {dynamicDomainFilters: null, cpuFilters: others, filterFuncs},+ dataset.dataContainer+ ).filteredIndex;+}+/*** Get a record of filters based on domain type and gpu / cpu*/@@ -764,7 +926,7 @@ export function diffFilters(filterChanged = set([record, filter.id], 'added', filterChanged);} else {// check what has changed- ['name', 'endName', 'value', 'dataId'].forEach(prop => {+ ['name', 'endName', 'value', 'dataId', 'inverted'].forEach(prop => {if (filter[prop] !== oldFilter[prop]) {filterChanged = set([record, filter.id], `${prop}_changed`, filterChanged);}@@ -941,10 +1103,16 @@ export function isInRange(val: any, domain: number[]): boolean {}if (Array.isArray(val)) {- return domain[0] <= val[0] && val[1] <= domain[1];+ return (+ val.length >= 2 &&+ Number.isFinite(val[0]) &&+ Number.isFinite(val[1]) &&+ domain[0] <= val[0] &&+ val[1] <= domain[1]+ );}- return val >= domain[0] && val <= domain[1];+ return Number.isFinite(val) && val >= domain[0] && val <= domain[1];}/**@@ -1051,16 +1219,31 @@ export function getColumnFilterProps<K extends KeplerTableModel<K, L>, L>(export function updateFilterPlot<K extends KeplerTableModel<K, any>>(datasets: {[id: string]: K},filter: Filter,- dataId: string | undefined = undefined+ dataId: string | undefined = undefined,+ layers: any[] = []) {if (dataId) {filter = removeFilterPlot(filter, dataId);}+ const plotBaseIndexByDataId = getPlotBaseIndexByDataId(datasets, filter, layers);+if (filter.type === FILTER_TYPES.timeRange) {- return updateTimeFilterPlotType(filter as TimeRangeFilter, filter.plotType, datasets);+ return updateTimeFilterPlotType(+ filter as TimeRangeFilter,+ filter.plotType,+ datasets,+ dataId,+ plotBaseIndexByDataId+ );} else if (filter.type === FILTER_TYPES.range) {- return updateRangeFilterPlotType(filter as RangeFilter, filter.plotType, datasets);+ return updateRangeFilterPlotType(+ filter as RangeFilter,+ filter.plotType,+ datasets,+ dataId,+ plotBaseIndexByDataId+ );}return filter;}@@ -1183,7 +1366,7 @@ export function applyFilterFieldName<K extends KeplerTableModel<K, L>, L>(}return {- filter: newFilter,+ filter: disableGpuIfInverted(newFilter),dataset};}@@ -1522,7 +1705,7 @@ export function validateFiltersUpdateDatasets<domain});- validated.push(updateFilterPlot(datasets, validatedFilter));+ validated.push(updateFilterPlot(datasets, validatedFilter, undefined, layers));updatedDatasets = {...updatedDatasets,...augmentedDatasetsdiff --git a/src/utils/src/plot.ts b/src/utils/src/plot.tsindex e96312665..2bfca138b 100644--- a/src/utils/src/plot.ts+++ b/src/utils/src/plot.ts@@ -280,7 +280,8 @@ export function histogramFromDomain(export function getTimeBins(filter: TimeRangeFilter,datasets: Datasets,- interval: PlotType['interval']+ interval: PlotType['interval'],+ plotBaseIndexByDataId?: Record<string, number[]>): TimeBins {let bins = filter.timeBins || {};@@ -292,7 +293,12 @@ export function getTimeBins(const dataset = datasets[dataId];// do not apply current filter- const indexes = runGpuFilterForPlot(dataset, filter);+ const indexes = runGpuFilterForPlot(+ dataset,+ filter,+ undefined,+ plotBaseIndexByDataId?.[dataId]+ );bins = {...bins,@@ -355,11 +361,13 @@ export function getBinThresholds(interval: string, domain: number[]): number[] {* @param dataset* @param filter Histogram filter whose dataId-paired column should be skipped* @param skipFieldNames Extra GPU field names to skip (charts cross-filter). Histogram callers omit this.+ * @param baseIndex CPU base that excludes the plotted filter and already includes polygon filters.*/export function runGpuFilterForPlot<K extends KeplerTableModel<K, L>, L>(dataset: K,filter?: Filter,- skipFieldNames?: string[]+ skipFieldNames?: string[],+ baseIndex?: number[]): number[] {const skipIndexes = getSkipIndexes(dataset, filter, skipFieldNames);@@ -368,8 +376,10 @@ export function runGpuFilterForPlot<K extends KeplerTableModel<K, L>, L>(filteredIndex,filteredIndexByLayer} = dataset;- // Polygon filters are per-layer; plots use the union of targeted layer indices- const plotFilteredIndex = mergePolygonLayerIndexes(filteredIndex, filteredIndexByLayer);+ // Cached polygon indexes were built after the current CPU filter. When that+ // filter is omitted, use the polygon-filtered base reconstructed by the caller.+ const plotFilteredIndex =+ baseIndex ?? mergePolygonLayerIndexes(filteredIndex, filteredIndexByLayer);const getFilterValue = filterValueAccessor(dataset.dataContainer)();const allChannels = Object.keys(filterValueUpdateTriggers)@@ -1003,7 +1013,8 @@ type MinVisStateForAnimationWindow = {export function adjustValueToAnimationWindow<S extends MinVisStateForAnimationWindow>(state: S,- filter: TimeRangeFilter+ filter: TimeRangeFilter,+ plotBaseIndexByDataId?: Record<string, number[]>) {const {plotType,@@ -1012,7 +1023,7 @@ export function adjustValueToAnimationWindow<S extends MinVisStateForAnimationWi} = filter;const interval = plotType.interval || getInitialInterval(filter, state.datasets);- const bins = getTimeBins(filter, state.datasets, interval);+ const bins = getTimeBins(filter, state.datasets, interval, plotBaseIndexByDataId);const datasetBins = bins && Object.keys(bins).length && Object.values(bins)[0][interval];const thresholds = (datasetBins || []).map(b => b.x0);@@ -1084,7 +1095,8 @@ export function updateTimeFilterPlotType(filter: TimeRangeFilter,plotType: TimeRangeFilter['plotType'],datasets: Datasets,- _dataId?: string+ _dataId?: string,+ plotBaseIndexByDataId?: Record<string, number[]>): TimeRangeFilter {let nextFilter = filter;let nextPlotType = plotType;@@ -1103,7 +1115,7 @@ export function updateTimeFilterPlotType(plotType: nextPlotType};- const bins = getTimeBins(nextFilter, datasets, nextPlotType.interval);+ const bins = getTimeBins(nextFilter, datasets, nextPlotType.interval, plotBaseIndexByDataId);nextFilter = {...nextFilter,@@ -1123,7 +1135,12 @@ export function updateTimeFilterPlotType(return nextFilter;}-export function getRangeFilterBins(filter, datasets, numBins) {+export function getRangeFilterBins(+ filter,+ datasets,+ numBins,+ plotBaseIndexByDataId?: Record<string, number[]>+) {const {domain} = filter;if (!filter.dataId) return null;@@ -1138,7 +1155,12 @@ export function getRangeFilterBins(filter, datasets, numBins) {const dataset = datasets[dataId];const field = dataset?.getColumnField(fieldName);if (dataset && field) {- const indexes = runGpuFilterForPlot(dataset, filter);+ const indexes = runGpuFilterForPlot(+ dataset,+ filter,+ undefined,+ plotBaseIndexByDataId?.[dataId]+ );const valueAccessor = index => field.valueAccessor({index});acc[dataId] = histogramFromDomain(domain, indexes, numBins, valueAccessor);}@@ -1151,7 +1173,8 @@ export function updateRangeFilterPlotType(filter: RangeFilter,plotType: RangeFilter['plotType'],datasets: Datasets,- _dataId?: string+ _dataId?: string,+ plotBaseIndexByDataId?: Record<string, number[]>): RangeFilter {const nextFilter = {...filter,@@ -1172,7 +1195,7 @@ export function updateRangeFilterPlotType(return {...filter,plotType,- bins: getRangeFilterBins(nextFilter, datasets, BINS)+ bins: getRangeFilterBins(nextFilter, datasets, BINS, plotBaseIndexByDataId)};}diff --git a/src/utils/src/types.ts b/src/utils/src/types.tsindex 43f8fe763..22ac5c22a 100644--- a/src/utils/src/types.ts+++ b/src/utils/src/types.ts@@ -26,4 +26,5 @@ export interface KeplerTableModel<K, L, F extends Field = any> {};filteredIndex: number[];filteredIndexByLayer?: Record<string, number[]>;+ disableDataOperation?: boolean;}diff --git a/test/node/reducers/vis-state-test.js b/test/node/reducers/vis-state-test.jsindex 8624ba591..6dc6c97dd 100644--- a/test/node/reducers/vis-state-test.js+++ b/test/node/reducers/vis-state-test.js@@ -2771,6 +2771,45 @@ test('#visStateReducer -> SET_FILTER.name', t => {t.end();});+test('#visStateReducer -> SET_FILTER.inverted', t => {+ const oldState = CloneDeep(StateWFilters.visState);+ const dataId = testGeoJsonDataId;+ const allCount = oldState.datasets[dataId].dataContainer.numRows();+ const keptIn = oldState.datasets[dataId].filteredIndex.length;++ t.ok(keptIn > 0 && keptIn < allCount, 'fixture keeps a subset of rows');++ let next = reducer(oldState, VisStateActions.setFilter(1, 'inverted', true));+ let filter = next.filters[1];+ t.equal(filter.inverted, true, 'stores filter out');+ t.equal(filter.type, 'multiSelect', 'category filter stays a multi select');+ t.equal(+ next.datasets[dataId].filteredIndex.length + keptIn,+ allCount,+ 'filter out keeps the rows filter in would hide'+ );++ next = reducer(next, VisStateActions.setFilter(1, 'name', 'ZIP_CODE', 0));+ filter = next.filters[1];+ t.equal(filter.type, 'range', 'numeric field becomes a range filter');+ t.equal(filter.inverted, true, 'filter out survives a field change');+ t.equal(filter.gpu, false, 'an inverted range filter does not use the GPU');++ next = reducer(next, VisStateActions.setFilter(1, 'inverted', false));+ filter = next.filters[1];+ t.equal(filter.inverted, false, 'filter in is the default again');+ t.equal(filter.gpu, true, 'range filters return to the GPU');+ t.deepEqual(filter.gpuChannel, [0], 'a GPU channel is assigned again');++ next.datasets[dataId].disableDataOperation = true;+ next = reducer(next, VisStateActions.setFilter(1, 'inverted', true));+ filter = next.filters[1];+ t.equal(filter.inverted, false, 'GPU-only datasets reject unsupported filter out');+ t.equal(filter.gpu, true, 'GPU-only datasets keep their working GPU filter');++ t.end();+});+test('#visStateReducer -> SET_FILTER.dataId', t => {const oldState = CloneDeep(StateWFilters.visState);const oldFilter = {...oldState.filters[1]};@@ -6124,6 +6163,46 @@ test('#visStateReducer -> POLYGON: intersecting polygons AND on the same layer',t.end();});+test('#visStateReducer -> POLYGON: inverted polygon AND another polygon on the same layer', t => {+ let state = loadDualLonLatPolygonState();+ const startLayer = pointLayerByLat(state, 'start_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.setFilter(0, 'inverted', true));++ t.deepEqual(+ state.datasets.trips.filteredIndexByLayer[startLayer.id],+ [2, 3],+ 'inverted polygon should keep points outside its region'+ );+ t.deepEqual(+ layerDataIndexes(state, startLayer),+ [2, 3],+ 'layer data should use the inverted polygon complement'+ );++ state = reducer(state, VisStateActions.setSelectedFeature(mockEastOverlapPolygon));+ state = reducer(state, VisStateActions.setPolygonFilterLayer(startLayer, mockEastOverlapPolygon));++ t.deepEqual(+ state.datasets.trips.filteredIndexByLayer[startLayer.id],+ [2],+ 'inverted polygon should be ANDed with another polygon on the same layer'+ );+ t.deepEqual(+ layerDataIndexes(state, startLayer),+ [2],+ 'layer data should match the combined polygon filters'+ );++ t.end();+});+test('#visStateReducer -> POLYGON: disjoint polygons AND on the same layer', t => {let state = loadDualLonLatPolygonState();const startLayer = pointLayerByLat(state, 'start_point_lat');diff --git a/test/node/schemas/vis-state-schema-test.js b/test/node/schemas/vis-state-schema-test.jsindex f2c75c318..47eeac839 100644--- a/test/node/schemas/vis-state-schema-test.js+++ b/test/node/schemas/vis-state-schema-test.js@@ -88,6 +88,7 @@ test('#visStateSchema -> v1 -> load layers', t => {test('#visStateSchema -> v1 -> save load filters', t => {const initialState = cloneDeep(StateWFilesFiltersLayerColor);+ initialState.visState.filters[0].inverted = true;const savedState = SchemaManager.getConfigToSave(initialState);// save state@@ -103,6 +104,7 @@ test('#visStateSchema -> v1 -> save load filters', t => {dataId: [testCsvDataId],id: 'hjpn8frza',enabled: true,+ inverted: true,name: ['time'],type: 'timeRange',value: [1474606800000, 1474617600000],diff --git a/test/node/utils/filter-utils-test.js b/test/node/utils/filter-utils-test.jsindex 9bb08534b..5d59b1881 100644--- a/test/node/utils/filter-utils-test.js+++ b/test/node/utils/filter-utils-test.js@@ -4,7 +4,7 @@import test from 'tape';import moment from 'moment';-import {getDatasetFieldIndexForFilter} from '@kepler.gl/table';+import {getDatasetFieldIndexForFilter, KeplerTable} from '@kepler.gl/table';import {isValidFilterValue,@@ -22,7 +22,10 @@ import {createDataContainer,isTimeIntervalFilter,timeWindowOverlapsInterval,- applyTimeFilterEndFieldName+ applyTimeFilterEndFieldName,+ validateFilterWithData,+ disableGpuIfInverted,+ getPlotBaseIndexByDataId} from '@kepler.gl/utils';import {FILTER_TYPES} from '@kepler.gl/constants';@@ -1060,3 +1063,248 @@ test('filterUtils -> applyTimeFilterEndFieldName', t => {t.end();});++test('filterUtils -> getFilterFunction inverted', t => {+ const field = {valueAccessor: d => d.value};+ const range = {type: FILTER_TYPES.range, value: [2, 4], enabled: true};+ const keep = getFilterFunction(field, 'ds', range, [], null);+ const drop = getFilterFunction(field, 'ds', {...range, inverted: true}, [], null);++ t.equal(keep({value: 3}), true, 'keeps values inside the range');+ t.equal(keep({value: 5}), false, 'drops values outside the range');+ t.equal(drop({value: 3}), false, 'filter out hides values inside the range');+ t.equal(drop({value: 5}), true, 'filter out keeps values outside the range');+ t.equal(keep({value: null}), false, 'a null is not coerced to zero by a range filter');+ t.equal(drop({value: null}), true, 'filter out keeps a null that does not match the range');+ t.equal(keep({value: ''}), false, 'an empty value is not coerced to zero by a range filter');+ t.equal(drop({value: ''}), true, 'filter out keeps an empty value that does not match the range');++ const disabled = getFilterFunction(+ field,+ 'ds',+ {...range, inverted: true, enabled: false},+ [],+ null+ );+ t.equal(disabled({value: 5}), true, 'a disabled filter still keeps every row');++ const multi = {type: FILTER_TYPES.multiSelect, value: ['a'], enabled: true};+ const exclude = getFilterFunction(field, 'ds', {...multi, inverted: true}, [], null);+ t.equal(exclude({value: 'a'}), false, 'filter out hides a selected category');+ t.equal(exclude({value: 'b'}), true, 'filter out keeps an unselected category');++ const timeField = {+ valueAccessor: () => null,+ format: '',+ filterProps: {mappedValue: [0, 10, 20]}+ };+ const time = {+ type: FILTER_TYPES.timeRange,+ dataId: ['ds'],+ value: [12, 18],+ enabled: true,+ inverted: true,+ endName: ['end'],+ endMappedValue: [[15, 15, 40]]+ };+ const timeOut = getFilterFunction(timeField, 'ds', time, [], null);+ t.equal(timeOut({index: 1}), false, 'filter out hides an interval that overlaps the window');+ t.equal(timeOut({index: 2}), true, 'filter out keeps an interval outside the window');++ t.end();+});++test('filterUtils -> disableGpuIfInverted', t => {+ const inverted = disableGpuIfInverted({+ inverted: true,+ gpu: true,+ gpuChannel: [0],+ gpuEndChannel: [1],+ type: FILTER_TYPES.range+ });+ t.equal(inverted.gpu, false, 'inverted range filters leave the GPU');+ t.equal(inverted.gpuChannel, undefined, 'should release the GPU channel');+ t.equal(inverted.gpuEndChannel, undefined, 'should release the end channel');++ const kept = disableGpuIfInverted({inverted: false, gpu: true, gpuChannel: [0]});+ t.equal(kept.gpu, true, 'filter in still uses the GPU');+ t.deepEqual(kept.gpuChannel, [0], 'filter in keeps its channel');++ t.end();+});++test('filterUtils -> validateFilterWithData rejects unsupported inversion', t => {+ const dataset = new KeplerTable({+ info: {id: 'remote'},+ color: [0, 0, 0],+ disableDataOperation: true+ });+ dataset.updateSchema({+ fields: [{name: 'value', type: 'real', analyzerType: 'FLOAT'}],+ rows: []+ });++ const {filter} = validateFilterWithData(+ {remote: dataset},+ 'remote',+ {+ ...getDefaultFilter({dataId: ['remote']}),+ name: ['value'],+ type: FILTER_TYPES.range,+ value: [0, 10],+ inverted: true+ },+ []+ );++ t.equal(filter.inverted, false, 'saved filter out is cleared for a GPU-only dataset');+ t.equal(filter.gpu, true, 'the validated range filter remains on the GPU');+ t.end();+});++test('filterUtils -> getPlotBaseIndexByDataId excludes the plotted filter', t => {+ const values = [1, 5, 9];+ const dataContainer = createDataContainer(values.map(v => [v]));+ const field = {valueAccessor: d => dataContainer.valueAt(d.index, 0)};+ const inverted = {+ id: 'self',+ type: FILTER_TYPES.range,+ dataId: ['ds'],+ fieldIdx: [0],+ value: [4, 6],+ inverted: true,+ enabled: true+ };+ const other = {+ id: 'other',+ type: FILTER_TYPES.range,+ dataId: ['ds'],+ fieldIdx: [0],+ value: [0, 8],+ enabled: true+ };+ const dataset = {+ id: 'ds',+ fields: [field],+ dataContainer,+ allIndexes: [0, 1, 2],+ filterRecord: {+ cpu: [inverted, other],+ gpu: [],+ dynamicDomain: [],+ fixedDomain: []+ }+ };++ t.deepEqual(+ getPlotBaseIndexByDataId({ds: dataset}, inverted).ds,+ [0, 1],+ 'histogram index keeps the other filter and ignores the inverted filter itself'+ );+ t.equal(+ getPlotBaseIndexByDataId({ds: dataset}, {id: 'gpu-only', dataId: ['ds']}),+ undefined,+ 'GPU filters are already absent from the CPU index'+ );++ t.end();+});++test('filterUtils -> getPlotBaseIndexByDataId retains polygon filters', t => {+ const dataset = new KeplerTable({info: {id: 'ds'}, color: [0, 0, 0]});+ dataset.updateSchema({+ fields: [+ {name: 'value', type: 'real', analyzerType: 'FLOAT'},+ {name: 'lat', type: 'real', analyzerType: 'FLOAT'},+ {name: 'lng', type: 'real', analyzerType: 'FLOAT'}+ ],+ rows: [+ [1, 12.25, 30.5],+ [5, 12.25, 35.5],+ [9, 14.25, 30.5]+ ]+ });++ const layer = {+ id: 'layer',+ type: 'point',+ config: {dataId: 'ds'},+ getPositionAccessor:+ dataContainer =>+ ({index}) =>+ [dataContainer.valueAt(index, 2), dataContainer.valueAt(index, 1)]+ };+ const inverted = {+ id: 'self',+ type: FILTER_TYPES.range,+ dataId: ['ds'],+ fieldIdx: [0],+ name: ['value'],+ value: [4, 6],+ inverted: true,+ enabled: true,+ gpu: false+ };+ const other = {+ id: 'other',+ type: FILTER_TYPES.range,+ dataId: ['ds'],+ fieldIdx: [0],+ name: ['value'],+ value: [0, 8],+ enabled: true,+ gpu: false+ };+ const polygon = {+ id: 'polygon',+ type: FILTER_TYPES.polygon,+ dataId: ['ds'],+ fieldIdx: [],+ layerId: ['layer'],+ value: mockPolygonFeature,+ enabled: true,+ fixedDomain: true,+ gpu: false+ };++ dataset.filterTable([inverted, other, polygon], [layer]);+ const customTable = {+ id: dataset.id,+ fields: dataset.fields,+ dataContainer: dataset.dataContainer,+ allIndexes: dataset.allIndexes,+ filteredIndex: dataset.filteredIndex,+ filterRecord: dataset.filterRecord+ };++ t.deepEqual(+ getPlotBaseIndexByDataId({ds: customTable}, inverted, [layer]).ds,+ [0],+ 'custom-table histogram base omits itself while keeping CPU and polygon filters'+ );++ t.end();+});++test('filterUtils -> diffFilters notices inverted', t => {+ const filterRecord = {+ dynamicDomain: [],+ fixedDomain: [],+ cpu: [{id: 'aa', name: 'col', value: ['a'], inverted: true}],+ gpu: []+ };+ const oldFilterRecord = {+ dynamicDomain: [],+ fixedDomain: [],+ cpu: [{id: 'aa', name: 'col', value: ['a'], inverted: false}],+ gpu: []+ };++ t.deepEqual(+ diffFilters(filterRecord, oldFilterRecord).cpu,+ {aa: 'inverted_changed'},+ 'toggling filter out should recompute CPU filters'+ );++ t.end();+});diff --git a/test/node/utils/plot-test.js b/test/node/utils/plot-test.jsindex 2dd14937f..078856f61 100644--- a/test/node/utils/plot-test.js+++ b/test/node/utils/plot-test.js@@ -98,6 +98,12 @@ test('Utils -> runGpuFilterForPlot applies polygon layer indexes', t => {'should fall back to filteredIndex when no polygon layer indexes exist');+ t.deepEqual(+ runGpuFilterForPlot(dataset, undefined, undefined, [1, 3]),+ [1, 3],+ 'should plot from an explicit polygon-filtered base instead of stale polygon indexes'+ );+t.end();});