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

package/typed/grid-aggregation-layer.js

@@ -0,0 +1,172 @@
+// 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 AggregationLayer from './aggregation-layer';
+import GPUGridAggregator from './utils/gpu-grid-aggregation/gpu-grid-aggregator';
+import { Buffer } from '@luma.gl/core';
+import { log } from '@deck.gl/core';
+import GL from '@luma.gl/constants';
+import BinSorter from './utils/bin-sorter';
+import { pointToDensityGridDataCPU } from './cpu-grid-layer/grid-aggregator';
+export default class GridAggregationLayer extends AggregationLayer {
+    initializeAggregationLayer({ dimensions }) {
+        const { gl } = this.context;
+        super.initializeAggregationLayer(dimensions);
+        this.setState({
+            // CPU aggregation results
+            layerData: {},
+            gpuGridAggregator: new GPUGridAggregator(gl, { id: `${this.id}-gpu-aggregator` }),
+            cpuGridAggregator: pointToDensityGridDataCPU
+        });
+    }
+    updateState(opts) {
+        // get current attributes
+        super.updateState(opts);
+        this.updateAggregationState(opts);
+        const { aggregationDataDirty, aggregationWeightsDirty, gpuAggregation } = this.state;
+        if (this.getNumInstances() <= 0) {
+            return;
+        }
+        let aggregationDirty = false;
+        // CPU aggregation is two steps
+        // 1. Create bins (based on cellSize and position) 2. Aggregate weights for each bin
+        // For GPU aggregation both above steps are combined into one step
+        // step-1
+        if (aggregationDataDirty || (gpuAggregation && aggregationWeightsDirty)) {
+            this._updateAggregation(opts);
+            aggregationDirty = true;
+        }
+        // step-2 (Applicalbe for CPU aggregation only)
+        if (!gpuAggregation && (aggregationDataDirty || aggregationWeightsDirty)) {
+            this._updateWeightBins();
+            this._uploadAggregationResults();
+            aggregationDirty = true;
+        }
+        this.setState({ aggregationDirty });
+    }
+    finalizeState(context) {
+        const { count } = this.state.weights;
+        if (count && count.aggregationBuffer) {
+            count.aggregationBuffer.delete();
+        }
+        this.state.gpuGridAggregator?.delete();
+        super.finalizeState(context);
+    }
+    updateShaders(shaders) {
+        if (this.state.gpuAggregation) {
+            this.state.gpuGridAggregator.updateShaders(shaders);
+        }
+    }
+    // Methods that can be overriden by subclasses for customizations
+    updateAggregationState(opts) {
+        // Sublayers should implement this method.
+        log.assert(false);
+    }
+    allocateResources(numRow, numCol) {
+        if (this.state.numRow !== numRow || this.state.numCol !== numCol) {
+            const dataBytes = numCol * numRow * 4 * 4;
+            const gl = this.context.gl;
+            const { weights } = this.state;
+            for (const name in weights) {
+                const weight = weights[name];
+                if (weight.aggregationBuffer) {
+                    weight.aggregationBuffer.delete();
+                }
+                weight.aggregationBuffer = new Buffer(gl, {
+                    byteLength: dataBytes,
+                    accessor: {
+                        size: 4,
+                        type: GL.FLOAT,
+                        divisor: 1
+                    }
+                });
+            }
+        }
+    }
+    updateResults({ aggregationData, maxMinData, maxData, minData }) {
+        const { count } = this.state.weights;
+        if (count) {
+            count.aggregationData = aggregationData;
+            count.maxMinData = maxMinData;
+            count.maxData = maxData;
+            count.minData = minData;
+        }
+    }
+    // Private
+    _updateAggregation(opts) {
+        const { cpuGridAggregator, gpuGridAggregator, gridOffset, posOffset, translation = [0, 0], scaling = [0, 0, 0], boundingBox, projectPoints, gpuAggregation, numCol, numRow } = this.state;
+        const { props } = opts;
+        const { viewport } = this.context;
+        const attributes = this.getAttributes();
+        const vertexCount = this.getNumInstances();
+        if (!gpuAggregation) {
+            const result = cpuGridAggregator(props, {
+                gridOffset,
+                projectPoints,
+                attributes,
+                viewport,
+                posOffset,
+                boundingBox
+            });
+            this.setState({
+                layerData: result
+            });
+        }
+        else {
+            const { weights } = this.state;
+            gpuGridAggregator.run({
+                weights,
+                cellSize: [gridOffset.xOffset, gridOffset.yOffset],
+                numCol,
+                numRow,
+                translation,
+                scaling,
+                vertexCount,
+                projectPoints,
+                attributes,
+                moduleSettings: this.getModuleSettings()
+            });
+        }
+    }
+    _updateWeightBins() {
+        const { getValue } = this.state;
+        const sortedBins = new BinSorter(this.state.layerData.data || [], { getValue });
+        this.setState({ sortedBins });
+    }
+    _uploadAggregationResults() {
+        const { numCol, numRow } = this.state;
+        const { data } = this.state.layerData;
+        const { aggregatedBins, minValue, maxValue, totalCount } = this.state.sortedBins;
+        const ELEMENTCOUNT = 4;
+        const aggregationSize = numCol * numRow * ELEMENTCOUNT;
+        const aggregationData = new Float32Array(aggregationSize).fill(0);
+        for (const bin of aggregatedBins) {
+            const { lonIdx, latIdx } = data[bin.i];
+            const { value, counts } = bin;
+            const cellIndex = (lonIdx + latIdx * numCol) * ELEMENTCOUNT;
+            aggregationData[cellIndex] = value;
+            aggregationData[cellIndex + ELEMENTCOUNT - 1] = counts;
+        }
+        const maxMinData = new Float32Array([maxValue, 0, 0, minValue]);
+        const maxData = new Float32Array([maxValue, 0, 0, totalCount]);
+        const minData = new Float32Array([minValue, 0, 0, totalCount]);
+        this.updateResults({ aggregationData, maxMinData, maxData, minData });
+    }
+}
+GridAggregationLayer.layerName = 'GridAggregationLayer';

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

@@ -0,0 +1,31 @@
+import { CompositeLayer, CompositeLayerProps, Layer, UpdateParameters, DefaultProps } from '@deck.gl/core/typed';
+import { _GPUGridLayerProps } from '../gpu-grid-layer/gpu-grid-layer';
+import { _CPUGridLayerProps } from '../cpu-grid-layer/cpu-grid-layer';
+/** All properties supported by GridLayer. */
+export declare type GridLayerProps<DataT = any> = _GridLayerProps<DataT> & CompositeLayerProps<DataT>;
+/** Properties added by GridLayer. */
+declare type _GridLayerProps<DataT> = _CPUGridLayerProps<DataT> & _GPUGridLayerProps<DataT> & {
+    /**
+     * Whether the aggregation should be performed in high-precision 64-bit mode.
+     * @default false
+     */
+    fp64?: boolean;
+    /**
+     * When set to true, aggregation is performed on GPU, provided other conditions are met.
+     * @default false
+     */
+    gpuAggregation?: boolean;
+};
+export default class GridLayer<DataT = any, ExtraPropsT = {}> extends CompositeLayer<ExtraPropsT & Required<_GridLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: DefaultProps<GridLayerProps<any>>;
+    state: CompositeLayer['state'] & {
+        useGPUAggregation: boolean;
+    };
+    initializeState(): void;
+    updateState({ props }: UpdateParameters<this>): void;
+    renderLayers(): Layer;
+    canUseGPUAggregation(props: GridLayer['props']): boolean;
+}
+export {};
+//# sourceMappingURL=grid-layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grid-layer.d.ts","sourceRoot":"","sources":["../../src/grid-layer/grid-layer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,KAAK,EACL,gBAAgB,EAChB,YAAY,EACb,MAAM,eAAe,CAAC;AAEvB,OAAqB,EAAC,kBAAkB,EAAC,MAAM,kCAAkC,CAAC;AAClF,OAAqB,EAAC,kBAAkB,EAAC,MAAM,kCAAkC,CAAC;AAQlF,6CAA6C;AAC7C,oBAAY,cAAc,CAAC,KAAK,GAAG,GAAG,IAAI,eAAe,CAAC,KAAK,CAAC,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAE9F,qCAAqC;AACrC,aAAK,eAAe,CAAC,KAAK,IAAI,kBAAkB,CAAC,KAAK,CAAC,GACrD,kBAAkB,CAAC,KAAK,CAAC,GAAG;IAC1B;;;OAGG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEJ,MAAM,CAAC,OAAO,OAAO,SAAS,CAAC,KAAK,GAAG,GAAG,EAAE,WAAW,GAAG,EAAE,CAAE,SAAQ,cAAc,CAClF,WAAW,GAAG,QAAQ,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAC/C;IACC,MAAM,CAAC,SAAS,SAAe;IAC/B,MAAM,CAAC,YAAY,oCAAgB;IAEnC,KAAK,EAAG,cAAc,CAAC,OAAO,CAAC,GAAG;QAChC,iBAAiB,EAAE,OAAO,CAAC;KAC5B,CAAC;IAEF,eAAe;IAMf,WAAW,CAAC,EAAC,KAAK,EAAC,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAM3C,YAAY,IAAI,KAAK;IAoBrB,oBAAoB,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC;CA8B/C"}

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

@@ -0,0 +1,60 @@
+import { CompositeLayer } from '@deck.gl/core';
+import GPUGridAggregator from '../utils/gpu-grid-aggregation/gpu-grid-aggregator';
+import GPUGridLayer from '../gpu-grid-layer/gpu-grid-layer';
+import CPUGridLayer from '../cpu-grid-layer/cpu-grid-layer';
+const defaultProps = {
+    ...GPUGridLayer.defaultProps,
+    ...CPUGridLayer.defaultProps,
+    gpuAggregation: false
+};
+export default class GridLayer extends CompositeLayer {
+    initializeState() {
+        this.state = {
+            useGPUAggregation: true
+        };
+    }
+    updateState({ props }) {
+        this.setState({
+            useGPUAggregation: this.canUseGPUAggregation(props)
+        });
+    }
+    renderLayers() {
+        const { data, updateTriggers } = this.props;
+        const id = this.state.useGPUAggregation ? 'GPU' : 'CPU';
+        const LayerType = this.state.useGPUAggregation
+            ? this.getSubLayerClass('GPU', GPUGridLayer)
+            : this.getSubLayerClass('CPU', CPUGridLayer);
+        return new LayerType(this.props, this.getSubLayerProps({
+            id,
+            updateTriggers
+        }), {
+            data
+        });
+    }
+    // Private methods
+    canUseGPUAggregation(props) {
+        const { gpuAggregation, lowerPercentile, upperPercentile, getColorValue, getElevationValue, colorScaleType } = props;
+        if (!gpuAggregation) {
+            // cpu aggregation is requested
+            return false;
+        }
+        if (!GPUGridAggregator.isSupported(this.context.gl)) {
+            return false;
+        }
+        if (lowerPercentile !== 0 || upperPercentile !== 100) {
+            // percentile calculations requires sorting not supported on GPU
+            return false;
+        }
+        if (getColorValue !== null || getElevationValue !== null) {
+            // accessor for custom color or elevation calculation is specified
+            return false;
+        }
+        if (colorScaleType === 'quantile' || colorScaleType === 'ordinal') {
+            // quantile and ordinal scales are not supported on GPU
+            return false;
+        }
+        return true;
+    }
+}
+GridLayer.layerName = 'GridLayer';
+GridLayer.defaultProps = defaultProps;

package/typed/heatmap-layer/heatmap-layer-utils.d.ts

@@ -0,0 +1,13 @@
+export declare function getBounds(points: number[][]): number[];
+export declare function boundsContain(currentBounds: number[], targetBounds: number[]): boolean;
+export declare function packVertices(points: number[][], dimensions?: number): Float32Array;
+export declare function scaleToAspectRatio(boundingBox: number[], width: number, height: number): number[];
+export declare function getTextureCoordinates(point: number[], bounds: number[]): number[];
+export declare function getTextureParams({ gl, floatTargetSupport }: {
+    gl: any;
+    floatTargetSupport: any;
+}): {
+    format: number;
+    type: number;
+};
+//# sourceMappingURL=heatmap-layer-utils.d.ts.map

package/typed/heatmap-layer/heatmap-layer-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heatmap-layer-utils.d.ts","sourceRoot":"","sources":["../../src/heatmap-layer/heatmap-layer-utils.ts"],"names":[],"mappings":"AAGA,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,CAWtD;AAGD,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAUtF;AAKD,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,UAAU,GAAE,MAAU,GAAG,YAAY,CAQrF;AAGD,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CA6BjG;AAGD,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,YAGtE;AAGD,wBAAgB,gBAAgB,CAAC,EAAC,EAAE,EAAE,kBAAkB,EAAC;;;CAAA;;;EAWxD"}

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

@@ -0,0 +1,78 @@
+import GL from '@luma.gl/constants';
+import { isWebGL2 } from '@luma.gl/core';
+export function getBounds(points) {
+    // Now build bounding box in world space (aligned to world coordiante system)
+    const x = points.map(p => p[0]);
+    const y = points.map(p => p[1]);
+    const xMin = Math.min.apply(null, x);
+    const xMax = Math.max.apply(null, x);
+    const yMin = Math.min.apply(null, y);
+    const yMax = Math.max.apply(null, y);
+    return [xMin, yMin, xMax, yMax];
+}
+// true if currentBounds contains targetBounds, false otherwise
+export function boundsContain(currentBounds, targetBounds) {
+    if (targetBounds[0] >= currentBounds[0] &&
+        targetBounds[2] <= currentBounds[2] &&
+        targetBounds[1] >= currentBounds[1] &&
+        targetBounds[3] <= currentBounds[3]) {
+        return true;
+    }
+    return false;
+}
+const scratchArray = new Float32Array(12);
+// For given rectangle bounds generates two triangles vertices that coverit completely
+export function packVertices(points, dimensions = 2) {
+    let index = 0;
+    for (const point of points) {
+        for (let i = 0; i < dimensions; i++) {
+            scratchArray[index++] = point[i] || 0;
+        }
+    }
+    return scratchArray;
+}
+// Expands boundingBox:[xMin, yMin, xMax, yMax] to match aspect ratio of given width and height
+export function scaleToAspectRatio(boundingBox, width, height) {
+    const [xMin, yMin, xMax, yMax] = boundingBox;
+    const currentWidth = xMax - xMin;
+    const currentHeight = yMax - yMin;
+    let newWidth = currentWidth;
+    let newHeight = currentHeight;
+    if (currentWidth / currentHeight < width / height) {
+        // expand bounding box width
+        newWidth = (width / height) * currentHeight;
+    }
+    else {
+        newHeight = (height / width) * currentWidth;
+    }
+    if (newWidth < width) {
+        newWidth = width;
+        newHeight = height;
+    }
+    const xCenter = (xMax + xMin) / 2;
+    const yCenter = (yMax + yMin) / 2;
+    return [
+        xCenter - newWidth / 2,
+        yCenter - newHeight / 2,
+        xCenter + newWidth / 2,
+        yCenter + newHeight / 2
+    ];
+}
+// Get texture coordiante of point inside a bounding box
+export function getTextureCoordinates(point, bounds) {
+    const [xMin, yMin, xMax, yMax] = bounds;
+    return [(point[0] - xMin) / (xMax - xMin), (point[1] - yMin) / (yMax - yMin)];
+}
+// Returns format and type for creating texture objects
+export function getTextureParams({ gl, floatTargetSupport }) {
+    return floatTargetSupport
+        ? {
+            // format:  should be RGBA32F on WebGL2 (float textures), RGBA in WebGL1 for float or non float textures
+            format: isWebGL2(gl) ? GL.RGBA32F : GL.RGBA,
+            type: GL.FLOAT
+        }
+        : {
+            format: GL.RGBA,
+            type: GL.UNSIGNED_BYTE
+        };
+}

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

@@ -0,0 +1,116 @@
+import { Buffer, Texture2D } from '@luma.gl/core';
+import { Accessor, AccessorFunction, AttributeManager, ChangeFlags, Color, Layer, LayerContext, LayersList, Position, UpdateParameters, DefaultProps } from '@deck.gl/core/typed';
+import AggregationLayer, { AggregationLayerProps } from '../aggregation-layer';
+export declare type HeatmapLayerProps<DataT = any> = _HeatmapLayerProps<DataT> & AggregationLayerProps<DataT>;
+declare type _HeatmapLayerProps<DataT> = {
+    /**
+     * Radius of the circle in pixels, to which the weight of an object is distributed.
+     *
+     * @default 30
+     */
+    radiusPixels?: number;
+    /**
+     * Specified as an array of colors [color1, color2, ...].
+     *
+     * @default `6-class YlOrRd` - [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6)
+     */
+    colorRange?: Color[];
+    /**
+     * Value that is multiplied with the total weight at a pixel to obtain the final weight.
+     *
+     * @default 1
+     */
+    intensity?: number;
+    /**
+     * Ratio of the fading weight to the max weight, between `0` and `1`.
+     *
+     * For example, `0.1` affects all pixels with weight under 10% of the max.
+     *
+     * Ignored when `colorDomain` is specified.
+     * @default 0.05
+     */
+    threshold?: number;
+    /**
+     * Controls how weight values are mapped to the `colorRange`, as an array of two numbers [`minValue`, `maxValue`].
+     *
+     * @default null
+     */
+    colorDomain?: [number, number] | null;
+    /**
+     * Defines the type of aggregation operation
+     *
+     * V valid values are 'SUM', 'MEAN'.
+     *
+     * @default 'SUM'
+     */
+    aggregation?: 'SUM' | 'MEAN';
+    /**
+     * Specifies the size of weight texture.
+     * @default 2048
+     */
+    weightsTextureSize?: number;
+    /**
+     * Interval in milliseconds during which changes to the viewport don't trigger aggregation.
+     *
+     * @default 500
+     */
+    debounceTimeout?: number;
+    /**
+     * Method called to retrieve the position of each object.
+     *
+     * @default d => d.position
+     */
+    getPosition?: AccessorFunction<DataT, Position>;
+    /**
+     * The weight of each object.
+     *
+     * @default 1
+     */
+    getWeight?: Accessor<DataT, number>;
+};
+export default class HeatmapLayer<DataT = any, ExtraPropsT = {}> extends AggregationLayer<ExtraPropsT & Required<_HeatmapLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: DefaultProps<HeatmapLayerProps<any>>;
+    state: AggregationLayer['state'] & {
+        supported: boolean;
+        colorDomain?: number[];
+        isWeightMapDirty?: boolean;
+        weightsTexture?: Texture2D;
+        zoom?: number;
+        worldBounds?: number[];
+        normalizedCommonBounds?: number[];
+        updateTimer?: any;
+        triPositionBuffer?: Buffer;
+        triTexCoordBuffer?: Buffer;
+    };
+    initializeState(): void;
+    shouldUpdateState({ changeFlags }: UpdateParameters<this>): boolean;
+    updateState(opts: UpdateParameters<this>): void;
+    _updateHeatmapState(opts: UpdateParameters<this>): void;
+    renderLayers(): LayersList | Layer;
+    finalizeState(context: LayerContext): void;
+    _getAttributeManager(): AttributeManager;
+    _getChangeFlags(opts: UpdateParameters<this>): Partial<ChangeFlags> & {
+        boundsChanged?: boolean | undefined;
+        viewportZoomChanged?: boolean | undefined;
+    };
+    _createTextures(): void;
+    _setupAttributes(): void;
+    _setupTextureParams(): void;
+    getShaders(type: any): any;
+    _createWeightsTransform(shaders?: {}): void;
+    _setupResources(): void;
+    updateShaders(shaderOptions: any): void;
+    _updateMaxWeightValue(): void;
+    _updateBounds(forceUpdate?: any): boolean;
+    _updateTextureRenderingBounds(): void;
+    _updateColorTexture(opts: any): void;
+    _updateWeightmap(): void;
+    _debouncedUpdateWeightmap(fromTimer?: boolean): void;
+    _worldToCommonBounds(worldBounds: any, opts?: {
+        useLayerCoordinateSystem?: boolean;
+    }): number[];
+    _commonToWorldBounds(commonBounds: any): number[];
+}
+export {};
+//# sourceMappingURL=heatmap-layer.d.ts.map

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

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