@deck.gl/carto 9.0.17 → 9.0.18

package/package.json

@@ -3,7 +3,7 @@
   "description": "CARTO official integration with Deck.gl. Build geospatial applications using CARTO and Deck.gl.",
   "license": "MIT",
   "type": "module",
-  "version": "9.0.17",
+  "version": "9.0.18",
   "publishConfig": {
     "access": "public"
   },
@@ -73,5 +73,5 @@
     "@deck.gl/layers": "^9.0.0",
     "@loaders.gl/core": "^4.2.0"
   },
-  "gitHead": "203d25c47f421a29d607a2a6fd9e1ef50f67b2bf"
+  "gitHead": "32f7e51eb96319739a18a3ca22092e60948fcbdb"
 }

package/src/index.ts

@@ -1,23 +1,23 @@
 import {default as H3TileLayer} from './layers/h3-tile-layer';
+import {default as HeatmapTileLayer} from './layers/heatmap-tile-layer';
 import {default as _PointLabelLayer} from './layers/point-label-layer';
 import {default as QuadbinTileLayer} from './layers/quadbin-tile-layer';
-import {default as QuadbinHeatmapTileLayer} from './layers/quadbin-heatmap-tile-layer';
 import {default as RasterTileLayer} from './layers/raster-tile-layer';
 import {default as VectorTileLayer} from './layers/vector-tile-layer';
 const CARTO_LAYERS = {
   H3TileLayer,
+  HeatmapTileLayer,
   _PointLabelLayer,
   QuadbinTileLayer,
-  QuadbinHeatmapTileLayer,
   RasterTileLayer,
   VectorTileLayer
 };
 export {
   CARTO_LAYERS,
   H3TileLayer,
+  HeatmapTileLayer,
   _PointLabelLayer,
   QuadbinTileLayer,
-  QuadbinHeatmapTileLayer,
   RasterTileLayer,
   VectorTileLayer
 };

package/src/layers/heatmap-tile-layer.ts

@@ -0,0 +1,236 @@
+import {getResolution} from 'quadbin';
+
+import {Accessor, CompositeLayer, CompositeLayerProps, DefaultProps, Layer} from '@deck.gl/core';
+import {SolidPolygonLayer} from '@deck.gl/layers';
+
+import {HeatmapProps, heatmap} from './heatmap';
+import {RTTModifier, PostProcessModifier} from './post-process-utils';
+import QuadbinTileLayer, {QuadbinTileLayerProps} from './quadbin-tile-layer';
+import {TilejsonPropType} from './utils';
+import {TilejsonResult} from '../sources';
+import {_Tile2DHeader as Tile2DHeader} from '@deck.gl/geo-layers';
+
+/**
+ * Computes the unit density (inverse of cell area)
+ */
+function unitDensityForCell(cell: bigint) {
+  const cellResolution = Number(getResolution(cell));
+  return Math.pow(4.0, cellResolution);
+}
+
+// Modified polygon layer to draw offscreen and output value expected by heatmap
+class RTTSolidPolygonLayer extends RTTModifier(SolidPolygonLayer) {
+  static layerName = 'RTTSolidPolygonLayer';
+
+  getShaders(type) {
+    const shaders = super.getShaders(type);
+    shaders.inject = {
+      'vs:#decl': `
+uniform float densityFactor;
+`,
+      'vs:#main-end': `
+      // Value from getWeight accessor
+  float weight = elevations;
+
+  // Keep "power" delivered to screen constant when tiles update
+  // by outputting normalized density 
+  weight *= densityFactor;
+
+  // Pack float into 3 channels to pass to heatmap shader
+  // SCALE value important, as we don't want to saturate
+  // but also want enough definition to avoid banding
+  const vec3 SHIFT = vec3(1.0, 256.0, 256.0 * 256.0);
+  const float MAX_VAL = SHIFT.z * 255.0;
+  const float SCALE = MAX_VAL / 8.0;
+  weight *= SCALE;
+  weight = clamp(weight, 0.0, MAX_VAL);
+  vColor = vec4(mod(vec3(weight, floor(weight / SHIFT.yz)), 256.0), 255.0) / 255.0;
+`
+    };
+    return shaders;
+  }
+
+  draw(this, opts: any) {
+    const cell = this.props!.data[0];
+    const maxDensity = this.props.elevationScale;
+    const densityFactor = unitDensityForCell(cell.id) / maxDensity;
+    for (const model of this.state.models) {
+      model.setUniforms({densityFactor});
+    }
+
+    super.draw(opts);
+  }
+}
+
+// Modify QuadbinTileLayer to apply heatmap post process effect
+const PostProcessQuadbinTileLayer = PostProcessModifier(QuadbinTileLayer, heatmap);
+
+const defaultProps: DefaultProps<HeatmapTileLayerProps> = {
+  data: TilejsonPropType,
+  getWeight: {type: 'accessor', value: 1},
+  onMaxDensityChange: {type: 'function', optional: true, value: null},
+  colorDomain: {type: 'array', value: [0, 1]},
+  intensity: {type: 'number', value: 1},
+  radiusPixels: {type: 'number', min: 0, max: 100, value: 20}
+};
+
+/** All properties supported by HeatmapTileLayer. */
+export type HeatmapTileLayerProps<DataT = unknown> = _HeatmapTileLayerProps<DataT> &
+  CompositeLayerProps & {
+    data: null | TilejsonResult | Promise<TilejsonResult>;
+  };
+
+/** Properties added by HeatmapTileLayer. */
+type _HeatmapTileLayerProps<DataT> = QuadbinTileLayerProps<DataT> &
+  HeatmapProps & {
+    /**
+     * The weight of each object.
+     *
+     * @default 1
+     */
+    getWeight?: Accessor<DataT, number>;
+
+    /** Called when maximum density in displayed tiles changes. */
+    onMaxDensityChange?: ((maxDensity: number) => void) | null;
+  };
+
+class HeatmapTileLayer<DataT = any, ExtraProps extends {} = {}> extends CompositeLayer<
+  ExtraProps & Required<_HeatmapTileLayerProps<DataT>>
+> {
+  static layerName = 'HeatmapTileLayer';
+  static defaultProps = defaultProps;
+
+  state!: {
+    isLoaded: boolean;
+    tiles: Set<Tile2DHeader>;
+    viewportChanged?: boolean;
+  };
+  initializeState() {
+    this.state = {
+      isLoaded: false,
+      tiles: new Set(),
+      viewportChanged: false
+    };
+  }
+
+  shouldUpdateState({changeFlags}): boolean {
+    const {viewportChanged} = changeFlags;
+    this.setState({viewportChanged});
+    return changeFlags.somethingChanged;
+  }
+
+  renderLayers(): Layer {
+    const {
+      data,
+      getWeight,
+      colorDomain,
+      colorRange,
+      intensity,
+      radiusPixels,
+      _subLayerProps,
+      updateTriggers,
+      onMaxDensityChange,
+      onViewportLoad,
+      onTileLoad,
+      onTileUnload,
+      ...tileLayerProps
+    } = this.props;
+
+    // Inject modified polygon layer as sublayer into TileLayer
+    const subLayerProps = {
+      ..._subLayerProps,
+      cell: {
+        ..._subLayerProps?.cell,
+        _subLayerProps: {
+          ..._subLayerProps?.cell?._subLayerProps,
+          fill: {
+            ..._subLayerProps?.cell?._subLayerProps?.fill,
+            type: RTTSolidPolygonLayer
+          }
+        }
+      }
+    };
+
+    let tileZ = 0;
+    let maxDensity = 0;
+    const tiles = [...this.state.tiles].filter(t => t.isVisible && t.data);
+    for (const tile of tiles) {
+      const cell = tile.data[0];
+      const unitDensity = unitDensityForCell(cell.id);
+      maxDensity = Math.max(tile.userData!.maxWeight * unitDensity, maxDensity);
+      tileZ = Math.max(tile.zoom, tileZ);
+    }
+
+    // Between zoom levels the max density will change, but it isn't possible to know by what factor. Uniform data distributions lead to a factor of 4, while very localized data gives 1. As a heurstic estimate with a value inbetween (2) to make the transitions less obvious.
+    const overzoom = this.context.viewport.zoom - tileZ;
+    const estimatedMaxDensity = maxDensity * Math.pow(2, overzoom);
+
+    maxDensity = estimatedMaxDensity;
+    if (typeof onMaxDensityChange === 'function') {
+      onMaxDensityChange(maxDensity);
+    }
+    return new PostProcessQuadbinTileLayer(
+      tileLayerProps as Omit<QuadbinTileLayerProps, 'data'>,
+      this.getSubLayerProps({
+        id: 'heatmap',
+        data,
+
+        // Re-use existing props to pass down values to sublayer
+        // TODO replace with custom layer
+        getFillColor: 0,
+        getElevation: getWeight,
+        elevationScale: maxDensity,
+
+        colorDomain,
+
+        colorRange,
+        radiusPixels,
+        intensity,
+        _subLayerProps: subLayerProps,
+        refinementStrategy: 'no-overlap',
+
+        // Disable line rendering
+        extruded: false,
+        stroked: false,
+
+        updateTriggers: {
+          getElevation: updateTriggers.getWeight
+        },
+
+        // Tile stats
+        onViewportLoad: tiles => {
+          this.setState({isLoaded: true});
+          if (typeof onViewportLoad === 'function') {
+            onViewportLoad(tiles);
+          }
+        },
+        onTileLoad: (tile: Tile2DHeader) => {
+          let maxWeight = -Infinity;
+          if (typeof getWeight !== 'function') {
+            maxWeight = getWeight;
+          } else if (tile.content) {
+            for (const d of tile.content) {
+              maxWeight = Math.max(getWeight(d, {} as any), maxWeight);
+            }
+          }
+          tile.userData = {maxWeight};
+
+          this.state.tiles.add(tile);
+
+          if (typeof onTileLoad === 'function') {
+            onTileLoad(tile);
+          }
+        },
+        onTileUnload: (tile: Tile2DHeader) => {
+          this.state.tiles.delete(tile);
+          if (typeof onTileUnload === 'function') {
+            onTileUnload(tile);
+          }
+        },
+        transitions: {elevationScale: {type: 'spring', stiffness: 0.3, damping: 0.5}}
+      })
+    );
+  }
+}
+
+export default HeatmapTileLayer;

package/src/layers/heatmap.ts

@@ -1,5 +1,4 @@
 import type {ShaderPass} from '@luma.gl/shadertools';
-import {random} from '@luma.gl/shadertools';
 import {Color} from '@deck.gl/core';
 const glsl = (s: TemplateStringsArray) => `${s}`;
 
@@ -21,11 +20,10 @@ uniform heatmapUniforms {
   vec3 color4;
   vec3 color5;
   vec3 color6;
+  float intensity;
   float opacity;
 } heatmap;
 
-// Controls quality of heatmap, larger values increase quality at expense of performance
-const float SUPPORT = 8.0;
 const vec4 STOPS = vec4(0.2, 0.4, 0.6, 0.8);
 
 vec3 colorGradient(float value) {
@@ -44,20 +42,18 @@ vec3 colorGradient(float value) {
   } else if (value < STOPS.w) {
     range = STOPS.zw;
     c1 = heatmap.color4; c2 = heatmap.color5;
-  } else if (value < 1.0 ) {
+  } else {
     range = vec2(STOPS.w, 1.0);
     c1 = heatmap.color5; c2 = heatmap.color6;
-  } else {
-    // Fade out to white
-    range = vec2(1.0, 10.0);
-    c1 = heatmap.color6; c2 = vec3(255.0);
   }
 
-  float f = (value - range.x) / (range.y - range.x);
+  float f = (clamp(value, 0.0, 1.0) - 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);
+const float MAX_VAL = SHIFT.z * 255.0;
+const float SCALE = MAX_VAL / 8.0;
 vec4 pack(float value) {
   return vec4(mod(vec3(value, floor(value / SHIFT.yz)), 256.0), 255.0) / 255.0;
 }
@@ -69,16 +65,15 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
   bool firstPass = (heatmap.delta.y < 0.5);
   float accumulator = 0.0;
 
-  // Randomize the lookup values to hide the fixed number of samples
-  float offset = 0.5 * random(vec3(12.9898, 78.233, 151.7182), 0.0);
+  // Controls quality of heatmap, larger values increase quality at expense of performance
+  float SUPPORT = clamp(heatmap.radiusPixels / 2.0, 8.0, 32.0);
 
   // Gaussian normalization parameters
-  const float sigma = SUPPORT / 3.0;
-  const float a = -0.5 / (sigma * sigma);
-  const float w0 = 0.3989422804014327 / sigma; // 1D normalization
-
+  float sigma = SUPPORT / 3.0;
+  float a = -0.5 / (sigma * sigma);
+  float w0 = 0.3989422804014327 / sigma; // 1D normalization
   for (float t = -SUPPORT; t <= SUPPORT; t++) {
-    vec2 percent = (t * heatmap.delta + offset - 0.5) / SUPPORT;
+    vec2 percent = (t * heatmap.delta - 0.5) / SUPPORT;
     vec2 delta = percent * heatmap.radiusPixels / texSize;
     vec4 offsetColor = texture(source, texCoord + delta);
 
@@ -95,8 +90,18 @@ vec4 heatmap_sampleColor(sampler2D source, vec2 texSize, vec2 texCoord) {
     return pack(accumulator);
   }
 
+  // Undo scaling to obtain normalized density
+  float density = 10.0 * heatmap.intensity * accumulator / SCALE;
+ 
+  // Domain also in normalized density units
+  vec2 domain = heatmap.colorDomain;
+
   // Apply domain
-  float f = (accumulator - heatmap.colorDomain[0]) / (heatmap.colorDomain[1] - heatmap.colorDomain[0]);
+  float f = (density - domain[0]) / (domain[1] - domain[0]);
+
+  // sqrt/log scaling??
+  // float f = (log(density) - log(domain[0] + 1.0)) / (log(domain[1] + 1.0) - log(domain[0] + 1.0));
+  // f = sqrt(f);
 
   // Color map
   vec4 color = vec4(0.0);
@@ -138,6 +143,10 @@ export type HeatmapProps = {
    * @default `6-class YlOrRd` - [colorbrewer](http://colorbrewer2.org/#type=sequential&scheme=YlOrRd&n=6)
    */
   colorRange: Color[];
+  /**
+   * Value that is multiplied with the total weight at a pixel to obtain the final weight. A value larger than 1 biases the output color towards the higher end of the spectrum, and a value less than 1 biases the output color towards the lower end of the spectrum.
+   */
+  intensity?: number;
   opacity: number;
 };
 
@@ -151,6 +160,7 @@ export type HeatmapUniforms = {
   color4?: [number, number, number];
   color5?: [number, number, number];
   color6?: [number, number, number];
+  intensity: number;
   opacity?: number;
 };
 
@@ -166,6 +176,7 @@ export const heatmap: ShaderPass<HeatmapProps, HeatmapUniforms> = {
     color4: {value: [0, 0, 0]},
     color5: {value: [0, 0, 0]},
     color6: {value: [0, 0, 0]},
+    intensity: {value: 1, min: 0.1, max: 10},
     opacity: {value: 1, min: 0, max: 1}
   },
   uniformTypes: {
@@ -178,6 +189,7 @@ export const heatmap: ShaderPass<HeatmapProps, HeatmapUniforms> = {
     color4: 'vec3<f32>',
     color5: 'vec3<f32>',
     color6: 'vec3<f32>',
+    intensity: 'f32',
     opacity: 'f32'
   },
   getUniforms: opts => {
@@ -186,6 +198,7 @@ export const heatmap: ShaderPass<HeatmapProps, HeatmapUniforms> = {
       colorRange = defaultColorRange,
       radiusPixels = 20,
       colorDomain = [0, 1],
+      intensity = 1,
       opacity = 1
     } = opts as HeatmapProps & {delta: [number, number]};
     const [color1, color2, color3, color4, color5, color6] = colorRange;
@@ -199,10 +212,10 @@ export const heatmap: ShaderPass<HeatmapProps, HeatmapUniforms> = {
       color6,
       radiusPixels,
       colorDomain,
+      intensity,
       opacity
     };
   },
-  dependencies: [random],
   fs,
   passes: [
     {sampler: true, uniforms: {delta: [1, 0]}},

package/src/layers/vector-tile-layer.ts

@@ -14,9 +14,6 @@ import {
   _TileLoadProps as TileLoadProps
 } from '@deck.gl/geo-layers';
 import {GeoJsonLayer} from '@deck.gl/layers';
-import {binaryToGeojson} from '@loaders.gl/gis';
-import type {BinaryFeatureCollection} from '@loaders.gl/schema';
-import type {Feature, Geometry} from 'geojson';
 
 import type {TilejsonResult} from '../sources/types';
 import {TilejsonPropType, injectAccessToken, mergeBoundaryData} from './utils';
@@ -148,16 +145,9 @@ export default class VectorTileLayer<
     return subLayer;
   }
 
-  getPickingInfo(params) {
-    const info = super.getPickingInfo(params);
-
-    if (this.state.binary && info.index !== -1) {
-      const {data} = params.sourceLayer!.props;
-      info.object = binaryToGeojson(data as BinaryFeatureCollection, {
-        globalFeatureId: info.index
-      }) as Feature<Geometry, FeaturePropertiesT>;
-    }
-
-    return info;
+  protected override _isWGS84(): boolean {
+    // CARTO binary tile coordinates are [lng, lat], not tile-relative like MVT.
+    if (this.state.mvt) return super._isWGS84();
+    return true;
   }
 }

package/dist/layers/quadbin-heatmap-tile-layer.d.ts

@@ -1,24 +0,0 @@
-import { Accessor, CompositeLayer, CompositeLayerProps, DefaultProps, Layer } from '@deck.gl/core';
-import { HeatmapProps } from "./heatmap.js";
-import { QuadbinTileLayerProps } from "./quadbin-tile-layer.js";
-import { TilejsonResult } from "../sources.js";
-/** All properties supported by QuadbinHeatmapTileLayer. */
-export type QuadbinHeatmapTileLayerProps<DataT = unknown> = _QuadbinHeatmapTileLayerProps<DataT> & CompositeLayerProps & {
-    data: null | TilejsonResult | Promise<TilejsonResult>;
-};
-/** Properties added by QuadbinHeatmapTileLayer. */
-type _QuadbinHeatmapTileLayerProps<DataT> = QuadbinTileLayerProps<DataT> & HeatmapProps & {
-    /**
-     * The weight of each object.
-     *
-     * @default 1
-     */
-    getWeight?: Accessor<DataT, number>;
-};
-declare class QuadbinHeatmapTileLayer<DataT = any, ExtraProps extends {} = {}> extends CompositeLayer<ExtraProps & Required<_QuadbinHeatmapTileLayerProps<DataT>>> {
-    static layerName: string;
-    static defaultProps: DefaultProps<QuadbinHeatmapTileLayerProps<unknown>>;
-    renderLayers(): Layer;
-}
-export default QuadbinHeatmapTileLayer;
-//# sourceMappingURL=quadbin-heatmap-tile-layer.d.ts.map

package/dist/layers/quadbin-heatmap-tile-layer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"quadbin-heatmap-tile-layer.d.ts","sourceRoot":"","sources":["../../src/layers/quadbin-heatmap-tile-layer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,QAAQ,EAAE,cAAc,EAAE,mBAAmB,EAAE,YAAY,EAAE,KAAK,EAAC,MAAM,eAAe,CAAC;AAGjG,OAAO,EAAC,YAAY,EAAU,qBAAkB;AAEhD,OAAyB,EAAC,qBAAqB,EAAC,gCAA6B;AAE7E,OAAO,EAAC,cAAc,EAAC,sBAAmB;AAiD1C,2DAA2D;AAC3D,MAAM,MAAM,4BAA4B,CAAC,KAAK,GAAG,OAAO,IAAI,6BAA6B,CAAC,KAAK,CAAC,GAC9F,mBAAmB,GAAG;IACpB,IAAI,EAAE,IAAI,GAAG,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACvD,CAAC;AAEJ,mDAAmD;AACnD,KAAK,6BAA6B,CAAC,KAAK,IAAI,qBAAqB,CAAC,KAAK,CAAC,GACtE,YAAY,GAAG;IACb;;;;OAIG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CACrC,CAAC;AAEJ,cAAM,uBAAuB,CAAC,KAAK,GAAG,GAAG,EAAE,UAAU,SAAS,EAAE,GAAG,EAAE,CAAE,SAAQ,cAAc,CAC3F,UAAU,GAAG,QAAQ,CAAC,6BAA6B,CAAC,KAAK,CAAC,CAAC,CAC5D;IACC,MAAM,CAAC,SAAS,SAA6B;IAC7C,MAAM,CAAC,YAAY,sDAAgB;IAEnC,YAAY,IAAI,KAAK;CAmDtB;AAED,eAAe,uBAAuB,CAAC"}

package/dist/layers/quadbin-heatmap-tile-layer.js

@@ -1,84 +0,0 @@
-import { getResolution } from 'quadbin';
-import { CompositeLayer } from '@deck.gl/core';
-import { SolidPolygonLayer } from '@deck.gl/layers';
-import { heatmap } from "./heatmap.js";
-import { RTTModifier, PostProcessModifier } from "./post-process-utils.js";
-import QuadbinTileLayer from "./quadbin-tile-layer.js";
-import { TilejsonPropType } from "./utils.js";
-// Modified polygon layer to draw offscreen and output value expected by heatmap
-class RTTSolidPolygonLayer extends RTTModifier(SolidPolygonLayer) {
-    static { this.layerName = 'RTTSolidPolygonLayer'; }
-    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(getResolution(cell0.id));
-        for (const model of this.state.models) {
-            model.setUniforms({ cellResolution });
-        }
-        super.draw(opts);
-    }
-}
-// Modify QuadbinTileLayer to apply heatmap post process effect
-const PostProcessQuadbinTileLayer = PostProcessModifier(QuadbinTileLayer, heatmap);
-function encodeWeight(w) {
-    return [w % 256, Math.floor(w / 256), Math.floor(w / (256 * 256))];
-}
-const defaultProps = {
-    data: TilejsonPropType,
-    getWeight: { type: 'accessor', value: 1 }
-};
-class QuadbinHeatmapTileLayer extends CompositeLayer {
-    static { this.layerName = 'QuadbinHeatmapTileLayer'; }
-    static { this.defaultProps = defaultProps; }
-    renderLayers() {
-        const { data, getWeight, colorDomain, colorRange, radiusPixels, _subLayerProps, updateTriggers, ...tileLayerProps } = this.props;
-        // Inject modified polygon layer as sublayer into TileLayer
-        const subLayerProps = {
-            ..._subLayerProps,
-            cell: {
-                ..._subLayerProps?.cell,
-                _subLayerProps: {
-                    ..._subLayerProps?.cell?._subLayerProps,
-                    fill: {
-                        ..._subLayerProps?.cell?._subLayerProps?.fill,
-                        type: RTTSolidPolygonLayer
-                    }
-                }
-            }
-        };
-        const getFillColor = typeof getWeight === 'function'
-            ? (d, info) => encodeWeight(getWeight(d, info))
-            : encodeWeight(getWeight);
-        return new PostProcessQuadbinTileLayer(tileLayerProps, this.getSubLayerProps({
-            id: 'heatmap',
-            data,
-            getFillColor,
-            colorDomain,
-            colorRange,
-            radiusPixels,
-            _subLayerProps: subLayerProps,
-            updateTriggers: {
-                getPosition: updateTriggers.getWeight
-            }
-        }));
-    }
-}
-export default QuadbinHeatmapTileLayer;