Skip to content

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.tsx
new file mode 100644
index 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.tsx
new file mode 100644
index 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.tsx
index 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.tsx
index 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.tsx
index 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.tsx
index 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">
<TimeRangeFilter
diff --git a/src/localization/src/translations/en.ts b/src/localization/src/translations/en.ts
index 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.ts
index 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 filter
const 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.ts
index 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.ts
index 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.ts
index 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 specific
fixedDomain: boolean;
diff --git a/src/types/schemas.d.ts b/src/types/schemas.d.ts
index 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.ts
index 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}; id
return 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}; id
return 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}; id
return 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,
...augmentedDatasets
diff --git a/src/utils/src/plot.ts b/src/utils/src/plot.ts
index 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.ts
index 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.js
index 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.js
index 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.js
index 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.js
index 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();
});