@deck.gl/aggregation-layers 9.0.40 → 9.1.0-beta.3

package/src/screen-grid-layer/screen-grid-layer.ts

@@ -1,66 +1,41 @@
-// 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.
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 
 import {
   Accessor,
   Color,
   GetPickingInfoParams,
+  CompositeLayerProps,
   Layer,
-  LayerContext,
+  project32,
   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 {WebGLAggregator, CPUAggregator, AggregationOperation} from '../common/aggregator/index';
+import AggregationLayer from '../common/aggregation-layer';
 import ScreenGridCellLayer from './screen-grid-cell-layer';
-import GridAggregationLayer, {GridAggregationLayerProps} from '../grid-aggregation-layer';
-import {getFloatTexture} from '../utils/resource-utils';
+import {BinOptions, binOptionsUniforms} from './bin-options-uniforms';
+import {defaultColorRange} from '../common/utils/color-utils';
 
 const defaultProps: DefaultProps<ScreenGridLayerProps> = {
-  ...(ScreenGridCellLayer.defaultProps as DefaultProps<ScreenGridLayerProps<unknown>>),
+  cellSizePixels: {type: 'number', value: 100, min: 1},
+  cellMarginPixels: {type: 'number', value: 2, min: 0},
+  colorRange: defaultColorRange,
+  colorScaleType: 'linear',
   getPosition: {type: 'accessor', value: (d: any) => d.position},
   getWeight: {type: 'accessor', value: 1},
 
-  gpuAggregation: false, // TODO(v9): Re-enable GPU aggregation.
+  gpuAggregation: true,
   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>;
+  CompositeLayerProps;
 
 /** Properties added by ScreenGridLayer. */
 export type _ScreenGridLayerProps<DataT> = {
@@ -76,20 +51,6 @@ export type _ScreenGridLayerProps<DataT> = {
    */
   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)]
@@ -103,6 +64,13 @@ export type _ScreenGridLayerProps<DataT> = {
    */
   colorRange?: Color[];
 
+  /**
+   * Scaling function used to determine the color of the grid cell.
+   * Supported Values are 'quantize', 'linear', 'quantile' and 'ordinal'.
+   * @default 'quantize'
+   */
+  colorScaleType?: 'linear' | 'quantize';
+
   /**
    * Method called to retrieve the position of each object.
    *
@@ -126,220 +94,224 @@ export type _ScreenGridLayerProps<DataT> = {
 
   /**
    * Defines the type of aggregation operation
-   *
-   * V valid values are 'SUM', 'MEAN', 'MIN' and 'MAX'.
+   * Valid values are 'SUM', 'MEAN', 'MIN', 'MAX', 'COUNT'.
    *
    * @default 'SUM'
    */
-  aggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
+  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 GridAggregationLayer<DataT, ExtraProps & Required<_ScreenGridLayerProps<DataT>>> {
+> extends AggregationLayer<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;
-  };
+  getAggregatorType(): string {
+    return this.props.gpuAggregation && WebGLAggregator.isSupported(this.context.device)
+      ? 'gpu'
+      : 'cpu';
+  }
 
-  initializeState() {
-    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]
+  createAggregator(type: string): WebGLAggregator | CPUAggregator {
+    if (type === 'cpu' || !WebGLAggregator.isSupported(this.context.device)) {
+      return new CPUAggregator({
+        dimensions: 2,
+        getBin: {
+          sources: ['positions'],
+          getValue: ({positions}: {positions: number[]}, index: number, opts: BinOptions) => {
+            const viewport = this.context.viewport;
+            const p = viewport.project(positions);
+            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, binOptionsUniforms],
+        vs: `
+  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 / binOptions.cellSizePixels);
+    binId = ivec2(gridCoords);
+  }
+  void getValue(out float weight) {
+    weight = counts;
+  }
+  `
+      })
     });
+  }
+
+  initializeState() {
+    super.initializeState();
+
     const attributeManager = this.getAttributeManager()!;
     attributeManager.add({
-      [POSITION_ATTRIBUTE_NAME]: {
+      positions: {
         size: 3,
         accessor: 'getPosition',
         type: 'float64',
         fp64: this.use64bitPositions()
       },
       // this attribute is used in gpu aggregation path only
-      count: {size: 3, accessor: 'getWeight'}
+      counts: {size: 1, accessor: 'getWeight'}
     });
   }
 
   shouldUpdateState({changeFlags}: UpdateParameters<this>) {
-    return this.state.supported && changeFlags.somethingChanged;
+    return changeFlags.somethingChanged;
   }
 
-  updateState(opts: UpdateParameters<this>) {
-    super.updateState(opts);
+  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;
   }
 
-  renderLayers(): LayersList | Layer {
-    if (!this.state.supported) {
-      return [];
+  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
     }
-    const {maxTexture, numRow, numCol, weights} = this.state;
-    const {updateTriggers} = this.props;
-    const {aggregationBuffer} = weights.count;
+  }
+
+  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',
-        updateTriggers
+        id: 'cell-layer'
       }),
       {
-        data: {attributes: {instanceCounts: aggregationBuffer}},
-        maxTexture,
-        numInstances: numRow * numCol
+        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: []
       }
     );
   }
 
-  finalizeState(context: LayerContext): void {
-    super.finalizeState(context);
-
-    const {aggregationBuffer, maxBuffer, maxTexture} = this.state;
-
-    aggregationBuffer?.delete();
-    maxBuffer?.delete();
-    maxTexture?.delete();
-  }
-
-  getPickingInfo({info}: GetPickingInfoParams): PickingInfo {
+  getPickingInfo(params: GetPickingInfoParams): ScreenGridLayerPickingInfo<DataT> {
+    const info: ScreenGridLayerPickingInfo<DataT> = params.info;
     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 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;
     }
-    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;
-    }
+    return info;
   }
 }

package/dist/aggregation-layer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aggregation-layer.d.ts","sourceRoot":"","sources":["../src/aggregation-layer.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,eAAe,EAEf,gBAAgB,EAChB,mBAAmB,EACnB,SAAS,EACV,MAAM,eAAe,CAAC;AAGvB,MAAM,MAAM,qBAAqB,CAAC,KAAK,IAAI,mBAAmB,GAAG;IAC/D,IAAI,EAAE,eAAe,CAAC,KAAK,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,gBAAgB,CAC5C,KAAK,EACL,WAAW,SAAS,EAAE,GAAG,EAAE,CAC3B,SAAQ,cAAc,CAAC,QAAQ,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC,GAAG,WAAW,CAAC;IACvE,MAAM,CAAC,SAAS,SAAsB;IAEtC,KAAK,EAAG;QACN,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAClC,UAAU,CAAC,EAAE,GAAG,CAAC;QACjB,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KACzC,CAAC;IAEF,0BAA0B,CAAC,UAAU,EAAE,GAAG;IAU1C,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAexC,gBAAgB,CAAC,iBAAiB,KAAA;IAMlC,aAAa,IAAI;QAAC,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,CAAA;KAAC;IAI1C,iBAAiB;IAiBjB,aAAa,CAAC,OAAO,KAAA;IAIrB;;;;;;;QAOI;IACJ,kBAAkB,CAChB,UAAU,KAAA,EACV,MAAM,GAAE;QAAC,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,GAAG,CAAA;KAAM,GACnD,MAAM,GAAG,OAAO;IAyCnB;;;;;QAKI;IACJ,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM;IAYhC,oBAAoB;CAMrB"}

package/dist/cpu-grid-layer/cpu-grid-layer.d.ts

@@ -1,158 +0,0 @@
-import { Accessor, AccessorFunction, Color, Position, Material, DefaultProps } from '@deck.gl/core';
-import CPUAggregator from "../utils/cpu-aggregator.js";
-import AggregationLayer, { AggregationLayerProps } from "../aggregation-layer.js";
-import { Layer, UpdateParameters, GetPickingInfoParams, PickingInfo } from '@deck.gl/core';
-import { AggregateAccessor } from "../types.js";
-/** All properties supported by CPUGridLayer. */
-export type CPUGridLayerProps<DataT = unknown> = _CPUGridLayerProps<DataT> & AggregationLayerProps<DataT>;
-/** Properties added by CPUGridLayer. */
-type _CPUGridLayerProps<DataT> = {
-    /**
-     * Size of each cell in meters.
-     * @default 1000
-     */
-    cellSize?: number;
-    /**
-     * Color scale domain, default is set to the extent of aggregated weights in each cell.
-     * @default [min(colorWeight), max(colorWeight)]
-     */
-    colorDomain?: [number, number] | null;
-    /**
-     * Default: [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6) `6-class YlOrRd`
-     */
-    colorRange?: Color[];
-    /**
-     * Cell size multiplier, clamped between 0 - 1.
-     * @default 1
-     */
-    coverage?: number;
-    /**
-     * Elevation scale input domain, default is set to between 0 and the max of aggregated weights in each cell.
-     * @default [0, max(elevationWeight)]
-     */
-    elevationDomain?: [number, number] | null;
-    /**
-     * Elevation scale output range.
-     * @default [0, 1000]
-     */
-    elevationRange?: [number, number];
-    /**
-     * Cell elevation multiplier.
-     * @default 1
-     */
-    elevationScale?: number;
-    /**
-     * Whether to enable cell elevation. If set to false, all cell will be flat.
-     * @default true
-     */
-    extruded?: boolean;
-    /**
-     * Filter cells and re-calculate color by `upperPercentile`.
-     * Cells with value arger than the upperPercentile will be hidden.
-     * @default 100
-     */
-    upperPercentile?: number;
-    /**
-     * Filter cells and re-calculate color by `lowerPercentile`.
-     * Cells with value smaller than the lowerPercentile will be hidden.
-     * @default 0
-     */
-    lowerPercentile?: number;
-    /**
-     * Filter cells and re-calculate elevation by `elevationUpperPercentile`.
-     * Cells with elevation value larger than the `elevationUpperPercentile` will be hidden.
-     * @default 100
-     */
-    elevationUpperPercentile?: number;
-    /**
-     * Filter cells and re-calculate elevation by `elevationLowerPercentile`.
-     * Cells with elevation value larger than the `elevationLowerPercentile` will be hidden.
-     * @default 0
-     */
-    elevationLowerPercentile?: number;
-    /**
-     * Scaling function used to determine the color of the grid cell, default value is 'quantize'.
-     * Supported Values are 'quantize', 'linear', 'quantile' and 'ordinal'.
-     * @default 'quantize'
-     */
-    colorScaleType?: 'quantize' | 'linear' | 'quantile' | 'ordinal';
-    /**
-     * Scaling function used to determine the elevation of the grid cell, only supports 'linear'.
-     */
-    elevationScaleType?: 'linear';
-    gridAggregator?: (props: any, params: any) => any;
-    /**
-     * Material settings for lighting effect. Applies if `extruded: true`.
-     *
-     * @default true
-     * @see https://deck.gl/docs/developer-guide/using-lighting
-     */
-    material?: Material;
-    /**
-     * Defines the operation used to aggregate all data object weights to calculate a cell's color value.
-     * @default 'SUM'
-     */
-    colorAggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
-    /**
-     * Defines the operation used to aggregate all data object weights to calculate a cell's elevation value.
-     * @default 'SUM'
-     */
-    elevationAggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
-    /**
-     * Method called to retrieve the position of each object.
-     * @default object => object.position
-     */
-    getPosition?: AccessorFunction<DataT, Position>;
-    /**
-     * The weight of a data object used to calculate the color value for a cell.
-     * @default 1
-     */
-    getColorWeight?: Accessor<DataT, number>;
-    /**
-     * After data objects are aggregated into cells, this accessor is called on each cell to get the value that its color is based on.
-     * @default null
-     */
-    getColorValue?: AggregateAccessor<DataT> | null;
-    /**
-     * The weight of a data object used to calculate the elevation value for a cell.
-     * @default 1
-     */
-    getElevationWeight?: Accessor<DataT, number>;
-    /**
-     * After data objects are aggregated into cells, this accessor is called on each cell to get the value that its elevation is based on.
-     * @default null
-     */
-    getElevationValue?: AggregateAccessor<DataT> | null;
-    /**
-     * This callback will be called when bin color domain has been calculated.
-     * @default () => {}
-     */
-    onSetColorDomain?: (minMax: [number, number]) => void;
-    /**
-     * This callback will be called when bin elevation domain has been calculated.
-     * @default () => {}
-     */
-    onSetElevationDomain?: (minMax: [number, number]) => void;
-    /**
-     * (Experimental) Filter data objects
-     */
-    _filterData: null | ((d: DataT) => boolean);
-};
-/** Aggregate data into a grid-based heatmap. Aggregation is performed on CPU. */
-export default class CPUGridLayer<DataT = any, ExtraPropsT extends {} = {}> extends AggregationLayer<DataT, ExtraPropsT & Required<_CPUGridLayerProps<DataT>>> {
-    static layerName: string;
-    static defaultProps: DefaultProps<CPUGridLayerProps<unknown>>;
-    state: AggregationLayer<DataT>['state'] & {
-        cpuAggregator: CPUAggregator;
-        aggregatorState: CPUAggregator['state'];
-    };
-    initializeState(): void;
-    updateState(opts: UpdateParameters<this>): void;
-    getPickingInfo({ info }: GetPickingInfoParams): PickingInfo;
-    _onGetSublayerColor(cell: any): any;
-    _onGetSublayerElevation(cell: any): any;
-    _getSublayerUpdateTriggers(): {};
-    renderLayers(): Layer;
-}
-export {};
-//# sourceMappingURL=cpu-grid-layer.d.ts.map

package/dist/cpu-grid-layer/cpu-grid-layer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cpu-grid-layer.d.ts","sourceRoot":"","sources":["../../src/cpu-grid-layer/cpu-grid-layer.ts"],"names":[],"mappings":"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"}