@deck.gl/aggregation-layers 8.7.0-alpha.2 → 8.7.0-alpha.9

package/dist/es5/grid-aggregation-layer.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/grid-aggregation-layer.js"],"names":["GridAggregationLayer","AggregationLayer","initializeState","dimensions","gl","context","setState","layerData","gpuGridAggregator","GPUGridAggregator","id","cpuGridAggregator","pointToDensityGridDataCPU","updateState","opts","updateAggregationState","aggregationDataDirty","aggregationWeightsDirty","gpuAggregation","state","getNumInstances","aggregationDirty","_updateAggregation","_updateWeightBins","_uploadAggregationResults","finalizeState","count","weights","aggregationBuffer","delete","updateShaders","shaders","log","assert","allocateResources","numRow","numCol","dataBytes","name","weight","Buffer","byteLength","accessor","size","type","divisor","updateResults","aggregationData","maxMinData","maxData","minData","gridOffset","posOffset","translation","scaling","boundingBox","projectPoints","props","viewport","attributes","getAttributes","vertexCount","result","run","cellSize","xOffset","yOffset","moduleSettings","getModuleSettings","getValue","sortedBins","BinSorter","data","aggregatedBins","minValue","maxValue","totalCount","ELEMENTCOUNT","aggregationSize","Float32Array","fill","bin","lonIdx","latIdx","i","value","counts","cellIndex","layerName"],"mappings":"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","sourcesContent":["// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport AggregationLayer from './aggregation-layer';\nimport GPUGridAggregator from './utils/gpu-grid-aggregation/gpu-grid-aggregator';\nimport {Buffer} from '@luma.gl/core';\nimport {log} from '@deck.gl/core';\nimport GL from '@luma.gl/constants';\nimport BinSorter from './utils/bin-sorter';\nimport {pointToDensityGridDataCPU} from './cpu-grid-layer/grid-aggregator';\n\nexport default class GridAggregationLayer extends AggregationLayer {\n  initializeState({dimensions}) {\n    const {gl} = this.context;\n    super.initializeState(dimensions);\n    this.setState({\n      // CPU aggregation results\n      layerData: {},\n      gpuGridAggregator: new GPUGridAggregator(gl, {id: `${this.id}-gpu-aggregator`}),\n      cpuGridAggregator: pointToDensityGridDataCPU\n    });\n  }\n\n  updateState(opts) {\n    // get current attributes\n    super.updateState(opts);\n\n    this.updateAggregationState(opts);\n\n    const {aggregationDataDirty, aggregationWeightsDirty, gpuAggregation} = this.state;\n    if (this.getNumInstances() <= 0) {\n      return;\n    }\n    let aggregationDirty = false;\n    // CPU aggregation is two steps\n    // 1. Create bins (based on cellSize and position) 2. Aggregate weights for each bin\n    // For GPU aggregation both above steps are combined into one step\n\n    // step-1\n    if (aggregationDataDirty || (gpuAggregation && aggregationWeightsDirty)) {\n      this._updateAggregation(opts);\n      aggregationDirty = true;\n    }\n    // step-2 (Applicalbe for CPU aggregation only)\n    if (!gpuAggregation && (aggregationDataDirty || aggregationWeightsDirty)) {\n      this._updateWeightBins();\n      this._uploadAggregationResults();\n      aggregationDirty = true;\n    }\n\n    this.setState({aggregationDirty});\n  }\n\n  finalizeState() {\n    const {count} = this.state.weights;\n    if (count && count.aggregationBuffer) {\n      count.aggregationBuffer.delete();\n    }\n    this.state.gpuGridAggregator?.delete();\n    super.finalizeState();\n  }\n\n  updateShaders(shaders) {\n    if (this.state.gpuAggregation) {\n      this.state.gpuGridAggregator.updateShaders(shaders);\n    }\n  }\n\n  // Methods that can be overriden by subclasses for customizations\n\n  updateAggregationState(opts) {\n    // Sublayers should implement this method.\n    log.assert(false);\n  }\n\n  allocateResources(numRow, numCol) {\n    if (this.state.numRow !== numRow || this.state.numCol !== numCol) {\n      const dataBytes = numCol * numRow * 4 * 4;\n      const gl = this.context.gl;\n      const {weights} = this.state;\n      for (const name in weights) {\n        const weight = weights[name];\n        if (weight.aggregationBuffer) {\n          weight.aggregationBuffer.delete();\n        }\n        weight.aggregationBuffer = new Buffer(gl, {\n          byteLength: dataBytes,\n          accessor: {\n            size: 4,\n            type: GL.FLOAT,\n            divisor: 1\n          }\n        });\n      }\n    }\n  }\n\n  updateResults({aggregationData, maxMinData, maxData, minData}) {\n    const {count} = this.state.weights;\n    if (count) {\n      count.aggregationData = aggregationData;\n      count.maxMinData = maxMinData;\n      count.maxData = maxData;\n      count.minData = minData;\n    }\n  }\n\n  // Private\n\n  _updateAggregation(opts) {\n    const {\n      cpuGridAggregator,\n      gpuGridAggregator,\n      gridOffset,\n      posOffset,\n      translation = [0, 0],\n      scaling = [0, 0, 0],\n      boundingBox,\n      projectPoints,\n      gpuAggregation,\n      numCol,\n      numRow\n    } = this.state;\n    const {props} = opts;\n    const {viewport} = this.context;\n    const attributes = this.getAttributes();\n    const vertexCount = this.getNumInstances();\n\n    if (!gpuAggregation) {\n      const result = cpuGridAggregator(props, {\n        gridOffset,\n        projectPoints,\n        attributes,\n        viewport,\n        posOffset,\n        boundingBox\n      });\n      this.setState({\n        layerData: result\n      });\n    } else {\n      const {weights} = this.state;\n      gpuGridAggregator.run({\n        weights,\n        cellSize: [gridOffset.xOffset, gridOffset.yOffset],\n        numCol,\n        numRow,\n        translation,\n        scaling,\n        vertexCount,\n        projectPoints,\n        attributes,\n        moduleSettings: this.getModuleSettings()\n      });\n    }\n  }\n\n  _updateWeightBins() {\n    const {getValue} = this.state;\n\n    const sortedBins = new BinSorter(this.state.layerData.data || [], {getValue});\n    this.setState({sortedBins});\n  }\n\n  _uploadAggregationResults() {\n    const {numCol, numRow} = this.state;\n    const {data} = this.state.layerData;\n    const {aggregatedBins, minValue, maxValue, totalCount} = this.state.sortedBins;\n\n    const ELEMENTCOUNT = 4;\n    const aggregationSize = numCol * numRow * ELEMENTCOUNT;\n    const aggregationData = new Float32Array(aggregationSize).fill(0);\n    for (const bin of aggregatedBins) {\n      const {lonIdx, latIdx} = data[bin.i];\n      const {value, counts} = bin;\n      const cellIndex = (lonIdx + latIdx * numCol) * ELEMENTCOUNT;\n      aggregationData[cellIndex] = value;\n      aggregationData[cellIndex + ELEMENTCOUNT - 1] = counts;\n    }\n    const maxMinData = new Float32Array([maxValue, 0, 0, minValue]);\n    const maxData = new Float32Array([maxValue, 0, 0, totalCount]);\n    const minData = new Float32Array([minValue, 0, 0, totalCount]);\n    this.updateResults({aggregationData, maxMinData, maxData, minData});\n  }\n}\n\nGridAggregationLayer.layerName = 'GridAggregationLayer';\n"],"file":"grid-aggregation-layer.js"}
+{"version":3,"sources":["../../src/grid-aggregation-layer.js"],"names":["GridAggregationLayer","dimensions","gl","context","setState","layerData","gpuGridAggregator","GPUGridAggregator","id","cpuGridAggregator","pointToDensityGridDataCPU","opts","updateAggregationState","state","aggregationDataDirty","aggregationWeightsDirty","gpuAggregation","getNumInstances","aggregationDirty","_updateAggregation","_updateWeightBins","_uploadAggregationResults","count","weights","aggregationBuffer","delete","shaders","updateShaders","log","assert","numRow","numCol","dataBytes","name","weight","Buffer","byteLength","accessor","size","type","divisor","aggregationData","maxMinData","maxData","minData","gridOffset","posOffset","translation","scaling","boundingBox","projectPoints","props","viewport","attributes","getAttributes","vertexCount","result","run","cellSize","xOffset","yOffset","moduleSettings","getModuleSettings","getValue","sortedBins","BinSorter","data","aggregatedBins","minValue","maxValue","totalCount","ELEMENTCOUNT","aggregationSize","Float32Array","fill","bin","i","lonIdx","latIdx","value","counts","cellIndex","updateResults","AggregationLayer","layerName"],"mappings":"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","sourcesContent":["// Copyright (c) 2015 - 2017 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport AggregationLayer from './aggregation-layer';\nimport GPUGridAggregator from './utils/gpu-grid-aggregation/gpu-grid-aggregator';\nimport {Buffer} from '@luma.gl/core';\nimport {log} from '@deck.gl/core';\nimport GL from '@luma.gl/constants';\nimport BinSorter from './utils/bin-sorter';\nimport {pointToDensityGridDataCPU} from './cpu-grid-layer/grid-aggregator';\n\nexport default class GridAggregationLayer extends AggregationLayer {\n  initializeState({dimensions}) {\n    const {gl} = this.context;\n    super.initializeState(dimensions);\n    this.setState({\n      // CPU aggregation results\n      layerData: {},\n      gpuGridAggregator: new GPUGridAggregator(gl, {id: `${this.id}-gpu-aggregator`}),\n      cpuGridAggregator: pointToDensityGridDataCPU\n    });\n  }\n\n  updateState(opts) {\n    // get current attributes\n    super.updateState(opts);\n\n    this.updateAggregationState(opts);\n\n    const {aggregationDataDirty, aggregationWeightsDirty, gpuAggregation} = this.state;\n    if (this.getNumInstances() <= 0) {\n      return;\n    }\n    let aggregationDirty = false;\n    // CPU aggregation is two steps\n    // 1. Create bins (based on cellSize and position) 2. Aggregate weights for each bin\n    // For GPU aggregation both above steps are combined into one step\n\n    // step-1\n    if (aggregationDataDirty || (gpuAggregation && aggregationWeightsDirty)) {\n      this._updateAggregation(opts);\n      aggregationDirty = true;\n    }\n    // step-2 (Applicalbe for CPU aggregation only)\n    if (!gpuAggregation && (aggregationDataDirty || aggregationWeightsDirty)) {\n      this._updateWeightBins();\n      this._uploadAggregationResults();\n      aggregationDirty = true;\n    }\n\n    this.setState({aggregationDirty});\n  }\n\n  finalizeState() {\n    const {count} = this.state.weights;\n    if (count && count.aggregationBuffer) {\n      count.aggregationBuffer.delete();\n    }\n    this.state.gpuGridAggregator?.delete();\n    super.finalizeState();\n  }\n\n  updateShaders(shaders) {\n    if (this.state.gpuAggregation) {\n      this.state.gpuGridAggregator.updateShaders(shaders);\n    }\n  }\n\n  // Methods that can be overriden by subclasses for customizations\n\n  updateAggregationState(opts) {\n    // Sublayers should implement this method.\n    log.assert(false);\n  }\n\n  allocateResources(numRow, numCol) {\n    if (this.state.numRow !== numRow || this.state.numCol !== numCol) {\n      const dataBytes = numCol * numRow * 4 * 4;\n      const gl = this.context.gl;\n      const {weights} = this.state;\n      for (const name in weights) {\n        const weight = weights[name];\n        if (weight.aggregationBuffer) {\n          weight.aggregationBuffer.delete();\n        }\n        weight.aggregationBuffer = new Buffer(gl, {\n          byteLength: dataBytes,\n          accessor: {\n            size: 4,\n            type: GL.FLOAT,\n            divisor: 1\n          }\n        });\n      }\n    }\n  }\n\n  updateResults({aggregationData, maxMinData, maxData, minData}) {\n    const {count} = this.state.weights;\n    if (count) {\n      count.aggregationData = aggregationData;\n      count.maxMinData = maxMinData;\n      count.maxData = maxData;\n      count.minData = minData;\n    }\n  }\n\n  // Private\n\n  _updateAggregation(opts) {\n    const {\n      cpuGridAggregator,\n      gpuGridAggregator,\n      gridOffset,\n      posOffset,\n      translation = [0, 0],\n      scaling = [0, 0, 0],\n      boundingBox,\n      projectPoints,\n      gpuAggregation,\n      numCol,\n      numRow\n    } = this.state;\n    const {props} = opts;\n    const {viewport} = this.context;\n    const attributes = this.getAttributes();\n    const vertexCount = this.getNumInstances();\n\n    if (!gpuAggregation) {\n      const result = cpuGridAggregator(props, {\n        gridOffset,\n        projectPoints,\n        attributes,\n        viewport,\n        posOffset,\n        boundingBox\n      });\n      this.setState({\n        layerData: result\n      });\n    } else {\n      const {weights} = this.state;\n      gpuGridAggregator.run({\n        weights,\n        cellSize: [gridOffset.xOffset, gridOffset.yOffset],\n        numCol,\n        numRow,\n        translation,\n        scaling,\n        vertexCount,\n        projectPoints,\n        attributes,\n        moduleSettings: this.getModuleSettings()\n      });\n    }\n  }\n\n  _updateWeightBins() {\n    const {getValue} = this.state;\n\n    const sortedBins = new BinSorter(this.state.layerData.data || [], {getValue});\n    this.setState({sortedBins});\n  }\n\n  _uploadAggregationResults() {\n    const {numCol, numRow} = this.state;\n    const {data} = this.state.layerData;\n    const {aggregatedBins, minValue, maxValue, totalCount} = this.state.sortedBins;\n\n    const ELEMENTCOUNT = 4;\n    const aggregationSize = numCol * numRow * ELEMENTCOUNT;\n    const aggregationData = new Float32Array(aggregationSize).fill(0);\n    for (const bin of aggregatedBins) {\n      const {lonIdx, latIdx} = data[bin.i];\n      const {value, counts} = bin;\n      const cellIndex = (lonIdx + latIdx * numCol) * ELEMENTCOUNT;\n      aggregationData[cellIndex] = value;\n      aggregationData[cellIndex + ELEMENTCOUNT - 1] = counts;\n    }\n    const maxMinData = new Float32Array([maxValue, 0, 0, minValue]);\n    const maxData = new Float32Array([maxValue, 0, 0, totalCount]);\n    const minData = new Float32Array([minValue, 0, 0, totalCount]);\n    this.updateResults({aggregationData, maxMinData, maxData, minData});\n  }\n}\n\nGridAggregationLayer.layerName = 'GridAggregationLayer';\n"],"file":"grid-aggregation-layer.js"}

package/dist/es5/grid-layer/grid-layer.js

@@ -7,6 +7,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _core = require("@deck.gl/core");
 
 var _gpuGridAggregator = _interopRequireDefault(require("../utils/gpu-grid-aggregation/gpu-grid-aggregator"));
@@ -15,77 +27,95 @@ var _gpuGridLayer = _interopRequireDefault(require("../gpu-grid-layer/gpu-grid-l
 
 var _cpuGridLayer = _interopRequireDefault(require("../cpu-grid-layer/cpu-grid-layer"));
 
-const defaultProps = { ..._gpuGridLayer.default.defaultProps,
-  ..._cpuGridLayer.default.defaultProps,
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var defaultProps = _objectSpread(_objectSpread(_objectSpread({}, _gpuGridLayer.default.defaultProps), _cpuGridLayer.default.defaultProps), {}, {
   gpuAggregation: false
-};
+});
 
-class GridLayer extends _core.CompositeLayer {
-  initializeState() {
-    this.state = {
-      useGPUAggregation: true
-    };
-  }
+var GridLayer = function (_CompositeLayer) {
+  (0, _inherits2.default)(GridLayer, _CompositeLayer);
 
-  updateState({
-    oldProps,
-    props,
-    changeFlags
-  }) {
-    const newState = {};
-    newState.useGPUAggregation = this.canUseGPUAggregation(props);
-    this.setState(newState);
-  }
+  var _super = _createSuper(GridLayer);
 
-  renderLayers() {
-    const {
-      data,
-      updateTriggers
-    } = this.props;
-    const id = this.state.useGPUAggregation ? 'GPU' : 'CPU';
-    const LayerType = this.state.useGPUAggregation ? this.getSubLayerClass('GPU', _gpuGridLayer.default) : this.getSubLayerClass('CPU', _cpuGridLayer.default);
-    return new LayerType(this.props, this.getSubLayerProps({
-      id,
-      updateTriggers
-    }), {
-      data
-    });
+  function GridLayer() {
+    (0, _classCallCheck2.default)(this, GridLayer);
+    return _super.apply(this, arguments);
   }
 
-  canUseGPUAggregation(props) {
-    const {
-      gpuAggregation,
-      lowerPercentile,
-      upperPercentile,
-      getColorValue,
-      getElevationValue,
-      colorScaleType
-    } = props;
-
-    if (!gpuAggregation) {
-      return false;
+  (0, _createClass2.default)(GridLayer, [{
+    key: "initializeState",
+    value: function initializeState() {
+      this.state = {
+        useGPUAggregation: true
+      };
     }
-
-    if (!_gpuGridAggregator.default.isSupported(this.context.gl)) {
-      return false;
-    }
-
-    if (lowerPercentile !== 0 || upperPercentile !== 100) {
-      return false;
+  }, {
+    key: "updateState",
+    value: function updateState(_ref) {
+      var oldProps = _ref.oldProps,
+          props = _ref.props,
+          changeFlags = _ref.changeFlags;
+      var newState = {};
+      newState.useGPUAggregation = this.canUseGPUAggregation(props);
+      this.setState(newState);
     }
-
-    if (getColorValue !== null || getElevationValue !== null) {
-      return false;
+  }, {
+    key: "renderLayers",
+    value: function renderLayers() {
+      var _this$props = this.props,
+          data = _this$props.data,
+          updateTriggers = _this$props.updateTriggers;
+      var id = this.state.useGPUAggregation ? 'GPU' : 'CPU';
+      var LayerType = this.state.useGPUAggregation ? this.getSubLayerClass('GPU', _gpuGridLayer.default) : this.getSubLayerClass('CPU', _cpuGridLayer.default);
+      return new LayerType(this.props, this.getSubLayerProps({
+        id: id,
+        updateTriggers: updateTriggers
+      }), {
+        data: data
+      });
     }
-
-    if (colorScaleType === 'quantile' || colorScaleType === 'ordinal') {
-      return false;
+  }, {
+    key: "canUseGPUAggregation",
+    value: function canUseGPUAggregation(props) {
+      var gpuAggregation = props.gpuAggregation,
+          lowerPercentile = props.lowerPercentile,
+          upperPercentile = props.upperPercentile,
+          getColorValue = props.getColorValue,
+          getElevationValue = props.getElevationValue,
+          colorScaleType = props.colorScaleType;
+
+      if (!gpuAggregation) {
+        return false;
+      }
+
+      if (!_gpuGridAggregator.default.isSupported(this.context.gl)) {
+        return false;
+      }
+
+      if (lowerPercentile !== 0 || upperPercentile !== 100) {
+        return false;
+      }
+
+      if (getColorValue !== null || getElevationValue !== null) {
+        return false;
+      }
+
+      if (colorScaleType === 'quantile' || colorScaleType === 'ordinal') {
+        return false;
+      }
+
+      return true;
     }
-
-    return true;
-  }
-
-}
+  }]);
+  return GridLayer;
+}(_core.CompositeLayer);
 
 exports.default = GridLayer;
 GridLayer.layerName = 'GridLayer';

package/dist/es5/grid-layer/grid-layer.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/grid-layer/grid-layer.js"],"names":["defaultProps","GPUGridLayer","CPUGridLayer","gpuAggregation","GridLayer","CompositeLayer","initializeState","state","useGPUAggregation","updateState","oldProps","props","changeFlags","newState","canUseGPUAggregation","setState","renderLayers","data","updateTriggers","id","LayerType","getSubLayerClass","getSubLayerProps","lowerPercentile","upperPercentile","getColorValue","getElevationValue","colorScaleType","GPUGridAggregator","isSupported","context","gl","layerName"],"mappings":";;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AAEA,MAAMA,YAAY,GAAG,EACnB,GAAGC,sBAAaD,YADG;AAEnB,KAAGE,sBAAaF,YAFG;AAGnBG,EAAAA,cAAc,EAAE;AAHG,CAArB;;AAMe,MAAMC,SAAN,SAAwBC,oBAAxB,CAAuC;AACpDC,EAAAA,eAAe,GAAG;AAChB,SAAKC,KAAL,GAAa;AACXC,MAAAA,iBAAiB,EAAE;AADR,KAAb;AAGD;;AAEDC,EAAAA,WAAW,CAAC;AAACC,IAAAA,QAAD;AAAWC,IAAAA,KAAX;AAAkBC,IAAAA;AAAlB,GAAD,EAAiC;AAC1C,UAAMC,QAAQ,GAAG,EAAjB;AACAA,IAAAA,QAAQ,CAACL,iBAAT,GAA6B,KAAKM,oBAAL,CAA0BH,KAA1B,CAA7B;AACA,SAAKI,QAAL,CAAcF,QAAd;AACD;;AAEDG,EAAAA,YAAY,GAAG;AACb,UAAM;AAACC,MAAAA,IAAD;AAAOC,MAAAA;AAAP,QAAyB,KAAKP,KAApC;AACA,UAAMQ,EAAE,GAAG,KAAKZ,KAAL,CAAWC,iBAAX,GAA+B,KAA/B,GAAuC,KAAlD;AACA,UAAMY,SAAS,GAAG,KAAKb,KAAL,CAAWC,iBAAX,GACd,KAAKa,gBAAL,CAAsB,KAAtB,EAA6BpB,qBAA7B,CADc,GAEd,KAAKoB,gBAAL,CAAsB,KAAtB,EAA6BnB,qBAA7B,CAFJ;AAGA,WAAO,IAAIkB,SAAJ,CACL,KAAKT,KADA,EAEL,KAAKW,gBAAL,CAAsB;AACpBH,MAAAA,EADoB;AAEpBD,MAAAA;AAFoB,KAAtB,CAFK,EAML;AACED,MAAAA;AADF,KANK,CAAP;AAUD;;AAIDH,EAAAA,oBAAoB,CAACH,KAAD,EAAQ;AAC1B,UAAM;AACJR,MAAAA,cADI;AAEJoB,MAAAA,eAFI;AAGJC,MAAAA,eAHI;AAIJC,MAAAA,aAJI;AAKJC,MAAAA,iBALI;AAMJC,MAAAA;AANI,QAOFhB,KAPJ;;AAQA,QAAI,CAACR,cAAL,EAAqB;AAEnB,aAAO,KAAP;AACD;;AACD,QAAI,CAACyB,2BAAkBC,WAAlB,CAA8B,KAAKC,OAAL,CAAaC,EAA3C,CAAL,EAAqD;AACnD,aAAO,KAAP;AACD;;AACD,QAAIR,eAAe,KAAK,CAApB,IAAyBC,eAAe,KAAK,GAAjD,EAAsD;AAEpD,aAAO,KAAP;AACD;;AACD,QAAIC,aAAa,KAAK,IAAlB,IAA0BC,iBAAiB,KAAK,IAApD,EAA0D;AAExD,aAAO,KAAP;AACD;;AACD,QAAIC,cAAc,KAAK,UAAnB,IAAiCA,cAAc,KAAK,SAAxD,EAAmE;AAEjE,aAAO,KAAP;AACD;;AACD,WAAO,IAAP;AACD;;AA9DmD;;;AAiEtDvB,SAAS,CAAC4B,SAAV,GAAsB,WAAtB;AACA5B,SAAS,CAACJ,YAAV,GAAyBA,YAAzB","sourcesContent":["import {CompositeLayer} from '@deck.gl/core';\nimport GPUGridAggregator from '../utils/gpu-grid-aggregation/gpu-grid-aggregator';\nimport GPUGridLayer from '../gpu-grid-layer/gpu-grid-layer';\nimport CPUGridLayer from '../cpu-grid-layer/cpu-grid-layer';\n\nconst defaultProps = {\n  ...GPUGridLayer.defaultProps,\n  ...CPUGridLayer.defaultProps,\n  gpuAggregation: false\n};\n\nexport default class GridLayer extends CompositeLayer {\n  initializeState() {\n    this.state = {\n      useGPUAggregation: true\n    };\n  }\n\n  updateState({oldProps, props, changeFlags}) {\n    const newState = {};\n    newState.useGPUAggregation = this.canUseGPUAggregation(props);\n    this.setState(newState);\n  }\n\n  renderLayers() {\n    const {data, updateTriggers} = this.props;\n    const id = this.state.useGPUAggregation ? 'GPU' : 'CPU';\n    const LayerType = this.state.useGPUAggregation\n      ? this.getSubLayerClass('GPU', GPUGridLayer)\n      : this.getSubLayerClass('CPU', CPUGridLayer);\n    return new LayerType(\n      this.props,\n      this.getSubLayerProps({\n        id,\n        updateTriggers\n      }),\n      {\n        data\n      }\n    );\n  }\n\n  // Private methods\n\n  canUseGPUAggregation(props) {\n    const {\n      gpuAggregation,\n      lowerPercentile,\n      upperPercentile,\n      getColorValue,\n      getElevationValue,\n      colorScaleType\n    } = props;\n    if (!gpuAggregation) {\n      // cpu aggregation is requested\n      return false;\n    }\n    if (!GPUGridAggregator.isSupported(this.context.gl)) {\n      return false;\n    }\n    if (lowerPercentile !== 0 || upperPercentile !== 100) {\n      // percentile calculations requires sorting not supported on GPU\n      return false;\n    }\n    if (getColorValue !== null || getElevationValue !== null) {\n      // accessor for custom color or elevation calculation is specified\n      return false;\n    }\n    if (colorScaleType === 'quantile' || colorScaleType === 'ordinal') {\n      // quantile and ordinal scales are not supported on GPU\n      return false;\n    }\n    return true;\n  }\n}\n\nGridLayer.layerName = 'GridLayer';\nGridLayer.defaultProps = defaultProps;\n"],"file":"grid-layer.js"}
+{"version":3,"sources":["../../../src/grid-layer/grid-layer.js"],"names":["defaultProps","GPUGridLayer","CPUGridLayer","gpuAggregation","GridLayer","state","useGPUAggregation","oldProps","props","changeFlags","newState","canUseGPUAggregation","setState","data","updateTriggers","id","LayerType","getSubLayerClass","getSubLayerProps","lowerPercentile","upperPercentile","getColorValue","getElevationValue","colorScaleType","GPUGridAggregator","isSupported","context","gl","CompositeLayer","layerName"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;AACA;;AACA;;AACA;;;;;;;;;;AAEA,IAAMA,YAAY,iDACbC,sBAAaD,YADA,GAEbE,sBAAaF,YAFA;AAGhBG,EAAAA,cAAc,EAAE;AAHA,EAAlB;;IAMqBC,S;;;;;;;;;;;;WACnB,2BAAkB;AAChB,WAAKC,KAAL,GAAa;AACXC,QAAAA,iBAAiB,EAAE;AADR,OAAb;AAGD;;;WAED,2BAA4C;AAAA,UAA/BC,QAA+B,QAA/BA,QAA+B;AAAA,UAArBC,KAAqB,QAArBA,KAAqB;AAAA,UAAdC,WAAc,QAAdA,WAAc;AAC1C,UAAMC,QAAQ,GAAG,EAAjB;AACAA,MAAAA,QAAQ,CAACJ,iBAAT,GAA6B,KAAKK,oBAAL,CAA0BH,KAA1B,CAA7B;AACA,WAAKI,QAAL,CAAcF,QAAd;AACD;;;WAED,wBAAe;AACb,wBAA+B,KAAKF,KAApC;AAAA,UAAOK,IAAP,eAAOA,IAAP;AAAA,UAAaC,cAAb,eAAaA,cAAb;AACA,UAAMC,EAAE,GAAG,KAAKV,KAAL,CAAWC,iBAAX,GAA+B,KAA/B,GAAuC,KAAlD;AACA,UAAMU,SAAS,GAAG,KAAKX,KAAL,CAAWC,iBAAX,GACd,KAAKW,gBAAL,CAAsB,KAAtB,EAA6BhB,qBAA7B,CADc,GAEd,KAAKgB,gBAAL,CAAsB,KAAtB,EAA6Bf,qBAA7B,CAFJ;AAGA,aAAO,IAAIc,SAAJ,CACL,KAAKR,KADA,EAEL,KAAKU,gBAAL,CAAsB;AACpBH,QAAAA,EAAE,EAAFA,EADoB;AAEpBD,QAAAA,cAAc,EAAdA;AAFoB,OAAtB,CAFK,EAML;AACED,QAAAA,IAAI,EAAJA;AADF,OANK,CAAP;AAUD;;;WAID,8BAAqBL,KAArB,EAA4B;AAC1B,UACEL,cADF,GAOIK,KAPJ,CACEL,cADF;AAAA,UAEEgB,eAFF,GAOIX,KAPJ,CAEEW,eAFF;AAAA,UAGEC,eAHF,GAOIZ,KAPJ,CAGEY,eAHF;AAAA,UAIEC,aAJF,GAOIb,KAPJ,CAIEa,aAJF;AAAA,UAKEC,iBALF,GAOId,KAPJ,CAKEc,iBALF;AAAA,UAMEC,cANF,GAOIf,KAPJ,CAMEe,cANF;;AAQA,UAAI,CAACpB,cAAL,EAAqB;AAEnB,eAAO,KAAP;AACD;;AACD,UAAI,CAACqB,2BAAkBC,WAAlB,CAA8B,KAAKC,OAAL,CAAaC,EAA3C,CAAL,EAAqD;AACnD,eAAO,KAAP;AACD;;AACD,UAAIR,eAAe,KAAK,CAApB,IAAyBC,eAAe,KAAK,GAAjD,EAAsD;AAEpD,eAAO,KAAP;AACD;;AACD,UAAIC,aAAa,KAAK,IAAlB,IAA0BC,iBAAiB,KAAK,IAApD,EAA0D;AAExD,eAAO,KAAP;AACD;;AACD,UAAIC,cAAc,KAAK,UAAnB,IAAiCA,cAAc,KAAK,SAAxD,EAAmE;AAEjE,eAAO,KAAP;AACD;;AACD,aAAO,IAAP;AACD;;;EA9DoCK,oB;;;AAiEvCxB,SAAS,CAACyB,SAAV,GAAsB,WAAtB;AACAzB,SAAS,CAACJ,YAAV,GAAyBA,YAAzB","sourcesContent":["import {CompositeLayer} from '@deck.gl/core';\nimport GPUGridAggregator from '../utils/gpu-grid-aggregation/gpu-grid-aggregator';\nimport GPUGridLayer from '../gpu-grid-layer/gpu-grid-layer';\nimport CPUGridLayer from '../cpu-grid-layer/cpu-grid-layer';\n\nconst defaultProps = {\n  ...GPUGridLayer.defaultProps,\n  ...CPUGridLayer.defaultProps,\n  gpuAggregation: false\n};\n\nexport default class GridLayer extends CompositeLayer {\n  initializeState() {\n    this.state = {\n      useGPUAggregation: true\n    };\n  }\n\n  updateState({oldProps, props, changeFlags}) {\n    const newState = {};\n    newState.useGPUAggregation = this.canUseGPUAggregation(props);\n    this.setState(newState);\n  }\n\n  renderLayers() {\n    const {data, updateTriggers} = this.props;\n    const id = this.state.useGPUAggregation ? 'GPU' : 'CPU';\n    const LayerType = this.state.useGPUAggregation\n      ? this.getSubLayerClass('GPU', GPUGridLayer)\n      : this.getSubLayerClass('CPU', CPUGridLayer);\n    return new LayerType(\n      this.props,\n      this.getSubLayerProps({\n        id,\n        updateTriggers\n      }),\n      {\n        data\n      }\n    );\n  }\n\n  // Private methods\n\n  canUseGPUAggregation(props) {\n    const {\n      gpuAggregation,\n      lowerPercentile,\n      upperPercentile,\n      getColorValue,\n      getElevationValue,\n      colorScaleType\n    } = props;\n    if (!gpuAggregation) {\n      // cpu aggregation is requested\n      return false;\n    }\n    if (!GPUGridAggregator.isSupported(this.context.gl)) {\n      return false;\n    }\n    if (lowerPercentile !== 0 || upperPercentile !== 100) {\n      // percentile calculations requires sorting not supported on GPU\n      return false;\n    }\n    if (getColorValue !== null || getElevationValue !== null) {\n      // accessor for custom color or elevation calculation is specified\n      return false;\n    }\n    if (colorScaleType === 'quantile' || colorScaleType === 'ordinal') {\n      // quantile and ordinal scales are not supported on GPU\n      return false;\n    }\n    return true;\n  }\n}\n\nGridLayer.layerName = 'GridLayer';\nGridLayer.defaultProps = defaultProps;\n"],"file":"grid-layer.js"}

package/dist/es5/heatmap-layer/heatmap-layer-utils.js

@@ -1,5 +1,7 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -10,15 +12,27 @@ exports.scaleToAspectRatio = scaleToAspectRatio;
 exports.getTextureCoordinates = getTextureCoordinates;
 exports.getTextureParams = getTextureParams;
 
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
 var _core = require("@luma.gl/core");
 
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
 function getBounds(points) {
-  const x = points.map(p => p[0]);
-  const y = points.map(p => p[1]);
-  const xMin = Math.min.apply(null, x);
-  const xMax = Math.max.apply(null, x);
-  const yMin = Math.min.apply(null, y);
-  const yMax = Math.max.apply(null, y);
+  var x = points.map(function (p) {
+    return p[0];
+  });
+  var y = points.map(function (p) {
+    return p[1];
+  });
+  var xMin = Math.min.apply(null, x);
+  var xMax = Math.max.apply(null, x);
+  var yMin = Math.min.apply(null, y);
+  var yMax = Math.max.apply(null, y);
   return [xMin, yMin, xMax, yMax];
 }
 
@@ -30,26 +44,43 @@ function boundsContain(currentBounds, targetBounds) {
   return false;
 }
 
-const scratchArray = new Float32Array(12);
+var scratchArray = new Float32Array(12);
 
-function packVertices(points, dimensions = 2) {
-  let index = 0;
+function packVertices(points) {
+  var dimensions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+  var index = 0;
 
-  for (const point of points) {
-    for (let i = 0; i < dimensions; i++) {
-      scratchArray[index++] = point[i] || 0;
+  var _iterator = _createForOfIteratorHelper(points),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var point = _step.value;
+
+      for (var i = 0; i < dimensions; i++) {
+        scratchArray[index++] = point[i] || 0;
+      }
     }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
 
   return scratchArray;
 }
 
 function scaleToAspectRatio(boundingBox, width, height) {
-  const [xMin, yMin, xMax, yMax] = boundingBox;
-  const currentWidth = xMax - xMin;
-  const currentHeight = yMax - yMin;
-  let newWidth = currentWidth;
-  let newHeight = currentHeight;
+  var _boundingBox = (0, _slicedToArray2.default)(boundingBox, 4),
+      xMin = _boundingBox[0],
+      yMin = _boundingBox[1],
+      xMax = _boundingBox[2],
+      yMax = _boundingBox[3];
+
+  var currentWidth = xMax - xMin;
+  var currentHeight = yMax - yMin;
+  var newWidth = currentWidth;
+  var newHeight = currentHeight;
 
   if (currentWidth / currentHeight < width / height) {
     newWidth = width / height * currentHeight;
@@ -62,20 +93,24 @@ function scaleToAspectRatio(boundingBox, width, height) {
     newHeight = height;
   }
 
-  const xCenter = (xMax + xMin) / 2;
-  const yCenter = (yMax + yMin) / 2;
+  var xCenter = (xMax + xMin) / 2;
+  var yCenter = (yMax + yMin) / 2;
   return [xCenter - newWidth / 2, yCenter - newHeight / 2, xCenter + newWidth / 2, yCenter + newHeight / 2];
 }
 
 function getTextureCoordinates(point, bounds) {
-  const [xMin, yMin, xMax, yMax] = bounds;
+  var _bounds = (0, _slicedToArray2.default)(bounds, 4),
+      xMin = _bounds[0],
+      yMin = _bounds[1],
+      xMax = _bounds[2],
+      yMax = _bounds[3];
+
   return [(point[0] - xMin) / (xMax - xMin), (point[1] - yMin) / (yMax - yMin)];
 }
 
-function getTextureParams({
-  gl,
-  floatTargetSupport
-}) {
+function getTextureParams(_ref) {
+  var gl = _ref.gl,
+      floatTargetSupport = _ref.floatTargetSupport;
   return {
     format: (0, _core.isWebGL2)(gl) ? 34836 : 6408,
     type: floatTargetSupport ? 5126 : 5121

package/dist/es5/heatmap-layer/heatmap-layer-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/heatmap-layer/heatmap-layer-utils.js"],"names":["getBounds","points","x","map","p","y","xMin","Math","min","apply","xMax","max","yMin","yMax","boundsContain","currentBounds","targetBounds","scratchArray","Float32Array","packVertices","dimensions","index","point","i","scaleToAspectRatio","boundingBox","width","height","currentWidth","currentHeight","newWidth","newHeight","xCenter","yCenter","getTextureCoordinates","bounds","getTextureParams","gl","floatTargetSupport","format","type"],"mappings":"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","sourcesContent":["import GL from '@luma.gl/constants';\nimport {isWebGL2} from '@luma.gl/core';\n\nexport function getBounds(points) {\n  // Now build bounding box in world space (aligned to world coordiante system)\n  const x = points.map(p => p[0]);\n  const y = points.map(p => p[1]);\n\n  const xMin = Math.min.apply(null, x);\n  const xMax = Math.max.apply(null, x);\n  const yMin = Math.min.apply(null, y);\n  const yMax = Math.max.apply(null, y);\n\n  return [xMin, yMin, xMax, yMax];\n}\n\n// true if currentBounds contains targetBounds, false otherwise\nexport function boundsContain(currentBounds, targetBounds) {\n  if (\n    targetBounds[0] >= currentBounds[0] &&\n    targetBounds[2] <= currentBounds[2] &&\n    targetBounds[1] >= currentBounds[1] &&\n    targetBounds[3] <= currentBounds[3]\n  ) {\n    return true;\n  }\n  return false;\n}\n\nconst scratchArray = new Float32Array(12);\n\n// For given rectangle bounds generates two triangles vertices that coverit completely\nexport function packVertices(points, dimensions = 2) {\n  let index = 0;\n  for (const point of points) {\n    for (let i = 0; i < dimensions; i++) {\n      scratchArray[index++] = point[i] || 0;\n    }\n  }\n  return scratchArray;\n}\n\n// Expands boundingBox:[xMin, yMin, xMax, yMax] to match aspect ratio of given width and height\nexport function scaleToAspectRatio(boundingBox, width, height) {\n  const [xMin, yMin, xMax, yMax] = boundingBox;\n\n  const currentWidth = xMax - xMin;\n  const currentHeight = yMax - yMin;\n\n  let newWidth = currentWidth;\n  let newHeight = currentHeight;\n  if (currentWidth / currentHeight < width / height) {\n    // expand bounding box width\n    newWidth = (width / height) * currentHeight;\n  } else {\n    newHeight = (height / width) * currentWidth;\n  }\n\n  if (newWidth < width) {\n    newWidth = width;\n    newHeight = height;\n  }\n\n  const xCenter = (xMax + xMin) / 2;\n  const yCenter = (yMax + yMin) / 2;\n\n  return [\n    xCenter - newWidth / 2,\n    yCenter - newHeight / 2,\n    xCenter + newWidth / 2,\n    yCenter + newHeight / 2\n  ];\n}\n\n// Get texture coordiante of point inside a bounding box\nexport function getTextureCoordinates(point, bounds) {\n  const [xMin, yMin, xMax, yMax] = bounds;\n  return [(point[0] - xMin) / (xMax - xMin), (point[1] - yMin) / (yMax - yMin)];\n}\n\n// Returns format and type for creating texture objects\nexport function getTextureParams({gl, floatTargetSupport}) {\n  return {\n    // format:  should be RGBA32F on WebGL2 (float textures), RGBA in WebGL1 for float or non float textures\n    format: isWebGL2(gl) ? GL.RGBA32F : GL.RGBA,\n    type: floatTargetSupport ? GL.FLOAT : GL.UNSIGNED_BYTE\n  };\n}\n"],"file":"heatmap-layer-utils.js"}
+{"version":3,"sources":["../../../src/heatmap-layer/heatmap-layer-utils.js"],"names":["getBounds","points","x","map","p","y","xMin","Math","min","apply","xMax","max","yMin","yMax","boundsContain","currentBounds","targetBounds","scratchArray","Float32Array","packVertices","dimensions","index","point","i","scaleToAspectRatio","boundingBox","width","height","currentWidth","currentHeight","newWidth","newHeight","xCenter","yCenter","getTextureCoordinates","bounds","getTextureParams","gl","floatTargetSupport","format","type"],"mappings":"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","sourcesContent":["import GL from '@luma.gl/constants';\nimport {isWebGL2} from '@luma.gl/core';\n\nexport function getBounds(points) {\n  // Now build bounding box in world space (aligned to world coordiante system)\n  const x = points.map(p => p[0]);\n  const y = points.map(p => p[1]);\n\n  const xMin = Math.min.apply(null, x);\n  const xMax = Math.max.apply(null, x);\n  const yMin = Math.min.apply(null, y);\n  const yMax = Math.max.apply(null, y);\n\n  return [xMin, yMin, xMax, yMax];\n}\n\n// true if currentBounds contains targetBounds, false otherwise\nexport function boundsContain(currentBounds, targetBounds) {\n  if (\n    targetBounds[0] >= currentBounds[0] &&\n    targetBounds[2] <= currentBounds[2] &&\n    targetBounds[1] >= currentBounds[1] &&\n    targetBounds[3] <= currentBounds[3]\n  ) {\n    return true;\n  }\n  return false;\n}\n\nconst scratchArray = new Float32Array(12);\n\n// For given rectangle bounds generates two triangles vertices that coverit completely\nexport function packVertices(points, dimensions = 2) {\n  let index = 0;\n  for (const point of points) {\n    for (let i = 0; i < dimensions; i++) {\n      scratchArray[index++] = point[i] || 0;\n    }\n  }\n  return scratchArray;\n}\n\n// Expands boundingBox:[xMin, yMin, xMax, yMax] to match aspect ratio of given width and height\nexport function scaleToAspectRatio(boundingBox, width, height) {\n  const [xMin, yMin, xMax, yMax] = boundingBox;\n\n  const currentWidth = xMax - xMin;\n  const currentHeight = yMax - yMin;\n\n  let newWidth = currentWidth;\n  let newHeight = currentHeight;\n  if (currentWidth / currentHeight < width / height) {\n    // expand bounding box width\n    newWidth = (width / height) * currentHeight;\n  } else {\n    newHeight = (height / width) * currentWidth;\n  }\n\n  if (newWidth < width) {\n    newWidth = width;\n    newHeight = height;\n  }\n\n  const xCenter = (xMax + xMin) / 2;\n  const yCenter = (yMax + yMin) / 2;\n\n  return [\n    xCenter - newWidth / 2,\n    yCenter - newHeight / 2,\n    xCenter + newWidth / 2,\n    yCenter + newHeight / 2\n  ];\n}\n\n// Get texture coordiante of point inside a bounding box\nexport function getTextureCoordinates(point, bounds) {\n  const [xMin, yMin, xMax, yMax] = bounds;\n  return [(point[0] - xMin) / (xMax - xMin), (point[1] - yMin) / (yMax - yMin)];\n}\n\n// Returns format and type for creating texture objects\nexport function getTextureParams({gl, floatTargetSupport}) {\n  return {\n    // format:  should be RGBA32F on WebGL2 (float textures), RGBA in WebGL1 for float or non float textures\n    format: isWebGL2(gl) ? GL.RGBA32F : GL.RGBA,\n    type: floatTargetSupport ? GL.FLOAT : GL.UNSIGNED_BYTE\n  };\n}\n"],"file":"heatmap-layer-utils.js"}