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

package/src/contour-layer/contour-utils.ts

@@ -1,56 +1,87 @@
-import {getCode, getVertices, CONTOUR_TYPE} from './marching-squares';
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Color} from '@deck.gl/core';
+import {getCode, getLines, getPolygons} from './marching-squares';
+
+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;
+};
 
 // Given all the cell weights, generates contours for each threshold.
 /* eslint-disable max-depth */
 export function generateContours({
-  thresholdData,
-  cellWeights,
-  gridSize,
-  gridOrigin,
-  cellSize
+  contours,
+  getValue,
+  xRange,
+  yRange
 }: {
-  thresholdData: any;
-  cellWeights: Float32Array;
-  gridSize: number[];
-  gridOrigin: number[];
-  cellSize: number[];
+  contours: Contour[];
+  getValue: (x: number, y: number) => number;
+  xRange: [number, number];
+  yRange: [number, number];
 }) {
-  const contourSegments: {start: number[]; end: number[]; contour: any}[] = [];
-  const contourPolygons: {vertices: number[][]; contour: any}[] = [];
-  const width = gridSize[0];
-  const height = gridSize[1];
+  const contourLines: ContourLine[] = [];
+  const contourPolygons: ContourPolygon[] = [];
   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) as number[][][];
+          // ISO bands
+          const polygons = getPolygons(opts);
           for (const polygon of polygons) {
             contourPolygons[polygonIndex++] = {
               vertices: polygon,
@@ -58,13 +89,11 @@ export function generateContours({
             };
           }
         } else {
-          // Get the intersection vertices based on MarchingSquares code.
-          opts.type = CONTOUR_TYPE.ISO_LINES;
-          const vertices = getVertices(opts) as number[][];
-          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
             };
           }
@@ -72,6 +101,6 @@ export function generateContours({
       }
     }
   }
-  return {contourSegments, contourPolygons};
+  return {lines: contourLines, polygons: contourPolygons};
 }
 /* eslint-enable max-depth */

package/src/contour-layer/marching-squares-codes.ts

@@ -1,3 +1,7 @@
+// 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
 

package/src/contour-layer/marching-squares.ts

@@ -1,24 +1,19 @@
+// 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';
 
-export const CONTOUR_TYPE = {
-  ISO_LINES: 1,
-  ISO_BANDS: 2
-};
-
-const DEFAULT_THRESHOLD_DATA = {
-  zIndex: 0,
-  zOffset: 0.005
-};
-
 // Utility methods
 
 function getVertexCode(weight: number, threshold: number | number[]): number {
   // 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]) {
@@ -32,60 +27,71 @@ function getVertexCode(weight: number, threshold: number | number[]): number {
 
 // Returns marching square code for given cell
 /* eslint-disable complexity, max-statements*/
-export function getCode(opts) {
+export 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;
+} {
   // 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 {x, y, xRange, yRange, getValue, threshold} = opts;
 
-  const isLeftBoundary = x < 0;
-  const isRightBoundary = x >= width - 1;
-  const isBottomBoundary = y < 0;
-  const isTopBoundary = y >= height - 1;
+  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: Record<string, number> = {};
-  const codes: Record<string, number> = {};
+  let weights: number = 0;
+  let current: number;
+  let right: number;
+  let top: number;
+  let topRight: number;
 
   // 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;
@@ -99,10 +105,7 @@ 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};
 }
@@ -110,13 +113,15 @@ export function getCode(opts) {
 
 // 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: {
+  x: number;
+  y: number;
+  z: number;
+  code: number;
+  meanCode: number;
+}) {
+  const {x, y, z, code, meanCode} = opts;
+  let offsets: any = ISOBANDS_CODE_OFFSET_MAP[code];
 
   // handle saddle cases
   if (!Array.isArray(offsets)) {
@@ -124,49 +129,55 @@ export function getVertices(opts) {
   }
 
   // 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: number[][][] = [];
-    offsets.forEach(polygonOffsets => {
-      const polygon: number[][] = [];
-      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: number[][][] = [];
+  offsets.forEach(polygonOffsets => {
+    const polygon: number[][] = [];
+    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: {x: number; y: number; z: number; code: number; meanCode: number}) {
+  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: number[][] = [];
   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/src/contour-layer/value-reader.ts

@@ -0,0 +1,65 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Aggregator, CPUAggregator, WebGLAggregator} from '../common/aggregator/index';
+import type {TypedArray} from '@luma.gl/core';
+
+type ValueReader = (x: number, y: number) => number;
+
+/** Returns an accessor to the aggregated values from bin id */
+export function getAggregatorValueReader(opts: {
+  aggregator: Aggregator;
+  binIdRange: [number, number][];
+  channel: 0 | 1 | 2;
+}): ValueReader | null {
+  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: Float32Array,
+  binIdRange: [number, number][]
+): ValueReader {
+  const [[minX, maxX], [minY, maxY]] = binIdRange;
+  const width = maxX - minX;
+  const height = maxY - minY;
+  return (x: number, y: number) => {
+    x -= minX;
+    y -= minY;
+    if (x < 0 || x >= width || y < 0 || y >= height) {
+      return NaN;
+    }
+    return values[y * width + x];
+  };
+}
+
+function getCPUAggregatorValueReader(
+  values: TypedArray,
+  ids: TypedArray,
+  count: number
+): ValueReader {
+  const idMap: Record<string, Record<string, number>> = {};
+  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: number, y: number) => idMap[x]?.[y] ?? NaN;
+}

package/src/grid-layer/bin-options-uniforms.ts

@@ -0,0 +1,26 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {ShaderModule} from '@luma.gl/shadertools';
+
+const uniformBlock = /* glsl */ `\
+uniform binOptionsUniforms {
+  vec2 cellOriginCommon;
+  vec2 cellSizeCommon;
+} binOptions;
+`;
+
+export type BinOptions = {
+  cellOriginCommon: [number, number];
+  cellSizeCommon: [number, number];
+};
+
+export const binOptionsUniforms = {
+  name: 'binOptions',
+  vs: uniformBlock,
+  uniformTypes: {
+    cellOriginCommon: 'vec2<f32>',
+    cellSizeCommon: 'vec2<f32>'
+  }
+} as const satisfies ShaderModule<BinOptions>;

package/src/grid-layer/grid-cell-layer-vertex.glsl.ts

@@ -0,0 +1,68 @@
+// deck.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export default /* glsl */ `#version 300 es
+
+#define SHADER_NAME grid-cell-layer-vertex-shader
+
+in vec3 positions;
+in vec3 normals;
+
+in vec2 instancePositions;
+in float instanceElevationValues;
+in float instanceColorValues;
+in vec3 instancePickingColors;
+
+uniform sampler2D colorRange;
+
+// Result
+out vec4 vColor;
+
+float interp(float value, vec2 domain, vec2 range) {
+  float r = min(max((value - domain.x) / (domain.y - domain.x), 0.), 1.);
+  return mix(range.x, range.y, r);
+}
+
+vec4 interp(float value, vec2 domain, sampler2D range) {
+  float r = (value - domain.x) / (domain.y - domain.x);
+  return texture(range, vec2(r, 0.5));
+}
+
+void main(void) {
+  geometry.pickingColor = instancePickingColors;
+
+  if (isnan(instanceColorValues) ||
+    instanceColorValues < grid.colorDomain.z ||
+    instanceColorValues > grid.colorDomain.w ||
+    instanceElevationValues < grid.elevationDomain.z ||
+    instanceElevationValues > grid.elevationDomain.w
+  ) {
+    gl_Position = vec4(0.);
+    return;
+  }
+  
+  vec2 commonPosition = (instancePositions + (positions.xy + 1.0) / 2.0 * column.coverage) * grid.sizeCommon + grid.originCommon - project.commonOrigin.xy;
+  geometry.position = vec4(commonPosition, 0.0, 1.0);
+  geometry.normal = project_normal(normals);
+
+  // calculate z, if 3d not enabled set to 0
+  float elevation = 0.0;
+  if (column.extruded) {
+    elevation = interp(instanceElevationValues, grid.elevationDomain.xy, grid.elevationRange);
+    elevation = project_size(elevation);
+    // cylindar gemoetry height are between -1.0 to 1.0, transform it to between 0, 1
+    geometry.position.z = (positions.z + 1.0) / 2.0 * elevation;
+  }
+
+  gl_Position = project_common_position_to_clipspace(geometry.position);
+  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+
+  vColor = interp(instanceColorValues, grid.colorDomain.xy, colorRange);
+  vColor.a *= layer.opacity;
+  if (column.extruded) {
+    vColor.rgb = lighting_getLightColor(vColor.rgb, project.cameraPosition, geometry.position.xyz, geometry.normal);
+  }
+  DECKGL_FILTER_COLOR(vColor, geometry);
+}
+`;