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

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,161 @@
+import { Buffer, Texture2D } from '@luma.gl/core';
+import { Accessor, AccessorFunction, AttributeManager, ChangeFlags, Color, Layer, LayerContext, LayersList, Position, UpdateParameters } from '@deck.gl/core/typed';
+import AggregationLayer, { AggregationLayerProps } from '../aggregation-layer';
+export declare type HeatmapLayerProps<DataT> = _HeatmapLayerProps<DataT> & AggregationLayerProps<DataT>;
+declare type _HeatmapLayerProps<DataT = any> = {
+    /**
+     * 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: {
+        getPosition: {
+            type: string;
+            value: (x: any) => any;
+        };
+        getWeight: {
+            type: string;
+            value: number;
+        };
+        intensity: {
+            type: string;
+            min: number;
+            value: number;
+        };
+        radiusPixels: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        colorRange: number[][];
+        threshold: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        colorDomain: {
+            type: string;
+            value: null;
+            optional: boolean;
+        };
+        aggregation: string;
+        weightsTextureSize: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+        debounceTimeout: {
+            type: string;
+            min: number;
+            max: number;
+            value: number;
+        };
+    };
+    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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"}