@deck.gl/aggregation-layers 8.8.0-alpha.5 → 8.8.0-alpha.6

package/typed/utils/cpu-aggregator.d.ts

@@ -0,0 +1,155 @@
+export default class CPUAggregator {
+    static defaultDimensions(): ({
+        key: string;
+        accessor: string;
+        pickingInfo: string;
+        getBins: {
+            triggers: {
+                value: {
+                    prop: string;
+                    updateTrigger: string;
+                };
+                weight: {
+                    prop: string;
+                    updateTrigger: string;
+                };
+                aggregation: {
+                    prop: string;
+                };
+                filterData: {
+                    prop: string;
+                    updateTrigger: string;
+                };
+            };
+        };
+        getDomain: {
+            triggers: {
+                lowerPercentile: {
+                    prop: string;
+                };
+                upperPercentile: {
+                    prop: string;
+                };
+                scaleType: {
+                    prop: string;
+                };
+            };
+        };
+        getScaleFunc: {
+            triggers: {
+                domain: {
+                    prop: string;
+                };
+                range: {
+                    prop: string;
+                };
+            };
+            onSet: {
+                props: string;
+            };
+        };
+        nullValue: number[];
+    } | {
+        key: string;
+        accessor: string;
+        pickingInfo: string;
+        getBins: {
+            triggers: {
+                value: {
+                    prop: string;
+                    updateTrigger: string;
+                };
+                weight: {
+                    prop: string;
+                    updateTrigger: string;
+                };
+                aggregation: {
+                    prop: string;
+                };
+                filterData: {
+                    prop: string;
+                    updateTrigger: string;
+                };
+            };
+        };
+        getDomain: {
+            triggers: {
+                lowerPercentile: {
+                    prop: string;
+                };
+                upperPercentile: {
+                    prop: string;
+                };
+                scaleType: {
+                    prop: string;
+                };
+            };
+        };
+        getScaleFunc: {
+            triggers: {
+                domain: {
+                    prop: string;
+                };
+                range: {
+                    prop: string;
+                };
+            };
+            onSet: {
+                props: string;
+            };
+        };
+        nullValue: number;
+    })[];
+    constructor(opts: any);
+    state: {
+        layerData: {};
+        dimensions: {};
+    };
+    changeFlags: {};
+    dimensionUpdaters: {};
+    _getCellSize: any;
+    _getAggregator: any;
+    updateState(opts: any, aggregationParams: any): {
+        layerData: {};
+        dimensions: {};
+    };
+    setState(updateObject: any): void;
+    setDimensionState(key: any, updateObject: any): void;
+    normalizeResult(result?: {}): {};
+    getAggregatedData(props: any, aggregationParams: any): void;
+    updateGetValueFuncs(oldProps: any, props: any, changeFlags: any): void;
+    needsReProjectPoints(oldProps: any, props: any, changeFlags: any): any;
+    addDimension(dimensions: any): void;
+    _addDimension(dimensions?: any[]): void;
+    getDimensionUpdaters({ key, accessor, pickingInfo, getBins, getDomain, getScaleFunc, nullValue }: {
+        key: any;
+        accessor: any;
+        pickingInfo: any;
+        getBins: any;
+        getDomain: any;
+        getScaleFunc: any;
+        nullValue: any;
+    }): {
+        key: any;
+        accessor: any;
+        pickingInfo: any;
+        getBins: any;
+        getDomain: any;
+        getScaleFunc: any;
+        attributeAccessor: (cell: any) => any;
+    };
+    needUpdateDimensionStep(dimensionStep: any, oldProps: any, props: any, changeFlags: any): boolean;
+    getDimensionChanges(oldProps: any, props: any, changeFlags: any): any[] | null;
+    getUpdateTriggers(props: any): {};
+    getSortedBins(props: any): void;
+    getDimensionSortedBins(props: any, dimensionUpdater: any): void;
+    getDimensionValueDomain(props: any, dimensionUpdater: any): void;
+    getDimensionScale(props: any, dimensionUpdater: any): void;
+    getSubLayerDimensionAttribute(key: any, nullValue: any): (cell: any) => any;
+    getSubLayerAccessors(props: any): {};
+    getPickingInfo({ info }: {
+        info: any;
+    }): any;
+    getAccessor(dimensionKey: any): any;
+}
+//# sourceMappingURL=cpu-aggregator.d.ts.map

package/typed/utils/cpu-aggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cpu-aggregator.d.ts","sourceRoot":"","sources":["../../src/utils/cpu-aggregator.js"],"names":[],"mappings":"AA2HA;IA2BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAEC;IA5BD,uBAwBC;IAvBC;;;MAgBC;IACD,gBAAqB;IACrB,sBAA2B;IAE3B,kBAA0D;IAC1D,oBAAwC;IAQ1C;;;MAkBC;IAGD,kCAEC;IAGD,qDAOC;IAED,iCASC;IAED,4DAWC;IAED,uEAwBC;IAED,uEAOC;IAGD,oCAEC;IAED,wCAWC;IAED;;;;;;;;;;;;;;;;MAUC;IAED,kGAgCC;IAED,+EA4BC;IAED,kCAiCC;IAED,gCAIC;IAED,gEAUC;IAED,iEAYC;IAED,2DAeC;IAED,4EAiBC;IAED,qCAQC;IAED;;YA2BC;IAED,oCAKC;CACF"}

package/typed/utils/gpu-grid-aggregation/aggregate-all-fs.glsl.d.ts

@@ -0,0 +1,3 @@
+declare var _default: "#version 300 es\n#define SHADER_NAME gpu-aggregation-all-fs\n\nprecision highp float;\n\nin vec2 vTextureCoord;\nuniform sampler2D uSampler;\nuniform bool combineMaxMin;\nout vec4 fragColor;\nvoid main(void) {\n  vec4 textureColor = texture(uSampler, vec2(vTextureCoord.s, vTextureCoord.t));\n  if (textureColor.a == 0.) {\n    discard;\n  }\n  fragColor.rgb = textureColor.rgb;\n  // if combineMinMax is true, use Alpha channel for first weights min value.\n  fragColor.a = combineMaxMin ? textureColor.r : textureColor.a;\n}\n";
+export default _default;
+//# sourceMappingURL=aggregate-all-fs.glsl.d.ts.map

package/typed/utils/gpu-grid-aggregation/aggregate-all-fs.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-all-fs.glsl.d.ts","sourceRoot":"","sources":["../../../src/utils/gpu-grid-aggregation/aggregate-all-fs.glsl.js"],"names":[],"mappings":""}

package/typed/utils/gpu-grid-aggregation/aggregate-all-vs.glsl.d.ts

@@ -0,0 +1,3 @@
+declare var _default: "#version 300 es\n#define SHADER_NAME gpu-aggregation-all-vs-64\n\nin vec2 position;\nuniform ivec2 gridSize;\nout vec2 vTextureCoord;\n\nvoid main(void) {\n  // Map each position to single pixel\n  vec2 pos = vec2(-1.0, -1.0);\n\n  // Move to pixel center, pixel-size in screen sapce (2/gridSize) * 0.5 => 1/gridSize\n  vec2 offset = 1.0 / vec2(gridSize);\n  pos = pos + offset;\n\n  gl_Position = vec4(pos, 0.0, 1.0);\n\n  int yIndex = gl_InstanceID / gridSize[0];\n  int xIndex = gl_InstanceID - (yIndex * gridSize[0]);\n\n  vec2 yIndexFP64 = vec2(float(yIndex), 0.);\n  vec2 xIndexFP64 = vec2(float(xIndex), 0.);\n  vec2 gridSizeYFP64 = vec2(gridSize[1], 0.);\n  vec2 gridSizeXFP64 = vec2(gridSize[0], 0.);\n\n  vec2 texCoordXFP64 = div_fp64(yIndexFP64, gridSizeYFP64);\n  vec2 texCoordYFP64 = div_fp64(xIndexFP64, gridSizeXFP64);\n\n  vTextureCoord = vec2(texCoordYFP64.x, texCoordXFP64.x);\n  // Enforce default value for ANGLE issue (https://bugs.chromium.org/p/angleproject/issues/detail?id=3941)\n  gl_PointSize = 1.0;\n}\n";
+export default _default;
+//# sourceMappingURL=aggregate-all-vs.glsl.d.ts.map

package/typed/utils/gpu-grid-aggregation/aggregate-all-vs.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-all-vs.glsl.d.ts","sourceRoot":"","sources":["../../../src/utils/gpu-grid-aggregation/aggregate-all-vs.glsl.js"],"names":[],"mappings":""}

package/typed/utils/gpu-grid-aggregation/aggregate-to-grid-fs.glsl.d.ts

@@ -0,0 +1,3 @@
+declare var _default: "#define SHADER_NAME gpu-aggregation-to-grid-fs\n\nprecision highp float;\n\nvarying vec3 vWeights;\n\nvoid main(void) {\n  gl_FragColor = vec4(vWeights, 1.0);\n  DECKGL_FILTER_COLOR(gl_FragColor, geometry);\n}\n";
+export default _default;
+//# sourceMappingURL=aggregate-to-grid-fs.glsl.d.ts.map

package/typed/utils/gpu-grid-aggregation/aggregate-to-grid-fs.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-to-grid-fs.glsl.d.ts","sourceRoot":"","sources":["../../../src/utils/gpu-grid-aggregation/aggregate-to-grid-fs.glsl.js"],"names":[],"mappings":""}

package/typed/utils/gpu-grid-aggregation/aggregate-to-grid-vs.glsl.d.ts

@@ -0,0 +1,3 @@
+declare var _default: "#define SHADER_NAME gpu-aggregation-to-grid-vs\n\nattribute vec3 positions;\nattribute vec3 positions64Low;\nattribute vec3 weights;\nuniform vec2 cellSize;\nuniform vec2 gridSize;\nuniform bool projectPoints;\nuniform vec2 translation;\nuniform vec3 scaling;\n\nvarying vec3 vWeights;\n\nvec2 project_to_pixel(vec4 pos) {\n  vec4 result;\n  pos.xy = pos.xy/pos.w;\n  result = pos + vec4(translation, 0., 0.);\n  result.xy = scaling.z > 0. ? result.xy * scaling.xy : result.xy;\n  return result.xy;\n}\n\nvoid main(void) {\n\n  vWeights = weights;\n\n  vec4 windowPos = vec4(positions, 1.);\n  if (projectPoints) {\n    windowPos = project_position_to_clipspace(positions, positions64Low, vec3(0));\n  }\n\n  vec2 pos = project_to_pixel(windowPos);\n\n  vec2 pixelXY64[2];\n  pixelXY64[0] = vec2(pos.x, 0.);\n  pixelXY64[1] = vec2(pos.y, 0.);\n\n  // Transform (0,0):windowSize -> (0, 0): gridSize\n  vec2 gridXY64[2];\n  gridXY64[0] = div_fp64(pixelXY64[0], vec2(cellSize.x, 0));\n  gridXY64[1] = div_fp64(pixelXY64[1], vec2(cellSize.y, 0));\n  float x = floor(gridXY64[0].x);\n  float y = floor(gridXY64[1].x);\n  pos = vec2(x, y);\n\n  // Transform (0,0):gridSize -> (-1, -1):(1,1)\n  pos = (pos * (2., 2.) / (gridSize)) - (1., 1.);\n\n  // Move to pixel center, pixel-size in screen sapce (2/gridSize) * 0.5 => 1/gridSize\n  vec2 offset = 1.0 / gridSize;\n  pos = pos + offset;\n\n  gl_Position = vec4(pos, 0.0, 1.0);\n\n  // Enforce default value for ANGLE issue (https://bugs.chromium.org/p/angleproject/issues/detail?id=3941)\n  gl_PointSize = 1.0;\n}\n";
+export default _default;
+//# sourceMappingURL=aggregate-to-grid-vs.glsl.d.ts.map

package/typed/utils/gpu-grid-aggregation/aggregate-to-grid-vs.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-to-grid-vs.glsl.d.ts","sourceRoot":"","sources":["../../../src/utils/gpu-grid-aggregation/aggregate-to-grid-vs.glsl.js"],"names":[],"mappings":""}

package/typed/utils/gpu-grid-aggregation/gpu-grid-aggregator-constants.d.ts

@@ -0,0 +1,36 @@
+export namespace DEFAULT_RUN_PARAMS {
+    const projectPoints: boolean;
+    const viewport: null;
+    const createBufferObjects: boolean;
+    const moduleSettings: {};
+}
+export const MAX_32_BIT_FLOAT: 3.402823466e+38;
+export const MIN_BLEND_EQUATION: number[];
+export const MAX_BLEND_EQUATION: number[];
+export const MAX_MIN_BLEND_EQUATION: number[];
+export const EQUATION_MAP: {
+    [x: number]: number | number[];
+};
+export const ELEMENTCOUNT: 4;
+export namespace DEFAULT_WEIGHT_PARAMS {
+    const size: number;
+    const operation: number;
+    const needMin: boolean;
+    const needMax: boolean;
+    const combineMaxMin: boolean;
+}
+export const PIXEL_SIZE: 4;
+export const WEIGHT_SIZE: 3;
+export namespace MAX_MIN_TEXTURE_OPTS {
+    const format: number;
+    const type: number;
+    const border: number;
+    const mipmaps: boolean;
+    const parameters: {
+        [x: number]: number;
+    };
+    const dataFormat: number;
+    const width: number;
+    const height: number;
+}
+//# sourceMappingURL=gpu-grid-aggregator-constants.d.ts.map

package/typed/utils/gpu-grid-aggregation/gpu-grid-aggregator-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-grid-aggregator-constants.d.ts","sourceRoot":"","sources":["../../../src/utils/gpu-grid-aggregation/gpu-grid-aggregator-constants.js"],"names":[],"mappings":";;;;;;AAUA,+CAA+C;AAC/C,0CAAwD;AACxD,0CAAwD;AACxD,8CAAuD;AACvD;;EAKE;AAEF,6BAA8B;;;;;;;;AAS9B,2BAA4B;AAC5B,4BAA6B"}

package/typed/utils/gpu-grid-aggregation/gpu-grid-aggregator-utils.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=gpu-grid-aggregator-utils.d.ts.map

package/typed/utils/gpu-grid-aggregation/gpu-grid-aggregator-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-grid-aggregator-utils.d.ts","sourceRoot":"","sources":["../../../src/utils/gpu-grid-aggregation/gpu-grid-aggregator-utils.js"],"names":[],"mappings":""}

package/typed/utils/gpu-grid-aggregation/gpu-grid-aggregator.d.ts

@@ -0,0 +1,66 @@
+export default class GPUGridAggregator {
+    static getAggregationData({ aggregationData, maxData, minData, maxMinData, pixelIndex }: {
+        aggregationData: any;
+        maxData: any;
+        minData: any;
+        maxMinData: any;
+        pixelIndex: any;
+    }): {
+        cellCount: any;
+        cellWeight: any;
+        maxCellWieght: any;
+        minCellWeight: any;
+        totalCount: any;
+    };
+    static getCellData({ countsData, size }: {
+        countsData: any;
+        size?: number | undefined;
+    }): {
+        cellCounts: Uint32Array;
+        cellWeights: Float32Array;
+    };
+    static isSupported(gl: any): any;
+    constructor(gl: any, opts?: {});
+    id: any;
+    gl: any;
+    state: {
+        weightAttributes: {};
+        textures: {};
+        meanTextures: {};
+        buffers: {};
+        framebuffers: {};
+        maxMinFramebuffers: {};
+        minFramebuffers: {};
+        maxFramebuffers: {};
+        equations: {};
+        resources: {};
+        results: {};
+    };
+    _hasGPUSupport: any;
+    delete(): void;
+    run(opts?: {}): {};
+    getData(weightId: any): {
+        aggregationData: any;
+    };
+    updateShaders(shaderOptions?: {}): void;
+    _normalizeAggregationParams(opts: any): any;
+    setState(updateObject: any): void;
+    _getAggregateData(opts: any): {};
+    _renderAggregateData(opts: any): void;
+    _renderToMaxMinTexture(opts: any): void;
+    _renderToWeightsTexture(opts: any): void;
+    meanTransform: any;
+    _runAggregation(opts: any): {};
+    _setupFramebuffers(opts: any): void;
+    _getMinMaxTexture(name: any): any;
+    _setupModels({ numCol, numRow }?: {
+        numCol?: number | undefined;
+        numRow?: number | undefined;
+    }): void;
+    gridAggregationModel: any;
+    allAggregationModel: any;
+    _setupWeightAttributes(opts: any): void;
+    _trackGPUResultBuffers(results: any, weights: any): void;
+    _updateModels(opts: any): void;
+}
+//# sourceMappingURL=gpu-grid-aggregator.d.ts.map

package/typed/utils/gpu-grid-aggregation/gpu-grid-aggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpu-grid-aggregator.d.ts","sourceRoot":"","sources":["../../../src/utils/gpu-grid-aggregation/gpu-grid-aggregator.js"],"names":[],"mappings":"AAmEA;IAEE;;;;;;;;;;;;MAqBC;IAGD;;;;;;MAaC;IAED,iCAEC;IA2BD,gCAgCC;IA/BC,QAA0C;IAC1C,QAAY;IACZ;;;;;;;;;;;;MAiBC;IACD,oBAOG;IAOL,eAyBC;IAGD,mBAQC;IAKD;;MAqBC;IAED,wCAEC;IAID,4CAOC;IAGD,kCAEC;IAID,iCA6CC;IAED,sCAwEC;IAGD,wCAyBC;IAGD,yCAoDC;IAZK,mBAA2D;IAcjE,+BAOC;IAID,oCAsEC;IAGD,kCAMC;IAED;;;aASC;IALC,0BAAkE;IAGhE,yBAAoE;IAKxE,wCAMC;IAID,yDAiBC;IAGD,+BAgBC;CACF"}

package/typed/utils/gpu-grid-aggregation/transform-mean-vs.glsl.d.ts

@@ -0,0 +1,3 @@
+declare var _default: "#define SHADER_NAME gpu-aggregation-transform-mean-vs\nattribute vec4 aggregationValues;\nvarying vec4 meanValues;\n\nvoid main()\n{\n  // TODO: Use 64-bit division ?? not needed given this is aggregation ??\n  bool isCellValid = bool(aggregationValues.w > 0.);\n  // aggregationValues:  XYZ contain aggregated values, W contains count\n  meanValues.xyz = isCellValid ? aggregationValues.xyz/aggregationValues.w : vec3(0, 0, 0);\n  meanValues.w = aggregationValues.w;\n\n  // Enforce default value for ANGLE issue (https://bugs.chromium.org/p/angleproject/issues/detail?id=3941)\n  gl_PointSize = 1.0;\n}\n";
+export default _default;
+//# sourceMappingURL=transform-mean-vs.glsl.d.ts.map

package/typed/utils/gpu-grid-aggregation/transform-mean-vs.glsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform-mean-vs.glsl.d.ts","sourceRoot":"","sources":["../../../src/utils/gpu-grid-aggregation/transform-mean-vs.glsl.js"],"names":[],"mappings":""}

package/typed/utils/grid-aggregation-utils.d.ts

@@ -0,0 +1,24 @@
+export function getBoundingBox(attributes: any, vertexCount: any): {
+    xMin: any;
+    xMax: any;
+    yMin: any;
+    yMax: any;
+};
+export function alignToCell(inValue: any, cellSize: any): number;
+/**
+ * Based on geometric center of sample points, calculate cellSize in lng/lat (degree) space
+ * @param {object} boundingBox - {xMin, yMin, xMax, yMax} contains bounding box of data
+ * @param {number} cellSize - grid cell size in meters
+ * @param {boolean, optional} converToDegrees - when true offsets are converted from meters to lng/lat (degree) space
+ * @returns {xOffset, yOffset} - cellSize size
+ */
+export function getGridOffset(boundingBox: object, cellSize: number, convertToMeters?: boolean): any;
+export function getGridParams(boundingBox: any, cellSize: any, viewport: any, coordinateSystem: any): {
+    gridOffset: any;
+    translation: number[];
+    width: any;
+    height: any;
+    numCol: number;
+    numRow: number;
+};
+//# sourceMappingURL=grid-aggregation-utils.d.ts.map

package/typed/utils/grid-aggregation-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid-aggregation-utils.d.ts","sourceRoot":"","sources":["../../src/utils/grid-aggregation-utils.js"],"names":[],"mappings":"AASA;;;;;EA4BC;AA4BD,iEAQC;AAED;;;;;;GAMG;AAEH,2CANW,MAAM,YACN,MAAM,kCAchB;AAED;;;;;;;EAiBC"}

package/typed/utils/prop-utils.d.ts

@@ -0,0 +1,2 @@
+export function filterProps(props: any, filterKeys: any): {};
+//# sourceMappingURL=prop-utils.d.ts.map

package/typed/utils/prop-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-utils.d.ts","sourceRoot":"","sources":["../../src/utils/prop-utils.js"],"names":[],"mappings":"AAoBA,6DAQC"}

package/typed/utils/resource-utils.d.ts

@@ -0,0 +1,4 @@
+export function getFloatTexture(gl: any, opts?: {}): any;
+export function getFramebuffer(gl: any, opts: any): any;
+export function getFloatArray(array: any, size: any, fillValue?: number): any;
+//# sourceMappingURL=resource-utils.d.ts.map

package/typed/utils/resource-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-utils.d.ts","sourceRoot":"","sources":["../../src/utils/resource-utils.js"],"names":[],"mappings":"AAQA,yDAqBC;AAED,wDAYC;AAED,8EAKC"}

package/typed/utils/scale-utils.d.ts

@@ -0,0 +1,15 @@
+export function getScale(domain: any, range: any, scaleFunction: any): any;
+export function getQuantizeScale(domain: any, range: any): any;
+export function getLinearScale(domain: any, range: any): any;
+export function getQuantileScale(domain: any, range: any): any;
+export function getOrdinalScale(domain: any, range: any): any;
+export function quantizeScale(domain: any, range: any, value: any): any;
+export function linearScale(domain: any, range: any, value: any): any;
+export function unique(values: any): any[];
+export function getLinearDomain(data: any, valueAccessor: any): any[];
+export function getQuantileDomain(data: any, valueAccessor: any): any;
+export function getOrdinalDomain(data: any, valueAccessor: any): any[];
+export function getScaleDomain(scaleType: any, data: any, valueAccessor: any): any;
+export function clamp(value: any, min: any, max: any): number;
+export function getScaleFunctionByScaleType(scaleType: any): typeof getQuantizeScale;
+//# sourceMappingURL=scale-utils.d.ts.map

package/typed/utils/scale-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scale-utils.d.ts","sourceRoot":"","sources":["../../src/utils/scale-utils.js"],"names":[],"mappings":"AAuBA,2EAMC;AAKD,+DAIC;AAGD,6DAIC;AAED,+DAcC;AAqDD,8DAaC;AAID,wEAWC;AAGD,sEAEC;AAOD,2CASC;AAOD,sEAGC;AAED,sEAEC;AAED,uEAEC;AAED,mFAeC;AAED,8DAEC;AAED,qFAcC"}