8119906414

Committed 02 Mar 2024 03:00AM UTC coverage: 70.631% (-0.01%) from 70.643%

Build # 8119906414

Build Type

Pull #8572

github

Committed by

web-flow

Commit Message

Merge 1448a5d91 into 1d9b7be1d

Pull Request Pull Request #8572: Change Attribute.type to VertexType from WebGL constants

Run Details

3391 of 4010 branches covered (84.56%)

Branch coverage included in aggregate %.

82 of 102 new or added lines in 26 files covered. (80.39%)

1 existing line in 1 file now uncovered.

39935 of 57331 relevant lines covered (69.66%)

298.56 hits per line

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

51.42

/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,
  Layer,
  LayerContext,
  LayersList,
  log,
  PickingInfo,
  Position,
  UpdateParameters,
  DefaultProps
} from '@deck.gl/core';
import type {Buffer, Texture} from '@luma.gl/core';
import GPUGridAggregator from '../utils/gpu-grid-aggregation/gpu-grid-aggregator';
import {AGGREGATION_OPERATION, getValueFunc} from '../utils/aggregation-operation-utils';
import ScreenGridCellLayer from './screen-grid-cell-layer';
import GridAggregationLayer, {GridAggregationLayerProps} from '../grid-aggregation-layer';
import {getFloatTexture} from '../utils/resource-utils';

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

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

const POSITION_ATTRIBUTE_NAME = 'positions';
const DIMENSIONS = {
  data: {
    props: ['cellSizePixels']
  },
  weights: {
    props: ['aggregation'],
    accessors: ['getWeight']
  }
};

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

/** 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;

  /**
   * Expressed as an rgba array, minimal color that could be rendered by a tile.
   * @default [0, 0, 0, 255]
   * @deprecated Deprecated in version 5.2.0, use `colorRange` and `colorDomain` instead.
   */
  minColor?: Color | null;

  /**
   * Expressed as an rgba array, maximal color that could be rendered by a tile.
   * @default [0, 255, 0, 255]
   * @deprecated Deprecated in version 5.2.0, use `colorRange` and `colorDomain` instead.
   */
  maxColor?: Color | null;

  /**
   * 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
   *
   * V valid values are 'SUM', 'MEAN', 'MIN' and 'MAX'.
   *
   * @default 'SUM'
   */
  aggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
};

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

  state!: GridAggregationLayer<DataT>['state'] & {
    supported: boolean;
    gpuGridAggregator?: any;
    gpuAggregation?: any;
    weights?: any;
    maxTexture?: Texture;
    aggregationBuffer?: Buffer;
    maxBuffer?: Buffer;
  };

  initializeState() {
    if (!ScreenGridCellLayer.isSupported(this.context.device)) {
      // max aggregated value is sampled from a float texture
      this.setState({supported: false});
      log.error(`ScreenGridLayer: ${this.id} is not supported on this browser`)();
      return;
    }
    super.initializeAggregationLayer({
      dimensions: DIMENSIONS,
      // @ts-expect-error
      getCellSize: props => props.cellSizePixels // TODO
    });
    const weights = {
      count: {
        size: 1,
        operation: AGGREGATION_OPERATION.SUM,
        needMax: true,
        maxTexture: getFloatTexture(this.context.device, {id: `${this.id}-max-texture`})
      }
    };
    this.setState({
      supported: true,
      projectPoints: true, // aggregation in screen space
      weights,
      subLayerData: {attributes: {}},
      maxTexture: weights.count.maxTexture,
      positionAttributeName: 'positions',
      posOffset: [0, 0],
      translation: [1, -1]
    });
    const attributeManager = this.getAttributeManager()!;
    attributeManager.add({
      [POSITION_ATTRIBUTE_NAME]: {
        size: 3,
        accessor: 'getPosition',
        type: 'float64',
        fp64: this.use64bitPositions()
      },
      // this attribute is used in gpu aggregation path only
      count: {size: 3, accessor: 'getWeight'}
    });
  }

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

  updateState(opts: UpdateParameters<this>) {
    super.updateState(opts);
  }

  renderLayers(): LayersList | Layer {
    if (!this.state.supported) {
      return [];
    }
    const {maxTexture, numRow, numCol, weights} = this.state;
    const {updateTriggers} = this.props;
    const {aggregationBuffer} = weights.count;
    const CellLayerClass = this.getSubLayerClass('cells', ScreenGridCellLayer);

    return new CellLayerClass(
      this.props,
      this.getSubLayerProps({
        id: 'cell-layer',
        updateTriggers
      }),
      {
        data: {attributes: {instanceCounts: aggregationBuffer}},
        maxTexture,
        numInstances: numRow * numCol
      }
    );
  }

  finalizeState(context: LayerContext): void {
    super.finalizeState(context);

    const {aggregationBuffer, maxBuffer, maxTexture} = this.state;

    aggregationBuffer?.delete();
    maxBuffer?.delete();
    maxTexture?.delete();
  }

  getPickingInfo({info}: GetPickingInfoParams): PickingInfo {
    const {index} = info;
    if (index >= 0) {
      const {gpuGridAggregator, gpuAggregation, weights} = this.state;
      // Get count aggregation results
      const aggregationResults = gpuAggregation
        ? gpuGridAggregator.getData('count')
        : weights.count;

      // Each instance (one cell) is aggregated into single pixel,
      // Get current instance's aggregation details.
      info.object = GPUGridAggregator.getAggregationData({
        pixelIndex: index,
        ...aggregationResults
      });
    }

    return info;
  }

  // Aggregation Overrides

  updateResults({aggregationData, maxData}) {
    const {count} = this.state.weights;
    count.aggregationData = aggregationData;
    count.aggregationBuffer.write(aggregationData);
    count.maxData = maxData;
    count.maxTexture.setImageData({data: maxData});
  }

  /* eslint-disable complexity, max-statements */
  updateAggregationState(opts) {
    const cellSize = opts.props.cellSizePixels;
    const cellSizeChanged = opts.oldProps.cellSizePixels !== cellSize;
    const {viewportChanged} = opts.changeFlags;
    let gpuAggregation = opts.props.gpuAggregation;
    if (this.state.gpuAggregation !== opts.props.gpuAggregation) {
      if (gpuAggregation && !GPUGridAggregator.isSupported(this.context.device)) {
        log.warn('GPU Grid Aggregation not supported, falling back to CPU')();
        gpuAggregation = false;
      }
    }
    const gpuAggregationChanged = gpuAggregation !== this.state.gpuAggregation;
    this.setState({
      gpuAggregation
    });

    const positionsChanged = this.isAttributeChanged(POSITION_ATTRIBUTE_NAME);

    const {dimensions} = this.state;
    const {data, weights} = dimensions;
    const aggregationDataDirty =
      positionsChanged ||
      gpuAggregationChanged ||
      viewportChanged ||
      this.isAggregationDirty(opts, {
        compareAll: gpuAggregation, // check for all (including extentions props) when using gpu aggregation
        dimension: data
      });
    const aggregationWeightsDirty = this.isAggregationDirty(opts, {dimension: weights});

    this.setState({
      aggregationDataDirty,
      aggregationWeightsDirty
    });

    const {viewport} = this.context;

    if (viewportChanged || cellSizeChanged) {
      const {width, height} = viewport;
      const numCol = Math.ceil(width / cellSize);
      const numRow = Math.ceil(height / cellSize);
      this.allocateResources(numRow, numCol);
      this.setState({
        // transformation from clipspace to screen(pixel) space
        scaling: [width / 2, -height / 2, 1],

        gridOffset: {xOffset: cellSize, yOffset: cellSize},
        width,
        height,
        numCol,
        numRow
      });
    }

    if (aggregationWeightsDirty) {
      this._updateAccessors(opts);
    }
    if (aggregationDataDirty || aggregationWeightsDirty) {
      this._resetResults();
    }
  }
  /* eslint-enable complexity, max-statements */

  // Private

  _updateAccessors(opts) {
    const {getWeight, aggregation, data} = opts.props;
    const {count} = this.state.weights;
    if (count) {
      count.getWeight = getWeight;
      count.operation = AGGREGATION_OPERATION[aggregation];
    }
    this.setState({getValue: getValueFunc(aggregation, getWeight, {data})});
  }

  _resetResults() {
    const {count} = this.state.weights;
    if (count) {
      count.aggregationData = null;
    }
  }
}

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	Layer,	1✔
26	LayerContext,	1✔
27	LayersList,	1✔
28	log,	1✔
29	PickingInfo,	1✔
30	Position,	1✔
31	UpdateParameters,	1✔
32	DefaultProps	1✔
33	} from '@deck.gl/core';	1✔
34	import type {Buffer, Texture} from '@luma.gl/core';	1✔
35	import GPUGridAggregator from '../utils/gpu-grid-aggregation/gpu-grid-aggregator';	1✔
36	import {AGGREGATION_OPERATION, getValueFunc} from '../utils/aggregation-operation-utils';	1✔
37	import ScreenGridCellLayer from './screen-grid-cell-layer';	1✔
38	import GridAggregationLayer, {GridAggregationLayerProps} from '../grid-aggregation-layer';	1✔
39	import {getFloatTexture} from '../utils/resource-utils';	1✔
40		1✔
41	const defaultProps: DefaultProps<ScreenGridLayerProps> = {	1✔
42	...(ScreenGridCellLayer.defaultProps as DefaultProps<ScreenGridLayerProps<unknown>>),	1✔
43	getPosition: {type: 'accessor', value: (d: any) => d.position},	1✔
44	getWeight: {type: 'accessor', value: 1},	1✔
45		1✔
46	gpuAggregation: false, // TODO(v9): Re-enable GPU aggregation.	1✔
47	aggregation: 'SUM'	1✔
48	};	1✔
49		1✔
50	const POSITION_ATTRIBUTE_NAME = 'positions';	1✔
51	const DIMENSIONS = {	1✔
52	data: {	1✔
53	props: ['cellSizePixels']	1✔
54	},	1✔
55	weights: {	1✔
56	props: ['aggregation'],	1✔
57	accessors: ['getWeight']	1✔
58	}	1✔
59	};	1✔
60		1✔
61	/** All properties supported by ScreenGridLayer. */	1✔
62	export type ScreenGridLayerProps<DataT = unknown> = _ScreenGridLayerProps<DataT> &	1✔
63	GridAggregationLayerProps<DataT>;	1✔
64		1✔
65	/** Properties added by ScreenGridLayer. */	1✔
66	export type _ScreenGridLayerProps<DataT> = {	1✔
67	/**	1✔
68	* Unit width/height of the bins.	1✔
69	* @default 100	1✔
70	*/	1✔
71	cellSizePixels?: number;	1✔
72		1✔
73	/**	1✔
74	* Cell margin size in pixels.	1✔
75	* @default 2	1✔
76	*/	1✔
77	cellMarginPixels?: number;	1✔
78		1✔
79	/**	1✔
80	* Expressed as an rgba array, minimal color that could be rendered by a tile.	1✔
81	* @default [0, 0, 0, 255]	1✔
82	* @deprecated Deprecated in version 5.2.0, use `colorRange` and `colorDomain` instead.	1✔
83	*/	1✔
84	minColor?: Color \| null;	1✔
85		1✔
86	/**	1✔
87	* Expressed as an rgba array, maximal color that could be rendered by a tile.	1✔
88	* @default [0, 255, 0, 255]	1✔
89	* @deprecated Deprecated in version 5.2.0, use `colorRange` and `colorDomain` instead.	1✔
90	*/	1✔
91	maxColor?: Color \| null;	1✔
92		1✔
93	/**	1✔
94	* Color scale input domain. The color scale maps continues numeric domain into discrete color range.	1✔
95	* @default [1, max(weight)]	1✔
96	*/	1✔
97	colorDomain?: [number, number] \| null;	1✔
98		1✔
99	/**	1✔
100	* Specified as an array of colors [color1, color2, ...].	1✔
101	*	1✔
102	* @default `6-class YlOrRd` - [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6)	1✔
103	*/	1✔
104	colorRange?: Color[];	1✔
105		1✔
106	/**	1✔
107	* Method called to retrieve the position of each object.	1✔
108	*	1✔
109	* @default d => d.position	1✔
110	*/	1✔
111	getPosition?: Accessor<DataT, Position>;	1✔
112		1✔
113	/**	1✔
114	* The weight of each object.	1✔
115	*	1✔
116	* @default 1	1✔
117	*/	1✔
118	getWeight?: Accessor<DataT, number>;	1✔
119		1✔
120	/**	1✔
121	* Perform aggregation is performed on GPU.	1✔
122	*	1✔
123	* @default true	1✔
124	*/	1✔
125	gpuAggregation?: boolean;	1✔
126		1✔
127	/**	1✔
128	* Defines the type of aggregation operation	1✔
129	*	1✔
130	* V valid values are 'SUM', 'MEAN', 'MIN' and 'MAX'.	1✔
131	*	1✔
132	* @default 'SUM'	1✔
133	*/	1✔
134	aggregation?: 'SUM' \| 'MEAN' \| 'MIN' \| 'MAX';	1✔
135	};	1✔
136		1✔
137	/** Aggregates data into histogram bins and renders them as a grid. */	1✔
138	export default class ScreenGridLayer<	1✔
139	DataT = any,	1✔
140	ExtraProps extends {} = {}	1✔
141	> extends GridAggregationLayer<DataT, ExtraProps & Required<_ScreenGridLayerProps<DataT>>> {	1✔
142	static layerName = 'ScreenGridLayer';	1✔
143	static defaultProps = defaultProps;	1✔
144		1✔
145	state!: GridAggregationLayer<DataT>['state'] & {	1✔
146	supported: boolean;	1✔
147	gpuGridAggregator?: any;	1✔
148	gpuAggregation?: any;	1✔
149	weights?: any;	1✔
150	maxTexture?: Texture;	1✔
151	aggregationBuffer?: Buffer;	1✔
152	maxBuffer?: Buffer;	1✔
153	};	1✔
154		1✔
155	initializeState() {	1✔
156	if (!ScreenGridCellLayer.isSupported(this.context.device)) {	×
157	// max aggregated value is sampled from a float texture	×
158	this.setState({supported: false});	×
159	log.error(`ScreenGridLayer: ${this.id} is not supported on this browser`)();	×
160	return;	×
161	}	×
162	super.initializeAggregationLayer({	×
163	dimensions: DIMENSIONS,	×
164	// @ts-expect-error	×
165	getCellSize: props => props.cellSizePixels // TODO	×
166	});	×
167	const weights = {	×
168	count: {	×
169	size: 1,	×
170	operation: AGGREGATION_OPERATION.SUM,	×
171	needMax: true,	×
172	maxTexture: getFloatTexture(this.context.device, {id: `${this.id}-max-texture`})	×
173	}	×
174	};	×
175	this.setState({	×
176	supported: true,	×
177	projectPoints: true, // aggregation in screen space	×
178	weights,	×
179	subLayerData: {attributes: {}},	×
180	maxTexture: weights.count.maxTexture,	×
181	positionAttributeName: 'positions',	×
182	posOffset: [0, 0],	×
183	translation: [1, -1]	×
184	});	×
185	const attributeManager = this.getAttributeManager()!;	×
186	attributeManager.add({	×
187	[POSITION_ATTRIBUTE_NAME]: {	×
188	size: 3,	×
189	accessor: 'getPosition',	×
NEW 190	type: 'float64',	×
191	fp64: this.use64bitPositions()	×
192	},	×
193	// this attribute is used in gpu aggregation path only	×
194	count: {size: 3, accessor: 'getWeight'}	×
195	});	×
196	}	×
197		1✔
198	shouldUpdateState({changeFlags}: UpdateParameters<this>) {	1✔
199	return this.state.supported && changeFlags.somethingChanged;	×
200	}	×
201		1✔
202	updateState(opts: UpdateParameters<this>) {	1✔
203	super.updateState(opts);	×
204	}	×
205		1✔
206	renderLayers(): LayersList \| Layer {	1✔
207	if (!this.state.supported) {	×
208	return [];	×
209	}	×
210	const {maxTexture, numRow, numCol, weights} = this.state;	×
211	const {updateTriggers} = this.props;	×
212	const {aggregationBuffer} = weights.count;	×
213	const CellLayerClass = this.getSubLayerClass('cells', ScreenGridCellLayer);	×
214		×
215	return new CellLayerClass(	×
216	this.props,	×
217	this.getSubLayerProps({	×
218	id: 'cell-layer',	×
219	updateTriggers	×
220	}),	×
221	{	×
222	data: {attributes: {instanceCounts: aggregationBuffer}},	×
223	maxTexture,	×
224	numInstances: numRow * numCol	×
225	}	×
226	);	×
227	}	×
228		1✔
229	finalizeState(context: LayerContext): void {	1✔
230	super.finalizeState(context);	×
231		×
232	const {aggregationBuffer, maxBuffer, maxTexture} = this.state;	×
233		×
234	aggregationBuffer?.delete();	×
235	maxBuffer?.delete();	×
236	maxTexture?.delete();	×
237	}	×
238		1✔
239	getPickingInfo({info}: GetPickingInfoParams): PickingInfo {	1✔
240	const {index} = info;	×
241	if (index >= 0) {	×
242	const {gpuGridAggregator, gpuAggregation, weights} = this.state;	×
243	// Get count aggregation results	×
244	const aggregationResults = gpuAggregation	×
245	? gpuGridAggregator.getData('count')	×
246	: weights.count;	×
247		×
248	// Each instance (one cell) is aggregated into single pixel,	×
249	// Get current instance's aggregation details.	×
250	info.object = GPUGridAggregator.getAggregationData({	×
251	pixelIndex: index,	×
252	...aggregationResults	×
253	});	×
254	}	×
255		×
256	return info;	×
257	}	×
258		1✔
259	// Aggregation Overrides	1✔
260		1✔
261	updateResults({aggregationData, maxData}) {	1✔
262	const {count} = this.state.weights;	×
263	count.aggregationData = aggregationData;	×
264	count.aggregationBuffer.write(aggregationData);	×
265	count.maxData = maxData;	×
266	count.maxTexture.setImageData({data: maxData});	×
267	}	×
268		1✔
269	/* eslint-disable complexity, max-statements */	1✔
270	updateAggregationState(opts) {	1✔
271	const cellSize = opts.props.cellSizePixels;	×
272	const cellSizeChanged = opts.oldProps.cellSizePixels !== cellSize;	×
273	const {viewportChanged} = opts.changeFlags;	×
274	let gpuAggregation = opts.props.gpuAggregation;	×
275	if (this.state.gpuAggregation !== opts.props.gpuAggregation) {	×
276	if (gpuAggregation && !GPUGridAggregator.isSupported(this.context.device)) {	×
277	log.warn('GPU Grid Aggregation not supported, falling back to CPU')();	×
278	gpuAggregation = false;	×
279	}	×
280	}	×
281	const gpuAggregationChanged = gpuAggregation !== this.state.gpuAggregation;	×
282	this.setState({	×
283	gpuAggregation	×
284	});	×
285		×
286	const positionsChanged = this.isAttributeChanged(POSITION_ATTRIBUTE_NAME);	×
287		×
288	const {dimensions} = this.state;	×
289	const {data, weights} = dimensions;	×
290	const aggregationDataDirty =	×
291	positionsChanged \|\|	×
292	gpuAggregationChanged \|\|	×
293	viewportChanged \|\|	×
294	this.isAggregationDirty(opts, {	×
295	compareAll: gpuAggregation, // check for all (including extentions props) when using gpu aggregation	×
296	dimension: data	×
297	});	×
298	const aggregationWeightsDirty = this.isAggregationDirty(opts, {dimension: weights});	×
299		×
300	this.setState({	×
301	aggregationDataDirty,	×
302	aggregationWeightsDirty	×
303	});	×
304		×
305	const {viewport} = this.context;	×
306		×
307	if (viewportChanged \|\| cellSizeChanged) {	×
308	const {width, height} = viewport;	×
309	const numCol = Math.ceil(width / cellSize);	×
310	const numRow = Math.ceil(height / cellSize);	×
311	this.allocateResources(numRow, numCol);	×
312	this.setState({	×
313	// transformation from clipspace to screen(pixel) space	×
314	scaling: [width / 2, -height / 2, 1],	×
315		×
316	gridOffset: {xOffset: cellSize, yOffset: cellSize},	×
317	width,	×
318	height,	×
319	numCol,	×
320	numRow	×
321	});	×
322	}	×
323		×
324	if (aggregationWeightsDirty) {	×
325	this._updateAccessors(opts);	×
326	}	×
327	if (aggregationDataDirty \|\| aggregationWeightsDirty) {	×
328	this._resetResults();	×
329	}	×
330	}	×
331	/* eslint-enable complexity, max-statements */	1✔
332		1✔
333	// Private	1✔
334		1✔
335	_updateAccessors(opts) {	1✔
336	const {getWeight, aggregation, data} = opts.props;	×
337	const {count} = this.state.weights;	×
338	if (count) {	×
339	count.getWeight = getWeight;	×
340	count.operation = AGGREGATION_OPERATION[aggregation];	×
341	}	×
342	this.setState({getValue: getValueFunc(aggregation, getWeight, {data})});	×
343	}	×
344		1✔
345	_resetResults() {	1✔
346	const {count} = this.state.weights;	×
347	if (count) {	×
348	count.aggregationData = null;	×
349	}	×
350	}	×
351	}	1✔

visgl / deck.gl / 8119906414

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