@deck.gl/carto 9.0.11 → 9.0.12

package/dist/index.cjs

@@ -31,6 +31,7 @@ __export(dist_exports, {
   CARTO_SOURCES: () => CARTO_SOURCES,
   CartoAPIError: () => CartoAPIError,
   H3TileLayer: () => H3TileLayer,
+  QuadbinHeatmapTileLayer: () => quadbin_heatmap_tile_layer_default,
   QuadbinTileLayer: () => QuadbinTileLayer,
   RasterTileLayer: () => RasterTileLayer,
   SOURCE_DEFAULTS: () => SOURCE_DEFAULTS,
@@ -264,7 +265,7 @@ function scaleIdentity() {
 }
 
 // dist/layers/schema/carto-raster-tile-loader.js
-var VERSION = true ? "9.0.11" : "latest";
+var VERSION = true ? "9.0.12" : "latest";
 var id = "cartoRasterTile";
 var DEFAULT_OPTIONS = {
   cartoRasterTile: {
@@ -535,7 +536,7 @@ function binaryToSpatialjson(binary) {
 }
 
 // dist/layers/schema/carto-spatial-tile-loader.js
-var VERSION2 = true ? "9.0.11" : "latest";
+var VERSION2 = true ? "9.0.12" : "latest";
 var id2 = "cartoSpatialTile";
 var DEFAULT_OPTIONS2 = {
   cartoSpatialTile: {
@@ -1033,12 +1034,343 @@ var QuadbinTileLayer = _QuadbinTileLayer;
   _QuadbinTileLayer.defaultProps = defaultProps5;
 })();
 
-// dist/layers/raster-tile-layer.js
+// dist/layers/quadbin-heatmap-tile-layer.js
+var import_quadbin5 = require("quadbin");
 var import_core9 = require("@deck.gl/core");
+var import_layers2 = require("@deck.gl/layers");
 
-// dist/layers/raster-layer.js
+// dist/layers/heatmap.js
+var import_shadertools = require("@luma.gl/shadertools");
+var fs = `uniform heatmapUniforms {
+float radiusPixels;
+vec2 colorDomain;
+vec3 color1;
+vec3 color2;
+vec3 color3;
+vec3 color4;
+vec3 color5;
+vec3 color6;
+float opacity;
+} heatmap;
+const float SUPPORT = 8.0;
+const vec4 STOPS = vec4(0.2, 0.4, 0.6, 0.8);
+vec3 colorGradient(float value) {
+vec3 c1;
+vec3 c2;
+vec2 range;
+if (value < STOPS.x) {
+range = vec2(0.0, STOPS.x);
+c1 = heatmap.color1; c2 = heatmap.color2;
+} else if (value < STOPS.y) {
+range = STOPS.xy;
+c1 = heatmap.color2; c2 = heatmap.color3;
+} else if (value < STOPS.z) {
+range = STOPS.yz;
+c1 = heatmap.color3; c2 = heatmap.color4;
+} else if (value < STOPS.w) {
+range = STOPS.zw;
+c1 = heatmap.color4; c2 = heatmap.color5;
+} else if (value < 1.0 ) {
+range = vec2(STOPS.w, 1.0);
+c1 = heatmap.color5; c2 = heatmap.color6;
+} else {
+range = vec2(1.0, 10.0);
+c1 = heatmap.color6; c2 = vec3(255.0);
+}
+float f = (value - range.x) / (range.y - range.x);
+return mix(c1, c2, f) / 255.0;
+}
+const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
+float unpack(vec3 color) {
+return 255.0 * dot(color, SHIFT);
+}
+vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
+float accumulator = 0.0;
+float offset = 0.5 * random(vec3(12.9898, 78.233, 151.7182), 0.0);
+const float sigma = SUPPORT / 3.0;
+const float a = -0.5 / (sigma * sigma);
+const float w0 = 1.0 / (2.0 * 3.141592653589793 * sigma * sigma);
+for (float t = -SUPPORT; t <= SUPPORT; t++) {
+for (float s = -SUPPORT; s <= SUPPORT; s++) {
+vec2 percent = (vec2(s, t) + offset - 0.5) / SUPPORT;
+vec2 delta = percent * heatmap.radiusPixels / texSize;
+vec4 offsetColor = texture(source, texCoord + delta);
+float value = unpack(offsetColor.rgb);
+float weight = w0 * exp(a * (s * s + t * t));
+accumulator += value * weight;
+}
+}
+float f = (accumulator - heatmap.colorDomain[0]) / (heatmap.colorDomain[1] - heatmap.colorDomain[0]);
+vec4 color = vec4(0.0);
+color.rgb = colorGradient(f);
+color.a = smoothstep(0.0, 0.1, f);
+color.a = pow(color.a, 1.0 / 2.2);
+color.a *= heatmap.opacity;
+return color;
+}
+`;
+var defaultColorRange = [
+  [255, 255, 178],
+  [254, 217, 118],
+  [254, 178, 76],
+  [253, 141, 60],
+  [240, 59, 32],
+  [189, 0, 38]
+];
+var heatmap = {
+  name: "heatmap",
+  uniformPropTypes: {
+    radiusPixels: { value: 20, min: 0, softMax: 100 },
+    colorDomain: { value: [0, 1] },
+    color1: { value: [0, 0, 0] },
+    color2: { value: [0, 0, 0] },
+    color3: { value: [0, 0, 0] },
+    color4: { value: [0, 0, 0] },
+    color5: { value: [0, 0, 0] },
+    color6: { value: [0, 0, 0] },
+    opacity: { value: 1, min: 0, max: 1 }
+  },
+  uniformTypes: {
+    radiusPixels: "f32",
+    colorDomain: "vec2<f32>",
+    color1: "vec3<f32>",
+    color2: "vec3<f32>",
+    color3: "vec3<f32>",
+    color4: "vec3<f32>",
+    color5: "vec3<f32>",
+    color6: "vec3<f32>",
+    opacity: "f32"
+  },
+  getUniforms: (opts) => {
+    const { colorRange = defaultColorRange, radiusPixels = 20, colorDomain = [0, 1], opacity = 1 } = opts;
+    const [color1, color2, color3, color4, color5, color6] = colorRange;
+    return {
+      color1,
+      color2,
+      color3,
+      color4,
+      color5,
+      color6,
+      radiusPixels,
+      colorDomain,
+      opacity
+    };
+  },
+  dependencies: [import_shadertools.random],
+  fs,
+  passes: [{ sampler: true }]
+};
+
+// dist/layers/post-process-utils.js
 var import_core8 = require("@deck.gl/core");
-var import_layers2 = require("@deck.gl/layers");
+var TEXTURE_PROPS = {
+  format: "rgba8unorm",
+  mipmaps: false,
+  sampler: {
+    minFilter: "linear",
+    magFilter: "linear",
+    addressModeU: "clamp-to-edge",
+    addressModeV: "clamp-to-edge"
+  }
+};
+function getPostProcessLayer(layer) {
+  while (layer.parent && !layer.applyPostProcess) {
+    layer = layer.parent;
+  }
+  return layer;
+}
+var _DrawCallbackLayer = class extends import_core8.Layer {
+  initializeState() {
+    this.id = `draw-callback-${getPostProcessLayer(this).props.id}`;
+  }
+  _drawLayer() {
+    getPostProcessLayer(this).applyPostProcess();
+  }
+};
+var DrawCallbackLayer = _DrawCallbackLayer;
+(() => {
+  _DrawCallbackLayer.layerName = "DrawCallbackLayer";
+})();
+function RTTModifier(BaseLayer) {
+  var _a;
+  return _a = class extends BaseLayer {
+    draw(opts) {
+      const { moduleParameters } = opts;
+      const { picking } = moduleParameters;
+      const postProcessLayer = getPostProcessLayer(this);
+      if (!picking.isActive) {
+        postProcessLayer.enableRTT(opts);
+      }
+      super.draw(opts);
+      if (!picking.isActive) {
+        postProcessLayer.disableRTT();
+      }
+    }
+  }, (() => {
+    _a.layerName = `RTT-${BaseLayer.layerName}`;
+  })(), _a;
+}
+function PostProcessModifier(BaseLayer, effect) {
+  var _a;
+  return _a = class extends BaseLayer {
+    initializeState(context) {
+      super.initializeState(context);
+      this._createTextures();
+      this.internalState.postProcess = new import_core8.PostProcessEffect(effect, this.props);
+      this.internalState.postProcess.setup(context);
+    }
+    updateState(params) {
+      super.updateState(params);
+      this.internalState.postProcess.setProps(this.props);
+    }
+    renderLayers() {
+      let subLayers = super.renderLayers();
+      if (!subLayers) {
+        return null;
+      }
+      subLayers = Array.isArray(subLayers) ? subLayers : [subLayers];
+      return [...subLayers, new DrawCallbackLayer()];
+    }
+    _createTextures() {
+      const { device } = this.context;
+      this.internalState.renderBuffers = [0, 1].map((i) => {
+        return device.createFramebuffer({
+          id: `layer-fbo-${i}`,
+          colorAttachments: [device.createTexture(TEXTURE_PROPS)],
+          depthStencilAttachment: "depth16unorm"
+        });
+      });
+    }
+    _resizeBuffers(opts) {
+      const { moduleParameters } = opts;
+      const { viewport } = this.context;
+      const width = moduleParameters.devicePixelRatio * viewport.width;
+      const height = moduleParameters.devicePixelRatio * viewport.height;
+      this.internalState.renderBuffers.forEach((fbo) => fbo.resize({ width, height }));
+    }
+    enableRTT(opts) {
+      this._resizeBuffers(opts);
+      this.internalState.originalRenderPass = this.context.renderPass;
+      const [framebuffer] = this.internalState.renderBuffers;
+      this.internalState.internalRenderPass = this.context.device.beginRenderPass({
+        framebuffer,
+        parameters: { viewport: [0, 0, framebuffer.width, framebuffer.height] },
+        clearColor: this.internalState.renderInProgress ? false : [0, 0, 0, 0]
+      });
+      this.internalState.renderInProgress = true;
+      this.context.renderPass = this.internalState.internalRenderPass;
+    }
+    disableRTT() {
+      this.internalState.internalRenderPass.end();
+      this.context.renderPass = this.internalState.originalRenderPass;
+    }
+    applyPostProcess() {
+      if (!this.internalState.renderInProgress) {
+        return;
+      }
+      const [inputBuffer, swapBuffer] = this.internalState.renderBuffers;
+      const { framebuffer: target } = this.context.renderPass.props;
+      this.internalState.postProcess.postRender({
+        inputBuffer,
+        swapBuffer,
+        target
+      });
+      this.internalState.renderInProgress = false;
+    }
+  }, (() => {
+    _a.layerName = `PostProcess${BaseLayer.layerName}`;
+  })(), _a;
+}
+
+// dist/layers/quadbin-heatmap-tile-layer.js
+var _RTTSolidPolygonLayer = class extends RTTModifier(import_layers2.SolidPolygonLayer) {
+  getShaders(type) {
+    const shaders = super.getShaders(type);
+    shaders.inject = {
+      "vs:#decl": "uniform float cellResolution;",
+      "vs:DECKGL_FILTER_COLOR": `
+  const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
+  float value = 255.0 * dot(SHIFT, color.rgb);
+
+  // Keep "power" delivered to screen constant when tiles update
+  float relativeZoom = log2(project_uScale) - cellResolution + 3.5; // range 0-1
+  float relativeArea = pow(2.0, -2.0 * relativeZoom); // range 0.25-1
+  value *= relativeArea;
+
+  // Pack float into 3 channels to pass to heatmap shader
+  color = vec4(mod(vec3(value, floor(value / SHIFT.yz)), 256.0), 255.0) / 255.0;
+      `
+    };
+    return shaders;
+  }
+  draw(opts) {
+    const cell0 = this.props.data[0];
+    const cellResolution = Number((0, import_quadbin5.getResolution)(cell0.id));
+    for (const model of this.state.models) {
+      model.setUniforms({ cellResolution });
+    }
+    super.draw(opts);
+  }
+};
+var RTTSolidPolygonLayer = _RTTSolidPolygonLayer;
+(() => {
+  _RTTSolidPolygonLayer.layerName = "RTTSolidPolygonLayer";
+})();
+var PostProcessQuadbinTileLayer = PostProcessModifier(QuadbinTileLayer, heatmap);
+function encodeWeight(w) {
+  return [w % 256, Math.floor(w / 256), Math.floor(w / (256 * 256))];
+}
+var defaultProps6 = {
+  ...QuadbinTileLayer.defaultProps,
+  getWeight: { type: "accessor", value: 1 }
+};
+var _QuadbinHeatmapTileLayer = class extends import_core9.CompositeLayer {
+  renderLayers() {
+    var _a, _b, _c;
+    const { getWeight, colorDomain, colorRange, radiusPixels, _subLayerProps } = this.props;
+    const subLayerProps = {
+      ..._subLayerProps,
+      cell: {
+        ..._subLayerProps == null ? void 0 : _subLayerProps.cell,
+        _subLayerProps: {
+          ...(_a = _subLayerProps == null ? void 0 : _subLayerProps.cell) == null ? void 0 : _a._subLayerProps,
+          fill: {
+            ...(_c = (_b = _subLayerProps == null ? void 0 : _subLayerProps.cell) == null ? void 0 : _b._subLayerProps) == null ? void 0 : _c.fill,
+            type: RTTSolidPolygonLayer
+          }
+        }
+      }
+    };
+    const getFillColor = typeof getWeight === "function" ? (d, info) => encodeWeight(getWeight(d, info)) : encodeWeight(getWeight);
+    return new PostProcessQuadbinTileLayer(this.getSubLayerProps({
+      id: "heatmap",
+      data: this.props.data,
+      getFillColor,
+      colorDomain,
+      colorRange,
+      radiusPixels,
+      _subLayerProps: subLayerProps,
+      updateTriggers: {
+        getPosition: this.props.updateTriggers.getWeight
+      }
+    }));
+  }
+};
+var QuadbinHeatmapTileLayer = _QuadbinHeatmapTileLayer;
+(() => {
+  _QuadbinHeatmapTileLayer.layerName = "QuadbinHeatmapTileLayer";
+})();
+(() => {
+  _QuadbinHeatmapTileLayer.defaultProps = defaultProps6;
+})();
+var quadbin_heatmap_tile_layer_default = QuadbinHeatmapTileLayer;
+
+// dist/layers/raster-tile-layer.js
+var import_core11 = require("@deck.gl/core");
+
+// dist/layers/raster-layer.js
+var import_core10 = require("@deck.gl/core");
+var import_layers3 = require("@deck.gl/layers");
 
 // dist/layers/raster-layer-vertex.glsl.js
 var raster_layer_vertex_glsl_default = `#version 300 es
@@ -1110,8 +1442,8 @@ DECKGL_FILTER_COLOR(vColor, geometry);
 `;
 
 // dist/layers/raster-layer.js
-var defaultProps6 = {
-  ...import_layers2.ColumnLayer.defaultProps,
+var defaultProps7 = {
+  ...import_layers3.ColumnLayer.defaultProps,
   extruded: false,
   diskResolution: 4,
   vertices: [
@@ -1121,7 +1453,7 @@ var defaultProps6 = {
     [-0.5, 0.5]
   ]
 };
-var _RasterColumnLayer = class extends import_layers2.ColumnLayer {
+var _RasterColumnLayer = class extends import_layers3.ColumnLayer {
   getShaders() {
     const shaders = super.getShaders();
     const data = this.props.data;
@@ -1157,7 +1489,7 @@ var RasterColumnLayer = _RasterColumnLayer;
 (() => {
   _RasterColumnLayer.layerName = "RasterColumnLayer";
 })();
-var _RasterLayer = class extends import_core8.CompositeLayer {
+var _RasterLayer = class extends import_core10.CompositeLayer {
   renderLayers() {
     const { data, getElevation, getFillColor, getLineColor, getLineWidth, tileIndex, updateTriggers } = this.props;
     if (!data || !tileIndex)
@@ -1198,7 +1530,7 @@ var RasterLayer = _RasterLayer;
   _RasterLayer.layerName = "RasterLayer";
 })();
 (() => {
-  _RasterLayer.defaultProps = defaultProps6;
+  _RasterLayer.defaultProps = defaultProps7;
 })();
 
 // dist/layers/raster-tile-layer.js
@@ -1209,11 +1541,11 @@ var renderSubLayers3 = (props) => {
     return null;
   return new RasterLayer(props, { tileIndex });
 };
-var defaultProps7 = {
+var defaultProps8 = {
   data: TilejsonPropType,
   tileSize: DEFAULT_TILE_SIZE
 };
-var _RasterTileLayer = class extends import_core9.CompositeLayer {
+var _RasterTileLayer = class extends import_core11.CompositeLayer {
   getLoadOptions() {
     const loadOptions = super.getLoadOptions() || {};
     const tileJSON = this.props.data;
@@ -1243,11 +1575,11 @@ var RasterTileLayer = _RasterTileLayer;
   _RasterTileLayer.layerName = "RasterTileLayer";
 })();
 (() => {
-  _RasterTileLayer.defaultProps = defaultProps7;
+  _RasterTileLayer.defaultProps = defaultProps8;
 })();
 
 // dist/layers/vector-tile-layer.js
-var import_core10 = require("@loaders.gl/core");
+var import_core12 = require("@loaders.gl/core");
 
 // dist/layers/schema/carto-properties-tile.js
 var TileReader4 = class {
@@ -1287,7 +1619,7 @@ var carto_properties_tile_loader_default = CartoPropertiesTileLoader;
 
 // dist/layers/schema/carto-vector-tile-loader.js
 var import_earcut = __toESM(require("earcut"), 1);
-var VERSION3 = true ? "9.0.11" : "latest";
+var VERSION3 = true ? "9.0.12" : "latest";
 var id3 = "cartoVectorTile";
 var DEFAULT_OPTIONS3 = {
   cartoVectorTile: {
@@ -1346,10 +1678,10 @@ var carto_vector_tile_loader_default = CartoVectorTileLoader;
 // dist/layers/vector-tile-layer.js
 var import_extensions = require("@deck.gl/extensions");
 var import_geo_layers6 = require("@deck.gl/geo-layers");
-var import_layers3 = require("@deck.gl/layers");
+var import_layers4 = require("@deck.gl/layers");
 var import_gis = require("@loaders.gl/gis");
-(0, import_core10.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
-var defaultProps8 = {
+(0, import_core12.registerLoaders)([carto_properties_tile_loader_default, carto_vector_tile_loader_default]);
+var defaultProps9 = {
   ...import_geo_layers6.MVTLayer.defaultProps,
   data: TilejsonPropType,
   dataComparator: TilejsonPropType.equal,
@@ -1423,7 +1755,7 @@ var _VectorTileLayer = class extends import_geo_layers6.MVTLayer {
       extensions: [new import_extensions.ClipExtension(), ...props.extensions || []],
       clipBounds: [west, south, east, north]
     };
-    const subLayer = new import_layers3.GeoJsonLayer(subLayerProps);
+    const subLayer = new import_layers4.GeoJsonLayer(subLayerProps);
     return subLayer;
   }
   getPickingInfo(params) {
@@ -1442,7 +1774,7 @@ var VectorTileLayer = _VectorTileLayer;
   _VectorTileLayer.layerName = "VectorTileLayer";
 })();
 (() => {
-  _VectorTileLayer.defaultProps = defaultProps8;
+  _VectorTileLayer.defaultProps = defaultProps9;
 })();
 
 // dist/basemap.js
@@ -1604,14 +1936,14 @@ function formatErrorKey(key) {
 }
 
 // dist/api/common.js
-var import_core11 = require("@deck.gl/core");
+var import_core13 = require("@deck.gl/core");
 var DEFAULT_API_BASE_URL = "https://gcp-us-east1.api.carto.com";
 var DEFAULT_CLIENT = "deck-gl-carto";
 var V3_MINOR_VERSION = "3.4";
 var MAX_GET_LENGTH = 8192;
 var DEFAULT_PARAMETERS = {
   v: V3_MINOR_VERSION,
-  deckglVersion: import_core11.VERSION
+  deckglVersion: import_core13.VERSION
 };
 var DEFAULT_HEADERS = {
   Accept: "application/json",
@@ -1908,7 +2240,7 @@ var vectorTilesetSource = async function(options) {
 
 // dist/api/parse-map.js
 var import_constants12 = require("@luma.gl/constants");
-var import_core12 = require("@deck.gl/core");
+var import_core14 = require("@deck.gl/core");
 
 // dist/api/layer-map.js
 var import_d3_array = require("d3-array");
@@ -1917,7 +2249,7 @@ var import_d3_scale3 = require("d3-scale");
 var import_d3_format = require("d3-format");
 var import_moment_timezone = __toESM(require("moment-timezone"), 1);
 var import_aggregation_layers = require("@deck.gl/aggregation-layers");
-var import_layers4 = require("@deck.gl/layers");
+var import_layers5 = require("@deck.gl/layers");
 var import_geo_layers7 = require("@deck.gl/geo-layers");
 var SCALE_FUNCS = {
   linear: import_d3_scale3.scaleLinear,
@@ -1990,7 +2322,7 @@ var aggregationVisConfig = {
   elevationPercentile: ["elevationLowerPercentile", "elevationUpperPercentile"],
   percentile: ["lowerPercentile", "upperPercentile"]
 };
-var defaultProps9 = {
+var defaultProps10 = {
   lineMiterLimit: 2,
   lineWidthUnits: "pixels",
   pointRadiusUnits: "pixels",
@@ -2014,7 +2346,7 @@ function getLayer(type, config, dataset) {
   const hexagonId = (_b = config.columns) == null ? void 0 : _b.hex_id;
   const layerTypeDefs = {
     point: {
-      Layer: import_layers4.GeoJsonLayer,
+      Layer: import_layers5.GeoJsonLayer,
       propMap: {
         columns: {
           altitude: (x) => ({ parameters: { depthTest: Boolean(x) } })
@@ -2023,7 +2355,7 @@ function getLayer(type, config, dataset) {
       }
     },
     geojson: {
-      Layer: import_layers4.GeoJsonLayer
+      Layer: import_layers5.GeoJsonLayer
     },
     grid: {
       Layer: import_aggregation_layers.CPUGridLayer,
@@ -2051,7 +2383,7 @@ function getLayer(type, config, dataset) {
   return {
     ...layer,
     propMap: mergePropMaps(basePropMap, layer.propMap),
-    defaultProps: { ...defaultProps9, ...layer.defaultProps }
+    defaultProps: { ...defaultProps10, ...layer.defaultProps }
   };
 }
 function layerFromTileDataset(scheme, type) {
@@ -2072,7 +2404,7 @@ function getTileLayer(dataset, basePropMap) {
     Layer: layerFromTileDataset(scheme),
     propMap: basePropMap,
     defaultProps: {
-      ...defaultProps9,
+      ...defaultProps10,
       ...aggregationExp && { aggregationExp },
       ...aggregationResLevel && { aggregationResLevel },
       uniqueIdProperty: "geoid"
@@ -2286,12 +2618,12 @@ function parseMap(json) {
         assert(dataset, `No dataset matching dataId: ${dataId}`);
         const { data } = dataset;
         assert(data, `No data loaded for dataId: ${dataId}`);
-        const { Layer, propMap, defaultProps: defaultProps10 } = getLayer(type, config, dataset);
+        const { Layer: Layer2, propMap, defaultProps: defaultProps11 } = getLayer(type, config, dataset);
         const styleProps = createStyleProps(config, propMap);
-        return new Layer({
+        return new Layer2({
           id: id4,
           data,
-          ...defaultProps10,
+          ...defaultProps11,
           ...createInteractionProps(interactionConfig),
           ...styleProps,
           ...createChannelProps(id4, type, config, visualChannels, data),
@@ -2299,7 +2631,7 @@ function parseMap(json) {
           ...createLoadOptions(token)
         });
       } catch (e) {
-        import_core12.log.error(e.message)();
+        import_core14.log.error(e.message)();
         return void 0;
       }
     })
@@ -2701,6 +3033,7 @@ var CARTO_LAYERS = {
   H3TileLayer,
   _PointLabelLayer: PointLabelLayer,
   QuadbinTileLayer,
+  QuadbinHeatmapTileLayer: quadbin_heatmap_tile_layer_default,
   RasterTileLayer,
   VectorTileLayer
 };