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

package/typed/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],
+    E: [HALF, 0],
+    S: [0, -HALF],
+    W: [-HALF, 0],
+    // 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/typed/contour-layer/marching-squares.d.ts

@@ -0,0 +1,10 @@
+export declare const CONTOUR_TYPE: {
+    ISO_LINES: number;
+    ISO_BANDS: number;
+};
+export declare function getCode(opts: any): {
+    code: number;
+    meanCode: number;
+};
+export declare function getVertices(opts: any): number[][] | number[][][];
+//# sourceMappingURL=marching-squares.d.ts.map

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

@@ -0,0 +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"}

package/typed/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';
+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/typed/cpu-grid-layer/cpu-grid-layer.d.ts

@@ -0,0 +1,152 @@
+import { Accessor, AccessorFunction, Color, Position, Material, DefaultProps } from '@deck.gl/core/typed';
+import AggregationLayer, { AggregationLayerProps } from '../aggregation-layer';
+import Layer, { UpdateParameters } from 'modules/core/src/lib/layer';
+import { GetPickingInfoParams, PickingInfo } from 'modules/core/src/lib/picking/pick-info';
+import { AggregateAccessor } from '../types';
+/** All properties supported by CPUGridLayer. */
+export declare type CPUGridLayerProps<DataT = any> = _CPUGridLayerProps<DataT> & AggregationLayerProps<DataT>;
+/** Properties added by CPUGridLayer. */
+export declare type _CPUGridLayerProps<DataT> = {
+    /**
+     * Size of each cell in meters.
+     * @default 1000
+     */
+    cellSize?: number;
+    /**
+     * Color scale domain, default is set to the extent of aggregated weights in each cell.
+     * @default [min(colorWeight), max(colorWeight)]
+     */
+    colorDomain?: [number, number] | null;
+    /**
+     * Default: [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6) `6-class YlOrRd`
+     */
+    colorRange?: Color[];
+    /**
+     * Cell size multiplier, clamped between 0 - 1.
+     * @default 1
+     */
+    coverage?: number;
+    /**
+     * Elevation scale input domain, default is set to between 0 and the max of aggregated weights in each cell.
+     * @default [0, max(elevationWeight)]
+     */
+    elevationDomain?: [number, number] | null;
+    /**
+     * Elevation scale output range.
+     * @default [0, 1000]
+     */
+    elevationRange?: [number, number];
+    /**
+     * Cell elevation multiplier.
+     * @default 1
+     */
+    elevationScale?: number;
+    /**
+     * Whether to enable cell elevation. If set to false, all cell will be flat.
+     * @default true
+     */
+    extruded?: boolean;
+    /**
+     * Filter cells and re-calculate color by `upperPercentile`.
+     * Cells with value arger than the upperPercentile will be hidden.
+     * @default 100
+     */
+    upperPercentile?: number;
+    /**
+     * Filter cells and re-calculate color by `lowerPercentile`.
+     * Cells with value smaller than the lowerPercentile will be hidden.
+     * @default 0
+     */
+    lowerPercentile?: number;
+    /**
+     * Filter cells and re-calculate elevation by `elevationUpperPercentile`.
+     * Cells with elevation value larger than the `elevationUpperPercentile` will be hidden.
+     * @default 100
+     */
+    elevationUpperPercentile?: number;
+    /**
+     * Filter cells and re-calculate elevation by `elevationLowerPercentile`.
+     * Cells with elevation value larger than the `elevationLowerPercentile` will be hidden.
+     * @default 0
+     */
+    elevationLowerPercentile?: number;
+    /**
+     * Scaling function used to determine the color of the grid cell, default value is 'quantize'.
+     * Supported Values are 'quantize', 'linear', 'quantile' and 'ordinal'.
+     * @default 'quantize'
+     */
+    colorScaleType?: 'quantize' | 'linear' | 'quantile' | 'ordinal';
+    /**
+     * Scaling function used to determine the elevation of the grid cell, only supports 'linear'.
+     */
+    elevationScaleType?: 'linear';
+    gridAggregator?: (props: any, params: any) => any;
+    /**
+     * Material settings for lighting effect. Applies if `extruded: true`.
+     *
+     * @default true
+     * @see https://deck.gl/docs/developer-guide/using-lighting
+     */
+    material?: Material;
+    /**
+     * Defines the operation used to aggregate all data object weights to calculate a cell's color value.
+     * @default 'SUM'
+     */
+    colorAggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
+    /**
+     * Defines the operation used to aggregate all data object weights to calculate a cell's elevation value.
+     * @default 'SUM'
+     */
+    elevationAggregation?: 'SUM' | 'MEAN' | 'MIN' | 'MAX';
+    /**
+     * Method called to retrieve the position of each object.
+     * @default object => object.position
+     */
+    getPosition?: AccessorFunction<DataT, Position>;
+    /**
+     * The weight of a data object used to calculate the color value for a cell.
+     * @default 1
+     */
+    getColorWeight?: Accessor<DataT, number>;
+    /**
+     * After data objects are aggregated into cells, this accessor is called on each cell to get the value that its color is based on.
+     * @default null
+     */
+    getColorValue?: AggregateAccessor<DataT> | null;
+    /**
+     * The weight of a data object used to calculate the elevation value for a cell.
+     * @default 1
+     */
+    getElevationWeight?: Accessor<DataT, number>;
+    /**
+     * After data objects are aggregated into cells, this accessor is called on each cell to get the value that its elevation is based on.
+     * @default null
+     */
+    getElevationValue?: AggregateAccessor<DataT> | null;
+    /**
+     * This callback will be called when bin color domain has been calculated.
+     * @default () => {}
+     */
+    onSetColorDomain?: (minMax: [number, number]) => void;
+    /**
+     * This callback will be called when bin elevation domain has been calculated.
+     * @default () => {}
+     */
+    onSetElevationDomain?: (minMax: [number, number]) => void;
+    /**
+     * (Experimental) Filter data objects
+     */
+    _filterData: null | ((d: DataT) => boolean);
+};
+export default class CPUGridLayer<DataT = any, ExtraPropsT = {}> extends AggregationLayer<ExtraPropsT & Required<_CPUGridLayerProps<DataT>>> {
+    static layerName: string;
+    static defaultProps: DefaultProps<CPUGridLayerProps<any>>;
+    initializeState(): void;
+    updateState(opts: UpdateParameters<this>): void;
+    getPickingInfo({ info }: GetPickingInfoParams): PickingInfo;
+    _onGetSublayerColor(cell: any): any;
+    _onGetSublayerElevation(cell: any): any;
+    _getSublayerUpdateTriggers(): any;
+    renderLayers(): Layer;
+}
+//# sourceMappingURL=cpu-grid-layer.d.ts.map

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

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