9631763859

Committed 23 Jun 2024 07:32AM UTC coverage: 89.281% (-0.2%) from 89.454%

Build # 9631763859

Build Type

Pull #8942

github

Committed by

web-flow

Commit Message

Merge 7dcb8057e into b8f918193

Pull Request Pull Request #8942: GPU Aggregation (4/8): ScreenGridLayer

Run Details

6512 of 7149 branches covered (91.09%)

Branch coverage included in aggregate %.

341 of 359 new or added lines in 12 files covered. (94.99%)

234 existing lines in 6 files now uncovered.

53640 of 60225 relevant lines covered (89.07%)

6415.75 hits per line

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

92.94

/modules/aggregation-layers/src/screen-grid-layer/screen-grid-layer.ts

// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

import {
  Accessor,
  Color,
  GetPickingInfoParams,
  CompositeLayerProps,
  Layer,
  project32,
  LayersList,
  PickingInfo,
  Position,
  UpdateParameters,
  DefaultProps
} from '@deck.gl/core';
import {WebGLAggregator} from '../aggregation-layer-v9/gpu-aggregator/webgl-aggregator';
import {CPUAggregator} from '../aggregation-layer-v9/cpu-aggregator/cpu-aggregator';
import AggregationLayer from '../aggregation-layer-v9/aggregation-layer';
import {AggregationOperation} from '../aggregation-layer-v9/aggregator';
import ScreenGridCellLayer from './screen-grid-cell-layer';

const defaultProps: DefaultProps<ScreenGridLayerProps> = {
  ...(ScreenGridCellLayer.defaultProps as DefaultProps<ScreenGridLayerProps>),
  getPosition: {type: 'accessor', value: (d: any) => d.position},
  getWeight: {type: 'accessor', value: 1},

  gpuAggregation: false, // TODO(v9): Re-enable GPU aggregation.
  aggregation: 'SUM'
};

/** All properties supported by ScreenGridLayer. */
export type ScreenGridLayerProps<DataT = unknown> = _ScreenGridLayerProps<DataT> &
  CompositeLayerProps;

/** Properties added by ScreenGridLayer. */
export type _ScreenGridLayerProps<DataT> = {
  /**
   * Unit width/height of the bins.
   * @default 100
   */
  cellSizePixels?: number;

  /**
   * Cell margin size in pixels.
   * @default 2
   */
  cellMarginPixels?: number;

  /**
   * Color scale input domain. The color scale maps continues numeric domain into discrete color range.
   * @default [1, max(weight)]
   */
  colorDomain?: [number, number] | null;

  /**
   * Specified as an array of colors [color1, color2, ...].
   *
   * @default `6-class YlOrRd` - [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6)
   */
  colorRange?: Color[];

  /**
   * Method called to retrieve the position of each object.
   *
   * @default d => d.position
   */
  getPosition?: Accessor<DataT, Position>;

  /**
   * The weight of each object.
   *
   * @default 1
   */
  getWeight?: Accessor<DataT, number>;

  /**
   * Perform aggregation is performed on GPU.
   *
   * @default true
   */
  gpuAggregation?: boolean;

  /**
   * Defines the type of aggregation operation
   * Valid values are 'SUM', 'MEAN', 'MIN', 'MAX', 'COUNT'.
   *
   * @default 'SUM'
   */
  aggregation?: AggregationOperation;
};

export type ScreenGridLayerPickingInfo<DataT> = PickingInfo<{
  /** Column index of the picked cell, starting from 0 at the left of the viewport */
  col: number;
  /** Row index of the picked cell, starting from 0 at the top of the viewport */
  row: number;
  /** Aggregated value */
  value: number;
  /** Number of data points in the picked cell */
  count: number;
  /** Indices of the data objects in the picked cell. Only available if using CPU aggregation. */
  pointIndices?: number[];
  /** The data objects in the picked cell. Only available if using CPU aggregation and layer data is an array. */
  points?: DataT[];
}>;

/** Aggregates data into histogram bins and renders them as a grid. */
export default class ScreenGridLayer<
  DataT = any,
  ExtraProps extends {} = {}
> extends AggregationLayer<DataT, ExtraProps & Required<_ScreenGridLayerProps<DataT>>> {
  static layerName = 'ScreenGridLayer';
  static defaultProps = defaultProps;

  getAggregatorType(): string {
    return this.props.gpuAggregation ? 'gpu' : 'cpu';
  }

  createAggregator(type: string): WebGLAggregator | CPUAggregator {
    if (type === 'cpu' || !WebGLAggregator.isSupported(this.context.device)) {
      return new CPUAggregator({
        dimensions: 2,
        getBin: {
          sources: ['positions'],
          getValue: ({positions}, index, opts) => {
            const viewport = this.context.viewport;
            const p = viewport.project(positions as number[]);
            const cellSizePixels: number = opts.cellSizePixels;
            if (p[0] < 0 || p[0] >= viewport.width || p[1] < 0 || p[1] >= viewport.height) {
              // Not on screen
              return null;
            }
            return [Math.floor(p[0] / cellSizePixels), Math.floor(p[1] / cellSizePixels)];
          }
        },
        getValue: [{sources: ['counts'], getValue: ({counts}) => counts}]
      });
    }
    return new WebGLAggregator(this.context.device, {
      dimensions: 2,
      channelCount: 1,
      bufferLayout: this.getAttributeManager()!.getBufferLayouts({isInstanced: false}),
      ...super.getShaders({
        modules: [project32],
        vs: `
  uniform float cellSizePixels;
  in vec3 positions;
  in vec3 positions64Low;
  in float counts;
  
  void getBin(out ivec2 binId) {
    vec4 pos = project_position_to_clipspace(positions, positions64Low, vec3(0.0));
    vec2 screenCoords = vec2(pos.x / pos.w + 1.0, 1.0 - pos.y / pos.w) / 2.0 * project.viewportSize / project.devicePixelRatio;
    vec2 gridCoords = floor(screenCoords / cellSizePixels);
    binId = ivec2(gridCoords);
  }
  void getValue(out float weight) {
    weight = counts;
  }
  `
      })
    });
  }

  initializeState() {
    super.initializeState();

    const attributeManager = this.getAttributeManager()!;
    attributeManager.add({
      positions: {
        size: 3,
        accessor: 'getPosition',
        type: 'float64',
        fp64: this.use64bitPositions()
      },
      // this attribute is used in gpu aggregation path only
      counts: {size: 1, accessor: 'getWeight'}
    });
  }

  shouldUpdateState({changeFlags}: UpdateParameters<this>) {
    return changeFlags.somethingChanged;
  }

  updateState(params: UpdateParameters<this>) {
    const aggregatorChanged = super.updateState(params);

    const {props, oldProps, changeFlags} = params;
    const {cellSizePixels, aggregation} = props;
    if (
      aggregatorChanged ||
      changeFlags.dataChanged ||
      changeFlags.updateTriggersChanged ||
      changeFlags.viewportChanged ||
      aggregation !== oldProps.aggregation ||
      cellSizePixels !== oldProps.cellSizePixels
    ) {
      const {width, height} = this.context.viewport;
      const {aggregator} = this.state;

      if (aggregator instanceof WebGLAggregator) {
        aggregator.setProps({
          binIdRange: [
            [0, Math.ceil(width / cellSizePixels)],
            [0, Math.ceil(height / cellSizePixels)]
          ]
        });
      }

      aggregator.setProps({
        pointCount: this.getNumInstances(),
        operations: [aggregation],
        binOptions: {
          cellSizePixels
        }
      });
    }

    if (changeFlags.viewportChanged) {
      // Rerun aggregation on viewport change
      this.state.aggregator.setNeedsUpdate();
    }
    return aggregatorChanged;
  }

  onAttributeChange(id: string) {
    const {aggregator} = this.state;
    switch (id) {
      case 'positions':
        aggregator.setNeedsUpdate();
        break;

      case 'counts':
        aggregator.setNeedsUpdate(0);
        break;

      default:
      // This should not happen
    }
  }

  renderLayers(): LayersList | Layer | null {
    const {aggregator} = this.state;
    const CellLayerClass = this.getSubLayerClass('cells', ScreenGridCellLayer);
    const binAttribute = aggregator.getBins();
    const weightAttribute = aggregator.getResult(0);

    return new CellLayerClass(
      this.props,
      this.getSubLayerProps({
        id: 'cell-layer'
      }),
      {
        data: {
          length: aggregator.binCount,
          attributes: {
            getBin: binAttribute,
            getWeight: weightAttribute
          }
        },
        // Data has changed shallowly, but we likely don't need to update the attributes
        dataComparator: (data, oldData) => data.length === oldData.length,
        updateTriggers: {
          getBin: [binAttribute],
          getWeight: [weightAttribute]
        },
        parameters: {
          depthWriteEnabled: false,
          ...this.props.parameters
        },
        // Evaluate domain at draw() time
        colorDomain: () => this.props.colorDomain || aggregator.getResultDomain(0),
        // Extensions are already handled by the GPUAggregator, do not pass it down
        extensions: []
      }
    );
  }

  getPickingInfo(params: GetPickingInfoParams): ScreenGridLayerPickingInfo<DataT> {
    const info: ScreenGridLayerPickingInfo<DataT> = params.info;
    const {index} = info;
    if (index >= 0) {
      const bin = this.state.aggregator.getBin(index);
      let object: ScreenGridLayerPickingInfo<DataT>['object'];
      if (bin) {
        object = {
          col: bin.id[0],
          row: bin.id[1],
          value: bin.value[0],
          count: bin.count
        };
        if (bin.pointIndices) {
          object.pointIndices = bin.pointIndices;
          object.points = Array.isArray(this.props.data)
            ? bin.pointIndices.map(i => (this.props.data as DataT[])[i])
            : [];
        }
      }
      info.object = object;
    }

    return info;
  }
}

1	// Copyright (c) 2015 - 2017 Uber Technologies, Inc.	1✔
2	//	1✔
3	// Permission is hereby granted, free of charge, to any person obtaining a copy	1✔
4	// of this software and associated documentation files (the "Software"), to deal	1✔
5	// in the Software without restriction, including without limitation the rights	1✔
6	// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell	1✔
7	// copies of the Software, and to permit persons to whom the Software is	1✔
8	// furnished to do so, subject to the following conditions:	1✔
9	//	1✔
10	// The above copyright notice and this permission notice shall be included in	1✔
11	// all copies or substantial portions of the Software.	1✔
12	//	1✔
13	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR	1✔
14	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,	1✔
15	// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE	1✔
16	// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER	1✔
17	// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,	1✔
18	// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN	1✔
19	// THE SOFTWARE.	1✔
20		1✔
21	import {	1✔
22	Accessor,	1✔
23	Color,	1✔
24	GetPickingInfoParams,	1✔
25	CompositeLayerProps,	1✔
26	Layer,	1✔
27	project32,	1✔
28	LayersList,	1✔
29	PickingInfo,	1✔
30	Position,	1✔
31	UpdateParameters,	1✔
32	DefaultProps	1✔
33	} from '@deck.gl/core';	1✔
34	import {WebGLAggregator} from '../aggregation-layer-v9/gpu-aggregator/webgl-aggregator';	1✔
35	import {CPUAggregator} from '../aggregation-layer-v9/cpu-aggregator/cpu-aggregator';	1✔
36	import AggregationLayer from '../aggregation-layer-v9/aggregation-layer';	1✔
37	import {AggregationOperation} from '../aggregation-layer-v9/aggregator';	1✔
38	import ScreenGridCellLayer from './screen-grid-cell-layer';	1✔
39		1✔
40	const defaultProps: DefaultProps<ScreenGridLayerProps> = {	1✔
41	...(ScreenGridCellLayer.defaultProps as DefaultProps<ScreenGridLayerProps>),	1✔
42	getPosition: {type: 'accessor', value: (d: any) => d.position},	1✔
43	getWeight: {type: 'accessor', value: 1},	1✔
44		1✔
45	gpuAggregation: false, // TODO(v9): Re-enable GPU aggregation.	1✔
46	aggregation: 'SUM'	1✔
47	};	1✔
48		1✔
49	/** All properties supported by ScreenGridLayer. */	1✔
50	export type ScreenGridLayerProps<DataT = unknown> = _ScreenGridLayerProps<DataT> &	1✔
51	CompositeLayerProps;	1✔
52		1✔
53	/** Properties added by ScreenGridLayer. */	1✔
54	export type _ScreenGridLayerProps<DataT> = {	1✔
55	/**	1✔
56	* Unit width/height of the bins.	1✔
57	* @default 100	1✔
58	*/	1✔
59	cellSizePixels?: number;	1✔
60		1✔
61	/**	1✔
62	* Cell margin size in pixels.	1✔
63	* @default 2	1✔
64	*/	1✔
65	cellMarginPixels?: number;	1✔
66		1✔
67	/**	1✔
68	* Color scale input domain. The color scale maps continues numeric domain into discrete color range.	1✔
69	* @default [1, max(weight)]	1✔
70	*/	1✔
71	colorDomain?: [number, number] \| null;	1✔
72		1✔
73	/**	1✔
74	* Specified as an array of colors [color1, color2, ...].	1✔
75	*	1✔
76	* @default `6-class YlOrRd` - [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6)	1✔
77	*/	1✔
78	colorRange?: Color[];	1✔
79		1✔
80	/**	1✔
81	* Method called to retrieve the position of each object.	1✔
82	*	1✔
83	* @default d => d.position	1✔
84	*/	1✔
85	getPosition?: Accessor<DataT, Position>;	1✔
86		1✔
87	/**	1✔
88	* The weight of each object.	1✔
89	*	1✔
90	* @default 1	1✔
91	*/	1✔
92	getWeight?: Accessor<DataT, number>;	1✔
93		1✔
94	/**	1✔
95	* Perform aggregation is performed on GPU.	1✔
96	*	1✔
97	* @default true	1✔
98	*/	1✔
99	gpuAggregation?: boolean;	1✔
100		1✔
101	/**	1✔
102	* Defines the type of aggregation operation	1✔
103	* Valid values are 'SUM', 'MEAN', 'MIN', 'MAX', 'COUNT'.	1✔
104	*	1✔
105	* @default 'SUM'	1✔
106	*/	1✔
107	aggregation?: AggregationOperation;	1✔
108	};	1✔
109		1✔
110	export type ScreenGridLayerPickingInfo<DataT> = PickingInfo<{	1✔
111	/** Column index of the picked cell, starting from 0 at the left of the viewport */	1✔
112	col: number;	1✔
113	/** Row index of the picked cell, starting from 0 at the top of the viewport */	1✔
114	row: number;	1✔
115	/** Aggregated value */	1✔
116	value: number;	1✔
117	/** Number of data points in the picked cell */	1✔
118	count: number;	1✔
119	/** Indices of the data objects in the picked cell. Only available if using CPU aggregation. */	1✔
120	pointIndices?: number[];	1✔
121	/** The data objects in the picked cell. Only available if using CPU aggregation and layer data is an array. */	1✔
122	points?: DataT[];	1✔
123	}>;	1✔
124		1✔
125	/** Aggregates data into histogram bins and renders them as a grid. */	1✔
126	export default class ScreenGridLayer<	1✔
127	DataT = any,	1✔
128	ExtraProps extends {} = {}	1✔
129	> extends AggregationLayer<DataT, ExtraProps & Required<_ScreenGridLayerProps<DataT>>> {	1✔
130	static layerName = 'ScreenGridLayer';	1✔
131	static defaultProps = defaultProps;	1✔
132		1✔
133	getAggregatorType(): string {	1✔
134	return this.props.gpuAggregation ? 'gpu' : 'cpu';	27✔
135	}	27✔
136		1✔
137	createAggregator(type: string): WebGLAggregator \| CPUAggregator {	1✔
138	if (type === 'cpu' \|\| !WebGLAggregator.isSupported(this.context.device)) {	6✔
139	return new CPUAggregator({	5✔
140	dimensions: 2,	5✔
141	getBin: {	5✔
142	sources: ['positions'],	5✔
143	getValue: ({positions}, index, opts) => {	5✔
144	const viewport = this.context.viewport;	25,242✔
145	const p = viewport.project(positions as number[]);	25,242✔
146	const cellSizePixels: number = opts.cellSizePixels;	25,242✔
147	if (p[0] < 0 \|\| p[0] >= viewport.width \|\| p[1] < 0 \|\| p[1] >= viewport.height) {	25,242✔
148	// Not on screen	15,714✔
149	return null;	15,714✔
150	}	15,714✔
151	return [Math.floor(p[0] / cellSizePixels), Math.floor(p[1] / cellSizePixels)];	9,528✔
152	}	25,242✔
153	},	5✔
154	getValue: [{sources: ['counts'], getValue: ({counts}) => counts}]	5✔
155	});	5✔
156	}	5✔
157	return new WebGLAggregator(this.context.device, {	1✔
158	dimensions: 2,	1✔
159	channelCount: 1,	1✔
160	bufferLayout: this.getAttributeManager()!.getBufferLayouts({isInstanced: false}),	1✔
161	...super.getShaders({	1✔
162	modules: [project32],	1✔
163	vs: `	1✔
164	uniform float cellSizePixels;	1✔
165	in vec3 positions;	1✔
166	in vec3 positions64Low;	1✔
167	in float counts;	1✔
168		1✔
169	void getBin(out ivec2 binId) {	1✔
170	vec4 pos = project_position_to_clipspace(positions, positions64Low, vec3(0.0));	1✔
171	vec2 screenCoords = vec2(pos.x / pos.w + 1.0, 1.0 - pos.y / pos.w) / 2.0 * project.viewportSize / project.devicePixelRatio;	1✔
172	vec2 gridCoords = floor(screenCoords / cellSizePixels);	1✔
173	binId = ivec2(gridCoords);	1✔
174	}	1✔
175	void getValue(out float weight) {	1✔
176	weight = counts;	1✔
177	}	1✔
178	`	1✔
179	})	1✔
180	});	1✔
181	}	6✔
182		1✔
183	initializeState() {	1✔
184	super.initializeState();	5✔
185		5✔
186	const attributeManager = this.getAttributeManager()!;	5✔
187	attributeManager.add({	5✔
188	positions: {	5✔
189	size: 3,	5✔
190	accessor: 'getPosition',	5✔
191	type: 'float64',	5✔
192	fp64: this.use64bitPositions()	5✔
193	},	5✔
194	// this attribute is used in gpu aggregation path only	5✔
195	counts: {size: 1, accessor: 'getWeight'}	5✔
196	});	5✔
197	}	5✔
198		1✔
199	shouldUpdateState({changeFlags}: UpdateParameters<this>) {	1✔
200	return changeFlags.somethingChanged;	40✔
201	}	40✔
202		1✔
203	updateState(params: UpdateParameters<this>) {	1✔
204	const aggregatorChanged = super.updateState(params);	27✔
205		27✔
206	const {props, oldProps, changeFlags} = params;	27✔
207	const {cellSizePixels, aggregation} = props;	27✔
208	if (	27✔
209	aggregatorChanged \|\|	27✔
210	changeFlags.dataChanged \|\|	21✔
211	changeFlags.updateTriggersChanged \|\|	11✔
212	changeFlags.viewportChanged \|\|	7✔
213	aggregation !== oldProps.aggregation \|\|	2✔
214	cellSizePixels !== oldProps.cellSizePixels	2✔
215	) {	27✔
216	const {width, height} = this.context.viewport;	27✔
217	const {aggregator} = this.state;	27✔
218		27✔
219	if (aggregator instanceof WebGLAggregator) {	27✔
220	aggregator.setProps({	1✔
221	binIdRange: [	1✔
222	[0, Math.ceil(width / cellSizePixels)],	1✔
223	[0, Math.ceil(height / cellSizePixels)]	1✔
224	]	1✔
225	});	1✔
226	}	1✔
227		27✔
228	aggregator.setProps({	27✔
229	pointCount: this.getNumInstances(),	27✔
230	operations: [aggregation],	27✔
231	binOptions: {	27✔
232	cellSizePixels	27✔
233	}	27✔
234	});	27✔
235	}	27✔
236		27✔
237	if (changeFlags.viewportChanged) {	27✔
238	// Rerun aggregation on viewport change	10✔
239	this.state.aggregator.setNeedsUpdate();	10✔
240	}	10✔
241	return aggregatorChanged;	27✔
242	}	27✔
243		1✔
244	onAttributeChange(id: string) {	1✔
245	const {aggregator} = this.state;	35✔
246	switch (id) {	35✔
247	case 'positions':	35✔
248	aggregator.setNeedsUpdate();	15✔
249	break;	15✔
250		35✔
251	case 'counts':	35✔
252	aggregator.setNeedsUpdate(0);	20✔
253	break;	20✔
254		35✔
255	default:	35!
256	// This should not happen	35✔
257	}	35✔
258	}	35✔
259		1✔
260	renderLayers(): LayersList \| Layer \| null {	1✔
261	const {aggregator} = this.state;	27✔
262	const CellLayerClass = this.getSubLayerClass('cells', ScreenGridCellLayer);	27✔
263	const binAttribute = aggregator.getBins();	27✔
264	const weightAttribute = aggregator.getResult(0);	27✔
265		27✔
266	return new CellLayerClass(	27✔
267	this.props,	27✔
268	this.getSubLayerProps({	27✔
269	id: 'cell-layer'	27✔
270	}),	27✔
271	{	27✔
272	data: {	27✔
273	length: aggregator.binCount,	27✔
274	attributes: {	27✔
275	getBin: binAttribute,	27✔
276	getWeight: weightAttribute	27✔
277	}	27✔
278	},	27✔
279	// Data has changed shallowly, but we likely don't need to update the attributes	27✔
280	dataComparator: (data, oldData) => data.length === oldData.length,	27✔
281	updateTriggers: {	27✔
282	getBin: [binAttribute],	27✔
283	getWeight: [weightAttribute]	27✔
284	},	27✔
285	parameters: {	27✔
286	depthWriteEnabled: false,	27✔
287	...this.props.parameters	27✔
288	},	27✔
289	// Evaluate domain at draw() time	27✔
290	colorDomain: () => this.props.colorDomain \|\| aggregator.getResultDomain(0),	27✔
291	// Extensions are already handled by the GPUAggregator, do not pass it down	27✔
292	extensions: []	27✔
293	}	27✔
294	);	27✔
295	}	27✔
296		1✔
297	getPickingInfo(params: GetPickingInfoParams): ScreenGridLayerPickingInfo<DataT> {	1✔
NEW 298	const info: ScreenGridLayerPickingInfo<DataT> = params.info;	×
299	const {index} = info;	×
300	if (index >= 0) {	×
NEW 301	const bin = this.state.aggregator.getBin(index);	×
NEW 302	let object: ScreenGridLayerPickingInfo<DataT>['object'];	×
NEW 303	if (bin) {	×
NEW 304	object = {	×
NEW 305	col: bin.id[0],	×
NEW 306	row: bin.id[1],	×
NEW 307	value: bin.value[0],	×
NEW 308	count: bin.count	×
NEW 309	};	×
NEW 310	if (bin.pointIndices) {	×
NEW 311	object.pointIndices = bin.pointIndices;	×
NEW 312	object.points = Array.isArray(this.props.data)	×
NEW 313	? bin.pointIndices.map(i => (this.props.data as DataT[])[i])	×
NEW 314	: [];	×
NEW 315	}	×
UNCOV 316	}	×
NEW 317	info.object = object;	×
UNCOV 318	}	×
UNCOV 319		×
NEW 320	return info;	×
UNCOV 321	}	×
322	}	1✔

visgl / deck.gl / 9631763859

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