@deck.gl/aggregation-layers 8.8.7 → 8.9.0-alpha.2

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;
+    }
+}