@deck.gl/aggregation-layers 8.8.0-alpha.4 → 8.8.0-beta.1

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

@@ -0,0 +1,226 @@
+import { _MaterialProps as MaterialProps } from '@deck.gl/layers/typed';
+import { Accessor, AccessorFunction, Color, Position } from '@deck.gl/core/typed';
+import { pointToDensityGridDataCPU } from './grid-aggregator';
+import AggregationLayer, { AggregationLayerProps } from '../aggregation-layer';
+import Layer, { UpdateParameters } from 'modules/core/src/lib/layer';
+import { GetPickingInfoParams, PickingInfo } from 'modules/core/src/lib/picking/pick-info';
+import { AggregateAccessor } from '../types';
+declare function nop(): void;
+/** All properties supported by CPUGridLayer. */
+export declare type CPUGridLayerProps<DataT = any> = _CPUGridLayerProps<DataT> & AggregationLayerProps<DataT>;
+/** Properties added by CPUGridLayer. */
+export declare 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';
+    /**
+     * This is an object that contains material props
+     * for [lighting effect](/docs/api-reference/core/lighting-effect.md) applied on extruded polygons.
+     * @default true
+     */
+    material?: MaterialProps | null;
+    /**
+     * 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;
+};
+export default class CPUGridLayer<DataT = any, ExtraPropsT = {}> extends AggregationLayer<ExtraPropsT & Required<_CPUGridLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: {
+        colorDomain: null;
+        colorRange: number[][];
+        getColorValue: {
+            type: string;
+            value: null;
+        };
+        getColorWeight: {
+            type: string;
+            value: number;
+        };
+        colorAggregation: string;
+        lowerPercentile: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        upperPercentile: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        colorScaleType: string;
+        onSetColorDomain: typeof nop;
+        elevationDomain: null;
+        elevationRange: number[];
+        getElevationValue: {
+            type: string;
+            value: null;
+        };
+        getElevationWeight: {
+            type: string;
+            value: number;
+        };
+        elevationAggregation: string;
+        elevationLowerPercentile: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        elevationUpperPercentile: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        elevationScale: {
+            type: string;
+            min: number;
+            value: number;
+        };
+        elevationScaleType: string;
+        onSetElevationDomain: typeof nop;
+        gridAggregator: typeof pointToDensityGridDataCPU;
+        cellSize: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        coverage: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        getPosition: {
+            type: string;
+            value: (x: any) => any;
+        };
+        extruded: boolean;
+        material: boolean;
+        _filterData: {
+            type: string;
+            value: null;
+            optional: boolean;
+        };
+    };
+    initializeState(): void;
+    updateState(opts: UpdateParameters<this>): void;
+    getPickingInfo({ info }: GetPickingInfoParams): PickingInfo;
+    _onGetSublayerColor(cell: any): any;
+    _onGetSublayerElevation(cell: any): any;
+    _getSublayerUpdateTriggers(): any;
+    renderLayers(): Layer;
+}
+export {};
+//# sourceMappingURL=cpu-grid-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cpu-grid-layer.d.ts","sourceRoot":"","sources":["../../src/cpu-grid-layer/cpu-grid-layer.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAgB,cAAc,IAAI,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAC/E,OAAO,EAAC,QAAQ,EAAE,gBAAgB,EAAE,KAAK,EAAE,QAAQ,EAAC,MAAM,eAAe,CAAC;AAG1E,OAAO,EAAC,yBAAyB,EAAC,MAAM,mBAAmB,CAAC;AAE5D,OAAO,gBAAgB,EAAE,EAAC,qBAAqB,EAAC,MAAM,sBAAsB,CAAC;AAE7E,OAAO,KAAK,EAAE,EAAC,gBAAgB,EAAC,MAAM,4BAA4B,CAAC;AACnE,OAAO,EAAC,oBAAoB,EAAE,WAAW,EAAC,MAAM,wCAAwC,CAAC;AACzF,OAAO,EAAC,iBAAiB,EAAC,MAAM,UAAU,CAAC;AAG3C,iBAAS,GAAG,SAAK;AAyCjB,gDAAgD;AAChD,oBAAY,iBAAiB,CAAC,KAAK,GAAG,GAAG,IAAI,kBAAkB,CAAC,KAAK,CAAC,GACpE,qBAAqB,CAAC,KAAK,CAAC,CAAC;AAE/B,wCAAwC;AACxC,oBAAY,kBAAkB,CAAC,KAAK,IAAI;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAEtC;;OAEG;IACH,UAAU,CAAC,EAAE,KAAK,EAAE,CAAC;IAErB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,eAAe,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IAE1C;;;OAGG;IACH,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAElC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IAEzB;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAElC;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAElC;;;;OAIG;IACH,cAAc,CAAC,EAAE,UAAU,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;IAEhE;;;;OAIG;IACH,QAAQ,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAEhC;;;OAGG;IACH,gBAAgB,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;IAElD;;;OAGG;IACH,oBAAoB,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;IAEtD;;;OAGG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAEhD;;;OAGG;IACH,cAAc,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAEzC;;;OAGG;IACH,aAAa,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAEhD;;;OAGG;IACH,kBAAkB,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAE7C;;;OAGG;IACH,iBAAiB,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;IAEpD;;;OAGG;IACH,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,CAAC;IAEtD;;;OAGG;IACH,oBAAoB,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,IAAI,CAAC;CAC3D,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,YAAY,CAAC,KAAK,GAAG,GAAG,EAAE,WAAW,GAAG,EAAE,CAAE,SAAQ,gBAAgB,CACvF,WAAW,GAAG,QAAQ,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAClD;IACC,MAAM,CAAC,SAAS,SAAkB;IAClC,MAAM,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAgB;IAEnC,eAAe,IAAI,IAAI;IAkBvB,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAYxC,cAAc,CAAC,EAAC,IAAI,EAAC,EAAE,oBAAoB,GAAG,WAAW;IAKzD,mBAAmB,CAAC,IAAI,KAAA;IAKxB,uBAAuB,CAAC,IAAI,KAAA;IAI5B,0BAA0B;IAI1B,YAAY,IAAI,KAAK;CA8BtB"}

package/typed/cpu-grid-layer/cpu-grid-layer.js

@@ -0,0 +1,129 @@
+// 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 GL from '@luma.gl/constants';
+import { GridCellLayer } from '@deck.gl/layers';
+import { defaultColorRange } from '../utils/color-utils';
+import { pointToDensityGridDataCPU } from './grid-aggregator';
+import CPUAggregator from '../utils/cpu-aggregator';
+import AggregationLayer from '../aggregation-layer';
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function nop() { }
+const defaultProps = {
+    // color
+    colorDomain: null,
+    colorRange: defaultColorRange,
+    getColorValue: { type: 'accessor', value: null },
+    getColorWeight: { type: 'accessor', value: 1 },
+    colorAggregation: 'SUM',
+    lowerPercentile: { type: 'number', min: 0, max: 100, value: 0 },
+    upperPercentile: { type: 'number', min: 0, max: 100, value: 100 },
+    colorScaleType: 'quantize',
+    onSetColorDomain: nop,
+    // elevation
+    elevationDomain: null,
+    elevationRange: [0, 1000],
+    getElevationValue: { type: 'accessor', value: null },
+    getElevationWeight: { type: 'accessor', value: 1 },
+    elevationAggregation: 'SUM',
+    elevationLowerPercentile: { type: 'number', min: 0, max: 100, value: 0 },
+    elevationUpperPercentile: { type: 'number', min: 0, max: 100, value: 100 },
+    elevationScale: { type: 'number', min: 0, value: 1 },
+    elevationScaleType: 'linear',
+    onSetElevationDomain: nop,
+    gridAggregator: pointToDensityGridDataCPU,
+    // grid
+    cellSize: { type: 'number', min: 0, max: 1000, value: 1000 },
+    coverage: { type: 'number', min: 0, max: 1, value: 1 },
+    getPosition: { type: 'accessor', value: x => x.position },
+    extruded: false,
+    // Optional material for 'lighting' shader module
+    material: true,
+    // data filter
+    _filterData: { type: 'function', value: null, optional: true }
+};
+export default class CPUGridLayer extends AggregationLayer {
+    initializeState() {
+        const cpuAggregator = new CPUAggregator({
+            getAggregator: props => props.gridAggregator,
+            getCellSize: props => props.cellSize
+        });
+        this.state = {
+            cpuAggregator,
+            aggregatorState: cpuAggregator.state
+        };
+        const attributeManager = this.getAttributeManager();
+        attributeManager.add({
+            positions: { size: 3, type: GL.DOUBLE, accessor: 'getPosition' }
+        });
+        // color and elevation attributes can't be added as attributes
+        // they are calcualted using 'getValue' accessor that takes an array of pints.
+    }
+    updateState(opts) {
+        super.updateState(opts);
+        this.setState({
+            // make a copy of the internal state of cpuAggregator for testing
+            aggregatorState: this.state.cpuAggregator.updateState(opts, {
+                viewport: this.context.viewport,
+                attributes: this.getAttributes(),
+                numInstances: this.getNumInstances()
+            })
+        });
+    }
+    getPickingInfo({ info }) {
+        return this.state.cpuAggregator.getPickingInfo({ info });
+    }
+    // create a method for testing
+    _onGetSublayerColor(cell) {
+        return this.state.cpuAggregator.getAccessor('fillColor')(cell);
+    }
+    // create a method for testing
+    _onGetSublayerElevation(cell) {
+        return this.state.cpuAggregator.getAccessor('elevation')(cell);
+    }
+    _getSublayerUpdateTriggers() {
+        return this.state.cpuAggregator.getUpdateTriggers(this.props);
+    }
+    renderLayers() {
+        const { elevationScale, extruded, cellSize, coverage, material, transitions } = this.props;
+        const { cpuAggregator } = this.state;
+        const SubLayerClass = this.getSubLayerClass('grid-cell', GridCellLayer);
+        const updateTriggers = this._getSublayerUpdateTriggers();
+        return new SubLayerClass({
+            cellSize,
+            coverage,
+            material,
+            elevationScale,
+            extruded,
+            getFillColor: this._onGetSublayerColor.bind(this),
+            getElevation: this._onGetSublayerElevation.bind(this),
+            transitions: transitions && {
+                getFillColor: transitions.getColorValue || transitions.getColorWeight,
+                getElevation: transitions.getElevationValue || transitions.getElevationWeight
+            }
+        }, this.getSubLayerProps({
+            id: 'grid-cell',
+            updateTriggers
+        }), {
+            data: cpuAggregator.state.layerData.data
+        });
+    }
+}
+CPUGridLayer.layerName = 'CPUGridLayer';
+CPUGridLayer.defaultProps = defaultProps;

package/typed/cpu-grid-layer/grid-aggregator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Calculate density grid from an array of points
+ * @param {Object} props - object containing :
+ * @param {Iterable} [props.data] - data objects to be aggregated
+ * @param {Integer} [props.cellSize] - size of the grid cell
+ *
+ * @param {Object} aggregationParams - object containing :
+ * @param {Object} gridOffset - {xOffset, yOffset} cell size in meters
+ * @param {Integer} width - width of the grid
+ * @param {Integer} height - height of the grid
+ * @param {Boolean} projectPoints - `true` if doing screen space projection, `false` otherwise
+ * @param {Array} attributes - attributes array containing position values
+ * @param {Viewport} viewport - viewport to be used for projection
+ * @param {Array} posOffset - [xOffset, yOffset] offset to be applied to positions to get cell index
+ * @param {Object} boundingBox - {xMin, yMin, xMax, yMax} bounding box of input data
+ *
+ * @returns {object} - grid data, cell dimension
+ */
+export function pointToDensityGridDataCPU(props: {
+    data?: Iterable<any> | undefined;
+    cellSize?: any;
+}, aggregationParams: any): object;
+//# sourceMappingURL=grid-aggregator.d.ts.map

package/typed/cpu-grid-layer/grid-aggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-aggregator.d.ts","sourceRoot":"","sources":["../../src/cpu-grid-layer/grid-aggregator.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAf4B,IAAI;IACL,QAAQ;4BAYtB,MAAM,CAWlB"}

package/typed/cpu-grid-layer/grid-aggregator.js

@@ -0,0 +1,141 @@
+// 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 { createIterable } from '@deck.gl/core';
+import { getGridOffset } from '../utils/grid-aggregation-utils';
+/**
+ * Calculate density grid from an array of points
+ * @param {Object} props - object containing :
+ * @param {Iterable} [props.data] - data objects to be aggregated
+ * @param {Integer} [props.cellSize] - size of the grid cell
+ *
+ * @param {Object} aggregationParams - object containing :
+ * @param {Object} gridOffset - {xOffset, yOffset} cell size in meters
+ * @param {Integer} width - width of the grid
+ * @param {Integer} height - height of the grid
+ * @param {Boolean} projectPoints - `true` if doing screen space projection, `false` otherwise
+ * @param {Array} attributes - attributes array containing position values
+ * @param {Viewport} viewport - viewport to be used for projection
+ * @param {Array} posOffset - [xOffset, yOffset] offset to be applied to positions to get cell index
+ * @param {Object} boundingBox - {xMin, yMin, xMax, yMax} bounding box of input data
+ *
+ * @returns {object} - grid data, cell dimension
+ */
+export function pointToDensityGridDataCPU(props, aggregationParams) {
+    const hashInfo = pointsToGridHashing(props, aggregationParams);
+    const result = getGridLayerDataFromGridHash(hashInfo);
+    return {
+        gridHash: hashInfo.gridHash,
+        gridOffset: hashInfo.gridOffset,
+        data: result
+    };
+}
+/**
+ * Project points into each cell, return a hash table of cells
+ * @param {Iterable} points
+ * @param {number} cellSize - unit size in meters
+ * @param {function} getPosition - position accessor
+ * @returns {object} - grid hash and cell dimension
+ */
+/* eslint-disable max-statements, complexity */
+function pointsToGridHashing(props, aggregationParams) {
+    const { data = [], cellSize } = props;
+    const { attributes, viewport, projectPoints, numInstances } = aggregationParams;
+    const positions = attributes.positions.value;
+    const { size } = attributes.positions.getAccessor();
+    const boundingBox = aggregationParams.boundingBox || getPositionBoundingBox(attributes.positions, numInstances);
+    const offsets = aggregationParams.posOffset || [180, 90];
+    const gridOffset = aggregationParams.gridOffset || getGridOffset(boundingBox, cellSize);
+    if (gridOffset.xOffset <= 0 || gridOffset.yOffset <= 0) {
+        return { gridHash: {}, gridOffset };
+    }
+    const { width, height } = viewport;
+    const numCol = Math.ceil(width / gridOffset.xOffset);
+    const numRow = Math.ceil(height / gridOffset.yOffset);
+    // calculate count per cell
+    const gridHash = {};
+    const { iterable, objectInfo } = createIterable(data);
+    const position = new Array(3);
+    for (const pt of iterable) {
+        objectInfo.index++;
+        position[0] = positions[objectInfo.index * size];
+        position[1] = positions[objectInfo.index * size + 1];
+        position[2] = size >= 3 ? positions[objectInfo.index * size + 2] : 0;
+        const [x, y] = projectPoints ? viewport.project(position) : position;
+        if (Number.isFinite(x) && Number.isFinite(y)) {
+            const yIndex = Math.floor((y + offsets[1]) / gridOffset.yOffset);
+            const xIndex = Math.floor((x + offsets[0]) / gridOffset.xOffset);
+            if (!projectPoints ||
+                // when doing screen space agggregation (projectPoints = true), filter points outside of the viewport range.
+                (xIndex >= 0 && xIndex < numCol && yIndex >= 0 && yIndex < numRow)) {
+                const key = `${yIndex}-${xIndex}`;
+                gridHash[key] = gridHash[key] || { count: 0, points: [], lonIdx: xIndex, latIdx: yIndex };
+                gridHash[key].count += 1;
+                gridHash[key].points.push({
+                    source: pt,
+                    index: objectInfo.index
+                });
+            }
+        }
+    }
+    return { gridHash, gridOffset, offsets: [offsets[0] * -1, offsets[1] * -1] };
+}
+/* eslint-enable max-statements, complexity */
+function getGridLayerDataFromGridHash({ gridHash, gridOffset, offsets }) {
+    const data = new Array(Object.keys(gridHash).length);
+    let i = 0;
+    for (const key in gridHash) {
+        const idxs = key.split('-');
+        const latIdx = parseInt(idxs[0], 10);
+        const lonIdx = parseInt(idxs[1], 10);
+        const index = i++;
+        data[index] = {
+            index,
+            position: [
+                offsets[0] + gridOffset.xOffset * lonIdx,
+                offsets[1] + gridOffset.yOffset * latIdx
+            ],
+            ...gridHash[key]
+        };
+    }
+    return data;
+}
+// Calculate bounding box of position attribute
+function getPositionBoundingBox(positionAttribute, numInstance) {
+    // TODO - value might not exist (e.g. attribute transition)
+    const positions = positionAttribute.value;
+    const { size } = positionAttribute.getAccessor();
+    let yMin = Infinity;
+    let yMax = -Infinity;
+    let xMin = Infinity;
+    let xMax = -Infinity;
+    let y;
+    let x;
+    for (let i = 0; i < numInstance; i++) {
+        x = positions[i * size];
+        y = positions[i * size + 1];
+        if (Number.isFinite(x) && Number.isFinite(y)) {
+            yMin = y < yMin ? y : yMin;
+            yMax = y > yMax ? y : yMax;
+            xMin = x < xMin ? x : xMin;
+            xMax = x > xMax ? x : xMax;
+        }
+    }
+    return { xMin, xMax, yMin, yMax };
+}

package/typed/gpu-grid-layer/gpu-grid-cell-layer-fragment.glsl.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "#version 300 es\n#define SHADER_NAME gpu-grid-cell-layer-fragment-shader\n\nprecision highp float;\n\nin vec4 vColor;\n\nout vec4 fragColor;\n\nvoid main(void) {\n  fragColor = vColor;\n  fragColor = picking_filterColor(fragColor);\n}\n";
+export default _default;
+//# sourceMappingURL=gpu-grid-cell-layer-fragment.glsl.d.ts.map

package/typed/gpu-grid-layer/gpu-grid-cell-layer-fragment.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-grid-cell-layer-fragment.glsl.d.ts","sourceRoot":"","sources":["../../src/gpu-grid-layer/gpu-grid-cell-layer-fragment.glsl.ts"],"names":[],"mappings":";AAoBA,wBAcE"}

package/typed/gpu-grid-layer/gpu-grid-cell-layer-fragment.glsl.js

@@ -0,0 +1,34 @@
+// 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.
+export default `\
+#version 300 es
+#define SHADER_NAME gpu-grid-cell-layer-fragment-shader
+
+precision highp float;
+
+in vec4 vColor;
+
+out vec4 fragColor;
+
+void main(void) {
+  fragColor = vColor;
+  fragColor = picking_filterColor(fragColor);
+}
+`;

package/typed/gpu-grid-layer/gpu-grid-cell-layer-vertex.glsl.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "#version 300 es\n#define SHADER_NAME gpu-grid-cell-layer-vertex-shader\n#define RANGE_COUNT 6\n\nin vec3 positions;\nin vec3 normals;\n\nin vec4 colors;\nin vec4 elevations;\nin vec3 instancePickingColors;\n\n// Custom uniforms\nuniform vec2 offset;\nuniform bool extruded;\nuniform float cellSize;\nuniform float coverage;\nuniform float opacity;\nuniform float elevationScale;\n\nuniform ivec2 gridSize;\nuniform vec2 gridOrigin;\nuniform vec2 gridOriginLow;\nuniform vec2 gridOffset;\nuniform vec2 gridOffsetLow;\nuniform vec4 colorRange[RANGE_COUNT];\nuniform vec2 elevationRange;\n\n// Domain uniforms\nuniform vec2 colorDomain;\nuniform bool colorDomainValid;\nuniform vec2 elevationDomain;\nuniform bool elevationDomainValid;\n\nlayout(std140) uniform;\nuniform ColorData\n{\n  vec4 maxMinCount;\n} colorData;\nuniform ElevationData\n{\n  vec4 maxMinCount;\n} elevationData;\n\n#define EPSILON 0.00001\n\n// Result\nout vec4 vColor;\n\nvec4 quantizeScale(vec2 domain, vec4 range[RANGE_COUNT], float value) {\n  vec4 outColor = vec4(0., 0., 0., 0.);\n  if (value >= (domain.x - EPSILON) && value <= (domain.y + EPSILON)) {\n    float domainRange = domain.y - domain.x;\n    if (domainRange <= 0.) {\n      outColor = colorRange[0];\n    } else {\n      float rangeCount = float(RANGE_COUNT);\n      float rangeStep = domainRange / rangeCount;\n      float idx = floor((value - domain.x) / rangeStep);\n      idx = clamp(idx, 0., rangeCount - 1.);\n      int intIdx = int(idx);\n      outColor = colorRange[intIdx];\n    }\n  }\n  return outColor;\n}\n\nfloat linearScale(vec2 domain, vec2 range, float value) {\n  if (value >= (domain.x - EPSILON) && value <= (domain.y + EPSILON)) {\n    return ((value - domain.x) / (domain.y - domain.x)) * (range.y - range.x) + range.x;\n  }\n  return -1.;\n}\n\nvoid main(void) {\n  vec2 clrDomain = colorDomainValid ? colorDomain : vec2(colorData.maxMinCount.a, colorData.maxMinCount.r);\n  vec4 color = quantizeScale(clrDomain, colorRange, colors.r);\n\n  float elevation = 0.0;\n\n  if (extruded) {\n    vec2 elvDomain = elevationDomainValid ? elevationDomain : vec2(elevationData.maxMinCount.a, elevationData.maxMinCount.r);\n    elevation = linearScale(elvDomain, elevationRange, elevations.r);\n    elevation = elevation  * (positions.z + 1.0) / 2.0 * elevationScale;\n  }\n\n  // if aggregated color or elevation is 0 do not render\n  float shouldRender = float(color.r > 0.0 && elevations.r >= 0.0);\n  float dotRadius = cellSize / 2. * coverage * shouldRender;\n\n  int yIndex = (gl_InstanceID / gridSize[0]);\n  int xIndex = gl_InstanceID - (yIndex * gridSize[0]);\n\n  vec2 instancePositionXFP64 = mul_fp64(vec2(gridOffset[0], gridOffsetLow[0]), vec2(float(xIndex), 0.));\n  instancePositionXFP64 = sum_fp64(instancePositionXFP64, vec2(gridOrigin[0], gridOriginLow[0]));\n  vec2 instancePositionYFP64 = mul_fp64(vec2(gridOffset[1], gridOffsetLow[1]), vec2(float(yIndex), 0.));\n  instancePositionYFP64 = sum_fp64(instancePositionYFP64, vec2(gridOrigin[1], gridOriginLow[1]));\n\n  vec3 centroidPosition = vec3(instancePositionXFP64[0], instancePositionYFP64[0], elevation);\n  vec3 centroidPosition64Low = vec3(instancePositionXFP64[1], instancePositionYFP64[1], 0.0);\n  geometry.worldPosition = centroidPosition;\n  vec3 pos = vec3(project_size(positions.xy + offset) * dotRadius, 0.);\n\n  // Set color to be rendered to picking fbo (also used to check for selection highlight).\n  picking_setPickingColor(instancePickingColors);\n\n  gl_Position = project_position_to_clipspace(centroidPosition, centroidPosition64Low, pos, geometry.position);\n\n  // Light calculations\n  // Worldspace is the linear space after Mercator projection\n\n  vec3 normals_commonspace = project_normal(normals);\n\n   if (extruded) {\n    vec3 lightColor = lighting_getLightColor(color.rgb, project_uCameraPosition, geometry.position.xyz, normals_commonspace);\n    vColor = vec4(lightColor, color.a * opacity) / 255.;\n  } else {\n    vColor = vec4(color.rgb, color.a * opacity) / 255.;\n  }\n}\n";
+export default _default;
+//# sourceMappingURL=gpu-grid-cell-layer-vertex.glsl.d.ts.map

package/typed/gpu-grid-layer/gpu-grid-cell-layer-vertex.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-grid-cell-layer-vertex.glsl.d.ts","sourceRoot":"","sources":["../../src/gpu-grid-layer/gpu-grid-cell-layer-vertex.glsl.ts"],"names":[],"mappings":";AAsBA,wBAwHE"}