@deck.gl/aggregation-layers 9.0.0-beta.2 → 9.0.0-beta.3

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

@@ -0,0 +1,337 @@
+// 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
+// All offsets are relative to the center of marching cell (which is top right corner of grid-cell, and center of marching-square)
+const HALF = 0.5;
+const ONE6TH = 1 / 6;
+const OFFSET = {
+    N: [0, HALF], // NORTH
+    E: [HALF, 0], // EAST
+    S: [0, -HALF], // SOUTH
+    W: [-HALF, 0], // WEST
+    // CORNERS
+    NE: [HALF, HALF],
+    NW: [-HALF, HALF],
+    SE: [HALF, -HALF],
+    SW: [-HALF, -HALF]
+};
+// NOTE: vertices are ordered in CCW direction, starting from NW corner
+// Triangles
+const SW_TRIANGLE = [OFFSET.W, OFFSET.SW, OFFSET.S];
+const SE_TRIANGLE = [OFFSET.S, OFFSET.SE, OFFSET.E];
+const NE_TRIANGLE = [OFFSET.E, OFFSET.NE, OFFSET.N];
+const NW_TRIANGLE = [OFFSET.NW, OFFSET.W, OFFSET.N];
+// Trapezoids
+const SW_TRAPEZOID = [
+    [-HALF, ONE6TH],
+    [-HALF, -ONE6TH],
+    [-ONE6TH, -HALF],
+    [ONE6TH, -HALF]
+];
+const SE_TRAPEZOID = [
+    [-ONE6TH, -HALF],
+    [ONE6TH, -HALF],
+    [HALF, -ONE6TH],
+    [HALF, ONE6TH]
+];
+const NE_TRAPEZOID = [
+    [HALF, -ONE6TH],
+    [HALF, ONE6TH],
+    [ONE6TH, HALF],
+    [-ONE6TH, HALF]
+];
+const NW_TRAPEZOID = [
+    [-HALF, ONE6TH],
+    [-HALF, -ONE6TH],
+    [ONE6TH, HALF],
+    [-ONE6TH, HALF]
+];
+// Rectangles
+const S_RECTANGLE = [OFFSET.W, OFFSET.SW, OFFSET.SE, OFFSET.E];
+const E_RECTANGLE = [OFFSET.S, OFFSET.SE, OFFSET.NE, OFFSET.N];
+const N_RECTANGLE = [OFFSET.NW, OFFSET.W, OFFSET.E, OFFSET.NE];
+const W_RECTANGLE = [OFFSET.NW, OFFSET.SW, OFFSET.S, OFFSET.N];
+const EW_RECTANGEL = [
+    [-HALF, ONE6TH],
+    [-HALF, -ONE6TH],
+    [HALF, -ONE6TH],
+    [HALF, ONE6TH]
+];
+const SN_RECTANGEL = [
+    [-ONE6TH, -HALF],
+    [ONE6TH, -HALF],
+    [ONE6TH, HALF],
+    [-ONE6TH, HALF]
+];
+// Square
+const SQUARE = [OFFSET.NW, OFFSET.SW, OFFSET.SE, OFFSET.NE];
+// Pentagons
+const SW_PENTAGON = [OFFSET.NW, OFFSET.SW, OFFSET.SE, OFFSET.E, OFFSET.N];
+const SE_PENTAGON = [OFFSET.W, OFFSET.SW, OFFSET.SE, OFFSET.NE, OFFSET.N];
+const NE_PENTAGON = [OFFSET.NW, OFFSET.W, OFFSET.S, OFFSET.SE, OFFSET.NE];
+const NW_PENTAGON = [OFFSET.NW, OFFSET.SW, OFFSET.S, OFFSET.E, OFFSET.NE];
+const NW_N_PENTAGON = [OFFSET.NW, OFFSET.W, [HALF, -ONE6TH], [HALF, ONE6TH], OFFSET.N];
+const NE_E_PENTAGON = [[-ONE6TH, -HALF], [ONE6TH, -HALF], OFFSET.E, OFFSET.NE, OFFSET.N];
+const SE_S_PENTAGON = [[-HALF, ONE6TH], [-HALF, -ONE6TH], OFFSET.S, OFFSET.SE, OFFSET.E];
+const SW_W_PENTAGON = [OFFSET.W, OFFSET.SW, OFFSET.S, [ONE6TH, HALF], [-ONE6TH, HALF]];
+const NW_W_PENTAGON = [OFFSET.NW, OFFSET.W, [-ONE6TH, -HALF], [ONE6TH, -HALF], OFFSET.N];
+const NE_N_PENTAGON = [[-HALF, ONE6TH], [-HALF, -ONE6TH], OFFSET.E, OFFSET.NE, OFFSET.N];
+const SE_E_PENTAGON = [OFFSET.S, OFFSET.SE, OFFSET.E, [ONE6TH, HALF], [-ONE6TH, HALF]];
+const SW_S_PENTAGON = [OFFSET.W, OFFSET.SW, OFFSET.S, [HALF, -ONE6TH], [HALF, ONE6TH]];
+// Hexagon
+const S_HEXAGON = [OFFSET.W, OFFSET.SW, OFFSET.SE, OFFSET.E, [ONE6TH, HALF], [-ONE6TH, HALF]];
+const E_HEXAGON = [[-HALF, ONE6TH], [-HALF, -ONE6TH], OFFSET.S, OFFSET.SE, OFFSET.NE, OFFSET.N];
+const N_HEXAGON = [OFFSET.NW, OFFSET.W, [-ONE6TH, -HALF], [ONE6TH, -HALF], OFFSET.E, OFFSET.NE];
+const W_HEXAGON = [OFFSET.NW, OFFSET.SW, OFFSET.S, [HALF, -ONE6TH], [HALF, ONE6TH], OFFSET.N];
+const SW_NE_HEXAGON = [OFFSET.W, OFFSET.SW, OFFSET.S, OFFSET.E, OFFSET.NE, OFFSET.N];
+const NW_SE_HEXAGON = [OFFSET.NW, OFFSET.W, OFFSET.S, OFFSET.SE, OFFSET.E, OFFSET.N];
+// Heptagon (7-sided)
+const NE_HEPTAGON = [
+    [-HALF, ONE6TH],
+    [-HALF, -ONE6TH],
+    [-ONE6TH, -HALF],
+    [ONE6TH, -HALF],
+    OFFSET.E,
+    OFFSET.NE,
+    OFFSET.N
+];
+const SW_HEPTAGON = [
+    OFFSET.W,
+    OFFSET.SW,
+    OFFSET.S,
+    [HALF, -ONE6TH],
+    [HALF, ONE6TH],
+    [ONE6TH, HALF],
+    [-ONE6TH, HALF]
+];
+const NW_HEPTAGON = [
+    OFFSET.NW,
+    OFFSET.W,
+    [-ONE6TH, -HALF],
+    [ONE6TH, -HALF],
+    [HALF, -ONE6TH],
+    [HALF, ONE6TH],
+    OFFSET.N
+];
+const SE_HEPTAGON = [
+    [-HALF, ONE6TH],
+    [-HALF, -ONE6TH],
+    OFFSET.S,
+    OFFSET.SE,
+    OFFSET.E,
+    [ONE6TH, HALF],
+    [-ONE6TH, HALF]
+];
+// Octagon
+const OCTAGON = [
+    [-HALF, ONE6TH],
+    [-HALF, -ONE6TH],
+    [-ONE6TH, -HALF],
+    [ONE6TH, -HALF],
+    [HALF, -ONE6TH],
+    [HALF, ONE6TH],
+    [ONE6TH, HALF],
+    [-ONE6TH, HALF]
+];
+// Note: above wiki page invertes white/black dots for generating the code, we don't
+export const ISOLINES_CODE_OFFSET_MAP = {
+    // key is equal to the code of 4 vertices (invert the code specified in wiki)
+    // value can be an array or an Object
+    // Array : [line] or [line, line], where each line is [start-point, end-point], and each point is [x, y]
+    // Object : to handle saddle cases, whos output depends on mean value of all 4 corners
+    //  key: code of mean value (0 or 1)
+    //  value: Array , as above defines one or two line segments
+    0: [],
+    1: [[OFFSET.W, OFFSET.S]],
+    2: [[OFFSET.S, OFFSET.E]],
+    3: [[OFFSET.W, OFFSET.E]],
+    4: [[OFFSET.N, OFFSET.E]],
+    5: {
+        0: [
+            [OFFSET.W, OFFSET.S],
+            [OFFSET.N, OFFSET.E]
+        ],
+        1: [
+            [OFFSET.W, OFFSET.N],
+            [OFFSET.S, OFFSET.E]
+        ]
+    },
+    6: [[OFFSET.N, OFFSET.S]],
+    7: [[OFFSET.W, OFFSET.N]],
+    8: [[OFFSET.W, OFFSET.N]],
+    9: [[OFFSET.N, OFFSET.S]],
+    10: {
+        0: [
+            [OFFSET.W, OFFSET.N],
+            [OFFSET.S, OFFSET.E]
+        ],
+        1: [
+            [OFFSET.W, OFFSET.S],
+            [OFFSET.N, OFFSET.E]
+        ]
+    },
+    11: [[OFFSET.N, OFFSET.E]],
+    12: [[OFFSET.W, OFFSET.E]],
+    13: [[OFFSET.S, OFFSET.E]],
+    14: [[OFFSET.W, OFFSET.S]],
+    15: []
+};
+function ternaryToIndex(ternary) {
+    return parseInt(ternary, 4);
+}
+export const ISOBANDS_CODE_OFFSET_MAP = {
+    // Below list of cases, follow the same order as in above mentioned wiki page.
+    // Each case has its code on first commented line // T,TR,R,C
+    // where T: Top, TR: Top-right, R: Right and C: current, each will be either 0, 1 or 2
+    // final code is binary representation of above code , where takes 2 digits
+    // for example:  code 2-2-2-1 => 10-10-10-01 => 10101001 => 169
+    // no contours
+    [ternaryToIndex('0000')]: [],
+    [ternaryToIndex('2222')]: [],
+    // single triangle
+    [ternaryToIndex('2221')]: [SW_TRIANGLE],
+    [ternaryToIndex('2212')]: [SE_TRIANGLE],
+    [ternaryToIndex('2122')]: [NE_TRIANGLE],
+    [ternaryToIndex('1222')]: [NW_TRIANGLE],
+    [ternaryToIndex('0001')]: [SW_TRIANGLE],
+    [ternaryToIndex('0010')]: [SE_TRIANGLE],
+    [ternaryToIndex('0100')]: [NE_TRIANGLE],
+    [ternaryToIndex('1000')]: [NW_TRIANGLE],
+    // single trapezoid
+    [ternaryToIndex('2220')]: [SW_TRAPEZOID],
+    [ternaryToIndex('2202')]: [SE_TRAPEZOID],
+    [ternaryToIndex('2022')]: [NE_TRAPEZOID],
+    [ternaryToIndex('0222')]: [NW_TRAPEZOID],
+    [ternaryToIndex('0002')]: [SW_TRAPEZOID],
+    [ternaryToIndex('0020')]: [SE_TRAPEZOID],
+    [ternaryToIndex('0200')]: [NE_TRAPEZOID],
+    [ternaryToIndex('2000')]: [NW_TRAPEZOID],
+    // single rectangle
+    [ternaryToIndex('0011')]: [S_RECTANGLE],
+    [ternaryToIndex('0110')]: [E_RECTANGLE],
+    [ternaryToIndex('1100')]: [N_RECTANGLE],
+    [ternaryToIndex('1001')]: [W_RECTANGLE],
+    [ternaryToIndex('2211')]: [S_RECTANGLE],
+    [ternaryToIndex('2112')]: [E_RECTANGLE],
+    [ternaryToIndex('1122')]: [N_RECTANGLE],
+    [ternaryToIndex('1221')]: [W_RECTANGLE],
+    [ternaryToIndex('2200')]: [EW_RECTANGEL],
+    [ternaryToIndex('2002')]: [SN_RECTANGEL],
+    [ternaryToIndex('0022')]: [EW_RECTANGEL],
+    [ternaryToIndex('0220')]: [SN_RECTANGEL],
+    // single square
+    // 1111
+    [ternaryToIndex('1111')]: [SQUARE],
+    // single pentagon
+    [ternaryToIndex('1211')]: [SW_PENTAGON],
+    [ternaryToIndex('2111')]: [SE_PENTAGON],
+    [ternaryToIndex('1112')]: [NE_PENTAGON],
+    [ternaryToIndex('1121')]: [NW_PENTAGON],
+    [ternaryToIndex('1011')]: [SW_PENTAGON],
+    [ternaryToIndex('0111')]: [SE_PENTAGON],
+    [ternaryToIndex('1110')]: [NE_PENTAGON],
+    [ternaryToIndex('1101')]: [NW_PENTAGON],
+    [ternaryToIndex('1200')]: [NW_N_PENTAGON],
+    [ternaryToIndex('0120')]: [NE_E_PENTAGON],
+    [ternaryToIndex('0012')]: [SE_S_PENTAGON],
+    [ternaryToIndex('2001')]: [SW_W_PENTAGON],
+    [ternaryToIndex('1022')]: [NW_N_PENTAGON],
+    [ternaryToIndex('2102')]: [NE_E_PENTAGON],
+    [ternaryToIndex('2210')]: [SE_S_PENTAGON],
+    [ternaryToIndex('0221')]: [SW_W_PENTAGON],
+    [ternaryToIndex('1002')]: [NW_W_PENTAGON],
+    [ternaryToIndex('2100')]: [NE_N_PENTAGON],
+    [ternaryToIndex('0210')]: [SE_E_PENTAGON],
+    [ternaryToIndex('0021')]: [SW_S_PENTAGON],
+    [ternaryToIndex('1220')]: [NW_W_PENTAGON],
+    [ternaryToIndex('0122')]: [NE_N_PENTAGON],
+    [ternaryToIndex('2012')]: [SE_E_PENTAGON],
+    [ternaryToIndex('2201')]: [SW_S_PENTAGON],
+    // single hexagon
+    [ternaryToIndex('0211')]: [S_HEXAGON],
+    [ternaryToIndex('2110')]: [E_HEXAGON],
+    [ternaryToIndex('1102')]: [N_HEXAGON],
+    [ternaryToIndex('1021')]: [W_HEXAGON],
+    [ternaryToIndex('2011')]: [S_HEXAGON],
+    [ternaryToIndex('0112')]: [E_HEXAGON],
+    [ternaryToIndex('1120')]: [N_HEXAGON],
+    [ternaryToIndex('1201')]: [W_HEXAGON],
+    [ternaryToIndex('2101')]: [SW_NE_HEXAGON],
+    [ternaryToIndex('0121')]: [SW_NE_HEXAGON],
+    [ternaryToIndex('1012')]: [NW_SE_HEXAGON],
+    [ternaryToIndex('1210')]: [NW_SE_HEXAGON],
+    // 6-sided polygons based on mean weight
+    // NOTE: merges mean value codes for extreme changes (as per above Wiki doc)
+    [ternaryToIndex('0101')]: {
+        0: [SW_TRIANGLE, NE_TRIANGLE],
+        1: [SW_NE_HEXAGON],
+        2: [SW_NE_HEXAGON]
+    },
+    [ternaryToIndex('1010')]: {
+        0: [NW_TRIANGLE, SE_TRIANGLE],
+        1: [NW_SE_HEXAGON],
+        2: [NW_SE_HEXAGON]
+    },
+    [ternaryToIndex('2121')]: {
+        0: [SW_NE_HEXAGON],
+        1: [SW_NE_HEXAGON],
+        2: [SW_TRIANGLE, NE_TRIANGLE]
+    },
+    [ternaryToIndex('1212')]: {
+        0: [NW_SE_HEXAGON],
+        1: [NW_SE_HEXAGON],
+        2: [NW_TRIANGLE, SE_TRIANGLE]
+    },
+    // 7-sided polygons based on mean weight
+    [ternaryToIndex('2120')]: {
+        0: [NE_HEPTAGON],
+        1: [NE_HEPTAGON],
+        2: [SW_TRAPEZOID, NE_TRIANGLE]
+    },
+    [ternaryToIndex('2021')]: {
+        0: [SW_HEPTAGON],
+        1: [SW_HEPTAGON],
+        2: [SW_TRIANGLE, NE_TRAPEZOID]
+    },
+    [ternaryToIndex('1202')]: {
+        0: [NW_HEPTAGON],
+        1: [NW_HEPTAGON],
+        2: [NW_TRIANGLE, SE_TRAPEZOID]
+    },
+    [ternaryToIndex('0212')]: {
+        0: [SE_HEPTAGON],
+        1: [SE_HEPTAGON],
+        2: [SE_TRIANGLE, NW_TRAPEZOID]
+    },
+    [ternaryToIndex('0102')]: {
+        0: [SW_TRAPEZOID, NE_TRIANGLE],
+        1: [NE_HEPTAGON],
+        2: [NE_HEPTAGON]
+    },
+    [ternaryToIndex('0201')]: {
+        0: [SW_TRIANGLE, NE_TRAPEZOID],
+        1: [SW_HEPTAGON],
+        2: [SW_HEPTAGON]
+    },
+    [ternaryToIndex('1020')]: {
+        0: [NW_TRIANGLE, SE_TRAPEZOID],
+        1: [NW_HEPTAGON],
+        2: [NW_HEPTAGON]
+    },
+    [ternaryToIndex('2010')]: {
+        0: [SE_TRIANGLE, NW_TRAPEZOID],
+        1: [SE_HEPTAGON],
+        2: [SE_HEPTAGON]
+    },
+    // 8-sided polygons based on mean weight
+    [ternaryToIndex('2020')]: {
+        0: [NW_TRAPEZOID, SE_TRAPEZOID],
+        1: [OCTAGON],
+        2: [SW_TRAPEZOID, NE_TRAPEZOID]
+    },
+    [ternaryToIndex('0202')]: {
+        0: [NE_TRAPEZOID, SW_TRAPEZOID],
+        1: [OCTAGON],
+        2: [NW_TRAPEZOID, SE_TRAPEZOID]
+    }
+};

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

@@ -0,0 +1,147 @@
+// 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)
+    // Iso-bands
+    if (Array.isArray(threshold)) {
+        if (weight < threshold[0]) {
+            return 0;
+        }
+        return weight < threshold[1] ? 1 : 2;
+    }
+    // Iso-lines
+    return weight >= threshold ? 1 : 0;
+}
+// Returns marching square code for given cell
+/* eslint-disable complexity, max-statements*/
+export function getCode(opts) {
+    // Assumptions
+    // 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 isBoundary = isLeftBoundary || isRightBoundary || isBottomBoundary || isTopBoundary;
+    const weights = {};
+    const codes = {};
+    // TOP
+    if (isLeftBoundary || isTopBoundary) {
+        codes.top = 0;
+    }
+    else {
+        weights.top = cellWeights[(y + 1) * width + x];
+        codes.top = getVertexCode(weights.top, threshold);
+    }
+    // TOP-RIGHT
+    if (isRightBoundary || isTopBoundary) {
+        codes.topRight = 0;
+    }
+    else {
+        weights.topRight = cellWeights[(y + 1) * width + x + 1];
+        codes.topRight = getVertexCode(weights.topRight, threshold);
+    }
+    // RIGHT
+    if (isRightBoundary || isBottomBoundary) {
+        codes.right = 0;
+    }
+    else {
+        weights.right = cellWeights[y * width + x + 1];
+        codes.right = getVertexCode(weights.right, threshold);
+    }
+    // CURRENT
+    if (isLeftBoundary || isBottomBoundary) {
+        codes.current = 0;
+    }
+    else {
+        weights.current = cellWeights[y * width + x];
+        codes.current = getVertexCode(weights.current, threshold);
+    }
+    const { top, topRight, right, current } = codes;
+    let code = -1;
+    if (Number.isFinite(threshold)) {
+        code = (top << 3) | (topRight << 2) | (right << 1) | current;
+    }
+    if (Array.isArray(threshold)) {
+        code = (top << 6) | (topRight << 4) | (right << 2) | current;
+    }
+    let meanCode = 0;
+    // meanCode is only needed for saddle cases, and they should
+    // 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);
+    }
+    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];
+    // 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;
+    // offsets format
+    // ISO_LINES: [[1A, 1B], [2A, 2B]],
+    // ISO_BANDS: [[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] ... ],
+    //        ...
+    //      ]
+    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);
+        });
+        return polygons;
+    }
+    // default case is ISO_LINES
+    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]);
+        });
+    });
+    return lines;
+}

package/dist/cpu-grid-layer/cpu-grid-layer.js

@@ -0,0 +1,130 @@
+// 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 { GL } from '@luma.gl/constants';
+import { GridCellLayer } from '@deck.gl/layers';
+import { defaultColorRange } from "../utils/color-utils.js";
+import { pointToDensityGridDataCPU } from "./grid-aggregator.js";
+import CPUAggregator from "../utils/cpu-aggregator.js";
+import AggregationLayer from "../aggregation-layer.js";
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function nop() { }
+const defaultProps = {
+    // color
+    colorDomain: null,
+    colorRange: defaultColorRange,
+    getColorValue: { type: 'accessor', value: null }, // default value is calculated from `getColorWeight` and `colorAggregation`
+    getColorWeight: { type: 'accessor', value: 1 },
+    colorAggregation: 'SUM',
+    lowerPercentile: { type: 'number', min: 0, max: 100, value: 0 },
+    upperPercentile: { type: 'number', min: 0, max: 100, value: 100 },
+    colorScaleType: 'quantize',
+    onSetColorDomain: nop,
+    // elevation
+    elevationDomain: null,
+    elevationRange: [0, 1000],
+    getElevationValue: { type: 'accessor', value: null }, // default value is calculated from `getElevationWeight` and `elevationAggregation`
+    getElevationWeight: { type: 'accessor', value: 1 },
+    elevationAggregation: 'SUM',
+    elevationLowerPercentile: { type: 'number', min: 0, max: 100, value: 0 },
+    elevationUpperPercentile: { type: 'number', min: 0, max: 100, value: 100 },
+    elevationScale: { type: 'number', min: 0, value: 1 },
+    elevationScaleType: 'linear',
+    onSetElevationDomain: nop,
+    gridAggregator: pointToDensityGridDataCPU,
+    // grid
+    cellSize: { type: 'number', min: 0, max: 1000, value: 1000 },
+    coverage: { type: 'number', min: 0, max: 1, value: 1 },
+    getPosition: { type: 'accessor', value: (x) => x.position },
+    extruded: false,
+    // Optional material for 'lighting' shader module
+    material: true,
+    // data filter
+    _filterData: { type: 'function', value: null, optional: true }
+};
+/** Aggregate data into a grid-based heatmap. Aggregation is performed on CPU. */
+export default class CPUGridLayer extends AggregationLayer {
+    static { this.layerName = 'CPUGridLayer'; }
+    static { this.defaultProps = defaultProps; }
+    initializeState() {
+        const cpuAggregator = new CPUAggregator({
+            getAggregator: props => props.gridAggregator,
+            getCellSize: props => props.cellSize
+        });
+        this.state = {
+            cpuAggregator,
+            aggregatorState: cpuAggregator.state
+        };
+        const attributeManager = this.getAttributeManager();
+        attributeManager.add({
+            positions: { size: 3, type: GL.DOUBLE, accessor: 'getPosition' }
+        });
+        // color and elevation attributes can't be added as attributes
+        // they are calcualted using 'getValue' accessor that takes an array of pints.
+    }
+    updateState(opts) {
+        super.updateState(opts);
+        this.setState({
+            // make a copy of the internal state of cpuAggregator for testing
+            aggregatorState: this.state.cpuAggregator.updateState(opts, {
+                viewport: this.context.viewport,
+                attributes: this.getAttributes(),
+                numInstances: this.getNumInstances()
+            })
+        });
+    }
+    getPickingInfo({ info }) {
+        return this.state.cpuAggregator.getPickingInfo({ info });
+    }
+    // create a method for testing
+    _onGetSublayerColor(cell) {
+        return this.state.cpuAggregator.getAccessor('fillColor')(cell);
+    }
+    // create a method for testing
+    _onGetSublayerElevation(cell) {
+        return this.state.cpuAggregator.getAccessor('elevation')(cell);
+    }
+    _getSublayerUpdateTriggers() {
+        return this.state.cpuAggregator.getUpdateTriggers(this.props);
+    }
+    renderLayers() {
+        const { elevationScale, extruded, cellSize, coverage, material, transitions } = this.props;
+        const { cpuAggregator } = this.state;
+        const SubLayerClass = this.getSubLayerClass('grid-cell', GridCellLayer);
+        const updateTriggers = this._getSublayerUpdateTriggers();
+        return new SubLayerClass({
+            cellSize,
+            coverage,
+            material,
+            elevationScale,
+            extruded,
+            getFillColor: this._onGetSublayerColor.bind(this),
+            getElevation: this._onGetSublayerElevation.bind(this),
+            transitions: transitions && {
+                getFillColor: transitions.getColorValue || transitions.getColorWeight,
+                getElevation: transitions.getElevationValue || transitions.getElevationWeight
+            }
+        }, this.getSubLayerProps({
+            id: 'grid-cell',
+            updateTriggers
+        }), {
+            data: cpuAggregator.state.layerData.data
+        });
+    }
+}