@deck.gl/aggregation-layers 9.0.34 → 9.1.0-beta.1

package/dist/common/aggregator/gpu-aggregator/webgl-bin-sorter.d.ts

@@ -0,0 +1,38 @@
+import { Model, ModelProps } from '@luma.gl/engine';
+import type { Device, Texture } from '@luma.gl/core';
+import type { WebGLAggregatorProps } from "./webgl-aggregator.js";
+import type { AggregationOperation } from "../aggregator.js";
+export declare const TEXTURE_WIDTH = 1024;
+/**
+ * This class manages the resources for performing the first step of aggregation
+ * Sort a list of data points into a number of bins
+ */
+export declare class WebGLBinSorter {
+    device: Device;
+    model: Model;
+    /**
+     * A packed texture in which each pixel represents a bin.
+     * The index of the pixel in the memory layout is the bin index.
+     * Alpha value is the count of data points that fall into this bin
+     * R,G,B values are the aggregated values of each channel:
+     *   - Sum of all data points if operation is 'SUM', or 'MEAN'
+     *   - Min of all data points if operation is 'MIN'
+     *   - Max of all data points if operation is 'MAX'
+     */
+    private binsFBO;
+    constructor(device: Device, props: WebGLAggregatorProps);
+    get texture(): Texture | null;
+    destroy(): void;
+    getBinValues(index: number): Float32Array | null;
+    setDimensions(binCount: number, binIdRange: [number, number][]): void;
+    setModelProps(props: Pick<ModelProps, 'vertexCount' | 'uniforms' | 'attributes' | 'constantAttributes'> & {
+        shaderModuleProps?: Record<string, any>;
+    }): void;
+    /** Update aggregation */
+    update(
+    /** The aggregation operation for each channel. Use null to skip update. */
+    operations: (AggregationOperation | null)[]): void;
+    /** Recalculate aggregation on the given channels using the given operation */
+    private _updateBins;
+}
+//# sourceMappingURL=webgl-bin-sorter.d.ts.map

package/dist/common/aggregator/gpu-aggregator/webgl-bin-sorter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgl-bin-sorter.d.ts","sourceRoot":"","sources":["../../../../src/common/aggregator/gpu-aggregator/webgl-bin-sorter.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,KAAK,EAAE,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAGlD,OAAO,KAAK,EAAC,MAAM,EAAe,OAAO,EAAC,MAAM,eAAe,CAAC;AAChE,OAAO,KAAK,EAAC,oBAAoB,EAAC,8BAA2B;AAC7D,OAAO,KAAK,EAAC,oBAAoB,EAAC,yBAAsB;AAOxD,eAAO,MAAM,aAAa,OAAO,CAAC;AAElC;;;GAGG;AACH,qBAAa,cAAc;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;IAEb;;;;;;;;OAQG;IACH,OAAO,CAAC,OAAO,CAA4B;gBAE/B,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,oBAAoB;IAKvD,IAAI,OAAO,IAAI,OAAO,GAAG,IAAI,CAE5B;IAED,OAAO;IAMP,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IAehD,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE;IAuB9D,aAAa,CACX,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,aAAa,GAAG,UAAU,GAAG,YAAY,GAAG,oBAAoB,CAAC,GAAG;QAC1F,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;KACzC;IAiBH,yBAAyB;IACzB,MAAM;IACJ,2EAA2E;IAC3E,UAAU,EAAE,CAAC,oBAAoB,GAAG,IAAI,CAAC,EAAE;IAW7C,8EAA8E;IAC9E,OAAO,CAAC,WAAW;CAqCpB"}

package/dist/common/aggregator/gpu-aggregator/webgl-bin-sorter.js

@@ -0,0 +1,223 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { Model } from '@luma.gl/engine';
+import { createRenderTarget } from "./utils.js";
+import { binSorterUniforms } from "./bin-sorter-uniforms.js";
+const COLOR_CHANNELS = [0x1, 0x2, 0x4, 0x8]; // GPU color mask RED, GREEN, BLUE, ALPHA
+const MAX_FLOAT32 = 3e38;
+const EMPTY_MASKS = { SUM: 0, MEAN: 0, MIN: 0, MAX: 0, COUNT: 0 };
+export const TEXTURE_WIDTH = 1024;
+/**
+ * This class manages the resources for performing the first step of aggregation
+ * Sort a list of data points into a number of bins
+ */
+export class WebGLBinSorter {
+    constructor(device, props) {
+        /**
+         * A packed texture in which each pixel represents a bin.
+         * The index of the pixel in the memory layout is the bin index.
+         * Alpha value is the count of data points that fall into this bin
+         * R,G,B values are the aggregated values of each channel:
+         *   - Sum of all data points if operation is 'SUM', or 'MEAN'
+         *   - Min of all data points if operation is 'MIN'
+         *   - Max of all data points if operation is 'MAX'
+         */
+        this.binsFBO = null;
+        this.device = device;
+        this.model = createModel(device, props);
+    }
+    get texture() {
+        return this.binsFBO ? this.binsFBO.colorAttachments[0].texture : null;
+    }
+    destroy() {
+        this.model.destroy();
+        this.binsFBO?.colorAttachments[0].texture.destroy();
+        this.binsFBO?.destroy();
+    }
+    getBinValues(index) {
+        if (!this.binsFBO) {
+            return null;
+        }
+        const x = index % TEXTURE_WIDTH;
+        const y = Math.floor(index / TEXTURE_WIDTH);
+        const buffer = this.device.readPixelsToArrayWebGL(this.binsFBO, {
+            sourceX: x,
+            sourceY: y,
+            sourceWidth: 1,
+            sourceHeight: 1
+        }).buffer;
+        return new Float32Array(buffer);
+    }
+    setDimensions(binCount, binIdRange) {
+        const width = TEXTURE_WIDTH;
+        const height = Math.ceil(binCount / width);
+        // Only destroy existing texture if it is not large enough
+        if (!this.binsFBO) {
+            this.binsFBO = createRenderTarget(this.device, width, height);
+        }
+        else if (this.binsFBO.height < height) {
+            this.binsFBO.resize({ width, height });
+        }
+        const binSorterProps = {
+            binIdRange: [
+                binIdRange[0][0],
+                binIdRange[0][1],
+                binIdRange[1]?.[0] || 0,
+                binIdRange[1]?.[1] || 0
+            ],
+            targetSize: [this.binsFBO.width, this.binsFBO.height]
+        };
+        this.model.shaderInputs.setProps({ binSorter: binSorterProps });
+    }
+    setModelProps(props) {
+        const model = this.model;
+        if (props.attributes) {
+            model.setAttributes(props.attributes);
+        }
+        if (props.constantAttributes) {
+            model.setConstantAttributes(props.constantAttributes);
+        }
+        if (props.vertexCount !== undefined) {
+            model.setVertexCount(props.vertexCount);
+        }
+        if (props.shaderModuleProps) {
+            model.shaderInputs.setProps(props.shaderModuleProps);
+        }
+    }
+    /** Update aggregation */
+    update(
+    /** The aggregation operation for each channel. Use null to skip update. */
+    operations) {
+        if (!this.binsFBO) {
+            return;
+        }
+        const masks = getMaskByOperation(operations);
+        this._updateBins('SUM', masks.SUM + masks.MEAN);
+        this._updateBins('MIN', masks.MIN);
+        this._updateBins('MAX', masks.MAX);
+    }
+    /** Recalculate aggregation on the given channels using the given operation */
+    _updateBins(operation, 
+    /** GPU bit mask of one or more channels that should be updated */
+    colorMask) {
+        if (colorMask === 0) {
+            return;
+        }
+        colorMask |= COLOR_CHANNELS[3]; // Also renders to the alpha channel (point count)
+        const model = this.model;
+        const target = this.binsFBO;
+        const initialValue = operation === 'MAX' ? -MAX_FLOAT32 : operation === 'MIN' ? MAX_FLOAT32 : 0;
+        const renderPass = this.device.beginRenderPass({
+            id: `gpu-aggregation-${operation}`,
+            framebuffer: target,
+            parameters: {
+                viewport: [0, 0, target.width, target.height],
+                colorMask
+            },
+            clearColor: [initialValue, initialValue, initialValue, 0],
+            clearDepth: false,
+            clearStencil: false
+        });
+        model.setParameters({
+            blend: true,
+            blendColorSrcFactor: 'one',
+            blendColorDstFactor: 'one',
+            blendAlphaSrcFactor: 'one',
+            blendAlphaDstFactor: 'one',
+            blendColorOperation: operation === 'MAX' ? 'max' : operation === 'MIN' ? 'min' : 'add',
+            blendAlphaOperation: 'add'
+        });
+        model.draw(renderPass);
+        renderPass.end();
+    }
+}
+/** Convert a [channel -> operation] map to a [operation -> GPU color mask] map */
+function getMaskByOperation(operations) {
+    const result = { ...EMPTY_MASKS };
+    for (let channel = 0; channel < operations.length; channel++) {
+        const op = operations[channel];
+        if (op) {
+            result[op] += COLOR_CHANNELS[channel];
+        }
+    }
+    return result;
+}
+function createModel(device, props) {
+    let userVs = props.vs;
+    if (props.dimensions === 2) {
+        // If user provides 2d bin IDs, convert them to 1d indices for data packing
+        userVs += /* glsl */ `
+void getBin(out int binId) {
+  ivec2 binId2;
+  getBin(binId2);
+  if (binId2.x < binSorter.binIdRange.x || binId2.x >= binSorter.binIdRange.y) {
+    binId = -1;
+  } else {
+    binId = (binId2.y - binSorter.binIdRange.z) * (binSorter.binIdRange.y - binSorter.binIdRange.x) + binId2.x;
+  }
+}
+`;
+    }
+    const vs = `\
+#version 300 es
+#define SHADER_NAME gpu-aggregation-sort-bins-vertex
+
+${userVs}
+
+out vec3 v_Value;
+
+void main() {
+  int binIndex;
+  getBin(binIndex);
+  binIndex = binIndex - binSorter.binIdRange.x;
+  if (binIndex < 0) {
+    gl_Position = vec4(0.);
+    return;
+  }
+  int row = binIndex / binSorter.targetSize.x;
+  int col = binIndex - row * binSorter.targetSize.x;
+  vec2 position = (vec2(col, row) + 0.5) / vec2(binSorter.targetSize) * 2.0 - 1.0;
+  gl_Position = vec4(position, 0.0, 1.0);
+  gl_PointSize = 1.0;
+
+#if NUM_CHANNELS == 3
+  getValue(v_Value);
+#elif NUM_CHANNELS == 2
+  getValue(v_Value.xy);
+#else
+  getValue(v_Value.x);
+#endif
+}
+`;
+    const fs = /* glsl */ `\
+#version 300 es
+#define SHADER_NAME gpu-aggregation-sort-bins-fragment
+
+precision highp float;
+
+in vec3 v_Value;
+out vec4 fragColor;
+
+void main() {
+  fragColor.xyz = v_Value;
+
+  #ifdef MODULE_GEOMETRY
+  geometry.uv = vec2(0.);
+  DECKGL_FILTER_COLOR(fragColor, geometry);
+  #endif
+
+  fragColor.w = 1.0;
+}
+`;
+    const model = new Model(device, {
+        bufferLayout: props.bufferLayout,
+        modules: [...(props.modules || []), binSorterUniforms],
+        defines: { ...props.defines, NON_INSTANCED_MODEL: 1, NUM_CHANNELS: props.channelCount },
+        isInstanced: false,
+        vs,
+        fs,
+        topology: 'point-list'
+    });
+    return model;
+}

package/dist/common/aggregator/index.d.ts

@@ -0,0 +1,6 @@
+export { CPUAggregator } from "./cpu-aggregator/cpu-aggregator.js";
+export { WebGLAggregator } from "./gpu-aggregator/webgl-aggregator.js";
+export type { Aggregator, AggregatedBin, AggregationOperation, AggregationProps } from "./aggregator.js";
+export type { CPUAggregatorProps } from "./cpu-aggregator/cpu-aggregator.js";
+export type { WebGLAggregatorProps } from "./gpu-aggregator/webgl-aggregator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/common/aggregator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/common/aggregator/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,aAAa,EAAC,2CAAwC;AAC9D,OAAO,EAAC,eAAe,EAAC,6CAA0C;AAElE,YAAY,EAAC,UAAU,EAAE,aAAa,EAAE,oBAAoB,EAAE,gBAAgB,EAAC,wBAAqB;AACpG,YAAY,EAAC,kBAAkB,EAAC,2CAAwC;AACxE,YAAY,EAAC,oBAAoB,EAAC,6CAA0C"}

package/dist/common/aggregator/index.js

@@ -0,0 +1,5 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export { CPUAggregator } from "./cpu-aggregator/cpu-aggregator.js";
+export { WebGLAggregator } from "./gpu-aggregator/webgl-aggregator.js";

package/dist/common/types.d.ts

@@ -0,0 +1,11 @@
+/** Type assigned to e.g. getColorValue/getElevationValue props in aggregation layers (e.g. CPUGridLayer, HexagonLayer)*/
+export type AggregateAccessor<DataT = any> = (
+/** a list of objects whose positions fall inside this cell. */
+objects: DataT[], objectInfo: {
+    /** the indices of `objects` in the original data. */
+    indices: number[];
+    /** the value of the `data` prop */
+    data: any;
+}) => number;
+export type ScaleType = 'linear' | 'quantize' | 'quantile' | 'ordinal';
+//# sourceMappingURL=types.d.ts.map

package/dist/common/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/common/types.ts"],"names":[],"mappings":"AAIA,yHAAyH;AACzH,MAAM,MAAM,iBAAiB,CAAC,KAAK,GAAG,GAAG,IAAI;AAC3C,+DAA+D;AAC/D,OAAO,EAAE,KAAK,EAAE,EAChB,UAAU,EAAE;IACV,qDAAqD;IACrD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,mCAAmC;IACnC,IAAI,EAAE,GAAG,CAAC;CACX,KACE,MAAM,CAAC;AAEZ,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,CAAC"}

package/dist/common/types.js

@@ -0,0 +1,4 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export {};

package/dist/common/utils/bounds-utils.d.ts

@@ -0,0 +1,10 @@
+/** Utility to estimate binIdRange as expected by AggregatorProps */
+export declare function getBinIdRange({ dataBounds, getBinId, padding }: {
+    /** Bounds of the input data */
+    dataBounds: [min: number[], max: number[]];
+    /** Given a data point, returns the bin id that it belongs to */
+    getBinId: (p: number[]) => number[];
+    /** Add a border around the result to avoid clipping */
+    padding?: number;
+}): [number, number][];
+//# sourceMappingURL=bounds-utils.d.ts.map

package/dist/common/utils/bounds-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounds-utils.d.ts","sourceRoot":"","sources":["../../../src/common/utils/bounds-utils.ts"],"names":[],"mappings":"AAIA,oEAAoE;AACpE,wBAAgB,aAAa,CAAC,EAC5B,UAAU,EACV,QAAQ,EACR,OAAW,EACZ,EAAE;IACD,+BAA+B;IAC/B,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;IAC3C,gEAAgE;IAChE,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;IACpC,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAiBrB"}

package/dist/common/utils/bounds-utils.js

@@ -0,0 +1,20 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** Utility to estimate binIdRange as expected by AggregatorProps */
+export function getBinIdRange({ dataBounds, getBinId, padding = 0 }) {
+    const corners = [
+        dataBounds[0],
+        dataBounds[1],
+        [dataBounds[0][0], dataBounds[1][1]],
+        [dataBounds[1][0], dataBounds[0][1]]
+    ].map(p => getBinId(p));
+    const minX = Math.min(...corners.map(p => p[0])) - padding;
+    const minY = Math.min(...corners.map(p => p[1])) - padding;
+    const maxX = Math.max(...corners.map(p => p[0])) + padding + 1;
+    const maxY = Math.max(...corners.map(p => p[1])) + padding + 1;
+    return [
+        [minX, maxX],
+        [minY, maxY]
+    ];
+}

package/dist/common/utils/color-utils.d.ts

@@ -0,0 +1,10 @@
+import type { Color } from '@deck.gl/core';
+import type { Device, Texture } from '@luma.gl/core';
+import type { NumericArray, TypedArray, TypedArrayConstructor } from '@math.gl/types';
+import type { ScaleType } from "../types.js";
+export declare const defaultColorRange: Color[];
+export declare function colorRangeToFlatArray(colorRange: Color[] | NumericArray, normalize?: boolean, ArrayType?: TypedArrayConstructor): TypedArray;
+export declare const COLOR_RANGE_FILTER: Record<ScaleType, 'linear' | 'nearest'>;
+export declare function updateColorRangeTexture(texture: Texture, type: ScaleType): void;
+export declare function createColorRangeTexture(device: Device, colorRange: Color[] | NumericArray, type?: ScaleType): Texture;
+//# sourceMappingURL=color-utils.d.ts.map

package/dist/common/utils/color-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color-utils.d.ts","sourceRoot":"","sources":["../../../src/common/utils/color-utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAC,MAAM,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAC,YAAY,EAAE,UAAU,EAAE,qBAAqB,EAAC,MAAM,gBAAgB,CAAC;AACpF,OAAO,KAAK,EAAC,SAAS,EAAC,oBAAiB;AAExC,eAAO,MAAM,iBAAiB,EAAE,KAAK,EAOpC,CAAC;AAGF,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,KAAK,EAAE,GAAG,YAAY,EAClC,SAAS,UAAQ,EACjB,SAAS,GAAE,qBAAoC,GAC9C,UAAU,CA0BZ;AAED,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,SAAS,EAAE,QAAQ,GAAG,SAAS,CAK7D,CAAC;AAEX,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,QAKxE;AAED,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,KAAK,EAAE,GAAG,YAAY,EAClC,IAAI,GAAE,SAAoB,GACzB,OAAO,CAgBT"}

package/dist/common/utils/color-utils.js

@@ -0,0 +1,65 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export const defaultColorRange = [
+    [255, 255, 178],
+    [254, 217, 118],
+    [254, 178, 76],
+    [253, 141, 60],
+    [240, 59, 32],
+    [189, 0, 38]
+];
+// Converts a colorRange array to a flat array with 4 components per color
+export function colorRangeToFlatArray(colorRange, normalize = false, ArrayType = Float32Array) {
+    let flatArray;
+    if (Number.isFinite(colorRange[0])) {
+        // its already a flat array.
+        flatArray = new ArrayType(colorRange);
+    }
+    else {
+        // flatten it
+        flatArray = new ArrayType(colorRange.length * 4);
+        let index = 0;
+        for (let i = 0; i < colorRange.length; i++) {
+            const color = colorRange[i];
+            flatArray[index++] = color[0];
+            flatArray[index++] = color[1];
+            flatArray[index++] = color[2];
+            flatArray[index++] = Number.isFinite(color[3]) ? color[3] : 255;
+        }
+    }
+    if (normalize) {
+        for (let i = 0; i < flatArray.length; i++) {
+            flatArray[i] /= 255;
+        }
+    }
+    return flatArray;
+}
+export const COLOR_RANGE_FILTER = {
+    linear: 'linear',
+    quantile: 'nearest',
+    quantize: 'nearest',
+    ordinal: 'nearest'
+};
+export function updateColorRangeTexture(texture, type) {
+    texture.setSampler({
+        minFilter: COLOR_RANGE_FILTER[type],
+        magFilter: COLOR_RANGE_FILTER[type]
+    });
+}
+export function createColorRangeTexture(device, colorRange, type = 'linear') {
+    const colors = colorRangeToFlatArray(colorRange, false, Uint8Array);
+    return device.createTexture({
+        format: 'rgba8unorm',
+        mipmaps: false,
+        sampler: {
+            minFilter: COLOR_RANGE_FILTER[type],
+            magFilter: COLOR_RANGE_FILTER[type],
+            addressModeU: 'clamp-to-edge',
+            addressModeV: 'clamp-to-edge'
+        },
+        data: colors,
+        width: colors.length / 4,
+        height: 1
+    });
+}

package/dist/common/utils/prop-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-utils.d.ts","sourceRoot":"","sources":["../../../src/common/utils/prop-utils.ts"],"names":[],"mappings":"AAIA,wBAAgB,WAAW,CAAC,KAAK,KAAA,EAAE,UAAU,KAAA,MAQ5C"}

package/dist/common/utils/prop-utils.js

@@ -0,0 +1,12 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+export function filterProps(props, filterKeys) {
+    const filteredProps = {};
+    for (const key in props) {
+        if (!filterKeys.includes(key)) {
+            filteredProps[key] = props[key];
+        }
+    }
+    return filteredProps;
+}

package/dist/common/utils/scale-utils.d.ts

@@ -0,0 +1,46 @@
+import type { BinaryAttribute } from '@deck.gl/core';
+import type { ScaleType } from "../types.js";
+type ScaleProps = {
+    scaleType: ScaleType;
+    /** Trim the lower end of the domain by this percentile. Set to `0` to disable. */
+    lowerPercentile: number;
+    /** Trim the upper end of the domain by this percentile. Set to `100` to disable. */
+    upperPercentile: number;
+};
+/** Applies a scale to BinaryAttribute */
+export declare class AttributeWithScale {
+    /** Input values accessor. Has either a `value` (CPU aggregation) or a `buffer` (GPU aggregation) */
+    private readonly input;
+    private readonly inputLength;
+    private props;
+    private _percentile?;
+    private _ordinal?;
+    /** Output values accessor */
+    attribute: BinaryAttribute;
+    /** [min, max] of attribute values, or null if unknown */
+    domain: [number, number] | null;
+    /** Valid domain if lower/upper percentile are defined */
+    cutoff: [number, number] | null;
+    constructor(input: BinaryAttribute, inputLength: number);
+    private getScalePercentile;
+    private getScaleOrdinal;
+    /** Returns the [lowerCutoff, upperCutoff] of scaled values, or null if not applicable */
+    private getCutoff;
+    update(props: ScaleProps): this;
+}
+/**
+ * Transform an array of values to ordinal indices
+ */
+export declare function applyScaleOrdinal(values: Float32Array): {
+    attribute: BinaryAttribute;
+    domain: number[];
+};
+/**
+ * Transform an array of values to percentiles
+ */
+export declare function applyScaleQuantile(values: Float32Array, rangeLength?: number): {
+    attribute: BinaryAttribute;
+    domain: number[];
+};
+export {};
+//# sourceMappingURL=scale-utils.d.ts.map

package/dist/common/utils/scale-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scale-utils.d.ts","sourceRoot":"","sources":["../../../src/common/utils/scale-utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAC,SAAS,EAAC,oBAAiB;AAExC,KAAK,UAAU,GAAG;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,kFAAkF;IAClF,eAAe,EAAE,MAAM,CAAC;IACxB,oFAAoF;IACpF,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,yCAAyC;AACzC,qBAAa,kBAAkB;IAC7B,oGAAoG;IACpG,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAkB;IACxC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IAErC,OAAO,CAAC,KAAK,CAIX;IAGF,OAAO,CAAC,WAAW,CAAC,CAAiD;IACrE,OAAO,CAAC,QAAQ,CAAC,CAAiD;IAElE,6BAA6B;IAC7B,SAAS,EAAE,eAAe,CAAC;IAC3B,yDAAyD;IACzD,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAQ;IACvC,yDAAyD;IACzD,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAQ;gBAE3B,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM;IAOvD,OAAO,CAAC,kBAAkB;IAQ1B,OAAO,CAAC,eAAe;IAQvB,yFAAyF;IACzF,OAAO,CAAC,SAAS;IA4BjB,MAAM,CAAC,KAAK,EAAE,UAAU;CAiCzB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,YAAY,GAAG;IACvD,SAAS,EAAE,eAAe,CAAC;IAC3B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAqBA;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EACpB,WAAW,SAAM,GAChB;IACD,SAAS,EAAE,eAAe,CAAC;IAC3B,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAgBA"}

package/dist/common/utils/scale-utils.js

@@ -0,0 +1,180 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** Applies a scale to BinaryAttribute */
+export class AttributeWithScale {
+    constructor(input, inputLength) {
+        this.props = {
+            scaleType: 'linear',
+            lowerPercentile: 0,
+            upperPercentile: 100
+        };
+        /** [min, max] of attribute values, or null if unknown */
+        this.domain = null;
+        /** Valid domain if lower/upper percentile are defined */
+        this.cutoff = null;
+        this.input = input;
+        this.inputLength = inputLength;
+        // No processing is needed with the default scale
+        this.attribute = input;
+    }
+    getScalePercentile() {
+        if (!this._percentile) {
+            const value = getAttributeValue(this.input, this.inputLength);
+            this._percentile = applyScaleQuantile(value);
+        }
+        return this._percentile;
+    }
+    getScaleOrdinal() {
+        if (!this._ordinal) {
+            const value = getAttributeValue(this.input, this.inputLength);
+            this._ordinal = applyScaleOrdinal(value);
+        }
+        return this._ordinal;
+    }
+    /** Returns the [lowerCutoff, upperCutoff] of scaled values, or null if not applicable */
+    getCutoff({ scaleType, lowerPercentile, upperPercentile }) {
+        if (scaleType === 'quantile') {
+            return [lowerPercentile, upperPercentile - 1];
+        }
+        if (lowerPercentile > 0 || upperPercentile < 100) {
+            const { domain: thresholds } = this.getScalePercentile();
+            let lowValue = thresholds[Math.floor(lowerPercentile) - 1] ?? -Infinity;
+            let highValue = thresholds[Math.floor(upperPercentile) - 1] ?? Infinity;
+            if (scaleType === 'ordinal') {
+                const { domain: sortedUniqueValues } = this.getScaleOrdinal();
+                lowValue = sortedUniqueValues.findIndex(x => x >= lowValue);
+                highValue = sortedUniqueValues.findIndex(x => x > highValue) - 1;
+                if (highValue === -2) {
+                    highValue = sortedUniqueValues.length - 1;
+                }
+            }
+            return [lowValue, highValue];
+        }
+        return null;
+    }
+    update(props) {
+        const oldProps = this.props;
+        if (props.scaleType !== oldProps.scaleType) {
+            switch (props.scaleType) {
+                case 'quantile': {
+                    const { attribute } = this.getScalePercentile();
+                    this.attribute = attribute;
+                    this.domain = [0, 99];
+                    break;
+                }
+                case 'ordinal': {
+                    const { attribute, domain } = this.getScaleOrdinal();
+                    this.attribute = attribute;
+                    this.domain = [0, domain.length - 1];
+                    break;
+                }
+                default:
+                    this.attribute = this.input;
+                    this.domain = null;
+            }
+        }
+        if (props.scaleType !== oldProps.scaleType ||
+            props.lowerPercentile !== oldProps.lowerPercentile ||
+            props.upperPercentile !== oldProps.upperPercentile) {
+            this.cutoff = this.getCutoff(props);
+        }
+        this.props = props;
+        return this;
+    }
+}
+/**
+ * Transform an array of values to ordinal indices
+ */
+export function applyScaleOrdinal(values) {
+    const uniqueValues = new Set();
+    for (const x of values) {
+        if (Number.isFinite(x)) {
+            uniqueValues.add(x);
+        }
+    }
+    const sortedUniqueValues = Array.from(uniqueValues).sort();
+    const domainMap = new Map();
+    for (let i = 0; i < sortedUniqueValues.length; i++) {
+        domainMap.set(sortedUniqueValues[i], i);
+    }
+    return {
+        attribute: {
+            value: values.map(x => (Number.isFinite(x) ? domainMap.get(x) : NaN)),
+            type: 'float32',
+            size: 1
+        },
+        domain: sortedUniqueValues
+    };
+}
+/**
+ * Transform an array of values to percentiles
+ */
+export function applyScaleQuantile(values, rangeLength = 100) {
+    const sortedValues = Array.from(values).filter(Number.isFinite).sort(ascending);
+    let i = 0;
+    const n = Math.max(1, rangeLength);
+    const thresholds = new Array(n - 1);
+    while (++i < n) {
+        thresholds[i - 1] = threshold(sortedValues, i / n);
+    }
+    return {
+        attribute: {
+            value: values.map(x => (Number.isFinite(x) ? bisectRight(thresholds, x) : NaN)),
+            type: 'float32',
+            size: 1
+        },
+        domain: thresholds
+    };
+}
+function getAttributeValue(attribute, length) {
+    const elementStride = (attribute.stride ?? 4) / 4;
+    const elementOffset = (attribute.offset ?? 0) / 4;
+    let value = attribute.value;
+    if (!value) {
+        const bytes = attribute.buffer?.readSyncWebGL(0, elementStride * 4 * length);
+        if (bytes) {
+            value = new Float32Array(bytes.buffer);
+            attribute.value = value;
+        }
+    }
+    if (elementStride === 1) {
+        return value.subarray(0, length);
+    }
+    const result = new Float32Array(length);
+    for (let i = 0; i < length; i++) {
+        result[i] = value[i * elementStride + elementOffset];
+    }
+    return result;
+}
+function ascending(a, b) {
+    return a - b;
+}
+function threshold(domain, fraction) {
+    const domainLength = domain.length;
+    if (fraction <= 0 || domainLength < 2) {
+        return domain[0];
+    }
+    if (fraction >= 1) {
+        return domain[domainLength - 1];
+    }
+    const domainFraction = (domainLength - 1) * fraction;
+    const lowIndex = Math.floor(domainFraction);
+    const low = domain[lowIndex];
+    const high = domain[lowIndex + 1];
+    return low + (high - low) * (domainFraction - lowIndex);
+}
+function bisectRight(a, x) {
+    let lo = 0;
+    let hi = a.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        if (a[mid] > x) {
+            hi = mid;
+        }
+        else {
+            lo = mid + 1;
+        }
+    }
+    return lo;
+}