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

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

@@ -1,147 +0,0 @@
-// 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.js

@@ -1,129 +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 GL from '@luma.gl/constants';
-import { GridCellLayer } from '@deck.gl/layers';
-import { defaultColorRange } from '../utils/color-utils';
-import { pointToDensityGridDataCPU } from './grid-aggregator';
-import CPUAggregator from '../utils/cpu-aggregator';
-import AggregationLayer from '../aggregation-layer';
-// eslint-disable-next-line @typescript-eslint/no-empty-function
-function nop() { }
-const defaultProps = {
-    // color
-    colorDomain: null,
-    colorRange: defaultColorRange,
-    getColorValue: { type: 'accessor', value: null },
-    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 },
-    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 }
-};
-export default class CPUGridLayer extends AggregationLayer {
-    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
-        });
-    }
-}
-CPUGridLayer.layerName = 'CPUGridLayer';
-CPUGridLayer.defaultProps = defaultProps;

package/typed/cpu-grid-layer/grid-aggregator.js

@@ -1,141 +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';
-/**
- * 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 max-statements, complexity */
-function pointsToGridHashing(props, aggregationParams) {
-    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 };
-    }
-    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 }) {
-    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/typed/gpu-grid-layer/gpu-grid-cell-layer-fragment.glsl.js

@@ -1,34 +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/typed/gpu-grid-layer/gpu-grid-cell-layer-vertex.glsl.js

@@ -1,141 +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.;
-  }
-}
-`;