8139525056

Committed 04 Mar 2024 11:39AM UTC coverage: 70.685% (+0.04%) from 70.643%

Build # 8139525056

Build Type

Pull #8567

github

Committed by

web-flow

Commit Message

Merge 58f1b480a into 02885afbf

Pull Request Pull Request #8567: chore: Bump luma to 9.0.0-beta.6

Run Details

3402 of 4030 branches covered (84.42%)

Branch coverage included in aggregate %.

38 of 47 new or added lines in 20 files covered. (80.85%)

106 existing lines in 4 files now uncovered.

39995 of 57365 relevant lines covered (69.72%)

298.72 hits per line

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

50.0

/modules/aggregation-layers/src/contour-layer/contour-layer.ts

// Copyright (c) 2015 - 2018 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 {GL} from '@luma.gl/constants';
import {LineLayer, SolidPolygonLayer} from '@deck.gl/layers';
import {generateContours} from './contour-utils';
import {
  Accessor,
  AccessorFunction,
  Color,
  log,
  Position,
  UpdateParameters,
  DefaultProps,
  LayersList
} from '@deck.gl/core';

import GPUGridAggregator from '../utils/gpu-grid-aggregation/gpu-grid-aggregator';
import {AGGREGATION_OPERATION, getValueFunc} from '../utils/aggregation-operation-utils';
import {getBoundingBox, getGridParams} from '../utils/grid-aggregation-utils';
import GridAggregationLayer, {GridAggregationLayerProps} from '../grid-aggregation-layer';

const DEFAULT_COLOR = [255, 255, 255, 255];
const DEFAULT_STROKE_WIDTH = 1;
const DEFAULT_THRESHOLD = 1;

const defaultProps: DefaultProps<ContourLayerProps> = {
  // grid aggregation
  cellSize: {type: 'number', min: 1, max: 1000, value: 1000},
  getPosition: {type: 'accessor', value: (x: any) => x.position},
  getWeight: {type: 'accessor', value: 1},
  gpuAggregation: false, // TODO(v9): Re-enable GPU aggregation.
  aggregation: 'SUM',

  // contour lines
  contours: {
    type: 'object',
    value: [{threshold: DEFAULT_THRESHOLD}],
    optional: true,
    compare: 3
  },

  zOffset: 0.005
};

const POSITION_ATTRIBUTE_NAME = 'positions';

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

/** All properties supported by ContourLayer. */
export type ContourLayerProps<DataT = unknown> = _ContourLayerProps<DataT> &
  GridAggregationLayerProps<DataT>;

/** Properties added by ContourLayer. */
export type _ContourLayerProps<DataT> = {
  /**
   * Size of each cell in meters.
   * @default 1000
   */
  cellSize?: number;

  /**
   * When set to true, aggregation is performed on GPU, provided other conditions are met.
   * @default true
   */
  gpuAggregation?: boolean;

  /**
   * Defines the type of aggregation operation, valid values are 'SUM', 'MEAN', 'MIN' and 'MAX'.
   * @default 'SUM'
   */
  aggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';

  /**
   * Definition of contours to be drawn.
   * @default [{threshold: 1}]
   */
  contours: {
    /**
     * Isolines: `threshold` value must be a single `Number`, Isolines are generated based on this threshold value.
     *
     * Isobands: `threshold` value must be an Array of two `Number`s. Isobands are generated using `[threshold[0], threshold[1])` as threshold range, i.e area that has values `>= threshold[0]` and `< threshold[1]` are rendered with corresponding color. NOTE: `threshold[0]` is inclusive and `threshold[1]` is not inclusive.
     */
    threshold: number | number[];

    /**
     * RGBA color array to be used to render the contour.
     * @default [255, 255, 255, 255]
     */
    color?: Color;

    /**
     * Applicable for `Isoline`s only, width of the Isoline in pixels.
     * @default 1
     */
    strokeWidth?: number;

    /** Defines z order of the contour. */
    zIndex?: number;
  }[];

  /**
   * A very small z offset that is added for each vertex of a contour (Isoline or Isoband).
   * @default 0.005
   */
  zOffset?: number;

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

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

/** Aggregate data into iso-lines or iso-bands for a given threshold and cell size. */
export default class ContourLayer<
  DataT = any,
  ExtraPropsT extends {} = {}
> extends GridAggregationLayer<DataT, ExtraPropsT & Required<_ContourLayerProps<DataT>>> {
  static layerName = 'ContourLayer';
  static defaultProps = defaultProps;

  state!: GridAggregationLayer<DataT>['state'] & {
    contourData: {
      contourSegments: {
        start: number[];
        end: number[];
        contour: any;
      }[];
      contourPolygons: {
        vertices: number[][];
        contour: any;
      }[];
    };
    thresholdData: any;
  };

  initializeState(): void {
    super.initializeAggregationLayer({
      dimensions: DIMENSIONS
    });
    this.setState({
      contourData: {},
      projectPoints: false,
      weights: {
        count: {
          size: 1,
          operation: AGGREGATION_OPERATION.SUM
        }
      }
    });
    const attributeManager = this.getAttributeManager()!;
    attributeManager.add({
      [POSITION_ATTRIBUTE_NAME]: {
        size: 3,
        accessor: 'getPosition',
        type: GL.DOUBLE,
        fp64: this.use64bitPositions()
      },
      // this attribute is used in gpu aggregation path only
      count: {size: 3, accessor: 'getWeight'}
    });
  }

  updateState(opts: UpdateParameters<this>): void {
    super.updateState(opts);
    let contoursChanged = false;
    const {oldProps, props} = opts;
    const {aggregationDirty} = this.state;

    if (oldProps.contours !== props.contours || oldProps.zOffset !== props.zOffset) {
      contoursChanged = true;
      this._updateThresholdData(opts.props);
    }

    if (this.getNumInstances() > 0 && (aggregationDirty || contoursChanged)) {
      this._generateContours();
    }
  }

  renderLayers(): LayersList {
    const {contourSegments, contourPolygons} = this.state.contourData;

    const LinesSubLayerClass = this.getSubLayerClass('lines', LineLayer);
    const BandsSubLayerClass = this.getSubLayerClass('bands', SolidPolygonLayer);

    // Contour lines layer
    const lineLayer =
      contourSegments &&
      contourSegments.length > 0 &&
      new LinesSubLayerClass(
        this.getSubLayerProps({
          id: 'lines'
        }),
        {
          data: this.state.contourData.contourSegments,
          getSourcePosition: d => d.start,
          getTargetPosition: d => d.end,
          getColor: d => d.contour.color || DEFAULT_COLOR,
          getWidth: d => d.contour.strokeWidth || DEFAULT_STROKE_WIDTH
        }
      );

    // Contour bands layer
    const bandsLayer =
      contourPolygons &&
      contourPolygons.length > 0 &&
      new BandsSubLayerClass(
        this.getSubLayerProps({
          id: 'bands'
        }),
        {
          data: this.state.contourData.contourPolygons,
          getPolygon: d => d.vertices,
          getFillColor: d => d.contour.color || DEFAULT_COLOR
        }
      );

    return [lineLayer, bandsLayer];
  }

  // Aggregation Overrides

  /* eslint-disable max-statements, complexity */
  updateAggregationState(opts: UpdateParameters<this>) {
    const {props, oldProps} = opts;
    const {cellSize, coordinateSystem} = props;
    const {viewport} = this.context;
    const cellSizeChanged = oldProps.cellSize !== cellSize;
    let gpuAggregation = props.gpuAggregation;
    if (this.state.gpuAggregation !== 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 {dimensions} = this.state;
    const positionsChanged = this.isAttributeChanged(POSITION_ATTRIBUTE_NAME);
    const {data, weights} = dimensions;

    let {boundingBox} = this.state;
    if (positionsChanged) {
      boundingBox = getBoundingBox(this.getAttributes(), this.getNumInstances());
      this.setState({boundingBox});
    }
    if (positionsChanged || cellSizeChanged) {
      const {gridOffset, translation, width, height, numCol, numRow} = getGridParams(
        boundingBox,
        cellSize,
        viewport,
        coordinateSystem
      );
      this.allocateResources(numRow, numCol);
      this.setState({
        gridOffset,
        boundingBox,
        translation,
        posOffset: translation.slice(), // Used for CPU aggregation, to offset points
        gridOrigin: [-1 * translation[0], -1 * translation[1]],
        width,
        height,
        numCol,
        numRow
      });
    }

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

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

  // Private (Aggregation)

  private _updateAccessors(opts: UpdateParameters<this>) {
    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})});
  }

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

  // Private (Contours)

  private _generateContours() {
    const {numCol, numRow, gridOrigin, gridOffset, thresholdData} = this.state;
    const {count} = this.state.weights;
    let {aggregationData} = count;
    if (!aggregationData) {
      // @ts-ignore
      aggregationData = count.aggregationBuffer!.readSyncWebGL() as Float32Array;
      count.aggregationData = aggregationData;
    }

    const {cellWeights} = GPUGridAggregator.getCellData({countsData: aggregationData});
    const contourData = generateContours({
      thresholdData,
      cellWeights,
      gridSize: [numCol, numRow],
      gridOrigin,
      cellSize: [gridOffset.xOffset, gridOffset.yOffset]
    });

    // contourData contains both iso-lines and iso-bands if requested.
    this.setState({contourData});
  }

  private _updateThresholdData(props) {
    const {contours, zOffset} = props;
    const count = contours.length;
    const thresholdData = new Array(count);
    for (let i = 0; i < count; i++) {
      const contour = contours[i];
      thresholdData[i] = {
        contour,
        zIndex: contour.zIndex || i,
        zOffset
      };
    }
    this.setState({thresholdData});
  }
}

1	// Copyright (c) 2015 - 2018 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 {GL} from '@luma.gl/constants';	1✔
22	import {LineLayer, SolidPolygonLayer} from '@deck.gl/layers';	1✔
23	import {generateContours} from './contour-utils';	1✔
24	import {	1✔
25	Accessor,	1✔
26	AccessorFunction,	1✔
27	Color,	1✔
28	log,	1✔
29	Position,	1✔
30	UpdateParameters,	1✔
31	DefaultProps,	1✔
32	LayersList	1✔
33	} from '@deck.gl/core';	1✔
34		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 {getBoundingBox, getGridParams} from '../utils/grid-aggregation-utils';	1✔
38	import GridAggregationLayer, {GridAggregationLayerProps} from '../grid-aggregation-layer';	1✔
39		1✔
40	const DEFAULT_COLOR = [255, 255, 255, 255];	1✔
41	const DEFAULT_STROKE_WIDTH = 1;	1✔
42	const DEFAULT_THRESHOLD = 1;	1✔
43		1✔
44	const defaultProps: DefaultProps<ContourLayerProps> = {	1✔
45	// grid aggregation	1✔
46	cellSize: {type: 'number', min: 1, max: 1000, value: 1000},	1✔
47	getPosition: {type: 'accessor', value: (x: any) => x.position},	1✔
48	getWeight: {type: 'accessor', value: 1},	1✔
49	gpuAggregation: false, // TODO(v9): Re-enable GPU aggregation.	1✔
50	aggregation: 'SUM',	1✔
51		1✔
52	// contour lines	1✔
53	contours: {	1✔
54	type: 'object',	1✔
55	value: [{threshold: DEFAULT_THRESHOLD}],	1✔
56	optional: true,	1✔
57	compare: 3	1✔
58	},	1✔
59		1✔
60	zOffset: 0.005	1✔
61	};	1✔
62		1✔
63	const POSITION_ATTRIBUTE_NAME = 'positions';	1✔
64		1✔
65	const DIMENSIONS = {	1✔
66	data: {	1✔
67	props: ['cellSize']	1✔
68	},	1✔
69	weights: {	1✔
70	props: ['aggregation'],	1✔
71	accessors: ['getWeight']	1✔
72	}	1✔
73	};	1✔
74		1✔
75	/** All properties supported by ContourLayer. */	1✔
76	export type ContourLayerProps<DataT = unknown> = _ContourLayerProps<DataT> &	1✔
77	GridAggregationLayerProps<DataT>;	1✔
78		1✔
79	/** Properties added by ContourLayer. */	1✔
80	export type _ContourLayerProps<DataT> = {	1✔
81	/**	1✔
82	* Size of each cell in meters.	1✔
83	* @default 1000	1✔
84	*/	1✔
85	cellSize?: number;	1✔
86		1✔
87	/**	1✔
88	* When set to true, aggregation is performed on GPU, provided other conditions are met.	1✔
89	* @default true	1✔
90	*/	1✔
91	gpuAggregation?: boolean;	1✔
92		1✔
93	/**	1✔
94	* Defines the type of aggregation operation, valid values are 'SUM', 'MEAN', 'MIN' and 'MAX'.	1✔
95	* @default 'SUM'	1✔
96	*/	1✔
97	aggregation?: 'SUM' \| 'MEAN' \| 'MIN' \| 'MAX';	1✔
98		1✔
99	/**	1✔
100	* Definition of contours to be drawn.	1✔
101	* @default [{threshold: 1}]	1✔
102	*/	1✔
103	contours: {	1✔
104	/**	1✔
105	* Isolines: `threshold` value must be a single `Number`, Isolines are generated based on this threshold value.	1✔
106	*	1✔
107	* Isobands: `threshold` value must be an Array of two `Number`s. Isobands are generated using `[threshold[0], threshold[1])` as threshold range, i.e area that has values `>= threshold[0]` and `< threshold[1]` are rendered with corresponding color. NOTE: `threshold[0]` is inclusive and `threshold[1]` is not inclusive.	1✔
108	*/	1✔
109	threshold: number \| number[];	1✔
110		1✔
111	/**	1✔
112	* RGBA color array to be used to render the contour.	1✔
113	* @default [255, 255, 255, 255]	1✔
114	*/	1✔
115	color?: Color;	1✔
116		1✔
117	/**	1✔
118	* Applicable for `Isoline`s only, width of the Isoline in pixels.	1✔
119	* @default 1	1✔
120	*/	1✔
121	strokeWidth?: number;	1✔
122		1✔
123	/** Defines z order of the contour. */	1✔
124	zIndex?: number;	1✔
125	}[];	1✔
126		1✔
127	/**	1✔
128	* A very small z offset that is added for each vertex of a contour (Isoline or Isoband).	1✔
129	* @default 0.005	1✔
130	*/	1✔
131	zOffset?: number;	1✔
132		1✔
133	/**	1✔
134	* Method called to retrieve the position of each object.	1✔
135	* @default object => object.position	1✔
136	*/	1✔
137	getPosition?: AccessorFunction<DataT, Position>;	1✔
138		1✔
139	/**	1✔
140	* The weight of each object.	1✔
141	* @default 1	1✔
142	*/	1✔
143	getWeight?: Accessor<DataT, number>;	1✔
144	};	1✔
145		1✔
146	/** Aggregate data into iso-lines or iso-bands for a given threshold and cell size. */	1✔
147	export default class ContourLayer<	1✔
148	DataT = any,	1✔
149	ExtraPropsT extends {} = {}	1✔
150	> extends GridAggregationLayer<DataT, ExtraPropsT & Required<_ContourLayerProps<DataT>>> {	1✔
151	static layerName = 'ContourLayer';	1✔
152	static defaultProps = defaultProps;	1✔
153		1✔
154	state!: GridAggregationLayer<DataT>['state'] & {	1✔
155	contourData: {	1✔
156	contourSegments: {	1✔
157	start: number[];	1✔
158	end: number[];	1✔
159	contour: any;	1✔
160	}[];	1✔
161	contourPolygons: {	1✔
162	vertices: number[][];	1✔
163	contour: any;	1✔
164	}[];	1✔
165	};	1✔
166	thresholdData: any;	1✔
167	};	1✔
168		1✔
169	initializeState(): void {	1✔
170	super.initializeAggregationLayer({	×
171	dimensions: DIMENSIONS	×
172	});	×
173	this.setState({	×
174	contourData: {},	×
175	projectPoints: false,	×
176	weights: {	×
177	count: {	×
178	size: 1,	×
179	operation: AGGREGATION_OPERATION.SUM	×
180	}	×
181	}	×
182	});	×
183	const attributeManager = this.getAttributeManager()!;	×
184	attributeManager.add({	×
185	[POSITION_ATTRIBUTE_NAME]: {	×
186	size: 3,	×
187	accessor: 'getPosition',	×
188	type: GL.DOUBLE,	×
189	fp64: this.use64bitPositions()	×
190	},	×
191	// this attribute is used in gpu aggregation path only	×
192	count: {size: 3, accessor: 'getWeight'}	×
193	});	×
194	}	×
195		1✔
196	updateState(opts: UpdateParameters<this>): void {	1✔
197	super.updateState(opts);	×
198	let contoursChanged = false;	×
199	const {oldProps, props} = opts;	×
200	const {aggregationDirty} = this.state;	×
201		×
202	if (oldProps.contours !== props.contours \|\| oldProps.zOffset !== props.zOffset) {	×
203	contoursChanged = true;	×
204	this._updateThresholdData(opts.props);	×
205	}	×
206		×
207	if (this.getNumInstances() > 0 && (aggregationDirty \|\| contoursChanged)) {	×
208	this._generateContours();	×
209	}	×
210	}	×
211		1✔
212	renderLayers(): LayersList {	1✔
213	const {contourSegments, contourPolygons} = this.state.contourData;	×
214		×
215	const LinesSubLayerClass = this.getSubLayerClass('lines', LineLayer);	×
216	const BandsSubLayerClass = this.getSubLayerClass('bands', SolidPolygonLayer);	×
217		×
218	// Contour lines layer	×
219	const lineLayer =	×
220	contourSegments &&	×
221	contourSegments.length > 0 &&	×
222	new LinesSubLayerClass(	×
223	this.getSubLayerProps({	×
224	id: 'lines'	×
225	}),	×
226	{	×
227	data: this.state.contourData.contourSegments,	×
228	getSourcePosition: d => d.start,	×
229	getTargetPosition: d => d.end,	×
230	getColor: d => d.contour.color \|\| DEFAULT_COLOR,	×
231	getWidth: d => d.contour.strokeWidth \|\| DEFAULT_STROKE_WIDTH	×
232	}	×
233	);	×
234		×
235	// Contour bands layer	×
236	const bandsLayer =	×
237	contourPolygons &&	×
238	contourPolygons.length > 0 &&	×
239	new BandsSubLayerClass(	×
240	this.getSubLayerProps({	×
241	id: 'bands'	×
242	}),	×
243	{	×
244	data: this.state.contourData.contourPolygons,	×
245	getPolygon: d => d.vertices,	×
246	getFillColor: d => d.contour.color \|\| DEFAULT_COLOR	×
247	}	×
248	);	×
249		×
250	return [lineLayer, bandsLayer];	×
251	}	×
252		1✔
253	// Aggregation Overrides	1✔
254		1✔
255	/* eslint-disable max-statements, complexity */	1✔
256	updateAggregationState(opts: UpdateParameters<this>) {	1✔
257	const {props, oldProps} = opts;	×
258	const {cellSize, coordinateSystem} = props;	×
259	const {viewport} = this.context;	×
260	const cellSizeChanged = oldProps.cellSize !== cellSize;	×
261	let gpuAggregation = props.gpuAggregation;	×
262	if (this.state.gpuAggregation !== props.gpuAggregation) {	×
263	if (gpuAggregation && !GPUGridAggregator.isSupported(this.context.device)) {	×
264	log.warn('GPU Grid Aggregation not supported, falling back to CPU')();	×
265	gpuAggregation = false;	×
266	}	×
267	}	×
268	const gpuAggregationChanged = gpuAggregation !== this.state.gpuAggregation;	×
269	this.setState({	×
270	gpuAggregation	×
271	});	×
272		×
273	const {dimensions} = this.state;	×
274	const positionsChanged = this.isAttributeChanged(POSITION_ATTRIBUTE_NAME);	×
275	const {data, weights} = dimensions;	×
276		×
277	let {boundingBox} = this.state;	×
278	if (positionsChanged) {	×
279	boundingBox = getBoundingBox(this.getAttributes(), this.getNumInstances());	×
280	this.setState({boundingBox});	×
281	}	×
282	if (positionsChanged \|\| cellSizeChanged) {	×
283	const {gridOffset, translation, width, height, numCol, numRow} = getGridParams(	×
284	boundingBox,	×
285	cellSize,	×
286	viewport,	×
287	coordinateSystem	×
288	);	×
289	this.allocateResources(numRow, numCol);	×
290	this.setState({	×
291	gridOffset,	×
292	boundingBox,	×
293	translation,	×
294	posOffset: translation.slice(), // Used for CPU aggregation, to offset points	×
295	gridOrigin: [-1 * translation[0], -1 * translation[1]],	×
296	width,	×
297	height,	×
298	numCol,	×
299	numRow	×
300	});	×
301	}	×
302		×
303	const aggregationDataDirty =	×
304	positionsChanged \|\|	×
305	gpuAggregationChanged \|\|	×
306	this.isAggregationDirty(opts, {	×
307	dimension: data,	×
308	compareAll: gpuAggregation // check for all (including extentions props) when using gpu aggregation	×
309	});	×
310	const aggregationWeightsDirty = this.isAggregationDirty(opts, {	×
311	dimension: weights	×
312	});	×
313		×
314	if (aggregationWeightsDirty) {	×
315	this._updateAccessors(opts);	×
316	}	×
317	if (aggregationDataDirty \|\| aggregationWeightsDirty) {	×
318	this._resetResults();	×
319	}	×
320	this.setState({	×
321	aggregationDataDirty,	×
322	aggregationWeightsDirty	×
323	});	×
324	}	×
325	/* eslint-enable max-statements, complexity */	1✔
326		1✔
327	// Private (Aggregation)	1✔
328		1✔
329	private _updateAccessors(opts: UpdateParameters<this>) {	1✔
330	const {getWeight, aggregation, data} = opts.props;	×
331	const {count} = this.state.weights;	×
332	if (count) {	×
333	count.getWeight = getWeight;	×
334	count.operation = AGGREGATION_OPERATION[aggregation];	×
335	}	×
336	this.setState({getValue: getValueFunc(aggregation, getWeight, {data})});	×
337	}	×
338		1✔
339	private _resetResults() {	1✔
340	const {count} = this.state.weights;	×
341	if (count) {	×
342	count.aggregationData = null;	×
343	}	×
344	}	×
345		1✔
346	// Private (Contours)	1✔
347		1✔
348	private _generateContours() {	1✔
349	const {numCol, numRow, gridOrigin, gridOffset, thresholdData} = this.state;	×
350	const {count} = this.state.weights;	×
351	let {aggregationData} = count;	×
352	if (!aggregationData) {	×
353	// @ts-ignore	×
NEW 354	aggregationData = count.aggregationBuffer!.readSyncWebGL() as Float32Array;	×
355	count.aggregationData = aggregationData;	×
356	}	×
357		×
358	const {cellWeights} = GPUGridAggregator.getCellData({countsData: aggregationData});	×
359	const contourData = generateContours({	×
360	thresholdData,	×
361	cellWeights,	×
362	gridSize: [numCol, numRow],	×
363	gridOrigin,	×
364	cellSize: [gridOffset.xOffset, gridOffset.yOffset]	×
365	});	×
366		×
367	// contourData contains both iso-lines and iso-bands if requested.	×
368	this.setState({contourData});	×
369	}	×
370		1✔
371	private _updateThresholdData(props) {	1✔
372	const {contours, zOffset} = props;	×
373	const count = contours.length;	×
374	const thresholdData = new Array(count);	×
375	for (let i = 0; i < count; i++) {	×
376	const contour = contours[i];	×
377	thresholdData[i] = {	×
378	contour,	×
379	zIndex: contour.zIndex \|\| i,	×
380	zOffset	×
381	};	×
382	}	×
383	this.setState({thresholdData});	×
384	}	×
385	}	1✔

visgl / deck.gl / 8139525056

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