@vitessce/gl 2.0.3 → 3.0.0

package/dist-tsc/BitmaskLayer.js

@@ -0,0 +1,142 @@
+import GL from '@luma.gl/constants'; // eslint-disable-line import/no-extraneous-dependencies
+import { project32, picking } from '@deck.gl/core'; // eslint-disable-line import/no-extraneous-dependencies
+import { Texture2D, isWebGL2 } from '@luma.gl/core';
+import { XRLayer } from '@hms-dbmi/viv';
+import { fs, vs } from './bitmask-layer-shaders.js';
+import { GLSL_COLORMAPS, GLSL_COLORMAP_DEFAULT, COLORMAP_SHADER_PLACEHOLDER, } from './constants.js';
+function padWithDefault(arr, defaultValue, padWidth) {
+    const newArr = [...arr];
+    for (let i = 0; i < padWidth; i += 1) {
+        newArr.push(defaultValue);
+    }
+    return newArr;
+}
+const defaultProps = {
+    hoveredCell: { type: 'number', value: null, compare: true },
+    // We do not want to deep-compare cellColorData,
+    // as it is potentially a TypedArray with millions of elements.
+    // For `compare`: "if a number is supplied, indicates the maximum depth to deep-compare,
+    // where 0 is shallow comparison and -1 is infinite depth. true is equivalent to 1."
+    // Reference: https://deck.gl/docs/developer-guide/custom-layers/prop-types#array
+    cellColorData: { type: 'object', value: null, compare: 0 },
+    colormap: { type: 'string', value: GLSL_COLORMAP_DEFAULT, compare: true },
+    // Same as with cellColorData, we do not want to deep-compare expressionData.
+    expressionData: { type: 'object', value: null, compare: 0 },
+};
+/**
+ * A BitmapLayer that performs aggregation in the fragment shader,
+ * and renders its texture from a Uint8Array rather than an ImageData.
+ */
+export default class BitmaskLayer extends XRLayer {
+    // eslint-disable-next-line class-methods-use-this
+    getShaders() {
+        const { colormap } = this.props;
+        return {
+            fs,
+            vs,
+            modules: [project32, picking],
+            defines: {
+                [COLORMAP_SHADER_PLACEHOLDER]: GLSL_COLORMAPS.includes(colormap)
+                    ? colormap
+                    : GLSL_COLORMAP_DEFAULT,
+            },
+        };
+    }
+    updateState({ props, oldProps, changeFlags }) {
+        super.updateState({ props, oldProps, changeFlags });
+        // Check the cellColorData to determine whether
+        // to update the texture.
+        if (props.cellColorData !== oldProps.cellColorData) {
+            this.setColorTexture();
+        }
+        // Check the expressionData to determine whether
+        // to update the texture.
+        if (props.expressionData !== oldProps.expressionData) {
+            const { expressionData, cellTexHeight, cellTexWidth } = this.props;
+            const expressionTex = this.dataToTexture(expressionData, cellTexWidth, cellTexHeight);
+            this.setState({ expressionTex });
+        }
+        if (props.colormap !== oldProps.colormap) {
+            const { gl } = this.context;
+            if (this.state.model) {
+                this.state.model.delete();
+            }
+            // eslint-disable-next-line no-underscore-dangle
+            this.setState({ model: this._getModel(gl) });
+            this.getAttributeManager().invalidateAll();
+        }
+    }
+    setColorTexture() {
+        const { cellColorData: data, cellTexHeight: height, cellTexWidth: width, } = this.props;
+        const colorTex = new Texture2D(this.context.gl, {
+            width,
+            height,
+            // Only use Float32 so we don't have to write two shaders
+            data,
+            // we don't want or need mimaps
+            mipmaps: false,
+            parameters: {
+                // NEAREST for integer data
+                [GL.TEXTURE_MIN_FILTER]: GL.NEAREST,
+                [GL.TEXTURE_MAG_FILTER]: GL.NEAREST,
+                // CLAMP_TO_EDGE to remove tile artifacts
+                [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,
+                [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE,
+            },
+            format: GL.RGB,
+            dataFormat: GL.RGB,
+            type: GL.UNSIGNED_BYTE,
+        });
+        this.setState({ colorTex });
+    }
+    draw(opts) {
+        const { uniforms } = opts;
+        const { channelsVisible, hoveredCell, colorScaleLo, colorScaleHi, isExpressionMode, } = this.props;
+        const { textures, model, colorTex, expressionTex, } = this.state;
+        // Render the image
+        if (textures && model && colorTex) {
+            model
+                .setUniforms(Object.assign({}, uniforms, {
+                hovered: hoveredCell || 0,
+                colorTex,
+                expressionTex,
+                colorTexHeight: colorTex.height,
+                colorTexWidth: colorTex.width,
+                channelsVisible: padWithDefault(channelsVisible, false, 
+                // There are six texture entries on the shaders
+                6 - channelsVisible.length),
+                uColorScaleRange: [colorScaleLo, colorScaleHi],
+                uIsExpressionMode: isExpressionMode,
+                ...textures,
+            }))
+                .draw();
+        }
+    }
+    /**
+     * This function creates textures from the data
+     */
+    dataToTexture(data, width, height) {
+        const isWebGL2On = isWebGL2(this.context.gl);
+        return new Texture2D(this.context.gl, {
+            width,
+            height,
+            // Only use Float32 so we don't have to write two shaders
+            data: new Float32Array(data),
+            // we don't want or need mimaps
+            mipmaps: false,
+            parameters: {
+                // NEAREST for integer data
+                [GL.TEXTURE_MIN_FILTER]: GL.NEAREST,
+                [GL.TEXTURE_MAG_FILTER]: GL.NEAREST,
+                // CLAMP_TO_EDGE to remove tile artifacts
+                [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,
+                [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE,
+            },
+            format: isWebGL2On ? GL.R32F : GL.LUMINANCE,
+            dataFormat: isWebGL2On ? GL.RED : GL.LUMINANCE,
+            type: GL.FLOAT,
+        });
+    }
+}
+BitmaskLayer.layerName = 'BitmaskLayer';
+BitmaskLayer.defaultProps = defaultProps;

package/dist-tsc/HeatmapBitmapLayer.d.ts

@@ -0,0 +1,93 @@
+/**
+ * A BitmapLayer that performs aggregation in the fragment shader,
+ * and renders its texture from a Uint8Array rather than an ImageData.
+ */
+declare class HeatmapBitmapLayer {
+    /**
+     * Copy of getShaders from Layer (grandparent, parent of BitmapLayer).
+     * Reference: https://github.com/visgl/deck.gl/blob/0afd4e99a6199aeec979989e0c361c97e6c17a16/modules/core/src/lib/layer.js#L302
+     * @param {object} shaders
+     * @returns {object} Merged shaders.
+     */
+    _getShaders(shaders: object): object;
+    /**
+     * Need to override to provide custom shaders.
+     */
+    getShaders(): object;
+    updateState(args: any): void;
+    /**
+     * Need to override to provide additional uniform values.
+     * Simplified by removing video-related code.
+     * Reference: https://github.com/visgl/deck.gl/blob/0afd4e99a6199aeec979989e0c361c97e6c17a16/modules/layers/src/bitmap-layer/bitmap-layer.js#L173
+     * @param {*} opts
+     */
+    draw(opts: any): void;
+    /**
+     * Need to override to provide the custom DEFAULT_TEXTURE_PARAMETERS
+     * object.
+     * Simplified by removing video-related code.
+     * Reference: https://github.com/visgl/deck.gl/blob/0afd4e99a6199aeec979989e0c361c97e6c17a16/modules/layers/src/bitmap-layer/bitmap-layer.js#L218
+     * @param {Uint8Array} image
+     */
+    loadTexture(image: Uint8Array): void;
+}
+declare namespace HeatmapBitmapLayer {
+    export const layerName: string;
+    export { defaultProps };
+}
+export default HeatmapBitmapLayer;
+declare namespace defaultProps {
+    namespace image {
+        const type: string;
+        const value: null;
+        const async: boolean;
+    }
+    namespace colormap {
+        const type_1: string;
+        export { type_1 as type };
+        export { GLSL_COLORMAP_DEFAULT as value };
+        export const compare: boolean;
+    }
+    namespace bounds {
+        const type_2: string;
+        export { type_2 as type };
+        const value_1: number[];
+        export { value_1 as value };
+        const compare_1: boolean;
+        export { compare_1 as compare };
+    }
+    namespace aggSizeX {
+        const type_3: string;
+        export { type_3 as type };
+        const value_2: number;
+        export { value_2 as value };
+        const compare_2: boolean;
+        export { compare_2 as compare };
+    }
+    namespace aggSizeY {
+        const type_4: string;
+        export { type_4 as type };
+        const value_3: number;
+        export { value_3 as value };
+        const compare_3: boolean;
+        export { compare_3 as compare };
+    }
+    namespace colorScaleLo {
+        const type_5: string;
+        export { type_5 as type };
+        const value_4: number;
+        export { value_4 as value };
+        const compare_4: boolean;
+        export { compare_4 as compare };
+    }
+    namespace colorScaleHi {
+        const type_6: string;
+        export { type_6 as type };
+        const value_5: number;
+        export { value_5 as value };
+        const compare_5: boolean;
+        export { compare_5 as compare };
+    }
+}
+import { GLSL_COLORMAP_DEFAULT } from "./constants.js";
+//# sourceMappingURL=HeatmapBitmapLayer.d.ts.map

package/dist-tsc/HeatmapBitmapLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeatmapBitmapLayer.d.ts","sourceRoot":"","sources":["../src/HeatmapBitmapLayer.js"],"names":[],"mappings":"AAqBA;;;GAGG;AACH;IACE;;;;;OAKG;IAEH,qBAJW,MAAM,GACJ,MAAM,CAYlB;IAED;;OAEG;IACH,qBAcC;IAED,6BAYC;IAED;;;;;OAKG;IACH,sBAoBC;IAED;;;;;;OAMG;IACH,mBAFW,UAAU,QA8BpB;CACF"}

package/dist-tsc/HeatmapBitmapLayer.js

@@ -0,0 +1,123 @@
+import GL from '@luma.gl/constants'; // eslint-disable-line import/no-extraneous-dependencies
+import { _mergeShaders, project32, picking } from '@deck.gl/core'; // eslint-disable-line import/no-extraneous-dependencies
+import { BitmapLayer } from '@deck.gl/layers'; // eslint-disable-line import/no-extraneous-dependencies
+import { Texture2D } from '@luma.gl/core';
+import { PIXELATED_TEXTURE_PARAMETERS, TILE_SIZE } from './heatmap-constants.js';
+import { GLSL_COLORMAPS, GLSL_COLORMAP_DEFAULT, COLORMAP_SHADER_PLACEHOLDER, } from './constants.js';
+import { vertexShader, fragmentShader } from './heatmap-bitmap-layer-shaders.js';
+const defaultProps = {
+    image: { type: 'object', value: null, async: true },
+    colormap: { type: 'string', value: GLSL_COLORMAP_DEFAULT, compare: true },
+    bounds: { type: 'array', value: [1, 0, 0, 1], compare: true },
+    aggSizeX: { type: 'number', value: 8.0, compare: true },
+    aggSizeY: { type: 'number', value: 8.0, compare: true },
+    colorScaleLo: { type: 'number', value: 0.0, compare: true },
+    colorScaleHi: { type: 'number', value: 1.0, compare: true },
+};
+/**
+ * A BitmapLayer that performs aggregation in the fragment shader,
+ * and renders its texture from a Uint8Array rather than an ImageData.
+ */
+export default class HeatmapBitmapLayer extends BitmapLayer {
+    /**
+     * Copy of getShaders from Layer (grandparent, parent of BitmapLayer).
+     * Reference: https://github.com/visgl/deck.gl/blob/0afd4e99a6199aeec979989e0c361c97e6c17a16/modules/core/src/lib/layer.js#L302
+     * @param {object} shaders
+     * @returns {object} Merged shaders.
+     */
+    // eslint-disable-next-line no-underscore-dangle
+    _getShaders(shaders) {
+        this.props.extensions.forEach((extension) => {
+            // eslint-disable-next-line no-param-reassign
+            shaders = _mergeShaders(shaders, extension.getShaders.call(this, extension));
+        });
+        return shaders;
+    }
+    /**
+     * Need to override to provide custom shaders.
+     */
+    getShaders() {
+        const { colormap } = this.props;
+        const fragmentShaderWithColormap = GLSL_COLORMAPS.includes(colormap)
+            ? fragmentShader.replace(COLORMAP_SHADER_PLACEHOLDER, colormap)
+            : fragmentShader.replace(COLORMAP_SHADER_PLACEHOLDER, GLSL_COLORMAP_DEFAULT);
+        // eslint-disable-next-line no-underscore-dangle
+        return this._getShaders({
+            vs: vertexShader,
+            fs: fragmentShaderWithColormap,
+            modules: [project32, picking],
+        });
+    }
+    updateState(args) {
+        super.updateState(args);
+        this.loadTexture(this.props.image);
+        const { props, oldProps } = args;
+        if (props.colormap !== oldProps.colormap) {
+            const { gl } = this.context;
+            // eslint-disable-next-line no-unused-expressions
+            this.state.model?.delete();
+            // eslint-disable-next-line no-underscore-dangle
+            this.state.model = this._getModel(gl);
+            this.getAttributeManager().invalidateAll();
+        }
+    }
+    /**
+     * Need to override to provide additional uniform values.
+     * Simplified by removing video-related code.
+     * Reference: https://github.com/visgl/deck.gl/blob/0afd4e99a6199aeec979989e0c361c97e6c17a16/modules/layers/src/bitmap-layer/bitmap-layer.js#L173
+     * @param {*} opts
+     */
+    draw(opts) {
+        const { uniforms } = opts;
+        const { bitmapTexture, model } = this.state;
+        const { aggSizeX, aggSizeY, colorScaleLo, colorScaleHi, } = this.props;
+        // Render the image
+        if (bitmapTexture && model) {
+            model
+                .setUniforms(Object.assign({}, uniforms, {
+                uBitmapTexture: bitmapTexture,
+                uTextureSize: [TILE_SIZE, TILE_SIZE],
+                uAggSize: [aggSizeX, aggSizeY],
+                uColorScaleRange: [colorScaleLo, colorScaleHi],
+            }))
+                .draw();
+        }
+    }
+    /**
+     * Need to override to provide the custom DEFAULT_TEXTURE_PARAMETERS
+     * object.
+     * Simplified by removing video-related code.
+     * Reference: https://github.com/visgl/deck.gl/blob/0afd4e99a6199aeec979989e0c361c97e6c17a16/modules/layers/src/bitmap-layer/bitmap-layer.js#L218
+     * @param {Uint8Array} image
+     */
+    loadTexture(image) {
+        const { gl } = this.context;
+        if (this.state.bitmapTexture) {
+            this.state.bitmapTexture.delete();
+        }
+        if (image instanceof Texture2D) {
+            this.setState({
+                bitmapTexture: image,
+            });
+        }
+        else if (image) {
+            this.setState({
+                bitmapTexture: new Texture2D(gl, {
+                    data: image,
+                    mipmaps: false,
+                    parameters: PIXELATED_TEXTURE_PARAMETERS,
+                    // Each color contains a single luminance value.
+                    // When sampled, rgb are all set to this luminance, alpha is 1.0.
+                    // Reference: https://luma.gl/docs/api-reference/webgl/texture#texture-formats
+                    format: GL.LUMINANCE,
+                    dataFormat: GL.LUMINANCE,
+                    type: GL.UNSIGNED_BYTE,
+                    width: TILE_SIZE,
+                    height: TILE_SIZE,
+                }),
+            });
+        }
+    }
+}
+HeatmapBitmapLayer.layerName = 'HeatmapBitmapLayer';
+HeatmapBitmapLayer.defaultProps = defaultProps;

package/dist-tsc/HeatmapCompositeTextLayer.d.ts

@@ -0,0 +1,11 @@
+declare class HeatmapCompositeTextLayer {
+    _renderAxisTopLayers(): any[];
+    _renderCornerLayers(): any;
+    _renderAxisLeftLayers(): any[];
+    renderLayers(): any;
+}
+declare namespace HeatmapCompositeTextLayer {
+    const layerName: string;
+}
+export default HeatmapCompositeTextLayer;
+//# sourceMappingURL=HeatmapCompositeTextLayer.d.ts.map

package/dist-tsc/HeatmapCompositeTextLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeatmapCompositeTextLayer.d.ts","sourceRoot":"","sources":["../src/HeatmapCompositeTextLayer.js"],"names":[],"mappings":"AAYA;IACE,8BA2CC;IAED,2BAmCC;IAED,+BA2CC;IAED,oBAYC;CACF"}

package/dist-tsc/HeatmapCompositeTextLayer.js

@@ -0,0 +1,129 @@
+/* eslint-disable no-underscore-dangle */
+import { COORDINATE_SYSTEM, CompositeLayer } from '@deck.gl/core'; // eslint-disable-line import/no-extraneous-dependencies
+import { TextLayer } from '@deck.gl/layers'; // eslint-disable-line import/no-extraneous-dependencies
+import { AXIS_LABEL_TEXT_SIZE, AXIS_TITLE_TEXT_SIZE, AXIS_MARGIN, THEME_TO_TEXT_COLOR, AXIS_FONT_FAMILY, COLOR_BAR_SIZE, } from './heatmap-constants.js';
+export default class HeatmapCompositeTextLayer extends CompositeLayer {
+    _renderAxisTopLayers() {
+        const { axisTopLabelData, matrixLeft, width, matrixWidth, viewWidth, theme, targetX, targetY, axisTopTitle, cellWidth, axisOffsetTop, scaleFactor, hideTopLabels, } = this.props;
+        const showAxisTopLabels = cellWidth >= AXIS_LABEL_TEXT_SIZE;
+        const axisLabelTop = targetY + (axisOffsetTop - AXIS_MARGIN) / 2 / scaleFactor;
+        return hideTopLabels ? [] : [
+            new TextLayer({
+                id: 'axisTopLabels',
+                coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+                data: axisTopLabelData,
+                getText: d => d[1],
+                getPosition: d => [matrixLeft + ((d[0] + 0.5) / width) * matrixWidth, axisLabelTop],
+                getTextAnchor: 'start',
+                getColor: () => THEME_TO_TEXT_COLOR[theme],
+                getSize: (showAxisTopLabels ? AXIS_LABEL_TEXT_SIZE : 0),
+                getAngle: 75,
+                fontFamily: AXIS_FONT_FAMILY,
+                updateTriggers: {
+                    getPosition: [axisLabelTop, matrixLeft, matrixWidth, viewWidth],
+                    getSize: [showAxisTopLabels],
+                    getColor: [theme],
+                },
+            }),
+            new TextLayer({
+                id: 'axisTopTitle',
+                coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+                data: [{ title: axisTopTitle }],
+                getText: d => d.title,
+                getPosition: [targetX, targetY],
+                getTextAnchor: 'middle',
+                getColor: () => THEME_TO_TEXT_COLOR[theme],
+                getSize: (!showAxisTopLabels ? AXIS_TITLE_TEXT_SIZE : 0),
+                getAngle: 0,
+                fontFamily: AXIS_FONT_FAMILY,
+                updateTriggers: {
+                    getSize: [showAxisTopLabels],
+                    getColor: [theme],
+                },
+            }),
+        ];
+    }
+    _renderCornerLayers() {
+        const { theme, targetX, targetY, axisOffsetTop, scaleFactor, cellColorLabelsData, axisOffsetLeft, transpose, } = this.props;
+        const axisLabelTop = targetY + (axisOffsetTop - AXIS_MARGIN) / 2 / scaleFactor;
+        const axisLabelLeft = targetX + (axisOffsetLeft - AXIS_MARGIN) / 2 / scaleFactor;
+        return cellColorLabelsData.map(data => (new TextLayer({
+            id: `cellColorLabel-${data[0]}`,
+            coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+            data: [data],
+            getText: d => d[1],
+            getTextAnchor: (transpose ? 'end' : 'start'),
+            getAlignmentBaseline: 'top',
+            getColor: () => THEME_TO_TEXT_COLOR[theme],
+            getSize: AXIS_LABEL_TEXT_SIZE,
+            getPosition: d => [
+                (transpose
+                    ? axisLabelLeft
+                    : targetX
+                        + ((-cellColorLabelsData.length + d[0] * 2) * COLOR_BAR_SIZE + AXIS_MARGIN)
+                            / 2 / scaleFactor),
+                (transpose
+                    ? targetY
+                        + ((-cellColorLabelsData.length + d[0] * 2) * COLOR_BAR_SIZE + AXIS_MARGIN)
+                            / 2 / scaleFactor
+                    : axisLabelTop),
+            ],
+            getAngle: (transpose ? 0 : 90),
+            fontFamily: AXIS_FONT_FAMILY,
+        })));
+    }
+    _renderAxisLeftLayers() {
+        const { axisLeftLabelData, matrixTop, height, matrixHeight, viewHeight, theme, axisLeftTitle, targetX, targetY, cellHeight, axisOffsetLeft, scaleFactor, hideLeftLabels, } = this.props;
+        const showAxisLeftLabels = cellHeight >= AXIS_LABEL_TEXT_SIZE;
+        const axisLabelLeft = targetX + (axisOffsetLeft - AXIS_MARGIN) / 2 / scaleFactor;
+        return hideLeftLabels ? [] : [
+            new TextLayer({
+                id: 'axisLeftLabels',
+                coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+                data: axisLeftLabelData,
+                getText: d => d[1],
+                getPosition: d => [axisLabelLeft, matrixTop + ((d[0] + 0.5) / height) * matrixHeight],
+                getTextAnchor: 'end',
+                getColor: () => THEME_TO_TEXT_COLOR[theme],
+                getSize: (showAxisLeftLabels ? AXIS_LABEL_TEXT_SIZE : 0),
+                getAngle: 0,
+                fontFamily: AXIS_FONT_FAMILY,
+                updateTriggers: {
+                    getPosition: [axisLabelLeft, matrixTop, matrixHeight, viewHeight],
+                    getSize: [showAxisLeftLabels],
+                    getColor: [theme],
+                },
+            }),
+            new TextLayer({
+                id: 'axisLeftTitle',
+                coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+                data: [{ title: axisLeftTitle }],
+                getText: d => d.title,
+                getPosition: [targetX, targetY],
+                getTextAnchor: 'middle',
+                getColor: () => THEME_TO_TEXT_COLOR[theme],
+                getSize: (!showAxisLeftLabels ? AXIS_TITLE_TEXT_SIZE : 0),
+                getAngle: 90,
+                fontFamily: AXIS_FONT_FAMILY,
+                updateTriggers: {
+                    getSize: [showAxisLeftLabels],
+                    getColor: [theme],
+                },
+            }),
+        ];
+    }
+    renderLayers() {
+        const { axis } = this.props;
+        if (axis === 'left') {
+            return this._renderAxisLeftLayers();
+        }
+        if (axis === 'top') {
+            return this._renderAxisTopLayers();
+        }
+        if (axis === 'corner') {
+            return this._renderCornerLayers();
+        }
+        return [];
+    }
+}
+HeatmapCompositeTextLayer.layerName = 'HeatmapCompositeTextLayer';

package/dist-tsc/PaddedExpressionHeatmapBitmapLayer.d.ts

@@ -0,0 +1,93 @@
+/**
+ * A BitmapLayer that performs aggregation in the fragment shader,
+ * and renders its texture from a Uint8Array rather than an ImageData.
+ */
+declare class PaddedExpressionHeatmapBitmapLayer {
+    /**
+     * Copy of getShaders from Layer (grandparent, parent of BitmapLayer).
+     * Reference: https://github.com/visgl/deck.gl/blob/0afd4e99a6199aeec979989e0c361c97e6c17a16/modules/core/src/lib/layer.js#L302
+     * @param {object} shaders
+     * @returns {object} Merged shaders.
+     */
+    _getShaders(shaders: object): object;
+    /**
+     * Need to override to provide custom shaders.
+     */
+    getShaders(): object;
+    updateState(args: any): void;
+    /**
+     * Need to override to provide additional uniform values.
+     * Simplified by removing video-related code.
+     * Reference: https://github.com/visgl/deck.gl/blob/0afd4e99a6199aeec979989e0c361c97e6c17a16/modules/layers/src/bitmap-layer/bitmap-layer.js#L173
+     * @param {*} opts
+     */
+    draw(opts: any): void;
+    /**
+     * Need to override to provide the custom DEFAULT_TEXTURE_PARAMETERS
+     * object.
+     * Simplified by removing video-related code.
+     * Reference: https://github.com/visgl/deck.gl/blob/0afd4e99a6199aeec979989e0c361c97e6c17a16/modules/layers/src/bitmap-layer/bitmap-layer.js#L218
+     * @param {Array<Uint8Array>} images
+     */
+    loadTexture(image: any): void;
+}
+declare namespace PaddedExpressionHeatmapBitmapLayer {
+    export const layerName: string;
+    export { defaultProps };
+}
+export default PaddedExpressionHeatmapBitmapLayer;
+declare namespace defaultProps {
+    namespace image {
+        const type: string;
+        const value: null;
+        const async: boolean;
+    }
+    namespace colormap {
+        const type_1: string;
+        export { type_1 as type };
+        export { GLSL_COLORMAP_DEFAULT as value };
+        export const compare: boolean;
+    }
+    namespace bounds {
+        const type_2: string;
+        export { type_2 as type };
+        const value_1: number[];
+        export { value_1 as value };
+        const compare_1: boolean;
+        export { compare_1 as compare };
+    }
+    namespace aggSizeX {
+        const type_3: string;
+        export { type_3 as type };
+        const value_2: number;
+        export { value_2 as value };
+        const compare_2: boolean;
+        export { compare_2 as compare };
+    }
+    namespace aggSizeY {
+        const type_4: string;
+        export { type_4 as type };
+        const value_3: number;
+        export { value_3 as value };
+        const compare_3: boolean;
+        export { compare_3 as compare };
+    }
+    namespace colorScaleLo {
+        const type_5: string;
+        export { type_5 as type };
+        const value_4: number;
+        export { value_4 as value };
+        const compare_4: boolean;
+        export { compare_4 as compare };
+    }
+    namespace colorScaleHi {
+        const type_6: string;
+        export { type_6 as type };
+        const value_5: number;
+        export { value_5 as value };
+        const compare_5: boolean;
+        export { compare_5 as compare };
+    }
+}
+import { GLSL_COLORMAP_DEFAULT } from "./constants.js";
+//# sourceMappingURL=PaddedExpressionHeatmapBitmapLayer.d.ts.map

package/dist-tsc/PaddedExpressionHeatmapBitmapLayer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PaddedExpressionHeatmapBitmapLayer.d.ts","sourceRoot":"","sources":["../src/PaddedExpressionHeatmapBitmapLayer.js"],"names":[],"mappings":"AAmBA;;;GAGG;AACH;IACE;;;;;OAKG;IACH,qBAHW,MAAM,GACJ,MAAM,CAWlB;IAED;;OAEG;IACH,qBAaC;IAED,6BAaC;IAED;;;;;OAKG;IACH,sBAiCC;IAED;;;;;;OAMG;IACH,8BA4BC;CACF"}