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

package/dist/contour-layer/contour-utils.d.ts

@@ -1,18 +1,39 @@
-export declare function generateContours({ thresholdData, cellWeights, gridSize, gridOrigin, cellSize }: {
-    thresholdData: any;
-    cellWeights: Float32Array;
-    gridSize: number[];
-    gridOrigin: number[];
-    cellSize: number[];
+import type { Color } from '@deck.gl/core';
+export type Contour = {
+    /**
+     * Isolines: `threshold` value must be a single `Number`, Isolines are generated based on this threshold value.
+     *
+     * Isobands: `threshold` value must be an Array of two `Number`s. Isobands are generated using `[threshold[0], threshold[1])` as threshold range, i.e area that has values `>= threshold[0]` and `< threshold[1]` are rendered with corresponding color. NOTE: `threshold[0]` is inclusive and `threshold[1]` is not inclusive.
+     */
+    threshold: number | number[];
+    /**
+     * RGBA color array to be used to render the contour.
+     * @default [255, 255, 255, 255]
+     */
+    color?: Color;
+    /**
+     * Applicable for `Isoline`s only, width of the Isoline in pixels.
+     * @default 1
+     */
+    strokeWidth?: number;
+    /** Defines z order of the contour. */
+    zIndex?: number;
+};
+export type ContourLine = {
+    vertices: number[][];
+    contour: Contour;
+};
+export type ContourPolygon = {
+    vertices: number[][];
+    contour: Contour;
+};
+export declare function generateContours({ contours, getValue, xRange, yRange }: {
+    contours: Contour[];
+    getValue: (x: number, y: number) => number;
+    xRange: [number, number];
+    yRange: [number, number];
 }): {
-    contourSegments: {
-        start: number[];
-        end: number[];
-        contour: any;
-    }[];
-    contourPolygons: {
-        vertices: number[][];
-        contour: any;
-    }[];
+    lines: ContourLine[];
+    polygons: ContourPolygon[];
 };
 //# sourceMappingURL=contour-utils.d.ts.map

package/dist/contour-layer/contour-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contour-utils.d.ts","sourceRoot":"","sources":["../../src/contour-layer/contour-utils.ts"],"names":[],"mappings":"AAIA,wBAAgB,gBAAgB,CAAC,EAC/B,aAAa,EACb,WAAW,EACX,QAAQ,EACR,UAAU,EACV,QAAQ,EACT,EAAE;IACD,aAAa,EAAE,GAAG,CAAC;IACnB,WAAW,EAAE,YAAY,CAAC;IAC1B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;;eACgC,MAAM,EAAE;aAAO,MAAM,EAAE;iBAAW,GAAG;;;kBAClC,MAAM,EAAE,EAAE;iBAAW,GAAG;;EAyD3D"}
+{"version":3,"file":"contour-utils.d.ts","sourceRoot":"","sources":["../../src/contour-layer/contour-utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,eAAe,CAAC;AAGzC,MAAM,MAAM,OAAO,GAAG;IACpB;;;;OAIG;IACH,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE7B;;;OAGG;IACH,KAAK,CAAC,EAAE,KAAK,CAAC;IAEd;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,sCAAsC;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAIF,wBAAgB,gBAAgB,CAAC,EAC/B,QAAQ,EACR,QAAQ,EACR,MAAM,EACN,MAAM,EACP,EAAE;IACD,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3C,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1B;;;EAmDA"}

package/dist/contour-layer/contour-utils.js

@@ -1,42 +1,39 @@
-import { getCode, getVertices, CONTOUR_TYPE } from "./marching-squares.js";
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { getCode, getLines, getPolygons } from "./marching-squares.js";
 // Given all the cell weights, generates contours for each threshold.
 /* eslint-disable max-depth */
-export function generateContours({ thresholdData, cellWeights, gridSize, gridOrigin, cellSize }) {
-    const contourSegments = [];
+export function generateContours({ contours, getValue, xRange, yRange }) {
+    const contourLines = [];
     const contourPolygons = [];
-    const width = gridSize[0];
-    const height = gridSize[1];
     let segmentIndex = 0;
     let polygonIndex = 0;
-    for (const data of thresholdData) {
-        const { contour } = data;
+    for (let i = 0; i < contours.length; i++) {
+        const contour = contours[i];
+        const z = contour.zIndex ?? i;
         const { threshold } = contour;
-        for (let x = -1; x < width; x++) {
-            for (let y = -1; y < height; y++) {
+        for (let x = xRange[0] - 1; x < xRange[1]; x++) {
+            for (let y = yRange[0] - 1; y < yRange[1]; y++) {
                 // Get the MarchingSquares code based on neighbor cell weights.
                 const { code, meanCode } = getCode({
-                    cellWeights,
+                    getValue,
                     threshold,
                     x,
                     y,
-                    width,
-                    height
+                    xRange,
+                    yRange
                 });
                 const opts = {
-                    type: CONTOUR_TYPE.ISO_BANDS,
-                    gridOrigin,
-                    cellSize,
                     x,
                     y,
-                    width,
-                    height,
+                    z,
                     code,
-                    meanCode,
-                    thresholdData: data
+                    meanCode
                 };
                 if (Array.isArray(threshold)) {
-                    opts.type = CONTOUR_TYPE.ISO_BANDS;
-                    const polygons = getVertices(opts);
+                    // ISO bands
+                    const polygons = getPolygons(opts);
                     for (const polygon of polygons) {
                         contourPolygons[polygonIndex++] = {
                             vertices: polygon,
@@ -45,13 +42,11 @@ export function generateContours({ thresholdData, cellWeights, gridSize, gridOri
                     }
                 }
                 else {
-                    // Get the intersection vertices based on MarchingSquares code.
-                    opts.type = CONTOUR_TYPE.ISO_LINES;
-                    const vertices = getVertices(opts);
-                    for (let i = 0; i < vertices.length; i += 2) {
-                        contourSegments[segmentIndex++] = {
-                            start: vertices[i],
-                            end: vertices[i + 1],
+                    // ISO lines
+                    const path = getLines(opts);
+                    if (path.length > 0) {
+                        contourLines[segmentIndex++] = {
+                            vertices: path,
                             contour
                         };
                     }
@@ -59,6 +54,6 @@ export function generateContours({ thresholdData, cellWeights, gridSize, gridOri
             }
         }
     }
-    return { contourSegments, contourPolygons };
+    return { lines: contourLines, polygons: contourPolygons };
 }
 /* eslint-enable max-depth */

package/dist/contour-layer/marching-squares-codes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"marching-squares-codes.d.ts","sourceRoot":"","sources":["../../src/contour-layer/marching-squares-codes.ts"],"names":[],"mappings":"AAsJA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;CAyCpC,CAAC;AAMF,eAAO,MAAM,wBAAwB;;;;;;CAqKpC,CAAC"}
+{"version":3,"file":"marching-squares-codes.d.ts","sourceRoot":"","sources":["../../src/contour-layer/marching-squares-codes.ts"],"names":[],"mappings":"AA0JA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;CAyCpC,CAAC;AAMF,eAAO,MAAM,wBAAwB;;;;;;CAqKpC,CAAC"}

package/dist/contour-layer/marching-squares-codes.js

@@ -1,3 +1,6 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 // Code to Offsets Map needed to implement Marching Squares algorithm
 // Ref: https://en.wikipedia.org/wiki/Marching_squares
 // Table to map code to the intersection offsets

package/dist/contour-layer/marching-squares.d.ts

@@ -1,10 +1,26 @@
-export declare const CONTOUR_TYPE: {
-    ISO_LINES: number;
-    ISO_BANDS: number;
-};
-export declare function getCode(opts: any): {
+export declare function getCode(opts: {
+    getValue: (x: number, y: number) => number;
+    threshold: number | number[];
+    x: number;
+    xRange: [number, number];
+    y: number;
+    yRange: [number, number];
+}): {
     code: number;
     meanCode: number;
 };
-export declare function getVertices(opts: any): number[][] | number[][][];
+export declare function getPolygons(opts: {
+    x: number;
+    y: number;
+    z: number;
+    code: number;
+    meanCode: number;
+}): number[][][];
+export declare function getLines(opts: {
+    x: number;
+    y: number;
+    z: number;
+    code: number;
+    meanCode: number;
+}): number[][];
 //# sourceMappingURL=marching-squares.d.ts.map

package/dist/contour-layer/marching-squares.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"marching-squares.d.ts","sourceRoot":"","sources":["../../src/contour-layer/marching-squares.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,YAAY;;;CAGxB,CAAC;AAyBF,wBAAgB,OAAO,CAAC,IAAI,KAAA;;;EAyE3B;AAKD,wBAAgB,WAAW,CAAC,IAAI,KAAA,6BA4D/B"}
+{"version":3,"file":"marching-squares.d.ts","sourceRoot":"","sources":["../../src/contour-layer/marching-squares.ts"],"names":[],"mappings":"AA6BA,wBAAgB,OAAO,CAAC,IAAI,EAAE;IAC5B,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAC3C,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1B,GAAG;IACF,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAuEA;AAKD,wBAAgB,WAAW,CAAC,IAAI,EAAE;IAChC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,gBAgCA;AAID,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,cA0B/F"}

package/dist/contour-layer/marching-squares.js

@@ -1,18 +1,15 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 // All utility methods needed to implement Marching Squares algorithm
 // Ref: https://en.wikipedia.org/wiki/Marching_squares
-import { log } from '@deck.gl/core';
 import { ISOLINES_CODE_OFFSET_MAP, ISOBANDS_CODE_OFFSET_MAP } from "./marching-squares-codes.js";
-export const CONTOUR_TYPE = {
-    ISO_LINES: 1,
-    ISO_BANDS: 2
-};
-const DEFAULT_THRESHOLD_DATA = {
-    zIndex: 0,
-    zOffset: 0.005
-};
 // Utility methods
 function getVertexCode(weight, threshold) {
     // threshold must be a single value or a range (array of size 2)
+    if (Number.isNaN(weight)) {
+        return 0;
+    }
     // Iso-bands
     if (Array.isArray(threshold)) {
         if (weight < threshold[0]) {
@@ -30,52 +27,53 @@ export function getCode(opts) {
     // Origin is on bottom-left , and X increase to right, Y to top
     // When processing one cell, we process 4 cells, by extending row to top and on column to right
     // to create a 2X2 cell grid
-    const { cellWeights, x, y, width, height } = opts;
-    let threshold = opts.threshold;
-    if (opts.thresholdValue) {
-        log.deprecated('thresholdValue', 'threshold')();
-        threshold = opts.thresholdValue;
-    }
-    const isLeftBoundary = x < 0;
-    const isRightBoundary = x >= width - 1;
-    const isBottomBoundary = y < 0;
-    const isTopBoundary = y >= height - 1;
+    const { x, y, xRange, yRange, getValue, threshold } = opts;
+    const isLeftBoundary = x < xRange[0];
+    const isRightBoundary = x >= xRange[1] - 1;
+    const isBottomBoundary = y < yRange[0];
+    const isTopBoundary = y >= yRange[1] - 1;
     const isBoundary = isLeftBoundary || isRightBoundary || isBottomBoundary || isTopBoundary;
-    const weights = {};
-    const codes = {};
+    let weights = 0;
+    let current;
+    let right;
+    let top;
+    let topRight;
     // TOP
     if (isLeftBoundary || isTopBoundary) {
-        codes.top = 0;
+        top = 0;
     }
     else {
-        weights.top = cellWeights[(y + 1) * width + x];
-        codes.top = getVertexCode(weights.top, threshold);
+        const w = getValue(x, y + 1);
+        top = getVertexCode(w, threshold);
+        weights += w;
     }
     // TOP-RIGHT
     if (isRightBoundary || isTopBoundary) {
-        codes.topRight = 0;
+        topRight = 0;
     }
     else {
-        weights.topRight = cellWeights[(y + 1) * width + x + 1];
-        codes.topRight = getVertexCode(weights.topRight, threshold);
+        const w = getValue(x + 1, y + 1);
+        topRight = getVertexCode(w, threshold);
+        weights += w;
     }
     // RIGHT
     if (isRightBoundary || isBottomBoundary) {
-        codes.right = 0;
+        right = 0;
     }
     else {
-        weights.right = cellWeights[y * width + x + 1];
-        codes.right = getVertexCode(weights.right, threshold);
+        const w = getValue(x + 1, y);
+        right = getVertexCode(w, threshold);
+        weights += w;
     }
     // CURRENT
     if (isLeftBoundary || isBottomBoundary) {
-        codes.current = 0;
+        current = 0;
     }
     else {
-        weights.current = cellWeights[y * width + x];
-        codes.current = getVertexCode(weights.current, threshold);
+        const w = getValue(x, y);
+        current = getVertexCode(w, threshold);
+        weights += w;
     }
-    const { top, topRight, right, current } = codes;
     let code = -1;
     if (Number.isFinite(threshold)) {
         code = (top << 3) | (topRight << 2) | (right << 1) | current;
@@ -88,59 +86,64 @@ export function getCode(opts) {
     // only occur when we are not processing a cell on boundary
     // because when on a boundary either, bottom-row, top-row, left-column or right-column will have both 0 codes
     if (!isBoundary) {
-        meanCode = getVertexCode((weights.top + weights.topRight + weights.right + weights.current) / 4, threshold);
+        meanCode = getVertexCode(weights / 4, threshold);
     }
     return { code, meanCode };
 }
 /* eslint-enable complexity, max-statements*/
 // Returns intersection vertices for given cellindex
 // [x, y] refers current marching cell, reference vertex is always top-right corner
-export function getVertices(opts) {
-    const { gridOrigin, cellSize, x, y, code, meanCode, type = CONTOUR_TYPE.ISO_LINES } = opts;
-    const thresholdData = { ...DEFAULT_THRESHOLD_DATA, ...opts.thresholdData };
-    let offsets = type === CONTOUR_TYPE.ISO_BANDS
-        ? ISOBANDS_CODE_OFFSET_MAP[code]
-        : ISOLINES_CODE_OFFSET_MAP[code];
+export function getPolygons(opts) {
+    const { x, y, z, code, meanCode } = opts;
+    let offsets = ISOBANDS_CODE_OFFSET_MAP[code];
     // handle saddle cases
     if (!Array.isArray(offsets)) {
         offsets = offsets[meanCode];
     }
     // Reference vertex is at top-right move to top-right corner
-    const vZ = thresholdData.zIndex * thresholdData.zOffset;
-    const rX = (x + 1) * cellSize[0];
-    const rY = (y + 1) * cellSize[1];
-    const refVertexX = gridOrigin[0] + rX;
-    const refVertexY = gridOrigin[1] + rY;
+    const rX = x + 1;
+    const rY = y + 1;
     // offsets format
-    // ISO_LINES: [[1A, 1B], [2A, 2B]],
-    // ISO_BANDS: [[1A, 1B, 1C, ...], [2A, 2B, 2C, ...]],
+    // [[1A, 1B, 1C, ...], [2A, 2B, 2C, ...]],
     // vertices format
-    // ISO_LINES: [[x1A, y1A], [x1B, y1B], [x2A, x2B], ...],
-    // ISO_BANDS:  => confirms to SolidPolygonLayer's simple polygon format
-    //      [
-    //        [[x1A, y1A], [x1B, y1B], [x1C, y1C] ... ],
+    // [
+    //   [[x1A, y1A], [x1B, y1B], [x1C, y1C] ... ],
     //        ...
-    //      ]
-    if (type === CONTOUR_TYPE.ISO_BANDS) {
-        const polygons = [];
-        offsets.forEach(polygonOffsets => {
-            const polygon = [];
-            polygonOffsets.forEach(xyOffset => {
-                const vX = refVertexX + xyOffset[0] * cellSize[0];
-                const vY = refVertexY + xyOffset[1] * cellSize[1];
-                polygon.push([vX, vY, vZ]);
-            });
-            polygons.push(polygon);
+    // ]
+    const polygons = [];
+    offsets.forEach(polygonOffsets => {
+        const polygon = [];
+        polygonOffsets.forEach(xyOffset => {
+            const vX = rX + xyOffset[0];
+            const vY = rY + xyOffset[1];
+            polygon.push([vX, vY, z]);
         });
-        return polygons;
+        polygons.push(polygon);
+    });
+    return polygons;
+}
+// Returns intersection vertices for given cellindex
+// [x, y] refers current marching cell, reference vertex is always top-right corner
+export function getLines(opts) {
+    const { x, y, z, code, meanCode } = opts;
+    let offsets = ISOLINES_CODE_OFFSET_MAP[code];
+    // handle saddle cases
+    if (!Array.isArray(offsets)) {
+        offsets = offsets[meanCode];
     }
-    // default case is ISO_LINES
+    // Reference vertex is at top-right move to top-right corner
+    const rX = x + 1;
+    const rY = y + 1;
+    // offsets format
+    // [[1A, 1B], [2A, 2B]],
+    // vertices format
+    // [[x1A, y1A], [x1B, y1B], [x2A, x2B], ...],
     const lines = [];
     offsets.forEach(xyOffsets => {
         xyOffsets.forEach(offset => {
-            const vX = refVertexX + offset[0] * cellSize[0];
-            const vY = refVertexY + offset[1] * cellSize[1];
-            lines.push([vX, vY, vZ]);
+            const vX = rX + offset[0];
+            const vY = rY + offset[1];
+            lines.push([vX, vY, z]);
         });
     });
     return lines;

package/dist/contour-layer/value-reader.d.ts

@@ -0,0 +1,10 @@
+import { Aggregator } from "../common/aggregator/index.js";
+type ValueReader = (x: number, y: number) => number;
+/** Returns an accessor to the aggregated values from bin id */
+export declare function getAggregatorValueReader(opts: {
+    aggregator: Aggregator;
+    binIdRange: [number, number][];
+    channel: 0 | 1 | 2;
+}): ValueReader | null;
+export {};
+//# sourceMappingURL=value-reader.d.ts.map

package/dist/contour-layer/value-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-reader.d.ts","sourceRoot":"","sources":["../../src/contour-layer/value-reader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,UAAU,EAAiC,sCAAmC;AAGtF,KAAK,WAAW,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAEpD,+DAA+D;AAC/D,wBAAgB,wBAAwB,CAAC,IAAI,EAAE;IAC7C,UAAU,EAAE,UAAU,CAAC;IACvB,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IAC/B,OAAO,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;CACpB,GAAG,WAAW,GAAG,IAAI,CAkBrB"}

package/dist/contour-layer/value-reader.js

@@ -0,0 +1,46 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { CPUAggregator, WebGLAggregator } from "../common/aggregator/index.js";
+/** Returns an accessor to the aggregated values from bin id */
+export function getAggregatorValueReader(opts) {
+    const { aggregator, binIdRange, channel } = opts;
+    if (aggregator instanceof WebGLAggregator) {
+        const buffer = aggregator.getResult(channel)?.buffer;
+        if (buffer) {
+            const values = new Float32Array(buffer.readSyncWebGL().buffer);
+            return getWebGLAggregatorValueReader(values, binIdRange);
+        }
+    }
+    if (aggregator instanceof CPUAggregator) {
+        const values = aggregator.getResult(channel)?.value;
+        const ids = aggregator.getBins()?.value;
+        if (ids && values) {
+            return getCPUAggregatorValueReader(values, ids, aggregator.binCount);
+        }
+    }
+    return null;
+}
+function getWebGLAggregatorValueReader(values, binIdRange) {
+    const [[minX, maxX], [minY, maxY]] = binIdRange;
+    const width = maxX - minX;
+    const height = maxY - minY;
+    return (x, y) => {
+        x -= minX;
+        y -= minY;
+        if (x < 0 || x >= width || y < 0 || y >= height) {
+            return NaN;
+        }
+        return values[y * width + x];
+    };
+}
+function getCPUAggregatorValueReader(values, ids, count) {
+    const idMap = {};
+    for (let i = 0; i < count; i++) {
+        const x = ids[i * 2];
+        const y = ids[i * 2 + 1];
+        idMap[x] = idMap[x] || {};
+        idMap[x][y] = values[i];
+    }
+    return (x, y) => idMap[x]?.[y] ?? NaN;
+}