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

package/dist/heatmap-layer/triangle-layer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"triangle-layer.js","sourceRoot":"","sources":["../../src/heatmap-layer/triangle-layer.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAGpC,OAAO,EAAC,KAAK,EAAC,MAAM,iBAAiB,CAAC;AACtC,OAAO,EAAC,KAAK,EAAgB,SAAS,EAAC,MAAM,eAAe,CAAC;AAC7D,OAAO,EAAE,wCAAqC;AAC9C,OAAO,EAAE,0CAAuC;AAChD,OAAO,EAAgB,gBAAgB,EAAC,qCAAkC;AAc1E,MAAqB,aAAc,SAAQ,KAA0B;IASnE,UAAU;QACR,OAAO,KAAK,CAAC,UAAU,CAAC,EAAC,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,CAAC,SAAS,EAAE,gBAAgB,CAAC,EAAC,CAAC,CAAC;IAC5E,CAAC;IAED,eAAe,CAAC,EAAC,MAAM,EAAe;QACpC,IAAI,CAAC,QAAQ,CAAC,EAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAC,CAAC,CAAC;IACjD,CAAC;IAED,SAAS,CAAC,MAAc;QACtB,MAAM,EAAC,WAAW,EAAE,IAAI,EAAC,GAAG,IAAI,CAAC,KAAK,CAAC;QAEvC,OAAO,IAAI,KAAK,CAAC,MAAM,EAAE;YACvB,GAAG,IAAI,CAAC,UAAU,EAAE;YACpB,EAAE,EAAE,IAAI,CAAC,KAAK,CAAC,EAAE;YACjB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,YAAY,EAAE;gBACZ,EAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,EAAC;gBACxC,EAAC,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,EAAC;aACzC;YACD,QAAQ,EAAE,gBAAgB;YAC1B,WAAW;SACZ,CAAC,CAAC;IACL,CAAC;IAED,IAAI;QACF,MAAM,EAAC,KAAK,EAAC,GAAG,IAAI,CAAC,KAAK,CAAC;QAC3B,MAAM,EACJ,eAAe,EACf,WAAW,EACX,SAAS,EACT,SAAS,EACT,YAAY,EACZ,UAAU,EACV,cAAc,EACf,GAAG,IAAI,CAAC,KAAK,CAAC;QACf,MAAM,aAAa,GAAkB;YACnC,eAAe;YACf,WAAW;YACX,SAAS;YACT,SAAS;YACT,YAAY;YACZ,UAAU;YACV,cAAc;SACf,CAAC;QACF,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAC,QAAQ,EAAE,aAAa,EAAC,CAAC,CAAC;QACvD,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IACtC,CAAC;;AAtDM,uBAAS,GAAG,eAAe,CAAC;eADhB,aAAa"}

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

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

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

@@ -1,3 +1,6 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 export default `\
 #version 300 es
 in vec4 weightsTexture;
@@ -15,3 +18,4 @@ fragColor = weightsTexture * gaussianKDE(2. * dist);
 DECKGL_FILTER_COLOR(fragColor, geometry);
 }
 `;
+//# sourceMappingURL=weights-fs.glsl.js.map

package/dist/heatmap-layer/weights-fs.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"weights-fs.glsl.js","sourceRoot":"","sources":["../../src/heatmap-layer/weights-fs.glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC;;;;;;;;;;;;;;;;EAoBE"}

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

@@ -1,3 +1,3 @@
-declare const _default: "#version 300 es\nin vec3 positions;\nin vec3 positions64Low;\nin float weights;\nout vec4 weightsTexture;\nuniform float radiusPixels;\nuniform float textureWidth;\nuniform vec4 commonBounds;\nuniform float weightsScale;\n\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  gl_Position.w = 1.0;\n}\n";
+declare const _default: "#version 300 es\nin vec3 positions;\nin vec3 positions64Low;\nin float weights;\nout vec4 weightsTexture;\n\nvoid main()\n{\n  weightsTexture = vec4(weights * weight.weightsScale, 0., 0., 1.);\n\n  float radiusTexels = project_pixel_size(weight.radiusPixels) * weight.textureWidth / (weight.commonBounds.z - weight.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 - weight.commonBounds.xy) / (weight.commonBounds.zw - weight.commonBounds.xy) ;\n  gl_Position.xy = (gl_Position.xy * 2.) - (1.);\n  gl_Position.w = 1.0;\n}\n";
 export default _default;
 //# sourceMappingURL=weights-vs.glsl.d.ts.map

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

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

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

@@ -1,21 +1,21 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 export default `\
 #version 300 es
 in vec3 positions;
 in vec3 positions64Low;
 in float weights;
 out 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);
+weightsTexture = vec4(weights * weight.weightsScale, 0., 0., 1.);
+float radiusTexels = project_pixel_size(weight.radiusPixels) * weight.textureWidth / (weight.commonBounds.z - weight.commonBounds.x);
 gl_PointSize = radiusTexels * 2.;
 vec3 commonPosition = project_position(positions, positions64Low);
-gl_Position.xy = (commonPosition.xy - commonBounds.xy) / (commonBounds.zw - commonBounds.xy) ;
+gl_Position.xy = (commonPosition.xy - weight.commonBounds.xy) / (weight.commonBounds.zw - weight.commonBounds.xy) ;
 gl_Position.xy = (gl_Position.xy * 2.) - (1.);
 gl_Position.w = 1.0;
 }
 `;
+//# sourceMappingURL=weights-vs.glsl.js.map

package/dist/heatmap-layer/weights-vs.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"weights-vs.glsl.js","sourceRoot":"","sources":["../../src/heatmap-layer/weights-vs.glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC;;;;;;;;;;;;;;;;EAqBE"}

package/dist/hexagon-layer/bin-options-uniforms.d.ts

@@ -0,0 +1,14 @@
+import { NumberArray2 } from '@math.gl/core';
+export type BinOptions = {
+    hexOriginCommon: NumberArray2;
+    radiusCommon: number;
+};
+export declare const binOptionsUniforms: {
+    readonly name: "binOptions";
+    readonly vs: "uniform binOptionsUniforms {\n  vec2 hexOriginCommon;\n  float radiusCommon;\n} binOptions;\n";
+    readonly uniformTypes: {
+        readonly hexOriginCommon: "vec2<f32>";
+        readonly radiusCommon: "f32";
+    };
+};
+//# sourceMappingURL=bin-options-uniforms.d.ts.map

package/dist/hexagon-layer/bin-options-uniforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin-options-uniforms.d.ts","sourceRoot":"","sources":["../../src/hexagon-layer/bin-options-uniforms.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAC,MAAM,eAAe,CAAC;AAS3C,MAAM,MAAM,UAAU,GAAG;IACvB,eAAe,EAAE,YAAY,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,kBAAkB;;;;;;;CAOc,CAAC"}

package/dist/hexagon-layer/bin-options-uniforms.js

@@ -0,0 +1,18 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const uniformBlock = /* glsl */ `\
+uniform binOptionsUniforms {
+  vec2 hexOriginCommon;
+  float radiusCommon;
+} binOptions;
+`;
+export const binOptionsUniforms = {
+    name: 'binOptions',
+    vs: uniformBlock,
+    uniformTypes: {
+        hexOriginCommon: 'vec2<f32>',
+        radiusCommon: 'f32'
+    }
+};
+//# sourceMappingURL=bin-options-uniforms.js.map

package/dist/hexagon-layer/bin-options-uniforms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin-options-uniforms.js","sourceRoot":"","sources":["../../src/hexagon-layer/bin-options-uniforms.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAKpC,MAAM,YAAY,GAAG,UAAU,CAAC;;;;;CAK/B,CAAC;AAOF,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,YAAY;IAChB,YAAY,EAAE;QACZ,eAAe,EAAE,WAAW;QAC5B,YAAY,EAAE,KAAK;KACpB;CAC0C,CAAC"}

package/dist/hexagon-layer/hexagon-cell-layer-vertex.glsl.d.ts

@@ -0,0 +1,3 @@
+declare const _default: string;
+export default _default;
+//# sourceMappingURL=hexagon-cell-layer-vertex.glsl.d.ts.map

package/dist/hexagon-layer/hexagon-cell-layer-vertex.glsl.d.ts.map

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

package/dist/hexagon-layer/hexagon-cell-layer-vertex.glsl.js

@@ -0,0 +1,56 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { getHexbinCentroidGLSL } from "./hexbin.js";
+export default /* glsl */ `\
+#version 300 es
+#define SHADER_NAME hexagon-cell-layer-vertex-shader
+in vec3 positions;
+in vec3 normals;
+in vec2 instancePositions;
+in float instanceElevationValues;
+in float instanceColorValues;
+in vec3 instancePickingColors;
+uniform sampler2D colorRange;
+out vec4 vColor;
+${getHexbinCentroidGLSL}
+float interp(float value, vec2 domain, vec2 range) {
+float r = min(max((value - domain.x) / (domain.y - domain.x), 0.), 1.);
+return mix(range.x, range.y, r);
+}
+vec4 interp(float value, vec2 domain, sampler2D range) {
+float r = (value - domain.x) / (domain.y - domain.x);
+return texture(range, vec2(r, 0.5));
+}
+void main(void) {
+geometry.pickingColor = instancePickingColors;
+if (isnan(instanceColorValues) ||
+instanceColorValues < hexagon.colorDomain.z ||
+instanceColorValues > hexagon.colorDomain.w ||
+instanceElevationValues < hexagon.elevationDomain.z ||
+instanceElevationValues > hexagon.elevationDomain.w
+) {
+gl_Position = vec4(0.);
+return;
+}
+vec2 commonPosition = hexbinCentroid(instancePositions, column.radius) + (hexagon.originCommon - project.commonOrigin.xy);
+commonPosition += positions.xy * column.radius * column.coverage;
+geometry.position = vec4(commonPosition, 0.0, 1.0);
+geometry.normal = project_normal(normals);
+float elevation = 0.0;
+if (column.extruded) {
+elevation = interp(instanceElevationValues, hexagon.elevationDomain.xy, hexagon.elevationRange);
+elevation = project_size(elevation);
+geometry.position.z = (positions.z + 1.0) / 2.0 * elevation;
+}
+gl_Position = project_common_position_to_clipspace(geometry.position);
+DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+vColor = interp(instanceColorValues, hexagon.colorDomain.xy, colorRange);
+vColor.a *= layer.opacity;
+if (column.extruded) {
+vColor.rgb = lighting_getLightColor(vColor.rgb, project.cameraPosition, geometry.position.xyz, geometry.normal);
+}
+DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;
+//# sourceMappingURL=hexagon-cell-layer-vertex.glsl.js.map

package/dist/hexagon-layer/hexagon-cell-layer-vertex.glsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hexagon-cell-layer-vertex.glsl.js","sourceRoot":"","sources":["../../src/hexagon-layer/hexagon-cell-layer-vertex.glsl.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC,OAAO,EAAC,qBAAqB,EAAC,oBAAiB;AAE/C,eAAe,UAAU,CAAC;;;;;;;;;;;EAiBxB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDtB,CAAC"}

package/dist/hexagon-layer/hexagon-cell-layer.d.ts

@@ -0,0 +1,29 @@
+import { Texture } from '@luma.gl/core';
+import { UpdateParameters, Color } from '@deck.gl/core';
+import { ColumnLayer } from '@deck.gl/layers';
+import type { ScaleType } from "../common/types.js";
+/** Proprties added by HexagonCellLayer. */
+export type _HexagonCellLayerProps = {
+    hexOriginCommon: [number, number];
+    colorDomain: [number, number];
+    colorCutoff: [number, number] | null;
+    colorRange: Color[];
+    colorScaleType: ScaleType;
+    elevationDomain: [number, number];
+    elevationCutoff: [number, number] | null;
+    elevationRange: [number, number];
+};
+export default class HexagonCellLayer<ExtraPropsT extends {} = {}> extends ColumnLayer<null, ExtraPropsT & Required<_HexagonCellLayerProps>> {
+    static layerName: string;
+    state: ColumnLayer['state'] & {
+        colorTexture: Texture;
+    };
+    getShaders(): any;
+    initializeState(): void;
+    updateState(params: UpdateParameters<this>): void;
+    finalizeState(context: any): void;
+    draw({ uniforms }: {
+        uniforms: any;
+    }): void;
+}
+//# sourceMappingURL=hexagon-cell-layer.d.ts.map

package/dist/hexagon-layer/hexagon-cell-layer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hexagon-cell-layer.d.ts","sourceRoot":"","sources":["../../src/hexagon-layer/hexagon-cell-layer.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AACtC,OAAO,EAAC,gBAAgB,EAAE,KAAK,EAAC,MAAM,eAAe,CAAC;AACtD,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAC;AAI5C,OAAO,KAAK,EAAC,SAAS,EAAC,2BAAwB;AAE/C,2CAA2C;AAC3C,MAAM,MAAM,sBAAsB,GAAG;IACnC,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACrC,UAAU,EAAE,KAAK,EAAE,CAAC;IACpB,cAAc,EAAE,SAAS,CAAC;IAC1B,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC;IACzC,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,gBAAgB,CAAC,WAAW,SAAS,EAAE,GAAG,EAAE,CAAE,SAAQ,WAAW,CACpF,IAAI,EACJ,WAAW,GAAG,QAAQ,CAAC,sBAAsB,CAAC,CAC/C;IACC,MAAM,CAAC,SAAS,SAAsB;IAEtC,KAAK,EAAG,WAAW,CAAC,OAAO,CAAC,GAAG;QAC7B,YAAY,EAAE,OAAO,CAAC;KACvB,CAAC;IAEF,UAAU;IAMV,eAAe;IA6Bf,WAAW,CAAC,MAAM,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAoB1C,aAAa,CAAC,OAAO,KAAA;IAMrB,IAAI,CAAC,EAAC,QAAQ,EAAC;;KAAA;CA6ChB"}

package/dist/hexagon-layer/hexagon-cell-layer.js

@@ -0,0 +1,95 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { ColumnLayer } from '@deck.gl/layers';
+import { createColorRangeTexture, updateColorRangeTexture } from "../common/utils/color-utils.js";
+import vs from "./hexagon-cell-layer-vertex.glsl.js";
+import { hexagonUniforms } from "./hexagon-layer-uniforms.js";
+class HexagonCellLayer extends ColumnLayer {
+    getShaders() {
+        const shaders = super.getShaders();
+        shaders.modules.push(hexagonUniforms);
+        return { ...shaders, vs };
+    }
+    initializeState() {
+        super.initializeState();
+        const attributeManager = this.getAttributeManager();
+        attributeManager.remove([
+            'instanceElevations',
+            'instanceFillColors',
+            'instanceLineColors',
+            'instanceStrokeWidths'
+        ]);
+        attributeManager.addInstanced({
+            instancePositions: {
+                size: 2,
+                type: 'float32',
+                accessor: 'getBin'
+            },
+            instanceColorValues: {
+                size: 1,
+                type: 'float32',
+                accessor: 'getColorValue'
+            },
+            instanceElevationValues: {
+                size: 1,
+                type: 'float32',
+                accessor: 'getElevationValue'
+            }
+        });
+    }
+    updateState(params) {
+        super.updateState(params);
+        const { props, oldProps } = params;
+        const model = this.state.fillModel;
+        if (oldProps.colorRange !== props.colorRange) {
+            this.state.colorTexture?.destroy();
+            this.state.colorTexture = createColorRangeTexture(this.context.device, props.colorRange, props.colorScaleType);
+            const hexagonProps = { colorRange: this.state.colorTexture };
+            model.shaderInputs.setProps({ hexagon: hexagonProps });
+        }
+        else if (oldProps.colorScaleType !== props.colorScaleType) {
+            updateColorRangeTexture(this.state.colorTexture, props.colorScaleType);
+        }
+    }
+    finalizeState(context) {
+        super.finalizeState(context);
+        this.state.colorTexture?.destroy();
+    }
+    draw({ uniforms }) {
+        const { radius, hexOriginCommon, elevationRange, elevationScale, extruded, coverage, colorDomain, elevationDomain } = this.props;
+        const colorCutoff = this.props.colorCutoff || [-Infinity, Infinity];
+        const elevationCutoff = this.props.elevationCutoff || [-Infinity, Infinity];
+        const fillModel = this.state.fillModel;
+        if (fillModel.vertexArray.indexBuffer) {
+            // indices are for drawing wireframe, disable them
+            // TODO - this should be handled in ColumnLayer?
+            fillModel.setIndexBuffer(null);
+        }
+        fillModel.setVertexCount(this.state.fillVertexCount);
+        const hexagonProps = {
+            colorDomain: [
+                Math.max(colorDomain[0], colorCutoff[0]), // instanceColorValue that maps to colorRange[0]
+                Math.min(colorDomain[1], colorCutoff[1]), // instanceColorValue that maps to colorRange[colorRange.length - 1]
+                Math.max(colorDomain[0] - 1, colorCutoff[0]), // hide cell if instanceColorValue is less than this
+                Math.min(colorDomain[1] + 1, colorCutoff[1]) // hide cell if instanceColorValue is greater than this
+            ],
+            elevationDomain: [
+                Math.max(elevationDomain[0], elevationCutoff[0]), // instanceElevationValue that maps to elevationRange[0]
+                Math.min(elevationDomain[1], elevationCutoff[1]), // instanceElevationValue that maps to elevationRange[elevationRange.length - 1]
+                Math.max(elevationDomain[0] - 1, elevationCutoff[0]), // hide cell if instanceElevationValue is less than this
+                Math.min(elevationDomain[1] + 1, elevationCutoff[1]) // hide cell if instanceElevationValue is greater than this
+            ],
+            elevationRange: [elevationRange[0] * elevationScale, elevationRange[1] * elevationScale],
+            originCommon: hexOriginCommon
+        };
+        fillModel.shaderInputs.setProps({
+            column: { extruded, coverage, radius },
+            hexagon: hexagonProps
+        });
+        fillModel.draw(this.context.renderPass);
+    }
+}
+HexagonCellLayer.layerName = 'HexagonCellLayer';
+export default HexagonCellLayer;
+//# sourceMappingURL=hexagon-cell-layer.js.map

package/dist/hexagon-layer/hexagon-cell-layer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hexagon-cell-layer.js","sourceRoot":"","sources":["../../src/hexagon-layer/hexagon-cell-layer.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAIpC,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAC,uBAAuB,EAAE,uBAAuB,EAAC,uCAAoC;AAC7F,OAAO,EAAE,4CAAyC;AAClD,OAAO,EAAe,eAAe,EAAC,oCAAiC;AAevE,MAAqB,gBAA8C,SAAQ,WAG1E;IAOC,UAAU;QACR,MAAM,OAAO,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC;QACnC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QACtC,OAAO,EAAC,GAAG,OAAO,EAAE,EAAE,EAAC,CAAC;IAC1B,CAAC;IAED,eAAe;QACb,KAAK,CAAC,eAAe,EAAE,CAAC;QAExB,MAAM,gBAAgB,GAAG,IAAI,CAAC,mBAAmB,EAAG,CAAC;QACrD,gBAAgB,CAAC,MAAM,CAAC;YACtB,oBAAoB;YACpB,oBAAoB;YACpB,oBAAoB;YACpB,sBAAsB;SACvB,CAAC,CAAC;QACH,gBAAgB,CAAC,YAAY,CAAC;YAC5B,iBAAiB,EAAE;gBACjB,IAAI,EAAE,CAAC;gBACP,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,QAAQ;aACnB;YACD,mBAAmB,EAAE;gBACnB,IAAI,EAAE,CAAC;gBACP,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,eAAe;aAC1B;YACD,uBAAuB,EAAE;gBACvB,IAAI,EAAE,CAAC;gBACP,IAAI,EAAE,SAAS;gBACf,QAAQ,EAAE,mBAAmB;aAC9B;SACF,CAAC,CAAC;IACL,CAAC;IAED,WAAW,CAAC,MAA8B;QACxC,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAE1B,MAAM,EAAC,KAAK,EAAE,QAAQ,EAAC,GAAG,MAAM,CAAC;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,SAAU,CAAC;QAEpC,IAAI,QAAQ,CAAC,UAAU,KAAK,KAAK,CAAC,UAAU,EAAE,CAAC;YAC7C,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,OAAO,EAAE,CAAC;YACnC,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,uBAAuB,CAC/C,IAAI,CAAC,OAAO,CAAC,MAAM,EACnB,KAAK,CAAC,UAAU,EAChB,KAAK,CAAC,cAAc,CACrB,CAAC;YACF,MAAM,YAAY,GAA0B,EAAC,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY,EAAC,CAAC;YAClF,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAC,OAAO,EAAE,YAAY,EAAC,CAAC,CAAC;QACvD,CAAC;aAAM,IAAI,QAAQ,CAAC,cAAc,KAAK,KAAK,CAAC,cAAc,EAAE,CAAC;YAC5D,uBAAuB,CAAC,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;QACzE,CAAC;IACH,CAAC;IAED,aAAa,CAAC,OAAO;QACnB,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAE7B,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,OAAO,EAAE,CAAC;IACrC,CAAC;IAED,IAAI,CAAC,EAAC,QAAQ,EAAC;QACb,MAAM,EACJ,MAAM,EACN,eAAe,EACf,cAAc,EACd,cAAc,EACd,QAAQ,EACR,QAAQ,EACR,WAAW,EACX,eAAe,EAChB,GAAG,IAAI,CAAC,KAAK,CAAC;QACf,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,IAAI,CAAC,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QACpE,MAAM,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,IAAI,CAAC,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC5E,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,SAAU,CAAC;QAExC,IAAI,SAAS,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;YACtC,kDAAkD;YAClD,gDAAgD;YAChD,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QACjC,CAAC;QACD,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;QAErD,MAAM,YAAY,GAAqC;YACrD,WAAW,EAAE;gBACX,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,gDAAgD;gBAC1F,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,oEAAoE;gBAC9G,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,oDAAoD;gBAClG,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,uDAAuD;aACrG;YACD,eAAe,EAAE;gBACf,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,wDAAwD;gBAC1G,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,gFAAgF;gBAClI,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,wDAAwD;gBAC9G,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,2DAA2D;aACjH;YACD,cAAc,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC,GAAG,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC;YACxF,YAAY,EAAE,eAAe;SAC9B,CAAC;QAEF,SAAS,CAAC,YAAY,CAAC,QAAQ,CAAC;YAC9B,MAAM,EAAE,EAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAC;YACpC,OAAO,EAAE,YAAY;SACtB,CAAC,CAAC;QACH,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAC1C,CAAC;;AA/GM,0BAAS,GAAG,kBAAkB,CAAC;eAJnB,gBAAgB"}

package/dist/hexagon-layer/hexagon-layer-uniforms.d.ts

@@ -0,0 +1,19 @@
+import { Texture } from '@luma.gl/core';
+export type HexagonProps = {
+    colorDomain: [number, number, number, number];
+    colorRange: Texture;
+    elevationDomain: [number, number, number, number];
+    elevationRange: [number, number];
+    originCommon: [number, number];
+};
+export declare const hexagonUniforms: {
+    readonly name: "hexagon";
+    readonly vs: "uniform hexagonUniforms {\n  vec4 colorDomain;\n  vec4 elevationDomain;\n  vec2 elevationRange;\n  vec2 originCommon;\n} hexagon;\n";
+    readonly uniformTypes: {
+        readonly colorDomain: "vec4<f32>";
+        readonly elevationDomain: "vec4<f32>";
+        readonly elevationRange: "vec2<f32>";
+        readonly originCommon: "vec2<f32>";
+    };
+};
+//# sourceMappingURL=hexagon-layer-uniforms.d.ts.map

package/dist/hexagon-layer/hexagon-layer-uniforms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hexagon-layer-uniforms.d.ts","sourceRoot":"","sources":["../../src/hexagon-layer/hexagon-layer-uniforms.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,OAAO,EAAC,MAAM,eAAe,CAAC;AAYtC,MAAM,MAAM,YAAY,GAAG;IACzB,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9C,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAClD,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;CASmB,CAAC"}

package/dist/hexagon-layer/hexagon-layer-uniforms.js

@@ -0,0 +1,22 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+const uniformBlock = /* glsl */ `\
+uniform hexagonUniforms {
+  vec4 colorDomain;
+  vec4 elevationDomain;
+  vec2 elevationRange;
+  vec2 originCommon;
+} hexagon;
+`;
+export const hexagonUniforms = {
+    name: 'hexagon',
+    vs: uniformBlock,
+    uniformTypes: {
+        colorDomain: 'vec4<f32>',
+        elevationDomain: 'vec4<f32>',
+        elevationRange: 'vec2<f32>',
+        originCommon: 'vec2<f32>'
+    }
+};
+//# sourceMappingURL=hexagon-layer-uniforms.js.map

package/dist/hexagon-layer/hexagon-layer-uniforms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hexagon-layer-uniforms.js","sourceRoot":"","sources":["../../src/hexagon-layer/hexagon-layer-uniforms.ts"],"names":[],"mappings":"AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAKpC,MAAM,YAAY,GAAG,UAAU,CAAC;;;;;;;CAO/B,CAAC;AAUF,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,IAAI,EAAE,SAAS;IACf,EAAE,EAAE,YAAY;IAChB,YAAY,EAAE;QACZ,WAAW,EAAE,WAAW;QACxB,eAAe,EAAE,WAAW;QAC5B,cAAc,EAAE,WAAW;QAC3B,YAAY,EAAE,WAAW;KAC1B;CAC4C,CAAC"}

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

@@ -1,39 +1,40 @@
-import { Accessor, AccessorFunction, Color, Position, Material, UpdateParameters, DefaultProps } from '@deck.gl/core';
-import { ColumnLayer } from '@deck.gl/layers';
-import CPUAggregator from "../utils/cpu-aggregator.js";
-import AggregationLayer, { AggregationLayerProps } from "../aggregation-layer.js";
-import { AggregateAccessor } from "../types.js";
-/** All properties supported by by HexagonLayer. */
-export type HexagonLayerProps<DataT = unknown> = _HexagonLayerProps<DataT> & AggregationLayerProps<DataT>;
+import { Accessor, Color, GetPickingInfoParams, CompositeLayerProps, Layer, Material, LayersList, PickingInfo, Position, Viewport, UpdateParameters, DefaultProps } from '@deck.gl/core';
+import { WebGLAggregator, CPUAggregator, AggregationOperation } from "../common/aggregator/index.js";
+import AggregationLayer from "../common/aggregation-layer.js";
+import { AggregateAccessor } from "../common/types.js";
+import { AttributeWithScale } from "../common/utils/scale-utils.js";
+import { BinOptions } from "./bin-options-uniforms.js";
+/** All properties supported by HexagonLayer. */
+export type HexagonLayerProps<DataT = unknown> = _HexagonLayerProps<DataT> & CompositeLayerProps;
 /** Properties added by HexagonLayer. */
-type _HexagonLayerProps<DataT = unknown> = {
+type _HexagonLayerProps<DataT> = {
     /**
      * 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
+     * Custom accessor to retrieve a hexagonal bin index from each data object.
+     * Not supported by GPU aggregation.
+     * @default null
      */
-    hexagonAggregator?: (props: any, params: any) => any;
+    hexagonAggregator?: ((position: number[], radius: number) => [number, number]) | null;
     /**
-     * Color scale input domain.
+     * Color scale domain, default is set to the extent of aggregated weights in each cell.
      * @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)
+     * Default: [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6) `6-class YlOrRd`
      */
     colorRange?: Color[];
     /**
-     * Hexagon radius multiplier, clamped between 0 - 1.
+     * Cell size 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.
+     * 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;
@@ -43,47 +44,49 @@ type _HexagonLayerProps<DataT = unknown> = {
      */
     elevationRange?: [number, number];
     /**
-     * Hexagon elevation multiplier.
+     * Cell elevation multiplier.
      * @default 1
      */
     elevationScale?: number;
     /**
      * Whether to enable cell elevation. If set to false, all cell will be flat.
-     * @default false
+     * @default true
      */
     extruded?: boolean;
     /**
-     * Filter bins and re-calculate color by `upperPercentile`.
-     * Hexagons with color value larger than the `upperPercentile` will be hidden.
+     * Filter cells and re-calculate color by `upperPercentile`.
+     * Cells with 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.
+     * Filter cells and re-calculate color by `lowerPercentile`.
+     * Cells with 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.
+     * Filter cells and re-calculate elevation by `elevationUpperPercentile`.
+     * Cells 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.
+     * 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', 'quantile' and 'ordinal'.
+     * Supported Values are 'quantize', 'linear', 'quantile' and 'ordinal'.
      * @default 'quantize'
      */
-    colorScaleType?: 'quantize' | 'quantile' | 'ordinal';
+    colorScaleType?: 'quantize' | 'linear' | 'quantile' | 'ordinal';
     /**
      * Scaling function used to determine the elevation of the grid cell, only supports 'linear'.
+     * Supported Values are 'linear' and 'quantile'.
+     * @default 'linear'
      */
     elevationScaleType?: 'linear';
     /**
@@ -95,73 +98,100 @@ type _HexagonLayerProps<DataT = unknown> = {
     material?: Material;
     /**
      * Defines the operation used to aggregate all data object weights to calculate a cell's color value.
+     * Valid values are 'SUM', 'MEAN', 'MIN', 'MAX', 'COUNT'.
+     *
      * @default 'SUM'
      */
-    colorAggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
+    colorAggregation?: AggregationOperation;
     /**
      * Defines the operation used to aggregate all data object weights to calculate a cell's elevation value.
+     * Valid values are 'SUM', 'MEAN', 'MIN', 'MAX', 'COUNT'.
+     *
      * @default 'SUM'
      */
-    elevationAggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
+    elevationAggregation?: AggregationOperation;
     /**
      * Method called to retrieve the position of each object.
      * @default object => object.position
      */
-    getPosition?: AccessorFunction<DataT, Position>;
+    getPosition?: Accessor<DataT, Position>;
     /**
-     * The weight of a data object used to calculate the color value for a bin.
+     * 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 bins, this accessor is called on each cell to get the value that its color is based on.
+     * After data objects are aggregated into cells, this accessor is called on each cell to get the value that its color is based on.
+     * Not supported by GPU aggregation.
      * @default null
      */
     getColorValue?: AggregateAccessor<DataT> | null;
     /**
-     * The weight of a data object used to calculate the elevation value for a bin.
+     * 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 bins, this accessor is called on each cell to get the value that its elevation is based on.
+     * After data objects are aggregated into cells, this accessor is called on each cell to get the value that its elevation is based on.
+     * Not supported by GPU aggregation.
      * @default null
      */
     getElevationValue?: AggregateAccessor<DataT> | null;
     /**
-     * This callback will be called when cell color domain has been calculated.
+     * This callback will be called when bin color domain has been calculated.
      * @default () => {}
      */
     onSetColorDomain?: (minMax: [number, number]) => void;
     /**
-     * This callback will be called when cell elevation domain has been calculated.
+     * This callback will be called when bin elevation domain has been calculated.
      * @default () => {}
      */
     onSetElevationDomain?: (minMax: [number, number]) => void;
     /**
-     * (Experimental) Filter data objects
+     * When set to true, aggregation is performed on GPU, provided other conditions are met.
+     * @default true
      */
-    _filterData: null | ((d: DataT) => boolean);
+    gpuAggregation?: boolean;
 };
-/** Aggregates data into a hexagon-based heatmap. The color and height of a hexagon are determined based on the objects it contains. */
-export default class HexagonLayer<DataT, ExtraPropsT extends {} = {}> extends AggregationLayer<DataT, ExtraPropsT & Required<_HexagonLayerProps<DataT>>> {
+export type HexagonLayerPickingInfo<DataT> = PickingInfo<{
+    /** Column index of the picked cell */
+    col: number;
+    /** Row index of the picked cell */
+    row: number;
+    /** Aggregated color value, as determined by `getColorWeight` and `colorAggregation` */
+    colorValue: number;
+    /** Aggregated elevation value, as determined by `getElevationWeight` and `elevationAggregation` */
+    elevationValue: number;
+    /** Number of data points in the picked cell */
+    count: number;
+    /** Centroid of the hexagon */
+    position: [number, 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[];
+}>;
+/** Aggregate data into a grid-based heatmap. The color and height of a cell are determined based on the objects it contains. */
+export default class HexagonLayer<DataT = any, ExtraPropsT extends {} = {}> extends AggregationLayer<DataT, ExtraPropsT & Required<_HexagonLayerProps<DataT>>> {
     static layerName: string;
     static defaultProps: DefaultProps<HexagonLayerProps<unknown>>;
-    state: AggregationLayer<DataT>['state'] & {
-        cpuAggregator: CPUAggregator;
-        aggregatorState: CPUAggregator['state'];
-        vertices: number[][] | null;
+    state: AggregationLayer<DataT>['state'] & BinOptions & {
+        dataAsArray?: DataT[];
+        colors?: AttributeWithScale;
+        elevations?: AttributeWithScale;
+        binIdRange: [number, number][];
+        aggregatorViewport: Viewport;
     };
+    getAggregatorType(): string;
+    createAggregator(type: string): WebGLAggregator | CPUAggregator;
     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, {}>;
+    updateState(params: UpdateParameters<this>): boolean;
+    private _updateBinOptions;
+    draw(opts: any): void;
+    private _onAggregationUpdate;
+    onAttributeChange(id: string): void;
+    renderLayers(): LayersList | Layer | null;
+    getPickingInfo(params: GetPickingInfoParams): HexagonLayerPickingInfo<DataT>;
 }
 export {};
 //# sourceMappingURL=hexagon-layer.d.ts.map