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

package/package.json

@@ -2,7 +2,7 @@
   "name": "@deck.gl/aggregation-layers",
   "description": "deck.gl layers that aggregate the input data into alternative representations",
   "license": "MIT",
-  "version": "8.9.0-alpha.5",
+  "version": "8.9.0-beta.2",
   "publishConfig": {
     "access": "public"
   },
@@ -26,8 +26,8 @@
   ],
   "sideEffects": false,
   "scripts": {
-    "build-bundle": "webpack --config ../../scripts/bundle.config.js",
-    "prepublishOnly": "npm run build-bundle && npm run build-bundle -- --env.dev"
+    "build-bundle": "ocular-bundle ./bundle.ts",
+    "prepublishOnly": "npm run build-bundle && npm run build-bundle -- --env=dev"
   },
   "dependencies": {
     "@luma.gl/constants": "^8.5.16",
@@ -40,5 +40,5 @@
     "@deck.gl/layers": "^8.0.0",
     "@luma.gl/core": "^8.0.0"
   },
-  "gitHead": "36330f8ca588055b11ed8032dc68ced641cb258b"
+  "gitHead": "5dae086e4f3eb46c30d8e761f9d600be4f68e949"
 }

package/src/aggregation-layer.ts

@@ -31,7 +31,7 @@ import {filterProps} from './utils/prop-utils';
 export type AggregationLayerProps<DataT = any> = CompositeLayerProps<DataT>;
 
 export default abstract class AggregationLayer<
-  ExtraPropsT = {}
+  ExtraPropsT extends {} = {}
 > extends CompositeLayer<ExtraPropsT> {
   static layerName = 'AggregationLayer';
 

package/src/contour-layer/contour-layer.ts

@@ -50,7 +50,13 @@ const defaultProps: DefaultProps<ContourLayerProps> = {
   aggregation: 'SUM',
 
   // contour lines
-  contours: [{threshold: DEFAULT_THRESHOLD}],
+  contours: {
+    type: 'object',
+    value: [{threshold: DEFAULT_THRESHOLD}],
+    optional: true,
+    compare: true,
+    depth: 2
+  },
 
   zOffset: 0.005
 };
@@ -139,9 +145,10 @@ export type _ContourLayerProps<DataT> = {
 };
 
 /** Aggregate data into iso-lines or iso-bands for a given threshold and cell size. */
-export default class ContourLayer<DataT = any, ExtraPropsT = {}> extends GridAggregationLayer<
-  ExtraPropsT & Required<_ContourLayerProps<DataT>>
-> {
+export default class ContourLayer<
+  DataT = any,
+  ExtraPropsT extends {} = {}
+> extends GridAggregationLayer<ExtraPropsT & Required<_ContourLayerProps<DataT>>> {
   static layerName = 'ContourLayer';
   static defaultProps = defaultProps;
 

package/src/cpu-grid-layer/cpu-grid-layer.ts

@@ -237,9 +237,10 @@ export type _CPUGridLayerProps<DataT> = {
 };
 
 /** Aggregate data into a grid-based heatmap. Aggregation is performed on CPU. */
-export default class CPUGridLayer<DataT = any, ExtraPropsT = {}> extends AggregationLayer<
-  ExtraPropsT & Required<_CPUGridLayerProps<DataT>>
-> {
+export default class CPUGridLayer<
+  DataT = any,
+  ExtraPropsT extends {} = {}
+> extends AggregationLayer<ExtraPropsT & Required<_CPUGridLayerProps<DataT>>> {
   static layerName = 'CPUGridLayer';
   static defaultProps = defaultProps;
 

package/src/gpu-grid-layer/gpu-grid-layer.ts

@@ -169,9 +169,10 @@ export type _GPUGridLayerProps<DataT> = {
 };
 
 /** Aggregate data into a grid-based heatmap. Aggregation is performed on GPU (WebGL2 only). */
-export default class GPUGridLayer<DataT = any, ExtraPropsT = {}> extends GridAggregationLayer<
-  ExtraPropsT & Required<_GPUGridLayerProps<DataT>>
-> {
+export default class GPUGridLayer<
+  DataT = any,
+  ExtraPropsT extends {} = {}
+> extends GridAggregationLayer<ExtraPropsT & Required<_GPUGridLayerProps<DataT>>> {
   static layerName = 'GPUGridLayer';
   static defaultProps = defaultProps;
 

package/src/grid-aggregation-layer.ts

@@ -29,7 +29,7 @@ import {pointToDensityGridDataCPU} from './cpu-grid-layer/grid-aggregator';
 export type GridAggregationLayerProps<DataT = any> = AggregationLayerProps<DataT>;
 
 export default abstract class GridAggregationLayer<
-  ExtraPropsT = {}
+  ExtraPropsT extends {} = {}
 > extends AggregationLayer<ExtraPropsT> {
   static layerName = 'GridAggregationLayer';
 

package/src/grid-layer/grid-layer.ts

@@ -35,7 +35,7 @@ type _GridLayerProps<DataT> = _CPUGridLayerProps<DataT> &
   };
 
 /** Aggregate data into a grid-based heatmap. The color and height of a cell are determined based on the objects it contains. */
-export default class GridLayer<DataT = any, ExtraPropsT = {}> extends CompositeLayer<
+export default class GridLayer<DataT = any, ExtraPropsT extends {} = {}> extends CompositeLayer<
   ExtraPropsT & Required<_GridLayerProps<DataT>>
 > {
   static layerName = 'GridLayer';

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

@@ -187,9 +187,10 @@ type _HeatmapLayerProps<DataT> = {
 };
 
 /** Visualizes the spatial distribution of data. */
-export default class HeatmapLayer<DataT = any, ExtraPropsT = {}> extends AggregationLayer<
-  ExtraPropsT & Required<_HeatmapLayerProps<DataT>>
-> {
+export default class HeatmapLayer<
+  DataT = any,
+  ExtraPropsT extends {} = {}
+> extends AggregationLayer<ExtraPropsT & Required<_HeatmapLayerProps<DataT>>> {
   static layerName = 'HeatmapLayer';
   static defaultProps = defaultProps;
 

package/src/hexagon-layer/hexagon-layer.ts

@@ -247,7 +247,7 @@ type _HexagonLayerProps<DataT = any> = {
 };
 
 /** Aggregates data into a hexagon-based heatmap. The color and height of a hexagon are determined based on the objects it contains. */
-export default class HexagonLayer<ExtraPropsT = {}> extends AggregationLayer<
+export default class HexagonLayer<ExtraPropsT extends {} = {}> extends AggregationLayer<
   ExtraPropsT & Required<_HexagonLayerProps>
 > {
   static layerName = 'HexagonLayer';

package/src/screen-grid-layer/screen-grid-cell-layer.ts

@@ -47,7 +47,7 @@ export type _ScreenGridCellLayerProps<DataT> = _ScreenGridLayerProps<DataT> & {
   maxTexture: Texture2D;
 };
 
-export default class ScreenGridCellLayer<DataT = any, ExtraPropsT = {}> extends Layer<
+export default class ScreenGridCellLayer<DataT = any, ExtraPropsT extends {} = {}> extends Layer<
   ExtraPropsT & Required<_ScreenGridCellLayerProps<DataT>>
 > {
   static layerName = 'ScreenGridCellLayer';

package/src/screen-grid-layer/screen-grid-layer.ts

@@ -139,9 +139,10 @@ export type _ScreenGridLayerProps<DataT> = {
 };
 
 /** Aggregates data into histogram bins and renders them as a grid. */
-export default class ScreenGridLayer<DataT = any, ExtraProps = {}> extends GridAggregationLayer<
-  ExtraProps & Required<_ScreenGridLayerProps<DataT>>
-> {
+export default class ScreenGridLayer<
+  DataT = any,
+  ExtraProps extends {} = {}
+> extends GridAggregationLayer<ExtraProps & Required<_ScreenGridLayerProps<DataT>>> {
   static layerName = 'ScreenGridLayer';
   static defaultProps = defaultProps;
 

package/typed/aggregation-layer.d.ts

@@ -1,6 +1,6 @@
 import { CompositeLayer, AttributeManager, UpdateParameters, CompositeLayerProps } from '@deck.gl/core/typed';
 export declare type AggregationLayerProps<DataT = any> = CompositeLayerProps<DataT>;
-export default abstract class AggregationLayer<ExtraPropsT = {}> extends CompositeLayer<ExtraPropsT> {
+export default abstract class AggregationLayer<ExtraPropsT extends {} = {}> extends CompositeLayer<ExtraPropsT> {
     static layerName: string;
     state: CompositeLayer['state'] & {
         ignoreProps?: Record<string, any>;

package/typed/aggregation-layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregation-layer.d.ts","sourceRoot":"","sources":["../src/aggregation-layer.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,cAAc,EACd,gBAAgB,EAEhB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,eAAe,CAAC;AAIvB,oBAAY,qBAAqB,CAAC,KAAK,GAAG,GAAG,IAAI,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAE5E,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,gBAAgB,CAC5C,WAAW,GAAG,EAAE,CAChB,SAAQ,cAAc,CAAC,WAAW,CAAC;IACnC,MAAM,CAAC,SAAS,SAAsB;IAEtC,KAAK,EAAG,cAAc,CAAC,OAAO,CAAC,GAAG;QAChC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAClC,UAAU,CAAC,EAAE,GAAG,CAAC;KAClB,CAAC;IAEF,0BAA0B,CAAC,UAAU,EAAE,GAAG;IAU1C,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAexC,gBAAgB,CAAC,iBAAiB,KAAA;IAMlC,aAAa;;;IAIb,iBAAiB;IAcjB,aAAa,CAAC,OAAO,KAAA;IAIrB;;;;;;;QAOI;IACJ,kBAAkB,CAChB,UAAU,KAAA,EACV,MAAM,GAAE;QAAC,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,GAAG,CAAA;KAAM,GACnD,MAAM,GAAG,OAAO;IAyCnB;;;;;QAKI;IACJ,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM;IAYhC,oBAAoB;CAMrB"}
+{"version":3,"file":"aggregation-layer.d.ts","sourceRoot":"","sources":["../src/aggregation-layer.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,cAAc,EACd,gBAAgB,EAEhB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,eAAe,CAAC;AAIvB,oBAAY,qBAAqB,CAAC,KAAK,GAAG,GAAG,IAAI,mBAAmB,CAAC,KAAK,CAAC,CAAC;AAE5E,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,gBAAgB,CAC5C,WAAW,SAAS,EAAE,GAAG,EAAE,CAC3B,SAAQ,cAAc,CAAC,WAAW,CAAC;IACnC,MAAM,CAAC,SAAS,SAAsB;IAEtC,KAAK,EAAG,cAAc,CAAC,OAAO,CAAC,GAAG;QAChC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAClC,UAAU,CAAC,EAAE,GAAG,CAAC;KAClB,CAAC;IAEF,0BAA0B,CAAC,UAAU,EAAE,GAAG;IAU1C,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC;IAexC,gBAAgB,CAAC,iBAAiB,KAAA;IAMlC,aAAa;;;IAIb,iBAAiB;IAcjB,aAAa,CAAC,OAAO,KAAA;IAIrB;;;;;;;QAOI;IACJ,kBAAkB,CAChB,UAAU,KAAA,EACV,MAAM,GAAE;QAAC,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,GAAG,CAAA;KAAM,GACnD,MAAM,GAAG,OAAO;IAyCnB;;;;;QAKI;IACJ,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM;IAYhC,oBAAoB;CAMrB"}

package/typed/aggregation-layer.js

@@ -0,0 +1,151 @@
+// 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 { CompositeLayer, AttributeManager, _compareProps as compareProps } from '@deck.gl/core';
+import { cssToDeviceRatio } from '@luma.gl/core';
+import { filterProps } from './utils/prop-utils';
+export default class AggregationLayer extends CompositeLayer {
+    initializeAggregationLayer(dimensions) {
+        super.initializeState(this.context);
+        this.setState({
+            // Layer props , when changed doesn't require updating aggregation
+            ignoreProps: filterProps(this.constructor._propTypes, dimensions.data.props),
+            dimensions
+        });
+    }
+    updateState(opts) {
+        super.updateState(opts);
+        const { changeFlags } = opts;
+        if (changeFlags.extensionsChanged) {
+            const shaders = this.getShaders({});
+            if (shaders && shaders.defines) {
+                shaders.defines.NON_INSTANCED_MODEL = 1;
+            }
+            this.updateShaders(shaders);
+        }
+        // Explictly call to update attributes as 'CompositeLayer' doesn't call this
+        this._updateAttributes();
+    }
+    updateAttributes(changedAttributes) {
+        // Super classes, can refer to state.changedAttributes to determine what
+        // attributes changed
+        this.setState({ changedAttributes });
+    }
+    getAttributes() {
+        return this.getAttributeManager().getShaderAttributes();
+    }
+    getModuleSettings() {
+        // For regular layer draw this happens during draw cycle (_drawLayersInViewport) not during update cycle
+        // For aggregation layers this is called during updateState to update aggregation data
+        // NOTE: it is similar to LayerPass._getModuleParameters() but doesn't inlcude `effects` it is not needed for aggregation
+        const { viewport, mousePosition, gl } = this.context;
+        const moduleSettings = Object.assign(Object.create(this.props), {
+            viewport,
+            mousePosition,
+            pickingActive: 0,
+            devicePixelRatio: cssToDeviceRatio(gl)
+        });
+        return moduleSettings;
+    }
+    updateShaders(shaders) {
+        // Default implemention is empty, subclasses can update their Model objects if needed
+    }
+    /**
+     * Checks if aggregation is dirty
+     * @param {Object} updateOpts - object {props, oldProps, changeFlags}
+     * @param {Object} params - object {dimension, compareAll}
+     * @param {Object} params.dimension - {props, accessors} array of props and/or accessors
+     * @param {Boolean} params.compareAll - when `true` it will include non layer props for comparision
+     * @returns {Boolean} - returns true if dimensions' prop or accessor is changed
+     **/
+    isAggregationDirty(updateOpts, params = {}) {
+        const { props, oldProps, changeFlags } = updateOpts;
+        const { compareAll = false, dimension } = params;
+        const { ignoreProps } = this.state;
+        const { props: dataProps, accessors = [] } = dimension;
+        const { updateTriggersChanged } = changeFlags;
+        if (changeFlags.dataChanged) {
+            return true;
+        }
+        if (updateTriggersChanged) {
+            if (updateTriggersChanged.all) {
+                return true;
+            }
+            for (const accessor of accessors) {
+                if (updateTriggersChanged[accessor]) {
+                    return true;
+                }
+            }
+        }
+        if (compareAll) {
+            if (changeFlags.extensionsChanged) {
+                return true;
+            }
+            // Compare non layer props too (like extension props)
+            // ignoreprops refers to all Layer props other than aggregation props that need to be comapred
+            return compareProps({
+                oldProps,
+                newProps: props,
+                ignoreProps,
+                propTypes: this.constructor._propTypes
+            });
+        }
+        // Compare props of the dimension
+        for (const name of dataProps) {
+            if (props[name] !== oldProps[name]) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Checks if an attribute is changed
+     * @param {String} name - name of the attribute
+     * @returns {Boolean} - `true` if attribute `name` is changed, `false` otherwise,
+     *                       If `name` is not passed or `undefiend`, `true` if any attribute is changed, `false` otherwise
+     **/
+    isAttributeChanged(name) {
+        const { changedAttributes } = this.state;
+        if (!name) {
+            // if name not specified return true if any attribute is changed
+            return !isObjectEmpty(changedAttributes);
+        }
+        return changedAttributes && changedAttributes[name] !== undefined;
+    }
+    // Private
+    // override Composite layer private method to create AttributeManager instance
+    _getAttributeManager() {
+        return new AttributeManager(this.context.gl, {
+            id: this.props.id,
+            stats: this.context.stats
+        });
+    }
+}
+AggregationLayer.layerName = 'AggregationLayer';
+// Helper methods
+// Returns true if given object is empty, false otherwise.
+function isObjectEmpty(obj) {
+    let isEmpty = true;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    for (const key in obj) {
+        isEmpty = false;
+        break;
+    }
+    return isEmpty;
+}

package/typed/contour-layer/contour-layer.d.ts

@@ -60,7 +60,7 @@ export declare type _ContourLayerProps<DataT> = {
     getWeight?: Accessor<DataT, number>;
 };
 /** Aggregate data into iso-lines or iso-bands for a given threshold and cell size. */
-export default class ContourLayer<DataT = any, ExtraPropsT = {}> extends GridAggregationLayer<ExtraPropsT & Required<_ContourLayerProps<DataT>>> {
+export default class ContourLayer<DataT = any, ExtraPropsT extends {} = {}> extends GridAggregationLayer<ExtraPropsT & Required<_ContourLayerProps<DataT>>> {
     static layerName: string;
     static defaultProps: DefaultProps<ContourLayerProps<any>>;
     initializeState(): void;

package/typed/contour-layer/contour-layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contour-layer.d.ts","sourceRoot":"","sources":["../../src/contour-layer/contour-layer.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,KAAK,EACL,KAAK,EAEL,QAAQ,EACR,gBAAgB,EAChB,YAAY,EACb,MAAM,eAAe,CAAC;AAKvB,OAAO,oBAAoB,EAAE,EAAC,yBAAyB,EAAC,MAAM,2BAA2B,CAAC;AAgC1F,gDAAgD;AAChD,oBAAY,iBAAiB,CAAC,KAAK,GAAG,GAAG,IAAI,kBAAkB,CAAC,KAAK,CAAC,GACpE,yBAAyB,CAAC,KAAK,CAAC,CAAC;AAEnC,wCAAwC;AACxC,oBAAY,kBAAkB,CAAC,KAAK,IAAI;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,WAAW,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;IAE7C;;;OAGG;IACH,QAAQ,EAAE;QACR;;;;WAIG;QACH,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;QAE7B;;;WAGG;QACH,KAAK,CAAC,EAAE,KAAK,CAAC;QAEd;;;WAGG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC;QAErB,sCAAsC;QACtC,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,EAAE,CAAC;IAEJ;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAEhD;;;OAGG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CACrC,CAAC;AAEF,sFAAsF;AACtF,MAAM,CAAC,OAAO,OAAO,YAAY,CAAC,KAAK,GAAG,GAAG,EAAE,WAAW,GAAG,EAAE,CAAE,SAAQ,oBAAoB,CAC3F,WAAW,GAAG,QAAQ,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAClD;IACC,MAAM,CAAC,SAAS,SAAkB;IAClC,MAAM,CAAC,YAAY,uCAAgB;IAEnC,eAAe,IAAI,IAAI;IA2BvB,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;IAgB/C,YAAY,IAAI,KAAK,EAAE;IA4CvB,sBAAsB,CAAC,IAAI,KAAA;IAyE3B,OAAO,CAAC,gBAAgB;IAUxB,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,iBAAiB;IAsBzB,OAAO,CAAC,oBAAoB;CAc7B"}
+{"version":3,"file":"contour-layer.d.ts","sourceRoot":"","sources":["../../src/contour-layer/contour-layer.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,KAAK,EACL,KAAK,EAEL,QAAQ,EACR,gBAAgB,EAChB,YAAY,EACb,MAAM,eAAe,CAAC;AAKvB,OAAO,oBAAoB,EAAE,EAAC,yBAAyB,EAAC,MAAM,2BAA2B,CAAC;AAsC1F,gDAAgD;AAChD,oBAAY,iBAAiB,CAAC,KAAK,GAAG,GAAG,IAAI,kBAAkB,CAAC,KAAK,CAAC,GACpE,yBAAyB,CAAC,KAAK,CAAC,CAAC;AAEnC,wCAAwC;AACxC,oBAAY,kBAAkB,CAAC,KAAK,IAAI;IACtC;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,WAAW,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;IAE7C;;;OAGG;IACH,QAAQ,EAAE;QACR;;;;WAIG;QACH,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;QAE7B;;;WAGG;QACH,KAAK,CAAC,EAAE,KAAK,CAAC;QAEd;;;WAGG;QACH,WAAW,CAAC,EAAE,MAAM,CAAC;QAErB,sCAAsC;QACtC,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,EAAE,CAAC;IAEJ;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAEhD;;;OAGG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;CACrC,CAAC;AAEF,sFAAsF;AACtF,MAAM,CAAC,OAAO,OAAO,YAAY,CAC/B,KAAK,GAAG,GAAG,EACX,WAAW,SAAS,EAAE,GAAG,EAAE,CAC3B,SAAQ,oBAAoB,CAAC,WAAW,GAAG,QAAQ,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC;IAC/E,MAAM,CAAC,SAAS,SAAkB;IAClC,MAAM,CAAC,YAAY,uCAAgB;IAEnC,eAAe,IAAI,IAAI;IA2BvB,WAAW,CAAC,IAAI,EAAE,gBAAgB,CAAC,IAAI,CAAC,GAAG,IAAI;IAgB/C,YAAY,IAAI,KAAK,EAAE;IA4CvB,sBAAsB,CAAC,IAAI,KAAA;IAyE3B,OAAO,CAAC,gBAAgB;IAUxB,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,iBAAiB;IAsBzB,OAAO,CAAC,oBAAoB;CAc7B"}

package/typed/contour-layer/contour-layer.js

@@ -0,0 +1,234 @@
+// Copyright (c) 2015 - 2018 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 GL from '@luma.gl/constants';
+import { LineLayer, SolidPolygonLayer } from '@deck.gl/layers';
+import { generateContours } from './contour-utils';
+import { log } from '@deck.gl/core';
+import GPUGridAggregator from '../utils/gpu-grid-aggregation/gpu-grid-aggregator';
+import { AGGREGATION_OPERATION, getValueFunc } from '../utils/aggregation-operation-utils';
+import { getBoundingBox, getGridParams } from '../utils/grid-aggregation-utils';
+import GridAggregationLayer from '../grid-aggregation-layer';
+const DEFAULT_COLOR = [255, 255, 255, 255];
+const DEFAULT_STROKE_WIDTH = 1;
+const DEFAULT_THRESHOLD = 1;
+const defaultProps = {
+    // grid aggregation
+    cellSize: { type: 'number', min: 1, max: 1000, value: 1000 },
+    getPosition: { type: 'accessor', value: x => x.position },
+    getWeight: { type: 'accessor', value: 1 },
+    gpuAggregation: true,
+    aggregation: 'SUM',
+    // contour lines
+    contours: [{ threshold: DEFAULT_THRESHOLD }],
+    zOffset: 0.005
+};
+const POSITION_ATTRIBUTE_NAME = 'positions';
+const DIMENSIONS = {
+    data: {
+        props: ['cellSize']
+    },
+    weights: {
+        props: ['aggregation'],
+        accessors: ['getWeight']
+    }
+};
+export default class ContourLayer extends GridAggregationLayer {
+    initializeState() {
+        super.initializeAggregationLayer({
+            dimensions: DIMENSIONS
+        });
+        this.setState({
+            contourData: {},
+            projectPoints: false,
+            weights: {
+                count: {
+                    size: 1,
+                    operation: AGGREGATION_OPERATION.SUM
+                }
+            }
+        });
+        const attributeManager = this.getAttributeManager();
+        attributeManager.add({
+            [POSITION_ATTRIBUTE_NAME]: {
+                size: 3,
+                accessor: 'getPosition',
+                type: GL.DOUBLE,
+                fp64: this.use64bitPositions()
+            },
+            // this attribute is used in gpu aggregation path only
+            count: { size: 3, accessor: 'getWeight' }
+        });
+    }
+    updateState(opts) {
+        super.updateState(opts);
+        let contoursChanged = false;
+        const { oldProps, props } = opts;
+        const { aggregationDirty } = this.state;
+        if (oldProps.contours !== props.contours || oldProps.zOffset !== props.zOffset) {
+            contoursChanged = true;
+            this._updateThresholdData(opts.props);
+        }
+        if (this.getNumInstances() > 0 && (aggregationDirty || contoursChanged)) {
+            this._generateContours();
+        }
+    }
+    renderLayers() {
+        const { contourSegments, contourPolygons } = this.state.contourData;
+        const LinesSubLayerClass = this.getSubLayerClass('lines', LineLayer);
+        const BandsSubLayerClass = this.getSubLayerClass('bands', SolidPolygonLayer);
+        // Contour lines layer
+        const lineLayer = contourSegments &&
+            contourSegments.length > 0 &&
+            new LinesSubLayerClass(this.getSubLayerProps({
+                id: 'lines'
+            }), {
+                data: this.state.contourData.contourSegments,
+                getSourcePosition: d => d.start,
+                getTargetPosition: d => d.end,
+                getColor: d => d.contour.color || DEFAULT_COLOR,
+                getWidth: d => d.contour.strokeWidth || DEFAULT_STROKE_WIDTH
+            });
+        // Contour bands layer
+        const bandsLayer = contourPolygons &&
+            contourPolygons.length > 0 &&
+            new BandsSubLayerClass(this.getSubLayerProps({
+                id: 'bands'
+            }), {
+                data: this.state.contourData.contourPolygons,
+                getPolygon: d => d.vertices,
+                getFillColor: d => d.contour.color || DEFAULT_COLOR
+            });
+        return [lineLayer, bandsLayer];
+    }
+    // Aggregation Overrides
+    /* eslint-disable max-statements, complexity */
+    updateAggregationState(opts) {
+        const { props, oldProps } = opts;
+        const { cellSize, coordinateSystem } = props;
+        const { viewport } = this.context;
+        const cellSizeChanged = oldProps.cellSize !== cellSize;
+        let gpuAggregation = props.gpuAggregation;
+        if (this.state.gpuAggregation !== props.gpuAggregation) {
+            if (gpuAggregation && !GPUGridAggregator.isSupported(this.context.gl)) {
+                log.warn('GPU Grid Aggregation not supported, falling back to CPU')();
+                gpuAggregation = false;
+            }
+        }
+        const gpuAggregationChanged = gpuAggregation !== this.state.gpuAggregation;
+        this.setState({
+            gpuAggregation
+        });
+        const { dimensions } = this.state;
+        const positionsChanged = this.isAttributeChanged(POSITION_ATTRIBUTE_NAME);
+        const { data, weights } = dimensions;
+        let { boundingBox } = this.state;
+        if (positionsChanged) {
+            boundingBox = getBoundingBox(this.getAttributes(), this.getNumInstances());
+            this.setState({ boundingBox });
+        }
+        if (positionsChanged || cellSizeChanged) {
+            const { gridOffset, translation, width, height, numCol, numRow } = getGridParams(boundingBox, cellSize, viewport, coordinateSystem);
+            this.allocateResources(numRow, numCol);
+            this.setState({
+                gridOffset,
+                boundingBox,
+                translation,
+                posOffset: translation.slice(),
+                gridOrigin: [-1 * translation[0], -1 * translation[1]],
+                width,
+                height,
+                numCol,
+                numRow
+            });
+        }
+        const aggregationDataDirty = positionsChanged ||
+            gpuAggregationChanged ||
+            this.isAggregationDirty(opts, {
+                dimension: data,
+                compareAll: gpuAggregation // check for all (including extentions props) when using gpu aggregation
+            });
+        const aggregationWeightsDirty = this.isAggregationDirty(opts, {
+            dimension: weights
+        });
+        if (aggregationWeightsDirty) {
+            this._updateAccessors(opts);
+        }
+        if (aggregationDataDirty || aggregationWeightsDirty) {
+            this._resetResults();
+        }
+        this.setState({
+            aggregationDataDirty,
+            aggregationWeightsDirty
+        });
+    }
+    /* eslint-enable max-statements, complexity */
+    // Private (Aggregation)
+    _updateAccessors(opts) {
+        const { getWeight, aggregation, data } = opts.props;
+        const { count } = this.state.weights;
+        if (count) {
+            count.getWeight = getWeight;
+            count.operation = AGGREGATION_OPERATION[aggregation];
+        }
+        this.setState({ getValue: getValueFunc(aggregation, getWeight, { data }) });
+    }
+    _resetResults() {
+        const { count } = this.state.weights;
+        if (count) {
+            count.aggregationData = null;
+        }
+    }
+    // Private (Contours)
+    _generateContours() {
+        const { numCol, numRow, gridOrigin, gridOffset, thresholdData } = this.state;
+        const { count } = this.state.weights;
+        let { aggregationData } = count;
+        if (!aggregationData) {
+            aggregationData = count.aggregationBuffer.getData();
+            count.aggregationData = aggregationData;
+        }
+        const { cellWeights } = GPUGridAggregator.getCellData({ countsData: aggregationData });
+        const contourData = generateContours({
+            thresholdData,
+            cellWeights,
+            gridSize: [numCol, numRow],
+            gridOrigin,
+            cellSize: [gridOffset.xOffset, gridOffset.yOffset]
+        });
+        // contourData contains both iso-lines and iso-bands if requested.
+        this.setState({ contourData });
+    }
+    _updateThresholdData(props) {
+        const { contours, zOffset } = props;
+        const count = contours.length;
+        const thresholdData = new Array(count);
+        for (let i = 0; i < count; i++) {
+            const contour = contours[i];
+            thresholdData[i] = {
+                contour,
+                zIndex: contour.zIndex || i,
+                zOffset
+            };
+        }
+        this.setState({ thresholdData });
+    }
+}
+ContourLayer.layerName = 'ContourLayer';
+ContourLayer.defaultProps = defaultProps;

package/typed/contour-layer/contour-utils.js

@@ -0,0 +1,64 @@
+import { getCode, getVertices, CONTOUR_TYPE } from './marching-squares';
+// Given all the cell weights, generates contours for each threshold.
+/* eslint-disable max-depth */
+export function generateContours({ thresholdData, cellWeights, gridSize, gridOrigin, cellSize }) {
+    const contourSegments = [];
+    const contourPolygons = [];
+    const width = gridSize[0];
+    const height = gridSize[1];
+    let segmentIndex = 0;
+    let polygonIndex = 0;
+    for (const data of thresholdData) {
+        const { contour } = data;
+        const { threshold } = contour;
+        for (let x = -1; x < width; x++) {
+            for (let y = -1; y < height; y++) {
+                // Get the MarchingSquares code based on neighbor cell weights.
+                const { code, meanCode } = getCode({
+                    cellWeights,
+                    threshold,
+                    x,
+                    y,
+                    width,
+                    height
+                });
+                const opts = {
+                    type: CONTOUR_TYPE.ISO_BANDS,
+                    gridOrigin,
+                    cellSize,
+                    x,
+                    y,
+                    width,
+                    height,
+                    code,
+                    meanCode,
+                    thresholdData: data
+                };
+                if (Array.isArray(threshold)) {
+                    opts.type = CONTOUR_TYPE.ISO_BANDS;
+                    const polygons = getVertices(opts);
+                    for (const polygon of polygons) {
+                        contourPolygons[polygonIndex++] = {
+                            vertices: polygon,
+                            contour
+                        };
+                    }
+                }
+                else {
+                    // Get the intersection vertices based on MarchingSquares code.
+                    opts.type = CONTOUR_TYPE.ISO_LINES;
+                    const vertices = getVertices(opts);
+                    for (let i = 0; i < vertices.length; i += 2) {
+                        contourSegments[segmentIndex++] = {
+                            start: vertices[i],
+                            end: vertices[i + 1],
+                            contour
+                        };
+                    }
+                }
+            }
+        }
+    }
+    return { contourSegments, contourPolygons };
+}
+/* eslint-enable max-depth */