@deck.gl/aggregation-layers 8.8.0-alpha.5 → 8.8.0-beta.2

package/typed/heatmap-layer/triangle-layer.js

@@ -0,0 +1,67 @@
+// Copyright (c) 2015 - 2019 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 { Model, Geometry } from '@luma.gl/core';
+import { Layer, project32 } from '@deck.gl/core';
+import vs from './triangle-layer-vertex.glsl';
+import fs from './triangle-layer-fragment.glsl';
+export default class TriangleLayer extends Layer {
+    getShaders() {
+        return { vs, fs, modules: [project32] };
+    }
+    initializeState({ gl }) {
+        const attributeManager = this.getAttributeManager();
+        attributeManager.add({
+            positions: { size: 3, noAlloc: true },
+            texCoords: { size: 2, noAlloc: true }
+        });
+        this.setState({
+            model: this._getModel(gl)
+        });
+    }
+    _getModel(gl) {
+        const { vertexCount } = this.props;
+        return new Model(gl, {
+            ...this.getShaders(),
+            id: this.props.id,
+            geometry: new Geometry({
+                drawMode: GL.TRIANGLE_FAN,
+                vertexCount
+            })
+        });
+    }
+    draw({ uniforms }) {
+        const { model } = this.state;
+        const { texture, maxTexture, colorTexture, intensity, threshold, aggregationMode, colorDomain } = this.props;
+        model
+            .setUniforms({
+            ...uniforms,
+            texture,
+            maxTexture,
+            colorTexture,
+            intensity,
+            threshold,
+            aggregationMode,
+            colorDomain
+        })
+            .draw();
+    }
+}
+TriangleLayer.layerName = 'TriangleLayer';

package/typed/heatmap-layer/weights-fs.glsl.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "varying vec4 weightsTexture;\n// Epanechnikov function, keeping for reference\n// float epanechnikovKDE(float u) {\n//   return 0.75 * (1.0 - u * u);\n// }\nfloat gaussianKDE(float u){\n  return pow(2.71828, -u*u/0.05555)/(1.77245385*0.166666);\n}\nvoid main()\n{\n  float dist = length(gl_PointCoord - vec2(0.5, 0.5));\n  if (dist > 0.5) {\n    discard;\n  }\n  gl_FragColor = weightsTexture * gaussianKDE(2. * dist);\n  DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n";
+export default _default;
+//# sourceMappingURL=weights-fs.glsl.d.ts.map

package/typed/heatmap-layer/weights-fs.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weights-fs.glsl.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/weights-fs.glsl.ts"],"names":[],"mappings":";AAAA,wBAkBE"}

package/typed/heatmap-layer/weights-fs.glsl.js

@@ -0,0 +1,19 @@
+export default `\
+varying vec4 weightsTexture;
+// Epanechnikov function, keeping for reference
+// float epanechnikovKDE(float u) {
+//   return 0.75 * (1.0 - u * u);
+// }
+float gaussianKDE(float u){
+  return pow(2.71828, -u*u/0.05555)/(1.77245385*0.166666);
+}
+void main()
+{
+  float dist = length(gl_PointCoord - vec2(0.5, 0.5));
+  if (dist > 0.5) {
+    discard;
+  }
+  gl_FragColor = weightsTexture * gaussianKDE(2. * dist);
+  DECKGL_FILTER_COLOR(gl_FragColor, geometry);
+}
+`;

package/typed/heatmap-layer/weights-vs.glsl.d.ts

@@ -0,0 +1,3 @@
+declare const _default: "attribute vec3 positions;\nattribute vec3 positions64Low;\nattribute float weights;\nvarying vec4 weightsTexture;\nuniform float radiusPixels;\nuniform float textureWidth;\nuniform vec4 commonBounds;\nuniform float weightsScale;\nvoid main()\n{\n  weightsTexture = vec4(weights * weightsScale, 0., 0., 1.);\n\n  float radiusTexels  = project_pixel_size(radiusPixels) * textureWidth / (commonBounds.z - commonBounds.x);\n  gl_PointSize = radiusTexels * 2.;\n\n  vec3 commonPosition = project_position(positions, positions64Low);\n\n  // map xy from commonBounds to [-1, 1]\n  gl_Position.xy = (commonPosition.xy - commonBounds.xy) / (commonBounds.zw - commonBounds.xy) ;\n  gl_Position.xy = (gl_Position.xy * 2.) - (1.);\n}\n";
+export default _default;
+//# sourceMappingURL=weights-vs.glsl.d.ts.map

package/typed/heatmap-layer/weights-vs.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weights-vs.glsl.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/weights-vs.glsl.ts"],"names":[],"mappings":";AAAA,wBAsBE"}

package/typed/heatmap-layer/weights-vs.glsl.js

@@ -0,0 +1,23 @@
+export default `\
+attribute vec3 positions;
+attribute vec3 positions64Low;
+attribute float weights;
+varying vec4 weightsTexture;
+uniform float radiusPixels;
+uniform float textureWidth;
+uniform vec4 commonBounds;
+uniform float weightsScale;
+void main()
+{
+  weightsTexture = vec4(weights * weightsScale, 0., 0., 1.);
+
+  float radiusTexels  = project_pixel_size(radiusPixels) * textureWidth / (commonBounds.z - commonBounds.x);
+  gl_PointSize = radiusTexels * 2.;
+
+  vec3 commonPosition = project_position(positions, positions64Low);
+
+  // map xy from commonBounds to [-1, 1]
+  gl_Position.xy = (commonPosition.xy - commonBounds.xy) / (commonBounds.zw - commonBounds.xy) ;
+  gl_Position.xy = (gl_Position.xy * 2.) - (1.);
+}
+`;

package/typed/hexagon-layer/hexagon-aggregator.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Use d3-hexbin to performs hexagonal binning from geo points to hexagons
+ * @param {Iterable} data - array of points
+ * @param {Number} radius - hexagon radius in meter
+ * @param {function} getPosition - get points lon lat
+ * @param {Object} viewport - current viewport object
+
+ * @return {Object} - hexagons and countRange
+ */
+export function pointToHexbin(props: any, aggregationParams: any): any;
+/**
+ * Get the bounding box of all data points
+ */
+export function getPointsCenter(data: any, aggregationParams: any): number[] | null;
+/**
+ * Get radius in mercator world space coordinates from meter
+ * @param {Number} radius - in meter
+ * @param {Object} viewport - current viewport object
+ * @param {Array<Number>} center - data center
+
+ * @return {Number} radius in mercator world spcae coordinates
+ */
+export function getRadiusInCommon(radius: number, viewport: any, center: Array<number>): number;
+//# sourceMappingURL=hexagon-aggregator.d.ts.map

package/typed/hexagon-layer/hexagon-aggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hexagon-aggregator.d.ts","sourceRoot":"","sources":["../../src/hexagon-layer/hexagon-aggregator.js"],"names":[],"mappings":"AAuBA;;;;;;;;GAQG;AACH,uEA2CC;AAED;;GAEG;AACH,oFA4BC;AAED;;;;;;;GAOG;AACH,yEAJW,aAAa,UAQvB"}

package/typed/hexagon-layer/hexagon-aggregator.js

@@ -0,0 +1,112 @@
+// 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 { hexbin } from 'd3-hexbin';
+import { createIterable, log } from '@deck.gl/core';
+/**
+ * Use d3-hexbin to performs hexagonal binning from geo points to hexagons
+ * @param {Iterable} data - array of points
+ * @param {Number} radius - hexagon radius in meter
+ * @param {function} getPosition - get points lon lat
+ * @param {Object} viewport - current viewport object
+
+ * @return {Object} - hexagons and countRange
+ */
+export function pointToHexbin(props, aggregationParams) {
+    const { data, radius } = props;
+    const { viewport, attributes } = aggregationParams;
+    // get hexagon radius in mercator world unit
+    const centerLngLat = data.length ? getPointsCenter(data, aggregationParams) : null;
+    const radiusCommon = getRadiusInCommon(radius, viewport, centerLngLat);
+    // add world space coordinates to points
+    const screenPoints = [];
+    const { iterable, objectInfo } = createIterable(data);
+    const positions = attributes.positions.value;
+    const { size } = attributes.positions.getAccessor();
+    for (const object of iterable) {
+        objectInfo.index++;
+        const posIndex = objectInfo.index * size;
+        const position = [positions[posIndex], positions[posIndex + 1]];
+        const arrayIsFinite = Number.isFinite(position[0]) && Number.isFinite(position[1]);
+        if (arrayIsFinite) {
+            screenPoints.push({
+                screenCoord: viewport.projectFlat(position),
+                source: object,
+                index: objectInfo.index
+            });
+        }
+        else {
+            log.warn('HexagonLayer: invalid position')();
+        }
+    }
+    const newHexbin = hexbin()
+        .radius(radiusCommon)
+        .x(d => d.screenCoord[0])
+        .y(d => d.screenCoord[1]);
+    const hexagonBins = newHexbin(screenPoints);
+    return {
+        hexagons: hexagonBins.map((hex, index) => ({
+            position: viewport.unprojectFlat([hex.x, hex.y]),
+            points: hex,
+            index
+        })),
+        radiusCommon
+    };
+}
+/**
+ * Get the bounding box of all data points
+ */
+export function getPointsCenter(data, aggregationParams) {
+    const { attributes } = aggregationParams;
+    const positions = attributes.positions.value;
+    const { size } = attributes.positions.getAccessor();
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let i;
+    for (i = 0; i < size * data.length; i += size) {
+        const x = positions[i];
+        const y = positions[i + 1];
+        const arrayIsFinite = Number.isFinite(x) && Number.isFinite(y);
+        if (arrayIsFinite) {
+            minX = Math.min(x, minX);
+            maxX = Math.max(x, maxX);
+            minY = Math.min(y, minY);
+            maxY = Math.max(y, maxY);
+        }
+    }
+    // return center
+    return [minX, minY, maxX, maxY].every(Number.isFinite)
+        ? [(minX + maxX) / 2, (minY + maxY) / 2]
+        : null;
+}
+/**
+ * Get radius in mercator world space coordinates from meter
+ * @param {Number} radius - in meter
+ * @param {Object} viewport - current viewport object
+ * @param {Array<Number>} center - data center
+
+ * @return {Number} radius in mercator world spcae coordinates
+ */
+export function getRadiusInCommon(radius, viewport, center) {
+    const { unitsPerMeter } = viewport.getDistanceScales(center);
+    // x, y distance should be the same
+    return radius * unitsPerMeter[0];
+}

package/typed/hexagon-layer/hexagon-layer.d.ts

@@ -0,0 +1,165 @@
+import { Accessor, AccessorFunction, Color, Position, Material, UpdateParameters, DefaultProps } from '@deck.gl/core/typed';
+import { ColumnLayer } from '@deck.gl/layers/typed';
+import CPUAggregator from '../utils/cpu-aggregator';
+import AggregationLayer, { AggregationLayerProps } from '../aggregation-layer';
+import { AggregateAccessor } from '../types';
+/** All properties supported by by HexagonLayer. */
+export declare type HexagonLayerProps<DataT = any> = _HexagonLayerProps<DataT> & AggregationLayerProps<DataT>;
+/** Properties added by HexagonLayer. */
+declare type _HexagonLayerProps<DataT = any> = {
+    /**
+     * Radius of hexagon bin in meters. The hexagons are pointy-topped (rather than flat-topped).
+     * @default 1000
+     */
+    radius?: number;
+    /**
+     * Function to aggregate data into hexagonal bins.
+     * @default d3-hexbin
+     */
+    hexagonAggregator?: (props: any, params: any) => any;
+    /**
+     * Color scale input domain.
+     * @default [min(colorWeight), max(colorWeight)]
+     */
+    colorDomain?: [number, number] | null;
+    /**
+     * Specified as an array of colors [color1, color2, ...].
+     * @default `6-class YlOrRd` - [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6)
+     */
+    colorRange?: Color[];
+    /**
+     * Hexagon radius multiplier, clamped between 0 - 1.
+     * @default 1
+     */
+    coverage?: number;
+    /**
+     * Elevation scale input domain. The elevation scale is a linear scale that maps number of counts to elevation.
+     * @default [0, max(elevationWeight)]
+     */
+    elevationDomain?: [number, number] | null;
+    /**
+     * Elevation scale output range.
+     * @default [0, 1000]
+     */
+    elevationRange?: [number, number];
+    /**
+     * Hexagon elevation multiplier.
+     * @default 1
+     */
+    elevationScale?: number;
+    /**
+     * Whether to enable cell elevation. If set to false, all cell will be flat.
+     * @default false
+     */
+    extruded?: boolean;
+    /**
+     * Filter bins and re-calculate color by `upperPercentile`.
+     * Hexagons with color value larger than the `upperPercentile` will be hidden.
+     * @default 100
+     */
+    upperPercentile?: number;
+    /**
+     * Filter bins and re-calculate color by `lowerPercentile`.
+     * Hexagons with color value smaller than the `lowerPercentile` will be hidden.
+     * @default 0
+     */
+    lowerPercentile?: number;
+    /**
+     * Filter bins and re-calculate elevation by `elevationUpperPercentile`.
+     * Hexagons with elevation value larger than the `elevationUpperPercentile` will be hidden.
+     * @default 100
+     */
+    elevationUpperPercentile?: number;
+    /**
+     * Filter bins and re-calculate elevation by `elevationLowerPercentile`.
+     * Hexagons 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', 'quantile' and 'ordinal'.
+     * @default 'quantize'
+     */
+    colorScaleType?: 'quantize' | 'quantile' | 'ordinal';
+    /**
+     * Scaling function used to determine the elevation of the grid cell, only supports 'linear'.
+     */
+    elevationScaleType?: 'linear';
+    /**
+     * 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 bin.
+     * @default 1
+     */
+    getColorWeight?: Accessor<DataT, number>;
+    /**
+     * After data objects are aggregated into bins, 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 bin.
+     * @default 1
+     */
+    getElevationWeight?: Accessor<DataT, number>;
+    /**
+     * After data objects are aggregated into bins, 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 cell color domain has been calculated.
+     * @default () => {}
+     */
+    onSetColorDomain?: (minMax: [number, number]) => void;
+    /**
+     * This callback will be called when cell elevation domain has been calculated.
+     * @default () => {}
+     */
+    onSetElevationDomain?: (minMax: [number, number]) => void;
+    /**
+     * (Experimental) Filter data objects
+     */
+    _filterData: null | ((d: DataT) => boolean);
+};
+export default class HexagonLayer<ExtraPropsT = {}> extends AggregationLayer<ExtraPropsT & Required<_HexagonLayerProps>> {
+    static layerName: string;
+    static defaultProps: DefaultProps<HexagonLayerProps<any>>;
+    state: AggregationLayer['state'] & {
+        cpuAggregator: CPUAggregator;
+        aggregatorState: any;
+    };
+    initializeState(): void;
+    updateState(opts: UpdateParameters<this>): void;
+    convertLatLngToMeterOffset(hexagonVertices: any): number[][] | null;
+    getPickingInfo({ info }: {
+        info: any;
+    }): any;
+    _onGetSublayerColor(cell: any): any;
+    _onGetSublayerElevation(cell: any): any;
+    _getSublayerUpdateTriggers(): {};
+    renderLayers(): ColumnLayer<any, {}>;
+}
+export {};
+//# sourceMappingURL=hexagon-layer.d.ts.map

package/typed/hexagon-layer/hexagon-layer.d.ts.map

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

package/typed/hexagon-layer/hexagon-layer.js

@@ -0,0 +1,171 @@
+// 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 { ColumnLayer } from '@deck.gl/layers';
+import { defaultColorRange } from '../utils/color-utils';
+import { pointToHexbin } from './hexagon-aggregator';
+import CPUAggregator from '../utils/cpu-aggregator';
+import AggregationLayer from '../aggregation-layer';
+import GL from '@luma.gl/constants';
+// 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', value: 0, min: 0, max: 100 },
+    upperPercentile: { type: 'number', value: 100, min: 0, max: 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', value: 0, min: 0, max: 100 },
+    elevationUpperPercentile: { type: 'number', value: 100, min: 0, max: 100 },
+    elevationScale: { type: 'number', min: 0, value: 1 },
+    elevationScaleType: 'linear',
+    onSetElevationDomain: nop,
+    radius: { type: 'number', value: 1000, min: 1 },
+    coverage: { type: 'number', min: 0, max: 1, value: 1 },
+    extruded: false,
+    hexagonAggregator: pointToHexbin,
+    getPosition: { type: 'accessor', value: x => x.position },
+    // Optional material for 'lighting' shader module
+    material: true,
+    // data filter
+    _filterData: { type: 'function', value: null, optional: true }
+};
+export default class HexagonLayer extends AggregationLayer {
+    initializeState() {
+        const cpuAggregator = new CPUAggregator({
+            getAggregator: props => props.hexagonAggregator,
+            getCellSize: props => props.radius
+        });
+        this.state = {
+            cpuAggregator,
+            aggregatorState: cpuAggregator.state,
+            vertices: null
+        };
+        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 calculated using 'getValue' accessor that takes an array of pints.
+    }
+    updateState(opts) {
+        super.updateState(opts);
+        if (opts.changeFlags.propsOrDataChanged) {
+            const aggregatorState = this.state.cpuAggregator.updateState(opts, {
+                viewport: this.context.viewport,
+                attributes: this.getAttributes()
+            });
+            if (this.state.aggregatorState.layerData !== aggregatorState.layerData) {
+                // if user provided custom aggregator and returns hexagonVertices,
+                // Need to recalculate radius and angle based on vertices
+                const { hexagonVertices } = aggregatorState.layerData || {};
+                this.setState({
+                    vertices: hexagonVertices && this.convertLatLngToMeterOffset(hexagonVertices)
+                });
+            }
+            this.setState({
+                // make a copy of the internal state of cpuAggregator for testing
+                aggregatorState
+            });
+        }
+    }
+    convertLatLngToMeterOffset(hexagonVertices) {
+        const { viewport } = this.context;
+        if (Array.isArray(hexagonVertices) && hexagonVertices.length === 6) {
+            // get centroid of hexagons
+            const vertex0 = hexagonVertices[0];
+            const vertex3 = hexagonVertices[3];
+            const centroid = [(vertex0[0] + vertex3[0]) / 2, (vertex0[1] + vertex3[1]) / 2];
+            const centroidFlat = viewport.projectFlat(centroid);
+            const { metersPerUnit } = viewport.getDistanceScales(centroid);
+            // offset all points by centroid to meter offset
+            const vertices = hexagonVertices.map(vt => {
+                const vtFlat = viewport.projectFlat(vt);
+                return [
+                    (vtFlat[0] - centroidFlat[0]) * metersPerUnit[0],
+                    (vtFlat[1] - centroidFlat[1]) * metersPerUnit[1]
+                ];
+            });
+            return vertices;
+        }
+        log.error('HexagonLayer: hexagonVertices needs to be an array of 6 points')();
+        return null;
+    }
+    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, coverage, material, transitions } = this.props;
+        const { aggregatorState, vertices } = this.state;
+        const SubLayerClass = this.getSubLayerClass('hexagon-cell', ColumnLayer);
+        const updateTriggers = this._getSublayerUpdateTriggers();
+        const geometry = vertices
+            ? { vertices, radius: 1 }
+            : {
+                // default geometry
+                radius: aggregatorState.layerData.radiusCommon || 1,
+                radiusUnits: 'common',
+                angle: 90
+            };
+        return new SubLayerClass({
+            ...geometry,
+            diskResolution: 6,
+            elevationScale,
+            extruded,
+            coverage,
+            material,
+            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: 'hexagon-cell',
+            updateTriggers
+        }), {
+            data: aggregatorState.layerData.data
+        });
+    }
+}
+HexagonLayer.layerName = 'HexagonLayer';
+HexagonLayer.defaultProps = defaultProps;

package/typed/index.d.ts

@@ -0,0 +1,20 @@
+export { default as ScreenGridLayer } from './screen-grid-layer/screen-grid-layer';
+export { default as CPUGridLayer } from './cpu-grid-layer/cpu-grid-layer';
+export { default as HexagonLayer } from './hexagon-layer/hexagon-layer';
+export { default as ContourLayer } from './contour-layer/contour-layer';
+export { default as GridLayer } from './grid-layer/grid-layer';
+export { default as GPUGridLayer } from './gpu-grid-layer/gpu-grid-layer';
+export { AGGREGATION_OPERATION } from './utils/aggregation-operation-utils';
+export { default as HeatmapLayer } from './heatmap-layer/heatmap-layer';
+export { default as _GPUGridAggregator } from './utils/gpu-grid-aggregation/gpu-grid-aggregator';
+export { default as _CPUAggregator } from './utils/cpu-aggregator';
+export { default as _AggregationLayer } from './aggregation-layer';
+export { default as _BinSorter } from './utils/bin-sorter';
+export type { ContourLayerProps } from './contour-layer/contour-layer';
+export type { HeatmapLayerProps } from './heatmap-layer/heatmap-layer';
+export type { HexagonLayerProps } from './hexagon-layer/hexagon-layer';
+export type { CPUGridLayerProps } from './cpu-grid-layer/cpu-grid-layer';
+export type { GridLayerProps } from './grid-layer/grid-layer';
+export type { GPUGridLayerProps } from './gpu-grid-layer/gpu-grid-layer';
+export type { ScreenGridLayerProps } from './screen-grid-layer/screen-grid-layer';
+//# sourceMappingURL=index.d.ts.map

package/typed/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAqBA,OAAO,EAAC,OAAO,IAAI,eAAe,EAAC,MAAM,uCAAuC,CAAC;AACjF,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,iCAAiC,CAAC;AACxE,OAAO,EAAC,qBAAqB,EAAC,MAAM,qCAAqC,CAAC;AAG1E,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,OAAO,IAAI,kBAAkB,EAAC,MAAM,kDAAkD,CAAC;AAC/F,OAAO,EAAC,OAAO,IAAI,cAAc,EAAC,MAAM,wBAAwB,CAAC;AACjE,OAAO,EAAC,OAAO,IAAI,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAGzD,YAAY,EAAC,iBAAiB,EAAC,MAAM,+BAA+B,CAAC;AACrE,YAAY,EAAC,iBAAiB,EAAC,MAAM,+BAA+B,CAAC;AACrE,YAAY,EAAC,iBAAiB,EAAC,MAAM,+BAA+B,CAAC;AACrE,YAAY,EAAC,iBAAiB,EAAC,MAAM,iCAAiC,CAAC;AACvE,YAAY,EAAC,cAAc,EAAC,MAAM,yBAAyB,CAAC;AAC5D,YAAY,EAAC,iBAAiB,EAAC,MAAM,iCAAiC,CAAC;AACvE,YAAY,EAAC,oBAAoB,EAAC,MAAM,uCAAuC,CAAC"}