11013376001

Committed 24 Sep 2024 12:05PM UTC coverage: 70.805% (+0.1%) from 70.687%

Build # 11013376001

Build Type

push

github

Committed by

web-flow

Commit Message

[Feat] Add neighbor column mode to arc layer, support arc from hex (#2665)

- Cleanup columnMode logic, remove use of `assignColumnsByColumnMode`
- Add neighbor column mode to arc layer
- Support arc from hex_id
- [fix] Ensure Polygon layer filtering in table columns mode works
- [fix] Timestamp in the Trips layer is not required after switching from Polygon

Signed-off-by: Ihor Dykhta <dikhta.igor@gmail.com>

Run Details

4850 of 8001 branches covered (60.62%)

Branch coverage included in aggregate %.

121 of 143 new or added lines in 11 files covered. (84.62%)

2 existing lines in 2 files now uncovered.

10296 of 13390 relevant lines covered (76.89%)

97.14 hits per line

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

71.43

/src/layers/src/trip-layer/trip-layer.ts

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

import memoize from 'lodash.memoize';
import uniq from 'lodash.uniq';
import Layer, {LayerBaseConfig, defaultGetFieldValue} from '../base-layer';
import {TripsLayer as DeckGLTripsLayer} from '@deck.gl/geo-layers';

import {GEOJSON_FIELDS, ColorRange} from '@kepler.gl/constants';
import TripLayerIcon from './trip-layer-icon';

import {
  getGeojsonDataMaps,
  getGeojsonBounds,
  getGeojsonFeatureTypes,
  GeojsonDataMaps,
  detectTableColumns,
  groupColumnsAsGeoJson,
  applyFiltersToTableColumns
} from '../geojson-layer/geojson-utils';

import {isTripGeoJsonField, parseTripGeoJsonTimestamp} from './trip-utils';
import TripInfoModalFactory from './trip-info-modal';
import {bisectRight} from 'd3-array';
import {
  Merge,
  VisConfigColorRange,
  VisConfigNumber,
  VisConfigRange,
  LayerColumn
} from '@kepler.gl/types';
import {default as KeplerTable, Datasets} from '@kepler.gl/table';
import {DataContainerInterface} from '@kepler.gl/utils';

export type TripLayerVisConfigSettings = {
  opacity: VisConfigNumber;
  thickness: VisConfigNumber;
  colorRange: VisConfigColorRange;
  trailLength: VisConfigNumber;
  sizeRange: VisConfigRange;
};

export type TripLayerColumnsConfig = {
  geojson: LayerColumn;
};

export type TripLayerVisConfig = {
  opacity: number;
  thickness: number;
  colorRange: ColorRange;
  trailLength: number;
  sizeRange: [number, number];
};

export type TripLayerConfig = Merge<
  LayerBaseConfig,
  {columns: TripLayerColumnsConfig; visConfig: TripLayerVisConfig}
>;

export type TripLayerMeta = {
  getFeature: any;
};

const zoomFactorValue = 8;

export const defaultThickness = 0.5;
export const defaultLineWidth = 1;

export const tripVisConfigs: {
  opacity: 'opacity';
  thickness: VisConfigNumber;
  colorRange: 'colorRange';
  trailLength: 'trailLength';
  sizeRange: 'strokeWidthRange';
} = {
  opacity: 'opacity',
  thickness: {
    type: 'number',
    defaultValue: defaultThickness,
    label: 'Stroke Width',
    isRanged: false,
    range: [0, 100],
    step: 0.1,
    group: 'stroke',
    property: 'thickness'
  },
  colorRange: 'colorRange',
  trailLength: 'trailLength',
  sizeRange: 'strokeWidthRange'
};

export const featureAccessor =
  ({geojson}: TripLayerColumnsConfig) =>
  (dc: DataContainerInterface) =>
  d =>
    dc.valueAt(d.index, geojson.fieldIdx);
export const featureResolver = ({geojson}: TripLayerColumnsConfig) => geojson.fieldIdx;
const getTableModeValueAccessor = f => {
  // Called from gpu-filter-utils.getFilterValueAccessor()
  return field => f.properties.values.map(v => field.valueAccessor(v));
};
const getTableModeFieldValue = (field, data) => {
  let rv;
  if (typeof data === 'function') {
    rv = data(field);
  } else {
    rv = defaultGetFieldValue(field, data);
  }
  return rv;
};

export const COLUMN_MODE_GEOJSON = 'geojson';
export const COLUMN_MODE_TABLE = 'table';
const SUPPORTED_COLUMN_MODES = [
  {
    key: COLUMN_MODE_GEOJSON,
    label: 'GeoJSON',
    requiredColumns: ['geojson']
  },
  {
    key: COLUMN_MODE_TABLE,
    label: 'Table columns',
    requiredColumns: ['id', 'lat', 'lng', 'timestamp'],
    optionalColumns: ['altitude']
  }
];
const DEFAULT_COLUMN_MODE = COLUMN_MODE_GEOJSON;

export default class TripLayer extends Layer {
  declare visConfigSettings: TripLayerVisConfigSettings;
  declare config: TripLayerConfig;
  declare meta: TripLayerMeta;
  declare dataContainer: DataContainerInterface | null;

  dataToFeature: GeojsonDataMaps;
  dataToTimeStamp: any[];
  getFeature: (columns: TripLayerColumnsConfig) => (dataContainer: DataContainerInterface) => any;
  _layerInfoModal: Record<string, () => JSX.Element>;

  constructor(props) {
    super(props);

    this.dataToFeature = [];
    this.dataToTimeStamp = [];
    this.dataContainer = null;
    this.registerVisConfig(tripVisConfigs);
    this.getFeature = memoize(featureAccessor, featureResolver);
    this._layerInfoModal = {
      [COLUMN_MODE_TABLE]: TripInfoModalFactory(COLUMN_MODE_TABLE),
      [COLUMN_MODE_GEOJSON]: TripInfoModalFactory(COLUMN_MODE_GEOJSON)
    };
  }

  get supportedColumnModes() {
    return SUPPORTED_COLUMN_MODES;
  }

  static get type(): 'trip' {
    return 'trip';
  }
  get type() {
    return TripLayer.type;
  }

  get name(): 'Trip' {
    return 'Trip';
  }

  get layerIcon() {
    return TripLayerIcon;
  }

  get columnPairs() {
    return this.defaultPointColumnPairs;
  }

  accessVSFieldValue(field, indexKey) {
    if (this.config.columnMode === COLUMN_MODE_GEOJSON) {
      return defaultGetFieldValue;
    }
    return getTableModeFieldValue;
  }

  get visualChannels() {
    const visualChannels = super.visualChannels;

    return {
      ...visualChannels,
      color: {
        ...visualChannels.color,
        accessor: 'getColor',
        nullValue: visualChannels.color.nullValue,
        getAttributeValue: config => d => d.properties.lineColor || config.color,
        // used this to get updateTriggers
        defaultValue: config => config.color
      },
      size: {
        ...visualChannels.size,
        property: 'stroke',
        accessor: 'getWidth',
        condition: config => config.visConfig.stroked,
        nullValue: 0,
        getAttributeValue: () => d => d.properties.lineWidth || defaultLineWidth
      }
    };
  }

  get animationDomain() {
    return this.config.animation.domain;
  }

  get layerInfoModal() {
    return {
      [COLUMN_MODE_GEOJSON]: {
        id: 'iconInfo',
        template: this._layerInfoModal[COLUMN_MODE_GEOJSON],
        modalProps: {
          title: 'modal.tripInfo.title'
        }
      },
      [COLUMN_MODE_TABLE]: {
        id: 'iconInfo',
        template: this._layerInfoModal[COLUMN_MODE_TABLE],
        modalProps: {
          title: 'modal.tripInfo.titleTable'
        }
      }
    };
  }

  getPositionAccessor(dataContainer: DataContainerInterface) {
    if (this.config.columnMode === COLUMN_MODE_GEOJSON) {
      return this.getFeature(this.config.columns)(dataContainer);
    }
    return null;
  }

  static findDefaultLayerProps(
    {label, fieldPairs, fields = [], dataContainer, id}: KeplerTable,
    foundLayers: any[]
  ) {
    const geojsonColumns = fields.filter(f => f.type === 'geojson').map(f => f.name);

    const defaultColumns = {
      geojson: uniq([...GEOJSON_FIELDS.geojson, ...geojsonColumns])
    };

    const geoJsonColumns = this.findDefaultColumnField(defaultColumns, fields);

    const tripGeojsonColumns = (geoJsonColumns || []).filter(col =>
      isTripGeoJsonField(dataContainer, fields[col.geojson.fieldIdx])
    );

    if (tripGeojsonColumns.length) {
      return {
        props: tripGeojsonColumns.map(columns => ({
          label: (typeof label === 'string' && label.replace(/\.[^/.]+$/, '')) || this.type,
          columns,
          isVisible: true,
          columnMode: COLUMN_MODE_GEOJSON
        })),

        // if a geojson layer is created from this column, delete it
        foundLayers: foundLayers.filter(
          prop =>
            prop.type !== 'geojson' ||
            prop.dataId !== id ||
            !tripGeojsonColumns.find(c => prop.columns.geojson.name === c.geojson.name)
        )
      };
    }

    return {props: []};
  }

  getDefaultLayerConfig(props) {
    return {
      ...super.getDefaultLayerConfig(props),
      columnMode: props?.columnMode ?? DEFAULT_COLUMN_MODE,
      animation: {
        enabled: true,
        domain: null
      }
    };
  }

  getHoverData(object, dataContainer: DataContainerInterface, fields, animationConfig) {
    if (this.config.columnMode === COLUMN_MODE_GEOJSON) {
      // index for dataContainer is saved to feature.properties
      return dataContainer.row(object.properties.index);
    }
    return this._findColumnModeDatumForFeature(object.properties.index, animationConfig.currentTime)
      ?.datum;
  }

  calculateDataAttribute(dataset: KeplerTable, getPosition) {
    switch (this.config.columnMode) {
      case COLUMN_MODE_GEOJSON: {
        return (
          dataset.filteredIndex
            .map(i => this.dataToFeature[i])
            // TODO d can be BinaryFeatureCollection, fix logic
            .filter(d => d && (d as any).geometry?.type === 'LineString')
        );
      }

      case COLUMN_MODE_TABLE:
        return applyFiltersToTableColumns(dataset, this.dataToFeature);

      default:
        return [];
    }
  }

  formatLayerData(datasets: Datasets, oldLayerData) {
    if (this.config.dataId === null) {
      return {};
    }
    // to-do: parse segment from dataContainer

    const {dataContainer, gpuFilter} = datasets[this.config.dataId];
    const {data} = this.updateData(datasets, oldLayerData);

    let valueAccessor;
    if (this.config.columnMode === COLUMN_MODE_GEOJSON) {
      valueAccessor = (dc: DataContainerInterface, f, fieldIndex: number) => {
        return dc.valueAt(f.properties.index, fieldIndex);
      };
    } else {
      valueAccessor = getTableModeValueAccessor;
    }
    const indexAccessor = f => f.properties.index;
    const dataAccessor = dc => d => ({index: d.properties.index});
    const accessors = this.getAttributeAccessors({dataAccessor, dataContainer});
    const getFilterValue = gpuFilter.filterValueAccessor(dataContainer)(
      indexAccessor,
      valueAccessor
    );

    return {
      data,
      getFilterValue,
      getPath: d => d.geometry.coordinates,
      getTimestamps: d => this.dataToTimeStamp[d.properties.index],
      ...accessors
    };
  }

  updateAnimationDomain(domain) {
    this.updateLayerConfig({
      animation: {
        ...this.config.animation,
        domain
      }
    });
  }

  updateLayerMeta(dataContainer: DataContainerInterface) {
    let getFeature;
    if (this.config.columnMode === COLUMN_MODE_GEOJSON) {
      getFeature = this.getPositionAccessor(dataContainer);
      if (getFeature === this.meta.getFeature) {
        // TODO: revisit this after gpu filtering
        return;
      }
      this.dataToFeature = getGeojsonDataMaps(dataContainer, getFeature);
    } else {
      this.dataContainer = dataContainer;
      this.dataToFeature = groupColumnsAsGeoJson(dataContainer, this.config.columns, 'timestamp');
    }

    const {dataToTimeStamp, animationDomain} = parseTripGeoJsonTimestamp(this.dataToFeature);

    this.dataToTimeStamp = dataToTimeStamp;
    this.updateAnimationDomain(animationDomain);

    // get bounds from features
    const bounds = getGeojsonBounds(this.dataToFeature);

    // keep a record of what type of geometry the collection has
    const featureTypes = getGeojsonFeatureTypes(this.dataToFeature);

    this.updateMeta({bounds, featureTypes, getFeature});
  }

  setInitialLayerConfig(dataset) {
    const {dataContainer} = dataset;
    if (!dataContainer.numRows()) {
      return this;
    }

    // defefaultLayerProps will automatically find geojson column
    // if not found, we try to set it to id / lat /lng /ts
    if (!this.config.columns.geojson.value) {
      // find columns from lat, lng, id, and ts
      const columnConfig = detectTableColumns(dataset, this.config.columns);
      if (columnConfig) {
        this.updateLayerConfig({
          ...columnConfig,
          columnMode: COLUMN_MODE_TABLE
        });
      }
    }

    this.updateLayerMeta(dataContainer);
    return this;
  }

  renderLayer(opts) {
    const {data, gpuFilter, mapState, animationConfig} = opts;
    const {visConfig} = this.config;
    const zoomFactor = this.getZoomFactor(mapState);
    const isValidTime =
      animationConfig &&
      Array.isArray(animationConfig.domain) &&
      animationConfig.domain.every(Number.isFinite) &&
      Number.isFinite(animationConfig.currentTime);

    if (!isValidTime) {
      return [];
    }

    const domain0 = animationConfig.domain?.[0];

    const gpuFilterUpdateTriggers = {getFilterValue: gpuFilter.filterValueUpdateTriggers};
    const updateTriggers = {
      ...this.getVisualChannelUpdateTriggers(),
      getTimestamps: {
        columns: this.config.columns,
        domain0
      },
      ...gpuFilterUpdateTriggers
    };
    const defaultLayerProps = this.getDefaultDeckLayerProps(opts);

    const layerProps = {
      ...defaultLayerProps,
      ...data,
      getTimestamps: d => (data.getTimestamps(d) || []).map(ts => ts - domain0),
      widthScale: visConfig.thickness * zoomFactor * zoomFactorValue,
      capRounded: true,
      jointRounded: true,
      wrapLongitude: false,
      parameters: {
        depthTest: mapState.dragRotate,
        depthMask: false
      },
      trailLength: visConfig.trailLength * 1000,
      currentTime: animationConfig.currentTime - domain0,
      updateTriggers,
      id: `${defaultLayerProps.id}${mapState.globe?.enabled ? '-globe' : ''}`
    };
    return [new DeckGLTripsLayer(layerProps)];
  }

  /**
   * Finds coordinates and datum at the current animation time by the specified feature index.
   * @param featureIndex
   * @param time
   * @returns {{datum: (null|string|*), idx: *, coords}|{datum: null, idx: number, coords: null}}
   */
  private _findColumnModeDatumForFeature(
    featureIndex: number,
    time: number
  ): {
    idx: number;
    coords: number[] | null;
    datum: any;
  } {
    if (this.config.columnMode === COLUMN_MODE_TABLE) {
      const object = this.dataToFeature[featureIndex];
      const idx = bisectRight(this.dataToTimeStamp[featureIndex], time);
      // @ts-expect-error type geometry?
      const {coordinates} = object?.geometry || {coordinates: []};
      if (idx >= 0 && idx < coordinates.length) {
        const coords = coordinates[idx];
        return {
          idx,
          coords,
          datum: coords?.datum
        };
      }
    }
    return {
      idx: -1,
      coords: null,
      datum: null
    };
  }
}

1	// SPDX-License-Identifier: MIT
2	// Copyright contributors to the kepler.gl project
3
4	import memoize from 'lodash.memoize';
5	import uniq from 'lodash.uniq';
6	import Layer, {LayerBaseConfig, defaultGetFieldValue} from '../base-layer';
7	import {TripsLayer as DeckGLTripsLayer} from '@deck.gl/geo-layers';
8
9	import {GEOJSON_FIELDS, ColorRange} from '@kepler.gl/constants';
10	import TripLayerIcon from './trip-layer-icon';
11
12	import {
13	getGeojsonDataMaps,
14	getGeojsonBounds,
15	getGeojsonFeatureTypes,
16	GeojsonDataMaps,
17	detectTableColumns,
18	groupColumnsAsGeoJson,
19	applyFiltersToTableColumns
20	} from '../geojson-layer/geojson-utils';
21
22	import {isTripGeoJsonField, parseTripGeoJsonTimestamp} from './trip-utils';
23	import TripInfoModalFactory from './trip-info-modal';
24	import {bisectRight} from 'd3-array';
25	import {
26	Merge,
27	VisConfigColorRange,
28	VisConfigNumber,
29	VisConfigRange,
30	LayerColumn
31	} from '@kepler.gl/types';
32	import {default as KeplerTable, Datasets} from '@kepler.gl/table';
33	import {DataContainerInterface} from '@kepler.gl/utils';
34
35	export type TripLayerVisConfigSettings = {
36	opacity: VisConfigNumber;
37	thickness: VisConfigNumber;
38	colorRange: VisConfigColorRange;
39	trailLength: VisConfigNumber;
40	sizeRange: VisConfigRange;
41	};
42
43	export type TripLayerColumnsConfig = {
44	geojson: LayerColumn;
45	};
46
47	export type TripLayerVisConfig = {
48	opacity: number;
49	thickness: number;
50	colorRange: ColorRange;
51	trailLength: number;
52	sizeRange: [number, number];
53	};
54
55	export type TripLayerConfig = Merge<
56	LayerBaseConfig,
57	{columns: TripLayerColumnsConfig; visConfig: TripLayerVisConfig}
58	>;
59
60	export type TripLayerMeta = {
61	getFeature: any;
62	};
63
64	const zoomFactorValue = 8;	11✔
65
66	export const defaultThickness = 0.5;	11✔
67	export const defaultLineWidth = 1;	11✔
68
69	export const tripVisConfigs: {
70	opacity: 'opacity';
71	thickness: VisConfigNumber;
72	colorRange: 'colorRange';
73	trailLength: 'trailLength';
74	sizeRange: 'strokeWidthRange';
75	} = {	11✔
76	opacity: 'opacity',
77	thickness: {
78	type: 'number',
79	defaultValue: defaultThickness,
80	label: 'Stroke Width',
81	isRanged: false,
82	range: [0, 100],
83	step: 0.1,
84	group: 'stroke',
85	property: 'thickness'
86	},
87	colorRange: 'colorRange',
88	trailLength: 'trailLength',
89	sizeRange: 'strokeWidthRange'
90	};
91
92	export const featureAccessor =
93	({geojson}: TripLayerColumnsConfig) =>	11✔
94	(dc: DataContainerInterface) =>	10✔
95	d =>	27✔
96	dc.valueAt(d.index, geojson.fieldIdx);	118✔
97	export const featureResolver = ({geojson}: TripLayerColumnsConfig) => geojson.fieldIdx;	27✔
98	const getTableModeValueAccessor = f => {	11✔
99	// Called from gpu-filter-utils.getFilterValueAccessor()
100	return field => f.properties.values.map(v => field.valueAccessor(v));	×
101	};
102	const getTableModeFieldValue = (field, data) => {	11✔
103	let rv;
104	if (typeof data === 'function') {	×
105	rv = data(field);	×
106	} else {
107	rv = defaultGetFieldValue(field, data);	×
108	}
109	return rv;	×
110	};
111
112	export const COLUMN_MODE_GEOJSON = 'geojson';	11✔
113	export const COLUMN_MODE_TABLE = 'table';	11✔
114	const SUPPORTED_COLUMN_MODES = [	11✔
115	{
116	key: COLUMN_MODE_GEOJSON,
117	label: 'GeoJSON',
118	requiredColumns: ['geojson']
119	},
120	{
121	key: COLUMN_MODE_TABLE,
122	label: 'Table columns',
123	requiredColumns: ['id', 'lat', 'lng', 'timestamp'],
124	optionalColumns: ['altitude']
125	}
126	];
127	const DEFAULT_COLUMN_MODE = COLUMN_MODE_GEOJSON;	11✔
128
129	export default class TripLayer extends Layer {
130	declare visConfigSettings: TripLayerVisConfigSettings;
131	declare config: TripLayerConfig;
132	declare meta: TripLayerMeta;
133	declare dataContainer: DataContainerInterface \| null;
134
135	dataToFeature: GeojsonDataMaps;
136	dataToTimeStamp: any[];
137	getFeature: (columns: TripLayerColumnsConfig) => (dataContainer: DataContainerInterface) => any;
138	_layerInfoModal: Record<string, () => JSX.Element>;
139
140	constructor(props) {
141	super(props);	44✔
142
143	this.dataToFeature = [];	44✔
144	this.dataToTimeStamp = [];	44✔
145	this.dataContainer = null;	44✔
146	this.registerVisConfig(tripVisConfigs);	44✔
147	this.getFeature = memoize(featureAccessor, featureResolver);	44✔
148	this._layerInfoModal = {	44✔
149	[COLUMN_MODE_TABLE]: TripInfoModalFactory(COLUMN_MODE_TABLE),
150	[COLUMN_MODE_GEOJSON]: TripInfoModalFactory(COLUMN_MODE_GEOJSON)
151	};
152	}
153
154	get supportedColumnModes() {
155	return SUPPORTED_COLUMN_MODES;	136✔
156	}
157
158	static get type(): 'trip' {
159	return 'trip';	63✔
160	}
161	get type() {
162	return TripLayer.type;	63✔
163	}
164
165	get name(): 'Trip' {
166	return 'Trip';	27✔
167	}
168
169	get layerIcon() {
170	return TripLayerIcon;	28✔
171	}
172
173	get columnPairs() {
174	return this.defaultPointColumnPairs;	6✔
175	}
176
177	accessVSFieldValue(field, indexKey) {
178	if (this.config.columnMode === COLUMN_MODE_GEOJSON) {	×
179	return defaultGetFieldValue;	×
180	}
181	return getTableModeFieldValue;	×
182	}
183
184	get visualChannels() {
185	const visualChannels = super.visualChannels;	141✔
186
187	return {	141✔
188	...visualChannels,
189	color: {
190	...visualChannels.color,
191	accessor: 'getColor',
192	nullValue: visualChannels.color.nullValue,
193	getAttributeValue: config => d => d.properties.lineColor \|\| config.color,	12✔
194	// used this to get updateTriggers
195	defaultValue: config => config.color	1✔
196	},
197	size: {
198	...visualChannels.size,
199	property: 'stroke',
200	accessor: 'getWidth',
201	condition: config => config.visConfig.stroked,	×
202	nullValue: 0,
203	getAttributeValue: () => d => d.properties.lineWidth \|\| defaultLineWidth	15✔
204	}
205	};
206	}
207
208	get animationDomain() {
209	return this.config.animation.domain;	37✔
210	}
211
212	get layerInfoModal() {
213	return {	15✔
214	[COLUMN_MODE_GEOJSON]: {
215	id: 'iconInfo',
216	template: this._layerInfoModal[COLUMN_MODE_GEOJSON],
217	modalProps: {
218	title: 'modal.tripInfo.title'
219	}
220	},
221	[COLUMN_MODE_TABLE]: {
222	id: 'iconInfo',
223	template: this._layerInfoModal[COLUMN_MODE_TABLE],
224	modalProps: {
225	title: 'modal.tripInfo.titleTable'
226	}
227	}
228	};
229	}
230
231	getPositionAccessor(dataContainer: DataContainerInterface) {
232	if (this.config.columnMode === COLUMN_MODE_GEOJSON) {	30✔
233	return this.getFeature(this.config.columns)(dataContainer);	27✔
234	}
235	return null;	3✔
236	}
237
238	static findDefaultLayerProps(
239	{label, fieldPairs, fields = [], dataContainer, id}: KeplerTable,	×
240	foundLayers: any[]
241	) {
242	const geojsonColumns = fields.filter(f => f.type === 'geojson').map(f => f.name);	724✔
243
244	const defaultColumns = {	93✔
245	geojson: uniq([...GEOJSON_FIELDS.geojson, ...geojsonColumns])
246	};
247
248	const geoJsonColumns = this.findDefaultColumnField(defaultColumns, fields);	93✔
249
250	const tripGeojsonColumns = (geoJsonColumns \|\| []).filter(col =>	93✔
251	isTripGeoJsonField(dataContainer, fields[col.geojson.fieldIdx])	53✔
252	);
253
254	if (tripGeojsonColumns.length) {	93✔
255	return {	5✔
256	props: tripGeojsonColumns.map(columns => ({	5✔
257	label: (typeof label === 'string' && label.replace(/\.[^/.]+$/, '')) \|\| this.type,	10!
258	columns,
259	isVisible: true,
260	columnMode: COLUMN_MODE_GEOJSON
261	})),
262
263	// if a geojson layer is created from this column, delete it
264	foundLayers: foundLayers.filter(
265	prop =>
266	prop.type !== 'geojson' \|\|	5✔
267	prop.dataId !== id \|\|
268	!tripGeojsonColumns.find(c => prop.columns.geojson.name === c.geojson.name)	5✔
269	)
270	};
271	}
272
273	return {props: []};	88✔
274	}
275
276	getDefaultLayerConfig(props) {
277	return {	61✔
278	...super.getDefaultLayerConfig(props),
279	columnMode: props?.columnMode ?? DEFAULT_COLUMN_MODE,	114✔
280	animation: {
281	enabled: true,
282	domain: null
283	}
284	};
285	}
286
287	getHoverData(object, dataContainer: DataContainerInterface, fields, animationConfig) {
288	if (this.config.columnMode === COLUMN_MODE_GEOJSON) {	×
289	// index for dataContainer is saved to feature.properties
290	return dataContainer.row(object.properties.index);	×
291	}
292	return this._findColumnModeDatumForFeature(object.properties.index, animationConfig.currentTime)	×
293	?.datum;
294	}
295
296	calculateDataAttribute(dataset: KeplerTable, getPosition) {
297	switch (this.config.columnMode) {	12!
298	case COLUMN_MODE_GEOJSON: {
299	return (	9✔
300	dataset.filteredIndex
301	.map(i => this.dataToFeature[i])	63✔
302	// TODO d can be BinaryFeatureCollection, fix logic
303	.filter(d => d && (d as any).geometry?.type === 'LineString')	63✔
304	);
305	}
306
307	case COLUMN_MODE_TABLE:
308	return applyFiltersToTableColumns(dataset, this.dataToFeature);	3✔
309
310	default:
NEW 311	return [];	×
312	}
313	}
314
315	formatLayerData(datasets: Datasets, oldLayerData) {
316	if (this.config.dataId === null) {	16!
317	return {};	×
318	}
319	// to-do: parse segment from dataContainer
320
321	const {dataContainer, gpuFilter} = datasets[this.config.dataId];	16✔
322	const {data} = this.updateData(datasets, oldLayerData);	16✔
323
324	let valueAccessor;
325	if (this.config.columnMode === COLUMN_MODE_GEOJSON) {	16✔
326	valueAccessor = (dc: DataContainerInterface, f, fieldIndex: number) => {	13✔
327	return dc.valueAt(f.properties.index, fieldIndex);	6✔
328	};
329	} else {
330	valueAccessor = getTableModeValueAccessor;	3✔
331	}
332	const indexAccessor = f => f.properties.index;	16✔
333	const dataAccessor = dc => d => ({index: d.properties.index});	16✔
334	const accessors = this.getAttributeAccessors({dataAccessor, dataContainer});	16✔
335	const getFilterValue = gpuFilter.filterValueAccessor(dataContainer)(	16✔
336	indexAccessor,
337	valueAccessor
338	);
339
340	return {	16✔
341	data,
342	getFilterValue,
343	getPath: d => d.geometry.coordinates,	7✔
344	getTimestamps: d => this.dataToTimeStamp[d.properties.index],	4✔
345	...accessors
346	};
347	}
348
349	updateAnimationDomain(domain) {
350	this.updateLayerConfig({	19✔
351	animation: {
352	...this.config.animation,
353	domain
354	}
355	});
356	}
357
358	updateLayerMeta(dataContainer: DataContainerInterface) {
359	let getFeature;
360	if (this.config.columnMode === COLUMN_MODE_GEOJSON) {	17✔
361	getFeature = this.getPositionAccessor(dataContainer);	14✔
362	if (getFeature === this.meta.getFeature) {	14!
363	// TODO: revisit this after gpu filtering
364	return;	×
365	}
366	this.dataToFeature = getGeojsonDataMaps(dataContainer, getFeature);	14✔
367	} else {
368	this.dataContainer = dataContainer;	3✔
369	this.dataToFeature = groupColumnsAsGeoJson(dataContainer, this.config.columns, 'timestamp');	3✔
370	}
371
372	const {dataToTimeStamp, animationDomain} = parseTripGeoJsonTimestamp(this.dataToFeature);	17✔
373
374	this.dataToTimeStamp = dataToTimeStamp;	17✔
375	this.updateAnimationDomain(animationDomain);	17✔
376
377	// get bounds from features
378	const bounds = getGeojsonBounds(this.dataToFeature);	17✔
379
380	// keep a record of what type of geometry the collection has
381	const featureTypes = getGeojsonFeatureTypes(this.dataToFeature);	17✔
382
383	this.updateMeta({bounds, featureTypes, getFeature});	17✔
384	}
385
386	setInitialLayerConfig(dataset) {
387	const {dataContainer} = dataset;	5✔
388	if (!dataContainer.numRows()) {	5!
389	return this;	×
390	}
391
392	// defefaultLayerProps will automatically find geojson column
393	// if not found, we try to set it to id / lat /lng /ts
394	if (!this.config.columns.geojson.value) {	5!
395	// find columns from lat, lng, id, and ts
396	const columnConfig = detectTableColumns(dataset, this.config.columns);	×
397	if (columnConfig) {	×
398	this.updateLayerConfig({	×
399	...columnConfig,
400	columnMode: COLUMN_MODE_TABLE
401	});
402	}
403	}
404
405	this.updateLayerMeta(dataContainer);	5✔
406	return this;	5✔
407	}
408
409	renderLayer(opts) {
410	const {data, gpuFilter, mapState, animationConfig} = opts;	1✔
411	const {visConfig} = this.config;	1✔
412	const zoomFactor = this.getZoomFactor(mapState);	1✔
413	const isValidTime =
414	animationConfig &&	1✔
415	Array.isArray(animationConfig.domain) &&
416	animationConfig.domain.every(Number.isFinite) &&
417	Number.isFinite(animationConfig.currentTime);
418
419	if (!isValidTime) {	1!
420	return [];	×
421	}
422
423	const domain0 = animationConfig.domain?.[0];	1✔
424
425	const gpuFilterUpdateTriggers = {getFilterValue: gpuFilter.filterValueUpdateTriggers};	1✔
426	const updateTriggers = {	1✔
427	...this.getVisualChannelUpdateTriggers(),
428	getTimestamps: {
429	columns: this.config.columns,
430	domain0
431	},
432	...gpuFilterUpdateTriggers
433	};
434	const defaultLayerProps = this.getDefaultDeckLayerProps(opts);	1✔
435
436	const layerProps = {	1✔
437	...defaultLayerProps,
438	...data,
439	getTimestamps: d => (data.getTimestamps(d) \|\| []).map(ts => ts - domain0),	25!
440	widthScale: visConfig.thickness * zoomFactor * zoomFactorValue,
441	capRounded: true,
442	jointRounded: true,
443	wrapLongitude: false,
444	parameters: {
445	depthTest: mapState.dragRotate,
446	depthMask: false
447	},
448	trailLength: visConfig.trailLength * 1000,
449	currentTime: animationConfig.currentTime - domain0,
450	updateTriggers,
451	id: `${defaultLayerProps.id}${mapState.globe?.enabled ? '-globe' : ''}`	1!
452	};
453	return [new DeckGLTripsLayer(layerProps)];	1✔
454	}
455
456	/**
457	* Finds coordinates and datum at the current animation time by the specified feature index.
458	* @param featureIndex
459	* @param time
460	* @returns {{datum: (null\|string\|), idx: , coords}\|{datum: null, idx: number, coords: null}}
461	*/
462	private _findColumnModeDatumForFeature(
463	featureIndex: number,
464	time: number
465	): {
466	idx: number;
467	coords: number[] \| null;
468	datum: any;
469	} {
470	if (this.config.columnMode === COLUMN_MODE_TABLE) {	×
471	const object = this.dataToFeature[featureIndex];	×
472	const idx = bisectRight(this.dataToTimeStamp[featureIndex], time);	×
473	// @ts-expect-error type geometry?
474	const {coordinates} = object?.geometry \|\| {coordinates: []};	×
475	if (idx >= 0 && idx < coordinates.length) {	×
476	const coords = coordinates[idx];	×
477	return {	×
478	idx,
479	coords,
480	datum: coords?.datum
481	};
482	}
483	}
484	return {	×
485	idx: -1,
486	coords: null,
487	datum: null
488	};
489	}
490	}

keplergl / kepler.gl / 11013376001

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