@deck.gl/aggregation-layers 9.0.35 → 9.1.0-beta.1

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

@@ -1,8 +1,8 @@
-import { Accessor, Color, GetPickingInfoParams, Layer, LayerContext, LayersList, PickingInfo, Position, UpdateParameters, DefaultProps } from '@deck.gl/core';
-import type { Buffer, Texture } from '@luma.gl/core';
-import GridAggregationLayer, { GridAggregationLayerProps } from "../grid-aggregation-layer.js";
+import { Accessor, Color, GetPickingInfoParams, CompositeLayerProps, Layer, LayersList, PickingInfo, Position, UpdateParameters, DefaultProps } from '@deck.gl/core';
+import { WebGLAggregator, CPUAggregator, AggregationOperation } from "../common/aggregator/index.js";
+import AggregationLayer from "../common/aggregation-layer.js";
 /** All properties supported by ScreenGridLayer. */
-export type ScreenGridLayerProps<DataT = unknown> = _ScreenGridLayerProps<DataT> & GridAggregationLayerProps<DataT>;
+export type ScreenGridLayerProps<DataT = unknown> = _ScreenGridLayerProps<DataT> & CompositeLayerProps;
 /** Properties added by ScreenGridLayer. */
 export type _ScreenGridLayerProps<DataT> = {
     /**
@@ -15,18 +15,6 @@ export type _ScreenGridLayerProps<DataT> = {
      * @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)]
@@ -38,6 +26,12 @@ export type _ScreenGridLayerProps<DataT> = {
      * @default `6-class YlOrRd` - [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6)
      */
     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.
      *
@@ -58,38 +52,37 @@ export type _ScreenGridLayerProps<DataT> = {
     gpuAggregation?: boolean;
     /**
      * 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>>> {
+export default class ScreenGridLayer<DataT = any, ExtraProps extends {} = {}> extends AggregationLayer<DataT, ExtraProps & Required<_ScreenGridLayerProps<DataT>>> {
     static layerName: string;
     static defaultProps: DefaultProps<ScreenGridLayerProps<unknown>>;
-    state: GridAggregationLayer<DataT>['state'] & {
-        supported: boolean;
-        gpuGridAggregator?: any;
-        gpuAggregation?: any;
-        weights?: any;
-        maxTexture?: Texture;
-        aggregationBuffer?: Buffer;
-        maxBuffer?: Buffer;
-    };
+    getAggregatorType(): string;
+    createAggregator(type: string): WebGLAggregator | CPUAggregator;
     initializeState(): void;
     shouldUpdateState({ changeFlags }: UpdateParameters<this>): boolean;
-    updateState(opts: UpdateParameters<this>): void;
-    renderLayers(): LayersList | Layer;
-    finalizeState(context: LayerContext): void;
-    getPickingInfo({ info }: GetPickingInfoParams): PickingInfo;
-    updateResults({ aggregationData, maxData }: {
-        aggregationData: any;
-        maxData: any;
-    }): void;
-    updateAggregationState(opts: any): void;
-    _updateAccessors(opts: any): void;
-    _resetResults(): void;
+    updateState(params: UpdateParameters<this>): boolean;
+    onAttributeChange(id: string): void;
+    renderLayers(): LayersList | Layer | null;
+    getPickingInfo(params: GetPickingInfoParams): ScreenGridLayerPickingInfo<DataT>;
 }
 //# sourceMappingURL=screen-grid-layer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"screen-grid-layer.d.ts","sourceRoot":"","sources":["../../src/screen-grid-layer/screen-grid-layer.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,QAAQ,EACR,KAAK,EACL,oBAAoB,EACpB,KAAK,EACL,YAAY,EACZ,UAAU,EAEV,WAAW,EACX,QAAQ,EACR,gBAAgB,EAChB,YAAY,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAC,MAAM,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAInD,OAAO,oBAAoB,EAAE,EAAC,yBAAyB,EAAC,qCAAkC;AAuB1F,mDAAmD;AACnD,MAAM,MAAM,oBAAoB,CAAC,KAAK,GAAG,OAAO,IAAI,qBAAqB,CAAC,KAAK,CAAC,GAC9E,yBAAyB,CAAC,KAAK,CAAC,CAAC;AAEnC,2CAA2C;AAC3C,MAAM,MAAM,qBAAqB,CAAC,KAAK,IAAI;IACzC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAExB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAExB;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAEtC;;;;OAIG;IACH,UAAU,CAAC,EAAE,KAAK,EAAE,CAAC;IAErB;;;;OAIG;IACH,WAAW,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAExC;;;;OAIG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAEpC;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;CAC9C,CAAC;AAEF,sEAAsE;AACtE,MAAM,CAAC,OAAO,OAAO,eAAe,CAClC,KAAK,GAAG,GAAG,EACX,UAAU,SAAS,EAAE,GAAG,EAAE,CAC1B,SAAQ,oBAAoB,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC;IACxF,MAAM,CAAC,SAAS,SAAqB;IACrC,MAAM,CAAC,YAAY,8CAAgB;IAEnC,KAAK,EAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,GAAG;QAC7C,SAAS,EAAE,OAAO,CAAC;QACnB,iBAAiB,CAAC,EAAE,GAAG,CAAC;QACxB,cAAc,CAAC,EAAE,GAAG,CAAC;QACrB,OAAO,CAAC,EAAE,GAAG,CAAC;QACd,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;IAEF,eAAe;IAqCf,iBAAiB,CAAC,EAAC,WAAW,EAAC,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAIvD,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAIxC,YAAY,IAAI,UAAU,GAAG,KAAK;IAuBlC,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAU1C,cAAc,CAAC,EAAC,IAAI,EAAC,EAAE,oBAAoB,GAAG,WAAW;IAsBzD,aAAa,CAAC,EAAC,eAAe,EAAE,OAAO,EAAC;;;KAAA;IASxC,sBAAsB,CAAC,IAAI,KAAA;IAiE3B,gBAAgB,CAAC,IAAI,KAAA;IAUrB,aAAa;CAMd"}
+{"version":3,"file":"screen-grid-layer.d.ts","sourceRoot":"","sources":["../../src/screen-grid-layer/screen-grid-layer.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,QAAQ,EACR,KAAK,EACL,oBAAoB,EACpB,mBAAmB,EACnB,KAAK,EAEL,UAAU,EACV,WAAW,EACX,QAAQ,EACR,gBAAgB,EAChB,YAAY,EACb,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,eAAe,EAAE,aAAa,EAAE,oBAAoB,EAAC,sCAAmC;AAChG,OAAO,gBAAgB,uCAAoC;AAiB3D,mDAAmD;AACnD,MAAM,MAAM,oBAAoB,CAAC,KAAK,GAAG,OAAO,IAAI,qBAAqB,CAAC,KAAK,CAAC,GAC9E,mBAAmB,CAAC;AAEtB,2CAA2C;AAC3C,MAAM,MAAM,qBAAqB,CAAC,KAAK,IAAI;IACzC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAEtC;;;;OAIG;IACH,UAAU,CAAC,EAAE,KAAK,EAAE,CAAC;IAErB;;;;OAIG;IACH,cAAc,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;IAEvC;;;;OAIG;IACH,WAAW,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAExC;;;;OAIG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAEpC;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,oBAAoB,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,0BAA0B,CAAC,KAAK,IAAI,WAAW,CAAC;IAC1D,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAC;IACZ,+EAA+E;IAC/E,GAAG,EAAE,MAAM,CAAC;IACZ,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,+CAA+C;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,+FAA+F;IAC/F,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,+GAA+G;IAC/G,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC;CAClB,CAAC,CAAC;AAEH,sEAAsE;AACtE,MAAM,CAAC,OAAO,OAAO,eAAe,CAClC,KAAK,GAAG,GAAG,EACX,UAAU,SAAS,EAAE,GAAG,EAAE,CAC1B,SAAQ,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC,CAAC;IACpF,MAAM,CAAC,SAAS,SAAqB;IACrC,MAAM,CAAC,YAAY,8CAAgB;IAEnC,iBAAiB,IAAI,MAAM;IAM3B,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,aAAa;IA6C/D,eAAe;IAgBf,iBAAiB,CAAC,EAAC,WAAW,EAAC,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAIvD,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAyC1C,iBAAiB,CAAC,EAAE,EAAE,MAAM;IAgB5B,YAAY,IAAI,UAAU,GAAG,KAAK,GAAG,IAAI;IAqCzC,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG,0BAA0B,CAAC,KAAK,CAAC;CAyBhF"}

package/dist/screen-grid-layer/screen-grid-layer.js

@@ -1,208 +1,191 @@
-// 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 { log } from '@deck.gl/core';
-import GPUGridAggregator from "../utils/gpu-grid-aggregation/gpu-grid-aggregator.js";
-import { AGGREGATION_OPERATION, getValueFunc } from "../utils/aggregation-operation-utils.js";
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { project32 } from '@deck.gl/core';
+import { WebGLAggregator, CPUAggregator } from "../common/aggregator/index.js";
+import AggregationLayer from "../common/aggregation-layer.js";
 import ScreenGridCellLayer from "./screen-grid-cell-layer.js";
-import GridAggregationLayer from "../grid-aggregation-layer.js";
-import { getFloatTexture } from "../utils/resource-utils.js";
+import { binOptionsUniforms } from "./bin-options-uniforms.js";
+import { defaultColorRange } from "../common/utils/color-utils.js";
 const defaultProps = {
-    ...ScreenGridCellLayer.defaultProps,
+    cellSizePixels: { type: 'number', value: 100, min: 1 },
+    cellMarginPixels: { type: 'number', value: 2, min: 0 },
+    colorRange: defaultColorRange,
+    colorScaleType: 'linear',
     getPosition: { type: 'accessor', value: (d) => d.position },
     getWeight: { type: 'accessor', value: 1 },
-    gpuAggregation: false, // TODO(v9): Re-enable GPU aggregation.
+    gpuAggregation: false,
     aggregation: 'SUM'
 };
-const POSITION_ATTRIBUTE_NAME = 'positions';
-const DIMENSIONS = {
-    data: {
-        props: ['cellSizePixels']
-    },
-    weights: {
-        props: ['aggregation'],
-        accessors: ['getWeight']
-    }
-};
 /** Aggregates data into histogram bins and renders them as a grid. */
-class ScreenGridLayer extends GridAggregationLayer {
-    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]
+class ScreenGridLayer extends AggregationLayer {
+    getAggregatorType() {
+        return this.props.gpuAggregation && WebGLAggregator.isSupported(this.context.device)
+            ? 'gpu'
+            : 'cpu';
+    }
+    createAggregator(type) {
+        if (type === 'cpu' || !WebGLAggregator.isSupported(this.context.device)) {
+            return new CPUAggregator({
+                dimensions: 2,
+                getBin: {
+                    sources: ['positions'],
+                    getValue: ({ positions }, index, opts) => {
+                        const viewport = this.context.viewport;
+                        const p = viewport.project(positions);
+                        const cellSizePixels = 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 }) {
-        return this.state.supported && changeFlags.somethingChanged;
+        return changeFlags.somethingChanged;
     }
-    updateState(opts) {
-        super.updateState(opts);
+    updateState(params) {
+        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() {
-        if (!this.state.supported) {
-            return [];
+    onAttributeChange(id) {
+        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() {
+        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) {
-        super.finalizeState(context);
-        const { aggregationBuffer, maxBuffer, maxTexture } = this.state;
-        aggregationBuffer?.delete();
-        maxBuffer?.delete();
-        maxTexture?.delete();
-    }
-    getPickingInfo({ info }) {
+    getPickingInfo(params) {
+        const info = 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;
+            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[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;
     }
 }
 ScreenGridLayer.layerName = 'ScreenGridLayer';