10533668922

Committed 23 Aug 2024 11:27PM UTC coverage: 89.293% (+0.4%) from 88.902%

Build # 10533668922

Build Type

push

github

Committed by

web-flow

Commit Message

GPU Aggregation (7/8): ContourLayer (#9099)

Run Details

6755 of 7391 branches covered (91.39%)

Branch coverage included in aggregate %.

522 of 533 new or added lines in 6 files covered. (97.94%)

13 existing lines in 2 files now uncovered.

56179 of 63089 relevant lines covered (89.05%)

13893.01 hits per line

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

97.54

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

// deck.gl
// SPDX-License-Identifier: MIT
// Copyright (c) vis.gl contributors

import {
  Accessor,
  COORDINATE_SYSTEM,
  GetPickingInfoParams,
  project32,
  LayersList,
  PickingInfo,
  Position,
  Viewport,
  _deepEqual,
  UpdateParameters,
  DefaultProps
} from '@deck.gl/core';
import {PathLayer, SolidPolygonLayer} from '@deck.gl/layers';
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 {AggregationLayerProps} from '../aggregation-layer-v9/aggregation-layer';
import {AggregationOperation} from '../aggregation-layer-v9/aggregator';
import {generateContours, Contour, ContourLine, ContourPolygon} from './contour-utils';
import {getAggregatorValueReader} from './value-reader';
import {Matrix4} from '@math.gl/core';

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

const defaultProps: DefaultProps<ContourLayerProps> = {
  // grid aggregation
  cellSize: {type: 'number', min: 1, value: 1000},
  gridOrigin: {type: 'array', compare: true, value: [0, 0]},
  getPosition: {type: 'accessor', value: (x: any) => x.position},
  getWeight: {type: 'accessor', value: 1},
  gpuAggregation: true,
  aggregation: 'SUM',

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

  zOffset: 0.005
};

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

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

  /**
   * The grid origin
   * @default [0, 0]
   */
  gridOrigin?: [number, number];

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

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

  /**
   * Definition of contours to be drawn.
   * @default [{threshold: 1}]
   */
  contours?: Contour[];

  /**
   * 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?: Accessor<DataT, Position>;

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

export type ContourLayerPickingInfo = PickingInfo<{
  contour: Contour;
}>;

/** Aggregate data into a grid-based heatmap. The color and height of a cell are determined based on the objects it contains. */
export default class GridLayer<DataT = any, ExtraPropsT extends {} = {}> extends AggregationLayer<
  DataT,
  ExtraPropsT & Required<_ContourLayerProps<DataT>>
> {
  static layerName = 'ContourLayer';
  static defaultProps = defaultProps;

  state!: AggregationLayer<DataT>['state'] & {
    // Aggregator result
    aggregatedValueReader?: (x: number, y: number) => number;
    contourData?: {
      lines: ContourLine[];
      polygons: ContourPolygon[];
    };

    // Aggregator bin options
    cellSizeCommon: [number, number];
    cellOriginCommon: [number, number];
    binIdRange: [number, number][];
    aggregatorViewport: Viewport;
  };

  getAggregatorType(): string {
    return this.props.gpuAggregation && WebGLAggregator.isSupported(this.context.device)
      ? 'gpu'
      : 'cpu';
  }

  createAggregator(type: string): WebGLAggregator | CPUAggregator {
    if (type === 'cpu') {
      return new CPUAggregator({
        dimensions: 2,
        getBin: {
          sources: ['positions'],
          getValue: (
            {positions}: {positions: number[]},
            index: number,
            opts: {
              cellSizeCommon: [number, number];
              cellOriginCommon: [number, number];
            }
          ) => {
            const viewport = this.state.aggregatorViewport;
            // project to common space
            const p = viewport.projectPosition(positions);
            const {cellSizeCommon, cellOriginCommon} = opts;
            return [
              Math.floor((p[0] - cellOriginCommon[0]) / cellSizeCommon[0]),
              Math.floor((p[1] - cellOriginCommon[1]) / cellSizeCommon[1])
            ];
          }
        },
        getValue: [{sources: ['counts'], getValue: ({counts}) => counts}],
        onUpdate: this._onAggregationUpdate.bind(this)
      });
    }
    return new WebGLAggregator(this.context.device, {
      dimensions: 2,
      channelCount: 1,
      bufferLayout: this.getAttributeManager()!.getBufferLayouts({isInstanced: false}),
      ...super.getShaders({
        modules: [project32],
        vs: /* glsl */ `
  uniform vec2 cellOriginCommon;
  uniform vec2 cellSizeCommon;
  in vec3 positions;
  in vec3 positions64Low;
  in float counts;

  void getBin(out ivec2 binId) {
    vec3 positionCommon = project_position(positions, positions64Low);
    vec2 gridCoords = floor(positionCommon.xy / cellSizeCommon);
    binId = ivec2(gridCoords);
  }
  void getValue(out float value) {
    value = counts;
  }
  `
      }),
      onUpdate: this._onAggregationUpdate.bind(this)
    });
  }

  initializeState() {
    super.initializeState();

    const attributeManager = this.getAttributeManager()!;
    attributeManager.add({
      positions: {
        size: 3,
        accessor: 'getPosition',
        type: 'float64',
        fp64: this.use64bitPositions()
      },
      counts: {size: 1, accessor: 'getWeight'}
    });
  }

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

    const {props, oldProps, changeFlags} = params;
    const {aggregator} = this.state;
    if (
      aggregatorChanged ||
      changeFlags.dataChanged ||
      props.cellSize !== oldProps.cellSize ||
      !_deepEqual(props.gridOrigin, oldProps.gridOrigin, 1) ||
      props.aggregation !== oldProps.aggregation
    ) {
      this._updateBinOptions();
      const {cellSizeCommon, cellOriginCommon, binIdRange} = this.state;

      aggregator.setProps({
        // @ts-expect-error only used by GPUAggregator
        binIdRange,
        pointCount: this.getNumInstances(),
        operations: [props.aggregation],
        binOptions: {
          cellSizeCommon,
          cellOriginCommon
        }
      });
    }

    if (!_deepEqual(oldProps.contours, props.contours, 2)) {
      // Recalculate contours
      this.setState({contourData: null});
    }

    return aggregatorChanged;
  }

  private _updateBinOptions() {
    const bounds = this.getBounds();
    const cellSizeCommon: [number, number] = [1, 1];
    let cellOriginCommon: [number, number] = [0, 0];
    const binIdRange: [number, number][] = [
      [0, 1],
      [0, 1]
    ];
    let viewport = this.context.viewport;

    if (bounds && Number.isFinite(bounds[0][0])) {
      let centroid = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2];
      const {cellSize, gridOrigin} = this.props;
      const {unitsPerMeter} = viewport.getDistanceScales(centroid);
      cellSizeCommon[0] = unitsPerMeter[0] * cellSize;
      cellSizeCommon[1] = unitsPerMeter[1] * cellSize;

      // Offset common space to center at the origin of the grid cell where the data center is in
      // This improves precision without affecting the cell positions
      const centroidCommon = viewport.projectFlat(centroid);
      cellOriginCommon = [
        Math.floor((centroidCommon[0] - gridOrigin[0]) / cellSizeCommon[0]) * cellSizeCommon[0] +
          gridOrigin[0],
        Math.floor((centroidCommon[1] - gridOrigin[1]) / cellSizeCommon[1]) * cellSizeCommon[1] +
          gridOrigin[1]
      ];
      centroid = viewport.unprojectFlat(cellOriginCommon);

      const ViewportType = viewport.constructor as any;
      // We construct a viewport for the GPU aggregator's project module
      // This viewport is determined by data
      // removes arbitrary precision variance that depends on initial view state
      viewport = viewport.isGeospatial
        ? new ViewportType({longitude: centroid[0], latitude: centroid[1], zoom: 12})
        : new Viewport({position: [centroid[0], centroid[1], 0], zoom: 12});

      // Round to the nearest 32-bit float to match CPU and GPU results
      cellOriginCommon = [Math.fround(viewport.center[0]), Math.fround(viewport.center[1])];

      const corners = [
        bounds[0],
        bounds[1],
        [bounds[0][0], bounds[1][1]],
        [bounds[1][0], bounds[0][1]]
      ].map(p => viewport.projectFlat(p));

      const minX = Math.min(...corners.map(p => p[0]));
      const minY = Math.min(...corners.map(p => p[1]));
      const maxX = Math.max(...corners.map(p => p[0]));
      const maxY = Math.max(...corners.map(p => p[1]));
      binIdRange[0][0] = Math.floor((minX - cellOriginCommon[0]) / cellSizeCommon[0]);
      binIdRange[0][1] = Math.floor((maxX - cellOriginCommon[0]) / cellSizeCommon[0]) + 1;
      binIdRange[1][0] = Math.floor((minY - cellOriginCommon[1]) / cellSizeCommon[1]);
      binIdRange[1][1] = Math.floor((maxY - cellOriginCommon[1]) / cellSizeCommon[1]) + 1;
    }

    this.setState({cellSizeCommon, cellOriginCommon, binIdRange, aggregatorViewport: viewport});
  }

  override draw(opts) {
    // Replaces render time viewport with our own
    if (opts.moduleParameters.viewport) {
      opts.moduleParameters.viewport = this.state.aggregatorViewport;
    }
    super.draw(opts);
  }

  private _onAggregationUpdate() {
    const {aggregator, binIdRange} = this.state;
    this.setState({
      aggregatedValueReader: getAggregatorValueReader({aggregator, binIdRange, channel: 0}),
      contourData: null
    });
  }

  private _getContours(): {
    lines: ContourLine[];
    polygons: ContourPolygon[];
  } | null {
    const {aggregatedValueReader} = this.state;
    if (!aggregatedValueReader) {
      return null;
    }

    if (!this.state.contourData) {
      const {binIdRange} = this.state;
      const {contours} = this.props;
      const contourData = generateContours({
        contours,
        getValue: aggregatedValueReader,
        xRange: binIdRange[0],
        yRange: binIdRange[1]
      });

      this.state.contourData = contourData;
    }
    return this.state.contourData;
  }

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

        this._updateBinOptions();
        const {cellSizeCommon, cellOriginCommon, binIdRange} = this.state;
        aggregator.setProps({
          // @ts-expect-error only used by GPUAggregator
          binIdRange,
          binOptions: {
            cellSizeCommon,
            cellOriginCommon
          }
        });
        break;

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

      default:
      // This should not happen
    }
  }

  renderLayers(): LayersList | null {
    const contourData = this._getContours();
    if (!contourData) {
      return null;
    }
    const {lines, polygons} = contourData;
    const {zOffset} = this.props;
    const {cellOriginCommon, cellSizeCommon} = this.state;

    const LinesSubLayerClass = this.getSubLayerClass('lines', PathLayer);
    const BandsSubLayerClass = this.getSubLayerClass('bands', SolidPolygonLayer);
    const modelMatrix = new Matrix4()
      .translate([cellOriginCommon[0], cellOriginCommon[1], 0])
      .scale([cellSizeCommon[0], cellSizeCommon[1], zOffset]);

    // Contour lines layer
    const lineLayer =
      lines &&
      lines.length > 0 &&
      new LinesSubLayerClass(
        this.getSubLayerProps({
          id: 'lines'
        }),
        {
          data: lines,
          coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
          modelMatrix,
          getPath: d => d.vertices,
          getColor: d => d.contour.color ?? DEFAULT_COLOR,
          getWidth: d => d.contour.strokeWidth ?? DEFAULT_STROKE_WIDTH,
          widthUnits: 'pixels'
        }
      );

    // Contour bands layer
    const bandsLayer =
      polygons &&
      polygons.length > 0 &&
      new BandsSubLayerClass(
        this.getSubLayerProps({
          id: 'bands'
        }),
        {
          data: polygons,
          coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
          modelMatrix,
          getPolygon: d => d.vertices,
          getFillColor: d => d.contour.color ?? DEFAULT_COLOR
        }
      );

    return [lineLayer, bandsLayer];
  }

  getPickingInfo(params: GetPickingInfoParams): ContourLayerPickingInfo {
    const info: ContourLayerPickingInfo = params.info;
    const {object} = info;
    if (object) {
      info.object = {
        contour: (object as ContourLine | ContourPolygon).contour
      };
    }

    return info;
  }
}

1	// deck.gl	1✔
2	// SPDX-License-Identifier: MIT	1✔
3	// Copyright (c) vis.gl contributors	1✔
4		1✔
5	import {	1✔
6	Accessor,	1✔
7	COORDINATE_SYSTEM,	1✔
8	GetPickingInfoParams,	1✔
9	project32,	1✔
10	LayersList,	1✔
11	PickingInfo,	1✔
12	Position,	1✔
13	Viewport,	1✔
14	_deepEqual,	1✔
15	UpdateParameters,	1✔
16	DefaultProps	1✔
17	} from '@deck.gl/core';	1✔
18	import {PathLayer, SolidPolygonLayer} from '@deck.gl/layers';	1✔
19	import {WebGLAggregator} from '../aggregation-layer-v9/gpu-aggregator/webgl-aggregator';	1✔
20	import {CPUAggregator} from '../aggregation-layer-v9/cpu-aggregator/cpu-aggregator';	1✔
21	import AggregationLayer from '../aggregation-layer-v9/aggregation-layer';	1✔
22	import {AggregationLayerProps} from '../aggregation-layer-v9/aggregation-layer';	1✔
23	import {AggregationOperation} from '../aggregation-layer-v9/aggregator';	1✔
24	import {generateContours, Contour, ContourLine, ContourPolygon} from './contour-utils';	1✔
25	import {getAggregatorValueReader} from './value-reader';	1✔
26	import {Matrix4} from '@math.gl/core';	1✔
27		1✔
28	const DEFAULT_COLOR = [255, 255, 255, 255];	1✔
29	const DEFAULT_STROKE_WIDTH = 1;	1✔
30		1✔
31	const defaultProps: DefaultProps<ContourLayerProps> = {	1✔
32	// grid aggregation	1✔
33	cellSize: {type: 'number', min: 1, value: 1000},	1✔
34	gridOrigin: {type: 'array', compare: true, value: [0, 0]},	1✔
35	getPosition: {type: 'accessor', value: (x: any) => x.position},	1✔
36	getWeight: {type: 'accessor', value: 1},	1✔
37	gpuAggregation: true,	1✔
38	aggregation: 'SUM',	1✔
39		1✔
40	// contour lines	1✔
41	contours: {	1✔
42	type: 'object',	1✔
43	value: [{threshold: 1}],	1✔
44	optional: true,	1✔
45	compare: 3	1✔
46	},	1✔
47		1✔
48	zOffset: 0.005	1✔
49	};	1✔
50		1✔
51	/** All properties supported by GridLayer. */	1✔
52	export type ContourLayerProps<DataT = unknown> = _ContourLayerProps<DataT> &	1✔
53	AggregationLayerProps<DataT>;	1✔
54		1✔
55	/** Properties added by GridLayer. */	1✔
56	type _ContourLayerProps<DataT> = {	1✔
57	/**	1✔
58	* Size of each cell in meters.	1✔
59	* @default 1000	1✔
60	*/	1✔
61	cellSize?: number;	1✔
62		1✔
63	/**	1✔
64	* The grid origin	1✔
65	* @default [0, 0]	1✔
66	*/	1✔
67	gridOrigin?: [number, number];	1✔
68		1✔
69	/**	1✔
70	* When set to true, aggregation is performed on GPU, provided other conditions are met.	1✔
71	* @default false	1✔
72	*/	1✔
73	gpuAggregation?: boolean;	1✔
74		1✔
75	/**	1✔
76	* Defines the type of aggregation operation, valid values are 'SUM', 'MEAN', 'MIN' and 'MAX'.	1✔
77	* @default 'SUM'	1✔
78	*/	1✔
79	aggregation?: AggregationOperation;	1✔
80		1✔
81	/**	1✔
82	* Definition of contours to be drawn.	1✔
83	* @default [{threshold: 1}]	1✔
84	*/	1✔
85	contours?: Contour[];	1✔
86		1✔
87	/**	1✔
88	* A very small z offset that is added for each vertex of a contour (Isoline or Isoband).	1✔
89	* @default 0.005	1✔
90	*/	1✔
91	zOffset?: number;	1✔
92		1✔
93	/**	1✔
94	* Method called to retrieve the position of each object.	1✔
95	* @default object => object.position	1✔
96	*/	1✔
97	getPosition?: Accessor<DataT, Position>;	1✔
98		1✔
99	/**	1✔
100	* The weight of each object.	1✔
101	* @default 1	1✔
102	*/	1✔
103	getWeight?: Accessor<DataT, number>;	1✔
104	};	1✔
105		1✔
106	export type ContourLayerPickingInfo = PickingInfo<{	1✔
107	contour: Contour;	1✔
108	}>;	1✔
109		1✔
110	/** Aggregate data into a grid-based heatmap. The color and height of a cell are determined based on the objects it contains. */	1✔
111	export default class GridLayer<DataT = any, ExtraPropsT extends {} = {}> extends AggregationLayer<	1✔
112	DataT,	1✔
113	ExtraPropsT & Required<_ContourLayerProps<DataT>>	1✔
114	> {	1✔
115	static layerName = 'ContourLayer';	1✔
116	static defaultProps = defaultProps;	1✔
117		1✔
118	state!: AggregationLayer<DataT>['state'] & {	1✔
119	// Aggregator result	1✔
120	aggregatedValueReader?: (x: number, y: number) => number;	1✔
121	contourData?: {	1✔
122	lines: ContourLine[];	1✔
123	polygons: ContourPolygon[];	1✔
124	};	1✔
125		1✔
126	// Aggregator bin options	1✔
127	cellSizeCommon: [number, number];	1✔
128	cellOriginCommon: [number, number];	1✔
129	binIdRange: [number, number][];	1✔
130	aggregatorViewport: Viewport;	1✔
131	};	1✔
132		1✔
133	getAggregatorType(): string {	1✔
134	return this.props.gpuAggregation && WebGLAggregator.isSupported(this.context.device)	35✔
135	? 'gpu'	31✔
136	: 'cpu';	4✔
137	}	35✔
138		1✔
139	createAggregator(type: string): WebGLAggregator \| CPUAggregator {	1✔
140	if (type === 'cpu') {	10✔
141	return new CPUAggregator({	4✔
142	dimensions: 2,	4✔
143	getBin: {	4✔
144	sources: ['positions'],	4✔
145	getValue: (	4✔
146	{positions}: {positions: number[]},	5,055✔
147	index: number,	5,055✔
148	opts: {	5,055✔
149	cellSizeCommon: [number, number];	5,055✔
150	cellOriginCommon: [number, number];	5,055✔
151	}	5,055✔
152	) => {	5,055✔
153	const viewport = this.state.aggregatorViewport;	5,055✔
154	// project to common space	5,055✔
155	const p = viewport.projectPosition(positions);	5,055✔
156	const {cellSizeCommon, cellOriginCommon} = opts;	5,055✔
157	return [	5,055✔
158	Math.floor((p[0] - cellOriginCommon[0]) / cellSizeCommon[0]),	5,055✔
159	Math.floor((p[1] - cellOriginCommon[1]) / cellSizeCommon[1])	5,055✔
160	];	5,055✔
161	}	5,055✔
162	},	4✔
163	getValue: [{sources: ['counts'], getValue: ({counts}) => counts}],	4✔
164	onUpdate: this._onAggregationUpdate.bind(this)	4✔
165	});	4✔
166	}	4✔
167	return new WebGLAggregator(this.context.device, {	6✔
168	dimensions: 2,	6✔
169	channelCount: 1,	6✔
170	bufferLayout: this.getAttributeManager()!.getBufferLayouts({isInstanced: false}),	6✔
171	...super.getShaders({	6✔
172	modules: [project32],	6✔
173	vs: /* glsl */ `	6✔
174	uniform vec2 cellOriginCommon;	6✔
175	uniform vec2 cellSizeCommon;	6✔
176	in vec3 positions;	6✔
177	in vec3 positions64Low;	6✔
178	in float counts;	6✔
179		6✔
180	void getBin(out ivec2 binId) {	6✔
181	vec3 positionCommon = project_position(positions, positions64Low);	6✔
182	vec2 gridCoords = floor(positionCommon.xy / cellSizeCommon);	6✔
183	binId = ivec2(gridCoords);	6✔
184	}	6✔
185	void getValue(out float value) {	6✔
186	value = counts;	6✔
187	}	6✔
188	`	6✔
189	}),	6✔
190	onUpdate: this._onAggregationUpdate.bind(this)	6✔
191	});	6✔
192	}	10✔
193		1✔
194	initializeState() {	1✔
195	super.initializeState();	7✔
196		7✔
197	const attributeManager = this.getAttributeManager()!;	7✔
198	attributeManager.add({	7✔
199	positions: {	7✔
200	size: 3,	7✔
201	accessor: 'getPosition',	7✔
202	type: 'float64',	7✔
203	fp64: this.use64bitPositions()	7✔
204	},	7✔
205	counts: {size: 1, accessor: 'getWeight'}	7✔
206	});	7✔
207	}	7✔
208		1✔
209	updateState(params: UpdateParameters<this>) {	1✔
210	const aggregatorChanged = super.updateState(params);	35✔
211		35✔
212	const {props, oldProps, changeFlags} = params;	35✔
213	const {aggregator} = this.state;	35✔
214	if (	35✔
215	aggregatorChanged \|\|	35✔
216	changeFlags.dataChanged \|\|	25✔
217	props.cellSize !== oldProps.cellSize \|\|	20✔
218	!_deepEqual(props.gridOrigin, oldProps.gridOrigin, 1) \|\|	18✔
219	props.aggregation !== oldProps.aggregation	18✔
220	) {	35✔
221	this._updateBinOptions();	17✔
222	const {cellSizeCommon, cellOriginCommon, binIdRange} = this.state;	17✔
223		17✔
224	aggregator.setProps({	17✔
225	// @ts-expect-error only used by GPUAggregator	17✔
226	binIdRange,	17✔
227	pointCount: this.getNumInstances(),	17✔
228	operations: [props.aggregation],	17✔
229	binOptions: {	17✔
230	cellSizeCommon,	17✔
231	cellOriginCommon	17✔
232	}	17✔
233	});	17✔
234	}	17✔
235		35✔
236	if (!_deepEqual(oldProps.contours, props.contours, 2)) {	35✔
237	// Recalculate contours	9✔
238	this.setState({contourData: null});	9✔
239	}	9✔
240		35✔
241	return aggregatorChanged;	35✔
242	}	35✔
243		1✔
244	private _updateBinOptions() {	1✔
245	const bounds = this.getBounds();	29✔
246	const cellSizeCommon: [number, number] = [1, 1];	29✔
247	let cellOriginCommon: [number, number] = [0, 0];	29✔
248	const binIdRange: [number, number][] = [	29✔
249	[0, 1],	29✔
250	[0, 1]	29✔
251	];	29✔
252	let viewport = this.context.viewport;	29✔
253		29✔
254	if (bounds && Number.isFinite(bounds[0][0])) {	29✔
255	let centroid = [(bounds[0][0] + bounds[1][0]) / 2, (bounds[0][1] + bounds[1][1]) / 2];	20✔
256	const {cellSize, gridOrigin} = this.props;	20✔
257	const {unitsPerMeter} = viewport.getDistanceScales(centroid);	20✔
258	cellSizeCommon[0] = unitsPerMeter[0] * cellSize;	20✔
259	cellSizeCommon[1] = unitsPerMeter[1] * cellSize;	20✔
260		20✔
261	// Offset common space to center at the origin of the grid cell where the data center is in	20✔
262	// This improves precision without affecting the cell positions	20✔
263	const centroidCommon = viewport.projectFlat(centroid);	20✔
264	cellOriginCommon = [	20✔
265	Math.floor((centroidCommon[0] - gridOrigin[0]) / cellSizeCommon[0]) * cellSizeCommon[0] +	20✔
266	gridOrigin[0],	20✔
267	Math.floor((centroidCommon[1] - gridOrigin[1]) / cellSizeCommon[1]) * cellSizeCommon[1] +	20✔
268	gridOrigin[1]	20✔
269	];	20✔
270	centroid = viewport.unprojectFlat(cellOriginCommon);	20✔
271		20✔
272	const ViewportType = viewport.constructor as any;	20✔
273	// We construct a viewport for the GPU aggregator's project module	20✔
274	// This viewport is determined by data	20✔
275	// removes arbitrary precision variance that depends on initial view state	20✔
276	viewport = viewport.isGeospatial	20✔
277	? new ViewportType({longitude: centroid[0], latitude: centroid[1], zoom: 12})	18✔
278	: new Viewport({position: [centroid[0], centroid[1], 0], zoom: 12});	2✔
279		20✔
280	// Round to the nearest 32-bit float to match CPU and GPU results	20✔
281	cellOriginCommon = [Math.fround(viewport.center[0]), Math.fround(viewport.center[1])];	20✔
282		20✔
283	const corners = [	20✔
284	bounds[0],	20✔
285	bounds[1],	20✔
286	[bounds[0][0], bounds[1][1]],	20✔
287	[bounds[1][0], bounds[0][1]]	20✔
288	].map(p => viewport.projectFlat(p));	20✔
289		20✔
290	const minX = Math.min(...corners.map(p => p[0]));	20✔
291	const minY = Math.min(...corners.map(p => p[1]));	20✔
292	const maxX = Math.max(...corners.map(p => p[0]));	20✔
293	const maxY = Math.max(...corners.map(p => p[1]));	20✔
294	binIdRange[0][0] = Math.floor((minX - cellOriginCommon[0]) / cellSizeCommon[0]);	20✔
295	binIdRange[0][1] = Math.floor((maxX - cellOriginCommon[0]) / cellSizeCommon[0]) + 1;	20✔
296	binIdRange[1][0] = Math.floor((minY - cellOriginCommon[1]) / cellSizeCommon[1]);	20✔
297	binIdRange[1][1] = Math.floor((maxY - cellOriginCommon[1]) / cellSizeCommon[1]) + 1;	20✔
298	}	20✔
299		29✔
300	this.setState({cellSizeCommon, cellOriginCommon, binIdRange, aggregatorViewport: viewport});	29✔
301	}	29✔
302		1✔
303	override draw(opts) {	1✔
304	// Replaces render time viewport with our own	36✔
305	if (opts.moduleParameters.viewport) {	36✔
306	opts.moduleParameters.viewport = this.state.aggregatorViewport;	36✔
307	}	36✔
308	super.draw(opts);	36✔
309	}	36✔
310		1✔
311	private _onAggregationUpdate() {	1✔
312	const {aggregator, binIdRange} = this.state;	18✔
313	this.setState({	18✔
314	aggregatedValueReader: getAggregatorValueReader({aggregator, binIdRange, channel: 0}),	18✔
315	contourData: null	18✔
316	});	18✔
317	}	18✔
318		1✔
319	private _getContours(): {	1✔
320	lines: ContourLine[];	35✔
321	polygons: ContourPolygon[];	35✔
322	} \| null {	35✔
323	const {aggregatedValueReader} = this.state;	35✔
324	if (!aggregatedValueReader) {	35✔
325	return null;	5✔
326	}	5✔
327		30✔
328	if (!this.state.contourData) {	35✔
329	const {binIdRange} = this.state;	20✔
330	const {contours} = this.props;	20✔
331	const contourData = generateContours({	20✔
332	contours,	20✔
333	getValue: aggregatedValueReader,	20✔
334	xRange: binIdRange[0],	20✔
335	yRange: binIdRange[1]	20✔
336	});	20✔
337		20✔
338	this.state.contourData = contourData;	20✔
339	}	20✔
340	return this.state.contourData;	30✔
341	}	35✔
342		1✔
343	onAttributeChange(id: string) {	1✔
344	const {aggregator} = this.state;	27✔
345	switch (id) {	27✔
346	case 'positions':	27✔
347	aggregator.setNeedsUpdate();	12✔
348		12✔
349	this._updateBinOptions();	12✔
350	const {cellSizeCommon, cellOriginCommon, binIdRange} = this.state;	12✔
351	aggregator.setProps({	12✔
352	// @ts-expect-error only used by GPUAggregator	12✔
353	binIdRange,	12✔
354	binOptions: {	12✔
355	cellSizeCommon,	12✔
356	cellOriginCommon	12✔
357	}	12✔
358	});	12✔
359	break;	12✔
360		27✔
361	case 'counts':	27✔
362	aggregator.setNeedsUpdate(0);	15✔
363	break;	15✔
364		27✔
365	default:	27!
366	// This should not happen	27✔
367	}	27✔
368	}	27✔
369		1✔
370	renderLayers(): LayersList \| null {	1✔
371	const contourData = this._getContours();	35✔
372	if (!contourData) {	35✔
373	return null;	5✔
374	}	5✔
375	const {lines, polygons} = contourData;	30✔
376	const {zOffset} = this.props;	30✔
377	const {cellOriginCommon, cellSizeCommon} = this.state;	30✔
378		30✔
379	const LinesSubLayerClass = this.getSubLayerClass('lines', PathLayer);	30✔
380	const BandsSubLayerClass = this.getSubLayerClass('bands', SolidPolygonLayer);	30✔
381	const modelMatrix = new Matrix4()	30✔
382	.translate([cellOriginCommon[0], cellOriginCommon[1], 0])	30✔
383	.scale([cellSizeCommon[0], cellSizeCommon[1], zOffset]);	30✔
384		30✔
385	// Contour lines layer	30✔
386	const lineLayer =	30✔
387	lines &&	30✔
388	lines.length > 0 &&	30✔
389	new LinesSubLayerClass(	24✔
390	this.getSubLayerProps({	24✔
391	id: 'lines'	24✔
392	}),	24✔
393	{	24✔
394	data: lines,	24✔
395	coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,	24✔
396	modelMatrix,	24✔
397	getPath: d => d.vertices,	24✔
398	getColor: d => d.contour.color ?? DEFAULT_COLOR,	24✔
399	getWidth: d => d.contour.strokeWidth ?? DEFAULT_STROKE_WIDTH,	24✔
400	widthUnits: 'pixels'	24✔
401	}	24✔
402	);	24✔
403		35✔
404	// Contour bands layer	35✔
405	const bandsLayer =	35✔
406	polygons &&	35✔
407	polygons.length > 0 &&	30✔
408	new BandsSubLayerClass(	8✔
409	this.getSubLayerProps({	8✔
410	id: 'bands'	8✔
411	}),	8✔
412	{	8✔
413	data: polygons,	8✔
414	coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,	8✔
415	modelMatrix,	8✔
416	getPolygon: d => d.vertices,	8✔
417	getFillColor: d => d.contour.color ?? DEFAULT_COLOR	8!
418	}	8✔
419	);	8✔
420		35✔
421	return [lineLayer, bandsLayer];	35✔
422	}	35✔
423		1✔
424	getPickingInfo(params: GetPickingInfoParams): ContourLayerPickingInfo {	1✔
NEW 425	const info: ContourLayerPickingInfo = params.info;	×
NEW 426	const {object} = info;	×
NEW 427	if (object) {	×
NEW 428	info.object = {	×
NEW 429	contour: (object as ContourLine \| ContourPolygon).contour	×
430	};	×
431	}	×
NEW 432		×
NEW 433	return info;	×
UNCOV 434	}	×
435	}	1✔

visgl / deck.gl / 10533668922

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