10939534211

Committed 19 Sep 2024 10:53AM UTC coverage: 70.77% (-0.06%) from 70.829%

Build # 10939534211

Build Type

Pull #2662

github

Committed by

web-flow

Commit Message

Merge c4b999935 into ef32f7119

Pull Request Pull Request #2662: [feat] Layer Column Mode

Run Details

4743 of 7837 branches covered (60.52%)

Branch coverage included in aggregate %.

132 of 176 new or added lines in 18 files covered. (75.0%)

13 existing lines in 6 files now uncovered.

10157 of 13217 relevant lines covered (76.85%)

94.38 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.48

/src/table/src/gpu-filter-utils.ts

// SPDX-License-Identifier: MIT
// Copyright contributors to the kepler.gl project

import moment from 'moment';
import {MAX_GPU_FILTERS, FILTER_TYPES} from '@kepler.gl/constants';
import {Field, Filter} from '@kepler.gl/types';

import {set, toArray, notNullorUndefined, DataContainerInterface} from '@kepler.gl/utils';
import {GpuFilter} from './kepler-table';

/**
 * Set gpu mode based on current number of gpu filters exists
 */
export function setFilterGpuMode(filter: Filter, filters: Filter[]) {
  // filter can be applied to multiple datasets, hence gpu filter mode should also be
  // an array, however, to keep us sane, for now, we only check if there is available channel for every dataId,
  // if all of them has, we set gpu mode to true
  // TODO: refactor filter so we don't keep an array of everything

  filter.dataId.forEach(dataId => {
    const gpuFilters = filters.filter(f => f.dataId.includes(dataId) && f.gpu);

    if (filter.gpu && gpuFilters.length === MAX_GPU_FILTERS) {
      set(['gpu'], false, filter);
    }
  });

  return filter;
}

/**
 * Scan though all filters and assign gpu chanel to gpu filter
 */
export function assignGpuChannels(allFilters: Filter[]) {
  return allFilters.reduce((accu, f, index) => {
    let filters = accu;

    // if gpu is true assign and validate gpu Channel
    if (f.gpu) {
      f = assignGpuChannel(f, accu);
      filters = set([index], f, accu);
    }

    return filters;
  }, allFilters);
}
/**
 * Assign a new gpu filter a channel based on first availability
 */
export function assignGpuChannel(filter: Filter, filters: Filter[]) {
  // find first available channel
  if (!filter.gpu) {
    return filter;
  }

  const gpuChannel = filter.gpuChannel || [];

  filter.dataId.forEach((dataId, datasetIdx) => {
    const findGpuChannel = channel => f => {
      const dataIdx = toArray(f.dataId).indexOf(dataId);
      return (
        f.id !== filter.id && dataIdx > -1 && f.gpu && toArray(f.gpuChannel)[dataIdx] === channel
      );
    };

    if (
      Number.isFinite(gpuChannel[datasetIdx]) &&
      !filters.find(findGpuChannel(gpuChannel[datasetIdx]))
    ) {
      // if value is already assigned and valid
      return;
    }

    let i = 0;

    while (i < MAX_GPU_FILTERS) {
      if (!filters.find(findGpuChannel(i))) {
        gpuChannel[datasetIdx] = i;
        return;
      }
      i++;
    }
  });

  // if cannot find channel for all dataid, set gpu back to false
  // TODO: refactor filter to handle same filter different gpu mode
  if (!gpuChannel.length || !gpuChannel.every(Number.isFinite)) {
    return {
      ...filter,
      gpu: false
    };
  }

  return {
    ...filter,
    gpuChannel
  };
}
/**
 * Edit filter.gpu to ensure that only
 * X number of gpu filers can coexist.
 */
export function resetFilterGpuMode(filters: Filter[]): Filter[] {
  const gpuPerDataset = {};

  return filters.map(f => {
    if (f.gpu) {
      let gpu = true;
      toArray(f.dataId).forEach(dataId => {
        const count = gpuPerDataset[dataId];

        if (count === MAX_GPU_FILTERS) {
          gpu = false;
        } else {
          gpuPerDataset[dataId] = count ? count + 1 : 1;
        }
      });

      if (!gpu) {
        return set(['gpu'], false, f);
      }
    }

    return f;
  });
}

/**
 * Initial filter uniform
 */
function getEmptyFilterRange() {
  return new Array(MAX_GPU_FILTERS).fill(0).map(() => [0, 0]);
}

/**
 * Returns index of the data element.
 * @param {any} d Data element with row index info.
 * @returns number
 */
const defaultGetIndex = d => d.index;

/**
 * Returns value at the specified row from the data container.
 * @param dc Data container.
 * @param d Data element with row index info.
 * @param fieldIndex Column index in the data container.
 * @returns
 */
const defaultGetData = (dc: DataContainerInterface, d: any, fieldIndex: number) => {
  return dc.valueAt(d.index, fieldIndex);
};

/**
 * @param channels
 * @param dataId
 * @param fields
 * @return {Function} getFilterValue
 */
const getFilterValueAccessor =
  (channels: (Filter | undefined)[], dataId: string, fields: any[]) =>
  (dc: DataContainerInterface) =>
  (getIndex = defaultGetIndex, getData = defaultGetData) =>
  d => {
    // for empty channel, value is 0 and min max would be [0, 0]
    const channelValues = channels.map(filter => {
      if (!filter) {
        return 0;
      }
      const fieldIndex = getDatasetFieldIndexForFilter(dataId, filter);
      const field = fields[fieldIndex];

      const value =
        filter.type === FILTER_TYPES.timeRange
          ? field.filterProps && Array.isArray(field.filterProps.mappedValue)
            ? field.filterProps.mappedValue[getIndex(d)]
            : moment.utc(getData(dc, d, fieldIndex)).valueOf()
          : getData(dc, d, fieldIndex);

      return notNullorUndefined(value)
        ? Array.isArray(value)
          ? value.map(v => v - filter.domain?.[0])
          : value - filter.domain?.[0]
        : Number.MIN_SAFE_INTEGER;
    });

    // TODO: can we refactor the above to avoid the transformation below?
    const arrChannel = channelValues.find(v => Array.isArray(v));
    if (Array.isArray(arrChannel)) {
      // Convert info form supported by DataFilterExtension (relevant for TripLayer)
      const vals: number[][] = [];
      // if there are multiple arrays, they should have the same length
      for (let i = 0; i < arrChannel.length; i++) {
        vals.push(channelValues.map(v => (Array.isArray(v) ? v[i] : v)));
      }
      return vals;
    }

    return channelValues;
  };

/**
 * Get filter properties for gpu filtering
 */
export function getGpuFilterProps(filters: Filter[], dataId: string, fields: Field[]): GpuFilter {
  const filterRange = getEmptyFilterRange();
  const triggers = {};

  // array of filter for each channel, undefined, if no filter is assigned to that channel
  const channels: (Filter | undefined)[] = [];

  for (let i = 0; i < MAX_GPU_FILTERS; i++) {
    const filter = filters.find(
      f =>
        f.gpu &&
        f.dataId.includes(dataId) &&
        f.gpuChannel &&
        f.gpuChannel[f.dataId.indexOf(dataId)] === i
    );

    filterRange[i][0] = filter ? filter.value[0] - filter.domain?.[0] : 0;
    filterRange[i][1] = filter ? filter.value[1] - filter.domain?.[0] : 0;

    triggers[`gpuFilter_${i}`] = filter ? filter.name[filter.dataId.indexOf(dataId)] : null;
    channels.push(filter);
  }

  const filterValueAccessor = getFilterValueAccessor(channels, dataId, fields);

  return {
    filterRange,
    filterValueUpdateTriggers: triggers,
    filterValueAccessor
  };
}

/**
 * Return dataset field index from filter.fieldIdx
 * The index matches the same dataset index for filter.dataId
 */
export function getDatasetFieldIndexForFilter(dataId: string, filter: Filter): number {
  const datasetIndex = toArray(filter.dataId).indexOf(dataId);
  if (datasetIndex < 0) {
    return -1;
  }

  const fieldIndex = filter.fieldIdx[datasetIndex];

  return notNullorUndefined(fieldIndex) ? fieldIndex : -1;
}

1	// SPDX-License-Identifier: MIT
2	// Copyright contributors to the kepler.gl project
3
4	import moment from 'moment';
5	import {MAX_GPU_FILTERS, FILTER_TYPES} from '@kepler.gl/constants';
6	import {Field, Filter} from '@kepler.gl/types';
7
8	import {set, toArray, notNullorUndefined, DataContainerInterface} from '@kepler.gl/utils';
9	import {GpuFilter} from './kepler-table';
10
11	/**
12	* Set gpu mode based on current number of gpu filters exists
13	*/
14	export function setFilterGpuMode(filter: Filter, filters: Filter[]) {
15	// filter can be applied to multiple datasets, hence gpu filter mode should also be
16	// an array, however, to keep us sane, for now, we only check if there is available channel for every dataId,
17	// if all of them has, we set gpu mode to true
18	// TODO: refactor filter so we don't keep an array of everything
19
20	filter.dataId.forEach(dataId => {	21✔
21	const gpuFilters = filters.filter(f => f.dataId.includes(dataId) && f.gpu);	36✔
22
23	if (filter.gpu && gpuFilters.length === MAX_GPU_FILTERS) {	21!
24	set(['gpu'], false, filter);	×
25	}
26	});
27
28	return filter;	21✔
29	}
30
31	/**
32	* Scan though all filters and assign gpu chanel to gpu filter
33	*/
34	export function assignGpuChannels(allFilters: Filter[]) {
35	return allFilters.reduce((accu, f, index) => {	49✔
36	let filters = accu;	66✔
37
38	// if gpu is true assign and validate gpu Channel
39	if (f.gpu) {	66✔
40	f = assignGpuChannel(f, accu);	47✔
41	filters = set([index], f, accu);	47✔
42	}
43
44	return filters;	66✔
45	}, allFilters);
46	}
47	/**
48	* Assign a new gpu filter a channel based on first availability
49	*/
50	export function assignGpuChannel(filter: Filter, filters: Filter[]) {
51	// find first available channel
52	if (!filter.gpu) {	74!
53	return filter;	×
54	}
55
56	const gpuChannel = filter.gpuChannel \|\| [];	74✔
57
58	filter.dataId.forEach((dataId, datasetIdx) => {	74✔
59	const findGpuChannel = channel => f => {	100✔
60	const dataIdx = toArray(f.dataId).indexOf(dataId);	297✔
61	return (	297✔
62	f.id !== filter.id && dataIdx > -1 && f.gpu && toArray(f.gpuChannel)[dataIdx] === channel	714✔
63	);
64	};
65
66	if (	78✔
67	Number.isFinite(gpuChannel[datasetIdx]) &&	95✔
68	!filters.find(findGpuChannel(gpuChannel[datasetIdx]))
69	) {
70	// if value is already assigned and valid
71	return;	16✔
72	}
73
74	let i = 0;	62✔
75
76	while (i < MAX_GPU_FILTERS) {	62✔
77	if (!filters.find(findGpuChannel(i))) {	83✔
78	gpuChannel[datasetIdx] = i;	61✔
79	return;	61✔
80	}
81	i++;	22✔
82	}
83	});
84
85	// if cannot find channel for all dataid, set gpu back to false
86	// TODO: refactor filter to handle same filter different gpu mode
87	if (!gpuChannel.length \|\| !gpuChannel.every(Number.isFinite)) {	74✔
88	return {	1✔
89	...filter,
90	gpu: false
91	};
92	}
93
94	return {	73✔
95	...filter,
96	gpuChannel
97	};
98	}
99	/**
100	* Edit filter.gpu to ensure that only
101	* X number of gpu filers can coexist.
102	*/
103	export function resetFilterGpuMode(filters: Filter[]): Filter[] {
104	const gpuPerDataset = {};	47✔
105
106	return filters.map(f => {	47✔
107	if (f.gpu) {	59✔
108	let gpu = true;	40✔
109	toArray(f.dataId).forEach(dataId => {	40✔
110	const count = gpuPerDataset[dataId];	40✔
111
112	if (count === MAX_GPU_FILTERS) {	40✔
113	gpu = false;	1✔
114	} else {
115	gpuPerDataset[dataId] = count ? count + 1 : 1;	39✔
116	}
117	});
118
119	if (!gpu) {	40✔
120	return set(['gpu'], false, f);	1✔
121	}
122	}
123
124	return f;	58✔
125	});
126	}
127
128	/**
129	* Initial filter uniform
130	*/
131	function getEmptyFilterRange() {
132	return new Array(MAX_GPU_FILTERS).fill(0).map(() => [0, 0]);	900✔
133	}
134
135	/**
136	* Returns index of the data element.
137	* @param {any} d Data element with row index info.
138	* @returns number
139	*/
140	const defaultGetIndex = d => d.index;	102✔
141
142	/**
143	* Returns value at the specified row from the data container.
144	* @param dc Data container.
145	* @param d Data element with row index info.
146	* @param fieldIndex Column index in the data container.
147	* @returns
148	*/
149	const defaultGetData = (dc: DataContainerInterface, d: any, fieldIndex: number) => {	10✔
150	return dc.valueAt(d.index, fieldIndex);	13✔
151	};
152
153	/**
154	* @param channels
155	* @param dataId
156	* @param fields
157	* @return {Function} getFilterValue
158	*/
159	const getFilterValueAccessor =
160	(channels: (Filter \| undefined)[], dataId: string, fields: any[]) =>	10✔
161	(dc: DataContainerInterface) =>	225✔
162	(getIndex = defaultGetIndex, getData = defaultGetData) =>	439✔
163	d => {	439✔
164	// for empty channel, value is 0 and min max would be [0, 0]
165	const channelValues = channels.map(filter => {	199✔
166	if (!filter) {	796✔
167	return 0;	597✔
168	}
169	const fieldIndex = getDatasetFieldIndexForFilter(dataId, filter);	199✔
170	const field = fields[fieldIndex];	199✔
171
172	const value =
173	filter.type === FILTER_TYPES.timeRange	199✔
174	? field.filterProps && Array.isArray(field.filterProps.mappedValue)	501!
175	? field.filterProps.mappedValue[getIndex(d)]
176	: moment.utc(getData(dc, d, fieldIndex)).valueOf()
177	: getData(dc, d, fieldIndex);
178
179	return notNullorUndefined(value)	199✔
180	? Array.isArray(value)	143!
NEW 181	? value.map(v => v - filter.domain?.[0])	×
182	: value - filter.domain?.[0]
183	: Number.MIN_SAFE_INTEGER;
184	});
185
186	// TODO: can we refactor the above to avoid the transformation below?
187	const arrChannel = channelValues.find(v => Array.isArray(v));	796✔
188	if (Array.isArray(arrChannel)) {	199!
189	// Convert info form supported by DataFilterExtension (relevant for TripLayer)
NEW 190	const vals: number[][] = [];	×
191	// if there are multiple arrays, they should have the same length
NEW 192	for (let i = 0; i < arrChannel.length; i++) {	×
NEW 193	vals.push(channelValues.map(v => (Array.isArray(v) ? v[i] : v)));	×
194	}
NEW 195	return vals;	×
196	}
197
198	return channelValues;	199✔
199	};
200
201	/**
202	* Get filter properties for gpu filtering
203	*/
204	export function getGpuFilterProps(filters: Filter[], dataId: string, fields: Field[]): GpuFilter {
205	const filterRange = getEmptyFilterRange();	225✔
206	const triggers = {};	225✔
207
208	// array of filter for each channel, undefined, if no filter is assigned to that channel
209	const channels: (Filter \| undefined)[] = [];	225✔
210
211	for (let i = 0; i < MAX_GPU_FILTERS; i++) {	225✔
212	const filter = filters.find(	900✔
213	f =>
214	f.gpu &&	496✔
215	f.dataId.includes(dataId) &&
216	f.gpuChannel &&
217	f.gpuChannel[f.dataId.indexOf(dataId)] === i
218	);
219
220	filterRange[i][0] = filter ? filter.value[0] - filter.domain?.[0] : 0;	900✔
221	filterRange[i][1] = filter ? filter.value[1] - filter.domain?.[0] : 0;	900✔
222
223	triggers[`gpuFilter_${i}`] = filter ? filter.name[filter.dataId.indexOf(dataId)] : null;	900✔
224	channels.push(filter);	900✔
225	}
226
227	const filterValueAccessor = getFilterValueAccessor(channels, dataId, fields);	225✔
228
229	return {	225✔
230	filterRange,
231	filterValueUpdateTriggers: triggers,
232	filterValueAccessor
233	};
234	}
235
236	/**
237	* Return dataset field index from filter.fieldIdx
238	* The index matches the same dataset index for filter.dataId
239	*/
240	export function getDatasetFieldIndexForFilter(dataId: string, filter: Filter): number {
241	const datasetIndex = toArray(filter.dataId).indexOf(dataId);	283✔
242	if (datasetIndex < 0) {	283✔
243	return -1;	2✔
244	}
245
246	const fieldIndex = filter.fieldIdx[datasetIndex];	281✔
247
248	return notNullorUndefined(fieldIndex) ? fieldIndex : -1;	281✔
249	}

keplergl / kepler.gl / 10939534211

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous