@deck.gl/aggregation-layers 8.8.0-beta.3 → 8.8.0

package/typed/utils/grid-aggregation-utils.js

@@ -0,0 +1,114 @@
+import { log, COORDINATE_SYSTEM } from '@deck.gl/core';
+const R_EARTH = 6378000;
+function toFinite(n) {
+    return Number.isFinite(n) ? n : 0;
+}
+// Parse input data to build positions, wights and bounding box.
+/* eslint-disable max-statements */
+export function getBoundingBox(attributes, vertexCount) {
+    // TODO - value might not exist (e.g. attribute transition)
+    const positions = attributes.positions.value;
+    let yMin = Infinity;
+    let yMax = -Infinity;
+    let xMin = Infinity;
+    let xMax = -Infinity;
+    let y;
+    let x;
+    for (let i = 0; i < vertexCount; i++) {
+        x = positions[i * 3];
+        y = positions[i * 3 + 1];
+        yMin = y < yMin ? y : yMin;
+        yMax = y > yMax ? y : yMax;
+        xMin = x < xMin ? x : xMin;
+        xMax = x > xMax ? x : xMax;
+    }
+    const boundingBox = {
+        xMin: toFinite(xMin),
+        xMax: toFinite(xMax),
+        yMin: toFinite(yMin),
+        yMax: toFinite(yMax)
+    };
+    return boundingBox;
+}
+/* eslint-enable max-statements */
+// Returns XY translation for positions to peform aggregation in +ve sapce
+function getTranslation(boundingBox, gridOffset, coordinateSystem, viewport) {
+    const { width, height } = viewport;
+    // Origin to define grid
+    // DEFAULT coordinate system is treated as LNGLAT
+    const worldOrigin = coordinateSystem === COORDINATE_SYSTEM.CARTESIAN ? [-width / 2, -height / 2] : [-180, -90];
+    // Other coordinate systems not supported/verified yet
+    log.assert(coordinateSystem === COORDINATE_SYSTEM.CARTESIAN ||
+        coordinateSystem === COORDINATE_SYSTEM.LNGLAT ||
+        coordinateSystem === COORDINATE_SYSTEM.DEFAULT);
+    const { xMin, yMin } = boundingBox;
+    return [
+        // Align origin to match grid cell boundaries in CPU and GPU aggregations
+        -1 * (alignToCell(xMin - worldOrigin[0], gridOffset.xOffset) + worldOrigin[0]),
+        -1 * (alignToCell(yMin - worldOrigin[1], gridOffset.yOffset) + worldOrigin[1])
+    ];
+}
+// Aligns `inValue` to given `cellSize`
+export function alignToCell(inValue, cellSize) {
+    const sign = inValue < 0 ? -1 : 1;
+    let value = sign < 0 ? Math.abs(inValue) + cellSize : Math.abs(inValue);
+    value = Math.floor(value / cellSize) * cellSize;
+    return value * sign;
+}
+/**
+ * Based on geometric center of sample points, calculate cellSize in lng/lat (degree) space
+ * @param {object} boundingBox - {xMin, yMin, xMax, yMax} contains bounding box of data
+ * @param {number} cellSize - grid cell size in meters
+ * @param {boolean, optional} converToDegrees - when true offsets are converted from meters to lng/lat (degree) space
+ * @returns {xOffset, yOffset} - cellSize size
+ */
+export function getGridOffset(boundingBox, cellSize, convertToMeters = true) {
+    if (!convertToMeters) {
+        return { xOffset: cellSize, yOffset: cellSize };
+    }
+    const { yMin, yMax } = boundingBox;
+    const centerLat = (yMin + yMax) / 2;
+    return calculateGridLatLonOffset(cellSize, centerLat);
+}
+export function getGridParams(boundingBox, cellSize, viewport, coordinateSystem) {
+    const gridOffset = getGridOffset(boundingBox, cellSize, coordinateSystem !== COORDINATE_SYSTEM.CARTESIAN);
+    const translation = getTranslation(boundingBox, gridOffset, coordinateSystem, viewport);
+    const { xMin, yMin, xMax, yMax } = boundingBox;
+    const width = xMax - xMin + gridOffset.xOffset;
+    const height = yMax - yMin + gridOffset.yOffset;
+    const numCol = Math.ceil(width / gridOffset.xOffset);
+    const numRow = Math.ceil(height / gridOffset.yOffset);
+    return { gridOffset, translation, width, height, numCol, numRow };
+}
+/**
+ * calculate grid layer cell size in lat lon based on world unit size
+ * and current latitude
+ * @param {number} cellSize
+ * @param {number} latitude
+ * @returns {object} - lat delta and lon delta
+ */
+function calculateGridLatLonOffset(cellSize, latitude) {
+    const yOffset = calculateLatOffset(cellSize);
+    const xOffset = calculateLonOffset(latitude, cellSize);
+    return { yOffset, xOffset };
+}
+/**
+ * with a given x-km change, calculate the increment of latitude
+ * based on stackoverflow http://stackoverflow.com/questions/7477003
+ * @param {number} dy - change in km
+ * @return {number} - increment in latitude
+ */
+function calculateLatOffset(dy) {
+    return (dy / R_EARTH) * (180 / Math.PI);
+}
+/**
+ * with a given x-km change, and current latitude
+ * calculate the increment of longitude
+ * based on stackoverflow http://stackoverflow.com/questions/7477003
+ * @param {number} lat - latitude of current location (based on city)
+ * @param {number} dx - change in km
+ * @return {number} - increment in longitude
+ */
+function calculateLonOffset(lat, dx) {
+    return ((dx / R_EARTH) * (180 / Math.PI)) / Math.cos((lat * Math.PI) / 180);
+}

package/typed/utils/prop-utils.js

@@ -0,0 +1,28 @@
+// Copyright (c) 2015 - 2019 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 function filterProps(props, filterKeys) {
+    const filteredProps = {};
+    for (const key in props) {
+        if (!filterKeys.includes(key)) {
+            filteredProps[key] = props[key];
+        }
+    }
+    return filteredProps;
+}

package/typed/utils/resource-utils.js

@@ -0,0 +1,40 @@
+import GL from '@luma.gl/constants';
+import { Framebuffer, Texture2D, isWebGL2 } from '@luma.gl/core';
+const DEFAULT_PARAMETERS = {
+    [GL.TEXTURE_MAG_FILTER]: GL.NEAREST,
+    [GL.TEXTURE_MIN_FILTER]: GL.NEAREST
+};
+export function getFloatTexture(gl, opts = {}) {
+    const { width = 1, height = 1, data = null, unpackFlipY = true, parameters = DEFAULT_PARAMETERS } = opts;
+    const texture = new Texture2D(gl, {
+        data,
+        format: isWebGL2(gl) ? GL.RGBA32F : GL.RGBA,
+        type: GL.FLOAT,
+        border: 0,
+        mipmaps: false,
+        parameters,
+        dataFormat: GL.RGBA,
+        width,
+        height,
+        unpackFlipY
+    });
+    return texture;
+}
+export function getFramebuffer(gl, opts) {
+    const { id, width = 1, height = 1, texture } = opts;
+    const fb = new Framebuffer(gl, {
+        id,
+        width,
+        height,
+        attachments: {
+            [GL.COLOR_ATTACHMENT0]: texture
+        }
+    });
+    return fb;
+}
+export function getFloatArray(array, size, fillValue = 0) {
+    if (!array || array.length < size) {
+        return new Float32Array(size).fill(fillValue);
+    }
+    return array;
+}

package/typed/utils/scale-utils.js

@@ -0,0 +1,184 @@
+// 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 { log } from '@deck.gl/core';
+// a scale function wrapper just like d3-scales
+export function getScale(domain, range, scaleFunction) {
+    const scale = scaleFunction;
+    scale.domain = () => domain;
+    scale.range = () => range;
+    return scale;
+}
+// Quantize scale is similar to linear scales,
+// except it uses a discrete rather than continuous range
+// return a quantize scale function
+export function getQuantizeScale(domain, range) {
+    const scaleFunction = value => quantizeScale(domain, range, value);
+    return getScale(domain, range, scaleFunction);
+}
+// return a linear scale function
+export function getLinearScale(domain, range) {
+    const scaleFunction = value => linearScale(domain, range, value);
+    return getScale(domain, range, scaleFunction);
+}
+export function getQuantileScale(domain, range) {
+    // calculate threshold
+    const sortedDomain = domain.sort(ascending);
+    let i = 0;
+    const n = Math.max(1, range.length);
+    const thresholds = new Array(n - 1);
+    while (++i < n) {
+        thresholds[i - 1] = threshold(sortedDomain, i / n);
+    }
+    const scaleFunction = value => thresholdsScale(thresholds, range, value);
+    scaleFunction.thresholds = () => thresholds;
+    return getScale(domain, range, scaleFunction);
+}
+function ascending(a, b) {
+    return a - b;
+}
+function threshold(domain, fraction) {
+    const domainLength = domain.length;
+    if (fraction <= 0 || domainLength < 2) {
+        return domain[0];
+    }
+    if (fraction >= 1) {
+        return domain[domainLength - 1];
+    }
+    const domainFraction = (domainLength - 1) * fraction;
+    const lowIndex = Math.floor(domainFraction);
+    const low = domain[lowIndex];
+    const high = domain[lowIndex + 1];
+    return low + (high - low) * (domainFraction - lowIndex);
+}
+function bisectRight(a, x) {
+    let lo = 0;
+    let hi = a.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        if (ascending(a[mid], x) > 0) {
+            hi = mid;
+        }
+        else {
+            lo = mid + 1;
+        }
+    }
+    return lo;
+}
+// return a quantize scale function
+function thresholdsScale(thresholds, range, value) {
+    return range[bisectRight(thresholds, value)];
+}
+// ordinal Scale
+function ordinalScale(domain, domainMap, range, value) {
+    const key = `${value}`;
+    let d = domainMap.get(key);
+    if (d === undefined) {
+        // update the domain
+        d = domain.push(value);
+        domainMap.set(key, d);
+    }
+    return range[(d - 1) % range.length];
+}
+export function getOrdinalScale(domain, range) {
+    const domainMap = new Map();
+    const uniqueDomain = [];
+    for (const d of domain) {
+        const key = `${d}`;
+        if (!domainMap.has(key)) {
+            domainMap.set(key, uniqueDomain.push(d));
+        }
+    }
+    const scaleFunction = value => ordinalScale(uniqueDomain, domainMap, range, value);
+    return getScale(domain, range, scaleFunction);
+}
+// Quantize scale is similar to linear scales,
+// except it uses a discrete rather than continuous range
+export function quantizeScale(domain, range, value) {
+    const domainRange = domain[1] - domain[0];
+    if (domainRange <= 0) {
+        log.warn('quantizeScale: invalid domain, returning range[0]')();
+        return range[0];
+    }
+    const step = domainRange / range.length;
+    const idx = Math.floor((value - domain[0]) / step);
+    const clampIdx = Math.max(Math.min(idx, range.length - 1), 0);
+    return range[clampIdx];
+}
+// Linear scale maps continuous domain to continuous range
+export function linearScale(domain, range, value) {
+    return ((value - domain[0]) / (domain[1] - domain[0])) * (range[1] - range[0]) + range[0];
+}
+// get scale domains
+function notNullOrUndefined(d) {
+    return d !== undefined && d !== null;
+}
+export function unique(values) {
+    const results = [];
+    values.forEach(v => {
+        if (!results.includes(v) && notNullOrUndefined(v)) {
+            results.push(v);
+        }
+    });
+    return results;
+}
+function getTruthyValues(data, valueAccessor) {
+    const values = typeof valueAccessor === 'function' ? data.map(valueAccessor) : data;
+    return values.filter(notNullOrUndefined);
+}
+export function getLinearDomain(data, valueAccessor) {
+    const sorted = getTruthyValues(data, valueAccessor).sort();
+    return sorted.length ? [sorted[0], sorted[sorted.length - 1]] : [0, 0];
+}
+export function getQuantileDomain(data, valueAccessor) {
+    return getTruthyValues(data, valueAccessor);
+}
+export function getOrdinalDomain(data, valueAccessor) {
+    return unique(getTruthyValues(data, valueAccessor));
+}
+export function getScaleDomain(scaleType, data, valueAccessor) {
+    switch (scaleType) {
+        case 'quantize':
+        case 'linear':
+            return getLinearDomain(data, valueAccessor);
+        case 'quantile':
+            return getQuantileDomain(data, valueAccessor);
+        case 'ordinal':
+            return getOrdinalDomain(data, valueAccessor);
+        default:
+            return getLinearDomain(data, valueAccessor);
+    }
+}
+export function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+export function getScaleFunctionByScaleType(scaleType) {
+    switch (scaleType) {
+        case 'quantize':
+            return getQuantizeScale;
+        case 'linear':
+            return getLinearScale;
+        case 'quantile':
+            return getQuantileScale;
+        case 'ordinal':
+            return getOrdinalScale;
+        default:
+            return getQuantizeScale;
+    }
+}

package/dist/es5/aggregation-layer.md

@@ -1,54 +0,0 @@
-# AggregationLayer
-
-All of the layers in `@deck.gl/aggregation-layers` module perform some sort of data aggregation. All these layers perform aggregation with different parameters (CPU vs GPU, aggregation to rectangular bins vs hexagon bins, world space vs screen space, aggregation of single weight vs multiple weights etc).
-
-`AggregationLayer` and `GridAggregationLayer` perform most of the common tasks for aggregation with flexibility of customizations. This document describes what `AggregationLayer` does and how to use it in other aggregation layers.
-
-
-`AggregationLayer` is subclassed form `CompositeLayer` and all layers in `@deck.gl/aggregation-layers` are subclassed from this Layer.
-
-## Integration with `AttributeManager`
-
-This layer creates `AttributeManager` and makes it available for its subclasses. Any aggregation layer can add attributes to the `AttributeManager` and retrieve them using `getAttributes` method. This enables using `AttributeManager`'s features and optimization for using attributes. Also manual iteration of `data` prop can be removed and attributes can be directly set on GPU aggregation models or accessed directly for CPU aggregation.
-
-Example: Adding attributes to an aggregation layer
-
-```
-const attributeManager = this.getAttributeManager();
-attributeManager.add({
-  positions: {size: 3, accessor: 'getPosition'},
-  color: {size: 3, accessor: 'getColorWeight'},
-  elevation: {size: 3, accessor: 'getElevationWeight'}
-});
-```
-
-## updateState()
-
-During update state, Subclasses of `AggregationLayer` must first call 'super.updateState()', which calls
-
-- `updateShaders(shaders)` : Subclasses can override this if they need to update shaders, for example, when performing GPU aggregation, aggregation shaders must be merged with argument of this function  to correctly apply `extensions`.
-
-- `_updateAttributes`: This checks and updates attributes based on updated props.
-
-## Checking if aggregation is dirty
-
-### Dimensions
-
-Typical aggregation, involves :
-1. Group the input data points into bins
-2. Compute the aggregated value for each bin
-
-For example, when `cellSize` or `data` is changed, layer needs to perform both `1` and `2` steps, when a parameter affecting a bin's value is changed (like `getWeight` accessor), layer only need to perform step `2`.
-
-When doing CPU Aggregation, both above steps are performed individually. But for GPU aggregation, both are merged into single render call.
-
-To support what state is dirty, constructor takes `dimensions` object, which contains, several keyed dimensions. It must contain `data` dimension that defines, when re-aggregation needs to be performed.
-
-### isAggregationDirty()
-
-This helper can be used if a dimension is changed. Sublayers can defined custom dimensions and call this method to check if a dimension is changed.
-
-
-### isAttributeChanged()
-
-`AggregationLayer` tracks what attributes are changed in each update cycle. Super classes can use `isAttributeChanged()` method to check if a specific attribute is changed or any attribute is changed.

package/dist/es5/grid-aggregation-layer.md

@@ -1,46 +0,0 @@
-# GridAggregationLayer
-
-This layer performs some common tasks required to perform aggregation to grid cells, especially it takes care of deciding CPU vs GPU aggregation, allocating resources for GPU aggregation and uploading results.
-
-This in an abstract layer, subclassed form `AggregationLayer`, `GPUGridLayer`, `ScreenGridLayer` and `ContourLayer` are subclassed from this layer.
-
-## updateState()
-
-During `updateState()`, it calls `updateAggregationState()` which sub classes must implement. During this method, sub classes must set following aggregation flags and aggregation params.
-
-### Aggregation Flags
-
-* `gpuAggregation`: When `true` aggregation happens on GPU, otherwise on CPU.
-* `aggregationDataDirty` : When `true` data is re-aggregated.
-* `aggregationWeightsDirty` : This flag is applicable only for CPU aggregation. When `true`, bin's aggregated values are re computed.
-
-## Aggregation Parameters
-
-* `gridOffset` : Grid's cell size in the format {xOffset, yOffset}.
-* `projectPoints` : Should be `true` when doing screen space aggregation, when `false` it implies world space aggregation.
-* `attributes` : Layer's current set of attributes which provide position and weights to CPU/GPU aggregators.
-* `viewport` : current viewport object.
-* `posOffset` : Offset to be added to object's position before aggregating.
-* `boundingBox` : Bounding box of the input data.
-Following are applicable for GPU aggregation only:
-* `translation` : [xTranslation, yTranslation], position translation to be applied on positions.
-* `scaling` : [xScale, yScale, flag], scaling to be applied on positions. When scaling not needed `flag` should be set to `0`.
-* `vertexCount` : Number of objects to be aggregated.
-* `moduleSettings` : Object with set of fields required for applying shader modules.
-
-
-## updateResults()
-
-When aggregation performed on CPU, aggregation result is in JS Array objects. Subclasses can override this method to consume aggregation data. This method is called with an object with following fields:
-  * `aggregationData` (*Float32Array*) - Array containing aggregation data per grid cell. Four elements per grid cell in the format `[value, 0, 0, count]`, where `value` is the aggregated weight value, up to 3 different weights. `count` is the number of objects aggregated to the grid cell.
-  * `maxMinData` (*Float32Array*) - Array with four values in format, `[maxValue, 0, 0, minValue]`, where `maxValue` is max of all aggregated cells.
-  * `maxData` (*Float32Array*) - Array with four values in format, `[maxValue, 0, 0, count]`, where `maxValue` is max of all aggregated cells and `count` is total number aggregated objects.
-  * `minData` (*Float32Array*) - Array with four values in format, `[minValue, 0, 0, count]`, where `minValue` is min of all aggregated cells and `count` is total number aggregated objects.
-
-  NOTE: The goal is to match format of CPU aggregation results to that of GPU aggregation, so consumers of this data (Sublayers) don't have to change.
-
-## allocateResources()
-
-Called with following arguments to allocated resources required to hold aggregation results.
-  * `numRow` (*Number*) - Number of rows in the grid.
-  * `numCol` (*Number*) - Number of columns in the grid.

package/dist/esm/aggregation-layer.md

@@ -1,54 +0,0 @@
-# AggregationLayer
-
-All of the layers in `@deck.gl/aggregation-layers` module perform some sort of data aggregation. All these layers perform aggregation with different parameters (CPU vs GPU, aggregation to rectangular bins vs hexagon bins, world space vs screen space, aggregation of single weight vs multiple weights etc).
-
-`AggregationLayer` and `GridAggregationLayer` perform most of the common tasks for aggregation with flexibility of customizations. This document describes what `AggregationLayer` does and how to use it in other aggregation layers.
-
-
-`AggregationLayer` is subclassed form `CompositeLayer` and all layers in `@deck.gl/aggregation-layers` are subclassed from this Layer.
-
-## Integration with `AttributeManager`
-
-This layer creates `AttributeManager` and makes it available for its subclasses. Any aggregation layer can add attributes to the `AttributeManager` and retrieve them using `getAttributes` method. This enables using `AttributeManager`'s features and optimization for using attributes. Also manual iteration of `data` prop can be removed and attributes can be directly set on GPU aggregation models or accessed directly for CPU aggregation.
-
-Example: Adding attributes to an aggregation layer
-
-```
-const attributeManager = this.getAttributeManager();
-attributeManager.add({
-  positions: {size: 3, accessor: 'getPosition'},
-  color: {size: 3, accessor: 'getColorWeight'},
-  elevation: {size: 3, accessor: 'getElevationWeight'}
-});
-```
-
-## updateState()
-
-During update state, Subclasses of `AggregationLayer` must first call 'super.updateState()', which calls
-
-- `updateShaders(shaders)` : Subclasses can override this if they need to update shaders, for example, when performing GPU aggregation, aggregation shaders must be merged with argument of this function  to correctly apply `extensions`.
-
-- `_updateAttributes`: This checks and updates attributes based on updated props.
-
-## Checking if aggregation is dirty
-
-### Dimensions
-
-Typical aggregation, involves :
-1. Group the input data points into bins
-2. Compute the aggregated value for each bin
-
-For example, when `cellSize` or `data` is changed, layer needs to perform both `1` and `2` steps, when a parameter affecting a bin's value is changed (like `getWeight` accessor), layer only need to perform step `2`.
-
-When doing CPU Aggregation, both above steps are performed individually. But for GPU aggregation, both are merged into single render call.
-
-To support what state is dirty, constructor takes `dimensions` object, which contains, several keyed dimensions. It must contain `data` dimension that defines, when re-aggregation needs to be performed.
-
-### isAggregationDirty()
-
-This helper can be used if a dimension is changed. Sublayers can defined custom dimensions and call this method to check if a dimension is changed.
-
-
-### isAttributeChanged()
-
-`AggregationLayer` tracks what attributes are changed in each update cycle. Super classes can use `isAttributeChanged()` method to check if a specific attribute is changed or any attribute is changed.

package/dist/esm/grid-aggregation-layer.md

@@ -1,46 +0,0 @@
-# GridAggregationLayer
-
-This layer performs some common tasks required to perform aggregation to grid cells, especially it takes care of deciding CPU vs GPU aggregation, allocating resources for GPU aggregation and uploading results.
-
-This in an abstract layer, subclassed form `AggregationLayer`, `GPUGridLayer`, `ScreenGridLayer` and `ContourLayer` are subclassed from this layer.
-
-## updateState()
-
-During `updateState()`, it calls `updateAggregationState()` which sub classes must implement. During this method, sub classes must set following aggregation flags and aggregation params.
-
-### Aggregation Flags
-
-* `gpuAggregation`: When `true` aggregation happens on GPU, otherwise on CPU.
-* `aggregationDataDirty` : When `true` data is re-aggregated.
-* `aggregationWeightsDirty` : This flag is applicable only for CPU aggregation. When `true`, bin's aggregated values are re computed.
-
-## Aggregation Parameters
-
-* `gridOffset` : Grid's cell size in the format {xOffset, yOffset}.
-* `projectPoints` : Should be `true` when doing screen space aggregation, when `false` it implies world space aggregation.
-* `attributes` : Layer's current set of attributes which provide position and weights to CPU/GPU aggregators.
-* `viewport` : current viewport object.
-* `posOffset` : Offset to be added to object's position before aggregating.
-* `boundingBox` : Bounding box of the input data.
-Following are applicable for GPU aggregation only:
-* `translation` : [xTranslation, yTranslation], position translation to be applied on positions.
-* `scaling` : [xScale, yScale, flag], scaling to be applied on positions. When scaling not needed `flag` should be set to `0`.
-* `vertexCount` : Number of objects to be aggregated.
-* `moduleSettings` : Object with set of fields required for applying shader modules.
-
-
-## updateResults()
-
-When aggregation performed on CPU, aggregation result is in JS Array objects. Subclasses can override this method to consume aggregation data. This method is called with an object with following fields:
-  * `aggregationData` (*Float32Array*) - Array containing aggregation data per grid cell. Four elements per grid cell in the format `[value, 0, 0, count]`, where `value` is the aggregated weight value, up to 3 different weights. `count` is the number of objects aggregated to the grid cell.
-  * `maxMinData` (*Float32Array*) - Array with four values in format, `[maxValue, 0, 0, minValue]`, where `maxValue` is max of all aggregated cells.
-  * `maxData` (*Float32Array*) - Array with four values in format, `[maxValue, 0, 0, count]`, where `maxValue` is max of all aggregated cells and `count` is total number aggregated objects.
-  * `minData` (*Float32Array*) - Array with four values in format, `[minValue, 0, 0, count]`, where `minValue` is min of all aggregated cells and `count` is total number aggregated objects.
-
-  NOTE: The goal is to match format of CPU aggregation results to that of GPU aggregation, so consumers of this data (Sublayers) don't have to change.
-
-## allocateResources()
-
-Called with following arguments to allocated resources required to hold aggregation results.
-  * `numRow` (*Number*) - Number of rows in the grid.
-  * `numCol` (*Number*) - Number of columns in the grid.

package/src/aggregation-layer.md

@@ -1,54 +0,0 @@
-# AggregationLayer
-
-All of the layers in `@deck.gl/aggregation-layers` module perform some sort of data aggregation. All these layers perform aggregation with different parameters (CPU vs GPU, aggregation to rectangular bins vs hexagon bins, world space vs screen space, aggregation of single weight vs multiple weights etc).
-
-`AggregationLayer` and `GridAggregationLayer` perform most of the common tasks for aggregation with flexibility of customizations. This document describes what `AggregationLayer` does and how to use it in other aggregation layers.
-
-
-`AggregationLayer` is subclassed form `CompositeLayer` and all layers in `@deck.gl/aggregation-layers` are subclassed from this Layer.
-
-## Integration with `AttributeManager`
-
-This layer creates `AttributeManager` and makes it available for its subclasses. Any aggregation layer can add attributes to the `AttributeManager` and retrieve them using `getAttributes` method. This enables using `AttributeManager`'s features and optimization for using attributes. Also manual iteration of `data` prop can be removed and attributes can be directly set on GPU aggregation models or accessed directly for CPU aggregation.
-
-Example: Adding attributes to an aggregation layer
-
-```
-const attributeManager = this.getAttributeManager();
-attributeManager.add({
-  positions: {size: 3, accessor: 'getPosition'},
-  color: {size: 3, accessor: 'getColorWeight'},
-  elevation: {size: 3, accessor: 'getElevationWeight'}
-});
-```
-
-## updateState()
-
-During update state, Subclasses of `AggregationLayer` must first call 'super.updateState()', which calls
-
-- `updateShaders(shaders)` : Subclasses can override this if they need to update shaders, for example, when performing GPU aggregation, aggregation shaders must be merged with argument of this function  to correctly apply `extensions`.
-
-- `_updateAttributes`: This checks and updates attributes based on updated props.
-
-## Checking if aggregation is dirty
-
-### Dimensions
-
-Typical aggregation, involves :
-1. Group the input data points into bins
-2. Compute the aggregated value for each bin
-
-For example, when `cellSize` or `data` is changed, layer needs to perform both `1` and `2` steps, when a parameter affecting a bin's value is changed (like `getWeight` accessor), layer only need to perform step `2`.
-
-When doing CPU Aggregation, both above steps are performed individually. But for GPU aggregation, both are merged into single render call.
-
-To support what state is dirty, constructor takes `dimensions` object, which contains, several keyed dimensions. It must contain `data` dimension that defines, when re-aggregation needs to be performed.
-
-### isAggregationDirty()
-
-This helper can be used if a dimension is changed. Sublayers can defined custom dimensions and call this method to check if a dimension is changed.
-
-
-### isAttributeChanged()
-
-`AggregationLayer` tracks what attributes are changed in each update cycle. Super classes can use `isAttributeChanged()` method to check if a specific attribute is changed or any attribute is changed.