@deck.gl/aggregation-layers 9.0.40 → 9.1.0-beta.3

package/src/cpu-grid-layer/cpu-grid-layer.ts

@@ -1,329 +0,0 @@
-// 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 {GridCellLayer} from '@deck.gl/layers';
-import {Accessor, AccessorFunction, Color, Position, Material, DefaultProps} from '@deck.gl/core';
-
-import {defaultColorRange} from '../utils/color-utils';
-import {pointToDensityGridDataCPU} from './grid-aggregator';
-import CPUAggregator from '../utils/cpu-aggregator';
-import AggregationLayer, {AggregationLayerProps} from '../aggregation-layer';
-
-import {Layer, UpdateParameters, GetPickingInfoParams, PickingInfo} from '@deck.gl/core';
-import {AggregateAccessor} from '../types';
-
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-function nop() {}
-
-const defaultProps: DefaultProps<CPUGridLayerProps> = {
-  // 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: any) => x.position},
-  extruded: false,
-
-  // Optional material for 'lighting' shader module
-  material: true,
-
-  // data filter
-  _filterData: {type: 'function', value: null, optional: true}
-};
-
-/** All properties supported by CPUGridLayer. */
-export type CPUGridLayerProps<DataT = unknown> = _CPUGridLayerProps<DataT> &
-  AggregationLayerProps<DataT>;
-
-/** Properties added by CPUGridLayer. */
-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';
-
-  // TODO - document
-  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);
-};
-
-/** Aggregate data into a grid-based heatmap. Aggregation is performed on CPU. */
-export default class CPUGridLayer<
-  DataT = any,
-  ExtraPropsT extends {} = {}
-> extends AggregationLayer<DataT, ExtraPropsT & Required<_CPUGridLayerProps<DataT>>> {
-  static layerName = 'CPUGridLayer';
-  static defaultProps = defaultProps;
-
-  state!: AggregationLayer<DataT>['state'] & {
-    cpuAggregator: CPUAggregator;
-    aggregatorState: CPUAggregator['state'];
-  };
-
-  initializeState(): void {
-    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: 'float64', 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: UpdateParameters<this>) {
-    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}: GetPickingInfoParams): PickingInfo {
-    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(): Layer {
-    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
-      }
-    );
-  }
-}

package/src/cpu-grid-layer/grid-aggregator.ts

@@ -1,184 +0,0 @@
-// 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 {createIterable} from '@deck.gl/core';
-import {getGridOffset} from '../utils/grid-aggregation-utils';
-
-export type GridHash = {
-  [key: string]: {
-    count: number;
-    points: unknown[];
-    lonIdx: number;
-    latIdx: number;
-  };
-};
-
-/**
- * Calculate density grid from an array of points
- * @param {Object} props - object containing :
- * @param {Iterable} [props.data] - data objects to be aggregated
- * @param {Integer} [props.cellSize] - size of the grid cell
- *
- * @param {Object} aggregationParams - object containing :
- * @param {Object} gridOffset - {xOffset, yOffset} cell size in meters
- * @param {Integer} width - width of the grid
- * @param {Integer} height - height of the grid
- * @param {Boolean} projectPoints - `true` if doing screen space projection, `false` otherwise
- * @param {Array} attributes - attributes array containing position values
- * @param {Viewport} viewport - viewport to be used for projection
- * @param {Array} posOffset - [xOffset, yOffset] offset to be applied to positions to get cell index
- * @param {Object} boundingBox - {xMin, yMin, xMax, yMax} bounding box of input data
- *
- * @returns {object} - grid data, cell dimension
- */
-export function pointToDensityGridDataCPU(props, aggregationParams) {
-  const hashInfo = pointsToGridHashing(props, aggregationParams);
-  const result = getGridLayerDataFromGridHash(hashInfo);
-
-  return {
-    gridHash: hashInfo.gridHash,
-    gridOffset: hashInfo.gridOffset,
-    data: result
-  };
-}
-
-/**
- * Project points into each cell, return a hash table of cells
- * @param {Iterable} points
- * @param {number} cellSize - unit size in meters
- * @param {function} getPosition - position accessor
- * @returns {object} - grid hash and cell dimension
- */
-/* eslint-disable-next-line max-statements, complexity */
-function pointsToGridHashing(
-  props,
-  aggregationParams
-): {
-  gridHash: GridHash;
-  gridOffset: {xOffset: number; yOffset: number};
-  offsets: [number, number];
-} {
-  const {data = [], cellSize} = props;
-  const {attributes, viewport, projectPoints, numInstances} = aggregationParams;
-  const positions = attributes.positions.value;
-  const {size} = attributes.positions.getAccessor();
-  const boundingBox =
-    aggregationParams.boundingBox || getPositionBoundingBox(attributes.positions, numInstances);
-  const offsets = aggregationParams.posOffset || [180, 90];
-  const gridOffset = aggregationParams.gridOffset || getGridOffset(boundingBox, cellSize);
-
-  if (gridOffset.xOffset <= 0 || gridOffset.yOffset <= 0) {
-    return {gridHash: {}, gridOffset, offsets: [0, 0]};
-  }
-
-  const {width, height} = viewport;
-  const numCol = Math.ceil(width / gridOffset.xOffset);
-  const numRow = Math.ceil(height / gridOffset.yOffset);
-
-  // calculate count per cell
-  const gridHash = {};
-
-  const {iterable, objectInfo} = createIterable(data);
-  const position = new Array(3);
-  for (const pt of iterable) {
-    objectInfo.index++;
-    position[0] = positions[objectInfo.index * size];
-    position[1] = positions[objectInfo.index * size + 1];
-    position[2] = size >= 3 ? positions[objectInfo.index * size + 2] : 0;
-    const [x, y] = projectPoints ? viewport.project(position) : position;
-    if (Number.isFinite(x) && Number.isFinite(y)) {
-      const yIndex = Math.floor((y + offsets[1]) / gridOffset.yOffset);
-      const xIndex = Math.floor((x + offsets[0]) / gridOffset.xOffset);
-      if (
-        !projectPoints ||
-        // when doing screen space agggregation (projectPoints = true), filter points outside of the viewport range.
-        (xIndex >= 0 && xIndex < numCol && yIndex >= 0 && yIndex < numRow)
-      ) {
-        const key = `${yIndex}-${xIndex}`;
-
-        gridHash[key] = gridHash[key] || {count: 0, points: [], lonIdx: xIndex, latIdx: yIndex};
-        gridHash[key].count += 1;
-        gridHash[key].points.push({
-          source: pt,
-          index: objectInfo.index
-        });
-      }
-    }
-  }
-
-  return {gridHash, gridOffset, offsets: [offsets[0] * -1, offsets[1] * -1]};
-}
-/* eslint-enable max-statements, complexity */
-
-function getGridLayerDataFromGridHash({
-  gridHash,
-  gridOffset,
-  offsets
-}: {
-  gridHash: GridHash;
-  gridOffset: {xOffset: number; yOffset: number};
-  offsets: [number, number];
-}) {
-  const data = new Array(Object.keys(gridHash).length);
-  let i = 0;
-  for (const key in gridHash) {
-    const idxs = key.split('-');
-    const latIdx = parseInt(idxs[0], 10);
-    const lonIdx = parseInt(idxs[1], 10);
-    const index = i++;
-
-    data[index] = {
-      index,
-      position: [
-        offsets[0] + gridOffset.xOffset * lonIdx,
-        offsets[1] + gridOffset.yOffset * latIdx
-      ],
-      ...gridHash[key]
-    };
-  }
-  return data;
-}
-
-// Calculate bounding box of position attribute
-function getPositionBoundingBox(positionAttribute, numInstance) {
-  // TODO - value might not exist (e.g. attribute transition)
-  const positions = positionAttribute.value;
-  const {size} = positionAttribute.getAccessor();
-
-  let yMin = Infinity;
-  let yMax = -Infinity;
-  let xMin = Infinity;
-  let xMax = -Infinity;
-  let y;
-  let x;
-
-  for (let i = 0; i < numInstance; i++) {
-    x = positions[i * size];
-    y = positions[i * size + 1];
-    if (Number.isFinite(x) && Number.isFinite(y)) {
-      yMin = y < yMin ? y : yMin;
-      yMax = y > yMax ? y : yMax;
-      xMin = x < xMin ? x : xMin;
-      xMax = x > xMax ? x : xMax;
-    }
-  }
-
-  return {xMin, xMax, yMin, yMax};
-}

package/src/gpu-grid-layer/gpu-grid-cell-layer-fragment.glsl.ts

@@ -1,35 +0,0 @@
-// 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.
-
-export default `\
-#version 300 es
-#define SHADER_NAME gpu-grid-cell-layer-fragment-shader
-
-precision highp float;
-
-in vec4 vColor;
-
-out vec4 fragColor;
-
-void main(void) {
-  fragColor = vColor;
-  fragColor = picking_filterColor(fragColor);
-}
-`;

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

@@ -1,143 +0,0 @@
-// 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.
-
-// Inspired by screen-grid-layer vertex shader in deck.gl
-
-export default `\
-#version 300 es
-#define SHADER_NAME gpu-grid-cell-layer-vertex-shader
-#define RANGE_COUNT 6
-
-in vec3 positions;
-in vec3 normals;
-
-in vec4 colors;
-in vec4 elevations;
-in vec3 instancePickingColors;
-
-// Custom uniforms
-uniform vec2 offset;
-uniform bool extruded;
-uniform float cellSize;
-uniform float coverage;
-uniform float opacity;
-uniform float elevationScale;
-
-uniform ivec2 gridSize;
-uniform vec2 gridOrigin;
-uniform vec2 gridOriginLow;
-uniform vec2 gridOffset;
-uniform vec2 gridOffsetLow;
-uniform vec4 colorRange[RANGE_COUNT];
-uniform vec2 elevationRange;
-
-// Domain uniforms
-uniform vec2 colorDomain;
-uniform bool colorDomainValid;
-uniform vec2 elevationDomain;
-uniform bool elevationDomainValid;
-
-layout(std140) uniform;
-uniform ColorData
-{
-  vec4 maxMinCount;
-} colorData;
-uniform ElevationData
-{
-  vec4 maxMinCount;
-} elevationData;
-
-#define EPSILON 0.00001
-
-// Result
-out vec4 vColor;
-
-vec4 quantizeScale(vec2 domain, vec4 range[RANGE_COUNT], float value) {
-  vec4 outColor = vec4(0., 0., 0., 0.);
-  if (value >= (domain.x - EPSILON) && value <= (domain.y + EPSILON)) {
-    float domainRange = domain.y - domain.x;
-    if (domainRange <= 0.) {
-      outColor = colorRange[0];
-    } else {
-      float rangeCount = float(RANGE_COUNT);
-      float rangeStep = domainRange / rangeCount;
-      float idx = floor((value - domain.x) / rangeStep);
-      idx = clamp(idx, 0., rangeCount - 1.);
-      int intIdx = int(idx);
-      outColor = colorRange[intIdx];
-    }
-  }
-  return outColor;
-}
-
-float linearScale(vec2 domain, vec2 range, float value) {
-  if (value >= (domain.x - EPSILON) && value <= (domain.y + EPSILON)) {
-    return ((value - domain.x) / (domain.y - domain.x)) * (range.y - range.x) + range.x;
-  }
-  return -1.;
-}
-
-void main(void) {
-  vec2 clrDomain = colorDomainValid ? colorDomain : vec2(colorData.maxMinCount.a, colorData.maxMinCount.r);
-  vec4 color = quantizeScale(clrDomain, colorRange, colors.r);
-
-  float elevation = 0.0;
-
-  if (extruded) {
-    vec2 elvDomain = elevationDomainValid ? elevationDomain : vec2(elevationData.maxMinCount.a, elevationData.maxMinCount.r);
-    elevation = linearScale(elvDomain, elevationRange, elevations.r);
-    elevation = elevation  * (positions.z + 1.0) / 2.0 * elevationScale;
-  }
-
-  // if aggregated color or elevation is 0 do not render
-  float shouldRender = float(color.r > 0.0 && elevations.r >= 0.0);
-  float dotRadius = cellSize / 2. * coverage * shouldRender;
-
-  int yIndex = (gl_InstanceID / gridSize[0]);
-  int xIndex = gl_InstanceID - (yIndex * gridSize[0]);
-
-  vec2 instancePositionXFP64 = mul_fp64(vec2(gridOffset[0], gridOffsetLow[0]), vec2(float(xIndex), 0.));
-  instancePositionXFP64 = sum_fp64(instancePositionXFP64, vec2(gridOrigin[0], gridOriginLow[0]));
-  vec2 instancePositionYFP64 = mul_fp64(vec2(gridOffset[1], gridOffsetLow[1]), vec2(float(yIndex), 0.));
-  instancePositionYFP64 = sum_fp64(instancePositionYFP64, vec2(gridOrigin[1], gridOriginLow[1]));
-
-  vec3 centroidPosition = vec3(instancePositionXFP64[0], instancePositionYFP64[0], elevation);
-  vec3 centroidPosition64Low = vec3(instancePositionXFP64[1], instancePositionYFP64[1], 0.0);
-  geometry.worldPosition = centroidPosition;
-  vec3 pos = vec3(project_size(positions.xy + offset) * dotRadius, 0.);
-
-  // Set color to be rendered to picking fbo (also used to check for selection highlight).
-  picking_setPickingColor(instancePickingColors);
-
-  gl_Position = project_position_to_clipspace(centroidPosition, centroidPosition64Low, pos, geometry.position);
-
-  // Light calculations
-  // Worldspace is the linear space after Mercator projection
-
-  vec3 normals_commonspace = project_normal(normals);
-
-   if (extruded) {
-    vec3 lightColor = lighting_getLightColor(color.rgb, project_uCameraPosition, geometry.position.xyz, normals_commonspace);
-    vColor = vec4(lightColor, color.a * opacity) / 255.;
-  } else {
-    vColor = vec4(color.rgb, color.a * opacity) / 255.;
-  }
-}
-`;