@vitessce/gl 2.0.0-beta.0

package/dist/padded-expression-heatmap-bitmap-layer-shaders.js

@@ -0,0 +1,143 @@
+import { colormaps } from './glsl';
+/**
+ * No change to the vertex shader from the base BitmapLayer.
+ * Reference: https://github.com/visgl/deck.gl/blob/8.2-release/modules/layers/src/bitmap-layer/bitmap-layer-vertex.js
+ */
+export const vertexShader = `
+#define SHADER_NAME heatmap-bitmap-layer-vertex-shader
+
+attribute vec2 texCoords;
+attribute vec3 positions;
+attribute vec3 positions64Low;
+
+varying vec2 vTexCoord;
+
+const vec3 pickingColor = vec3(1.0, 0.0, 0.0);
+
+void main(void) {
+  geometry.worldPosition = positions;
+  geometry.uv = texCoords;
+  geometry.pickingColor = pickingColor;
+
+  gl_Position = project_position_to_clipspace(positions, positions64Low, vec3(0.0), geometry.position);
+  DECKGL_FILTER_GL_POSITION(gl_Position, geometry);
+
+  vTexCoord = texCoords;
+
+  vec4 color = vec4(0.0);
+  DECKGL_FILTER_COLOR(color, geometry);
+}
+`;
+/**
+ * Fragment shader adapted to perform aggregation and
+ * take color scale functions + sliders into account.
+ * Reference: https://github.com/visgl/deck.gl/blob/8.2-release/modules/layers/src/bitmap-layer/bitmap-layer-fragment.js
+ * Reference: https://github.com/hms-dbmi/viv/blob/06231ae02cac1ff57ba458c71e9bc59ed2fc4f8b/src/layers/XRLayer/xr-layer-fragment-colormap.webgl1.glsl
+ */
+export const fragmentShader = `
+#define SHADER_NAME heatmap-bitmap-layer-fragment-shader
+
+#ifdef GL_ES
+precision mediump float;
+#endif
+
+${colormaps}
+
+// The texture (GL.LUMINANCE & Uint8Array).
+uniform sampler2D uBitmapTexture;
+
+// height x width of the data matrix (i.e x and y are flipped compared to the graphics convention)
+uniform vec2 uOrigDataSize;
+uniform vec2 uReshapedDataSize;
+
+uniform vec2 tileIJ;
+uniform vec2 dataIJ;
+uniform vec2 numTiles;
+
+// What are the dimensions of the texture (width, height)?
+uniform vec2 uTextureSize;
+
+// How many consecutive pixels should be aggregated together along each axis?
+uniform vec2 uAggSize;
+
+// What are the values of the color scale sliders?
+uniform vec2 uColorScaleRange;
+
+// The texture coordinate, varying (interpolated between values set by the vertex shader).
+varying vec2 vTexCoord;
+
+vec2 offsetvTexcoord(vec2 coord) {
+  float xTileToDataRatio = uTextureSize.x / uOrigDataSize.y;
+  float yTileToDataRatio = uTextureSize.y / uOrigDataSize.x;
+  vec2 vTexCoordOffset = vec2(
+    (tileIJ.y * xTileToDataRatio) + (coord.x * xTileToDataRatio),
+    (tileIJ.x * yTileToDataRatio) + ((1. - coord.y) * yTileToDataRatio)
+  );
+  return vTexCoordOffset;
+}
+
+vec2 dataCoordinateFromvTexCoordOffset(vec2 vTexCoordOffset) {
+  
+  // True pixel coordinate on scale of uOrigDataSize
+  vec2 viewCoord = vec2(floor(vTexCoordOffset.x * uOrigDataSize.y), floor(vTexCoordOffset.y * uOrigDataSize.x));
+  return viewCoord;
+}
+
+float getIndexFromViewCoord(vec2 viewCoord) {
+  return viewCoord.y * uOrigDataSize.y + viewCoord.x;
+}
+
+vec2 transformDataCoordinate(float index) {
+  float textureX = (floor( index / uReshapedDataSize.x )) / uReshapedDataSize.x;
+  float textureY = (index - (floor( index / uReshapedDataSize.x ) * uReshapedDataSize.x)) / uReshapedDataSize.y;
+  vec2 texturedCoord = vec2(textureY, textureX);
+  return texturedCoord;
+}
+
+void main(void) {
+  // Compute 1 pixel in texture coordinates
+  vec2 onePixel = vec2(1.0, 1.0) / uTextureSize;
+  vec2 vTexCoordOffset = offsetvTexcoord(vTexCoord);
+  vec2 viewCoordTransformed = dataCoordinateFromvTexCoordOffset(vTexCoordOffset);
+  // Compute (x % aggSizeX, y % aggSizeY).
+  // These values will be the number of values to the left / above the current position to consider.
+  vec2 modAggSize = vec2(-1.0 * mod(viewCoordTransformed.x, uAggSize.x), -1.0 * mod(viewCoordTransformed.y, uAggSize.y));
+  // Take the sum of values along each axis.
+  float intensitySum = 0.0;
+  vec2 offsetPixels = vec2(0.0, 0.0);
+  for(int i = 0; i < 16; i++) {
+    // Check to break outer loop early.
+    // Uniforms cannot be used as conditions in GLSL for loops.
+    if(float(i) >= uAggSize.y) {
+      // Done in the y direction.
+      break;
+    }
+
+    offsetPixels = vec2(offsetPixels.x, (modAggSize.y + float(i)));
+
+    for(int j = 0; j < 16; j++) {
+      // Check to break inner loop early.
+      // Uniforms cannot be used as conditions in GLSL for loops.
+      if(float(j) >= uAggSize.x) {
+        // Done in the x direction.
+        break;
+      }
+      offsetPixels = vec2((modAggSize.x + float(j)), offsetPixels.y);
+      float indexFull = getIndexFromViewCoord(viewCoordTransformed + offsetPixels);
+      float index = indexFull - (floor(indexFull / (uReshapedDataSize.x * uReshapedDataSize.y)) * (uReshapedDataSize.x * uReshapedDataSize.y));
+      vec2 vTexCoordTransformed = transformDataCoordinate(index);
+      intensitySum += texture2D(uBitmapTexture, vTexCoordTransformed).r;
+    }
+  }
+  
+  // Compute the mean value.
+  float intensityMean = intensitySum / (uAggSize.x * uAggSize.y);
+  // Re-scale using the color scale slider values.
+  float scaledIntensityMean = (intensityMean - uColorScaleRange[0]) / max(0.005, (uColorScaleRange[1] - uColorScaleRange[0]));
+
+  gl_FragColor = COLORMAP_FUNC(clamp(scaledIntensityMean, 0.0, 1.0));
+
+  geometry.uv = vTexCoord;
+  DECKGL_FILTER_COLOR(gl_FragColor, geometry);
+}
+`;

package/dist/selection-utils.js

@@ -0,0 +1,92 @@
+import { COORDINATE_SYSTEM } from '@deck.gl/core'; // eslint-disable-line import/no-extraneous-dependencies
+import { DataFilterExtension } from '@deck.gl/extensions'; // eslint-disable-line import/no-extraneous-dependencies
+import SelectionLayer from './SelectionLayer';
+/**
+ * Convert a DeckGL layer ID to a "base" layer ID for selection.
+ * @param {string} layerId The layer ID to convert.
+ * @returns {string} The base layer ID.
+ */
+function getBaseLayerId(layerId) {
+    return `base-${layerId}`;
+}
+/**
+ * Convert a DeckGL layer ID to a "selected" layer ID for selection.
+ * @param {string} layerId The layer ID to convert.
+ * @returns {string} The base layer ID.
+ */
+function getSelectedLayerId(layerId) {
+    return `selected-${layerId}`;
+}
+/**
+ * Construct DeckGL selection layers.
+ * @param {string} tool
+ * @param {number} zoom
+ * @param {string} cellBaseLayerId
+ * @param {function} getCellCoords
+ * @param {function} updateCellsSelection
+ * @returns {object[]} The array of DeckGL selection layers.
+ */
+export function getSelectionLayers(tool, zoom, layerId, getCellCoords, obsIndex, updateCellsSelection, cellsQuadTree, flipY = false) {
+    if (!tool) {
+        return [];
+    }
+    const cellBaseLayerId = getBaseLayerId(layerId);
+    const editHandlePointRadius = 5 / (zoom + 16);
+    return [new SelectionLayer({
+            id: 'selection',
+            flipY,
+            cellsQuadTree,
+            getCellCoords,
+            coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
+            selectionType: tool,
+            onSelect: ({ pickingInfos }) => {
+                const cellIds = pickingInfos.map(i => obsIndex[i]);
+                if (updateCellsSelection) {
+                    updateCellsSelection(cellIds);
+                }
+            },
+            layerIds: [cellBaseLayerId],
+            getTentativeFillColor: () => [255, 255, 255, 95],
+            getTentativeLineColor: () => [143, 143, 143, 255],
+            getTentativeLineDashArray: () => [7, 4],
+            lineWidthMinPixels: 2,
+            lineWidthMaxPixels: 2,
+            getEditHandlePointColor: () => [0xff, 0xff, 0xff, 0xff],
+            getEditHandlePointRadius: () => editHandlePointRadius,
+            editHandlePointRadiusScale: 1,
+            editHandlePointRadiusMinPixels: editHandlePointRadius,
+            editHandlePointRadiusMaxPixels: 2 * editHandlePointRadius,
+        })];
+}
+/**
+ * Get deck.gl layer props for selection overlays.
+ * @param {object} props
+ * @returns {object} Object with two properties,
+ * overlay: overlayProps, base: baseProps,
+ * where the values are deck.gl layer props.
+ */
+export function overlayBaseProps(props) {
+    const { id, getColor, data, isSelected, ...rest } = props;
+    return {
+        overlay: {
+            id: getSelectedLayerId(id),
+            getFillColor: getColor,
+            getLineColor: getColor,
+            data,
+            getFilterValue: isSelected,
+            extensions: [new DataFilterExtension({ filterSize: 1 })],
+            filterRange: [1, 1],
+            ...rest,
+        },
+        base: {
+            id: getBaseLayerId(id),
+            getLineColor: getColor,
+            getFillColor: getColor,
+            // Alternatively: contrast outlines with solids:
+            // getLineColor: getColor,
+            // getFillColor: [255, 255, 255],
+            data: data.slice(),
+            ...rest,
+        },
+    };
+}

package/dist/spatial.js

@@ -0,0 +1,281 @@
+import isEqual from 'lodash/isEqual';
+import { Matrix4 } from 'math.gl';
+import { divide, compare, unit } from 'mathjs';
+import { VIEWER_PALETTE } from '@vitessce/utils';
+import { getMultiSelectionStats } from './layer-controller';
+import { RENDERING_MODES } from './viv';
+export function square(x, y, r) {
+    return [[x, y + r], [x + r, y], [x, y - r], [x - r, y]];
+}
+export const GLOBAL_LABELS = ['z', 't'];
+export const DEFAULT_RASTER_DOMAIN_TYPE = 'Min/Max';
+export const DEFAULT_RASTER_LAYER_PROPS = {
+    visible: true,
+    colormap: null,
+    opacity: 1,
+    domainType: DEFAULT_RASTER_DOMAIN_TYPE,
+    transparentColor: [0, 0, 0],
+    renderingMode: RENDERING_MODES.ADDITIVE,
+    use3d: false,
+};
+export const DEFAULT_MOLECULES_LAYER = {
+    opacity: 1, radius: 20, visible: true,
+};
+export const DEFAULT_CELLS_LAYER = {
+    opacity: 1, radius: 50, visible: true, stroked: false,
+};
+export const DEFAULT_NEIGHBORHOODS_LAYER = {
+    visible: false,
+};
+export const DEFAULT_LAYER_TYPE_ORDERING = [
+    'molecules',
+    'cells',
+    'neighborhoods',
+    'raster',
+];
+/**
+ * Get a representative PixelSource from a loader object returned from
+ * the Vitessce imaging loaders
+ * @param {object} loader { data: (PixelSource[]|PixelSource), metadata, channels } object
+ * @param {number=} level Level of the multiscale loader from which to get a PixelSource
+ * @returns {object} PixelSource object
+ */
+export function getSourceFromLoader(loader, level) {
+    const { data } = loader;
+    const source = Array.isArray(data) ? data[(level || data.length - 1)] : data;
+    return source;
+}
+/**
+ * Helper method to determine whether pixel data is interleaved and rgb or not.
+ * @param {object} loader
+ * @param {array|null} channels
+ */
+export function isRgb(loader, channels) {
+    const source = getSourceFromLoader(loader);
+    const { shape, dtype, labels } = source;
+    const channelSize = shape[(labels.includes('channel') ? labels.indexOf('channel') : labels.indexOf('c'))];
+    if (channelSize === 3 && dtype === 'Uint8') {
+        return true;
+    }
+    if (channels && channels.length === 3
+        && isEqual(channels[0].color, [255, 0, 0])
+        && isEqual(channels[1].color, [0, 255, 0])
+        && isEqual(channels[2].color, [0, 0, 255])) {
+        return true;
+    }
+    return false;
+}
+// From spatial/utils.js
+function getMetaWithTransformMatrices(imageMeta, imageLoaders) {
+    // Do not fill in transformation matrices if any of the layers specify one.
+    const sources = imageLoaders.map(loader => getSourceFromLoader(loader));
+    if (imageMeta.map(meta => meta?.metadata?.transform?.matrix
+        || meta?.metadata?.transform?.scale
+        || meta?.metadata?.transform?.translate).some(Boolean)
+        || sources.every(source => !source.meta?.physicalSizes?.x || !source.meta?.physicalSizes?.y)) {
+        return imageMeta;
+    }
+    // Get the minimum physical among all the current images.
+    const minPhysicalSize = sources.reduce((acc, source) => {
+        const hasZPhyscialSize = source.meta?.physicalSizes?.z?.size;
+        const sizes = [
+            unit(`${source.meta?.physicalSizes.x.size} ${source.meta?.physicalSizes.x.unit}`.replace('µ', 'u')),
+            unit(`${source.meta?.physicalSizes.y.size} ${source.meta?.physicalSizes.y.unit}`.replace('µ', 'u')),
+        ];
+        if (hasZPhyscialSize) {
+            sizes.push(unit(`${source.meta?.physicalSizes.z.size} ${source.meta?.physicalSizes.z.unit}`.replace('µ', 'u')));
+        }
+        acc[0] = (acc[0] === undefined || compare(sizes[0], acc[0]) === -1) ? sizes[0] : acc[0];
+        acc[1] = (acc[1] === undefined || compare(sizes[1], acc[1]) === -1) ? sizes[1] : acc[1];
+        acc[2] = (acc[2] === undefined || compare(sizes[2], acc[2]) === -1) ? sizes[2] : acc[2];
+        return acc;
+    }, []);
+    const imageMetaWithTransform = imageMeta.map((meta, j) => {
+        const source = sources[j];
+        const hasZPhyscialSize = source.meta?.physicalSizes?.z?.size;
+        const sizes = [
+            unit(`${source.meta?.physicalSizes.x.size} ${source.meta?.physicalSizes.x.unit}`.replace('µ', 'u')),
+            unit(`${source.meta?.physicalSizes.y.size} ${source.meta?.physicalSizes.y.unit}`.replace('µ', 'u')),
+        ];
+        if (hasZPhyscialSize) {
+            sizes.push(unit(`${source.meta?.physicalSizes.z.size} ${source.meta?.physicalSizes.z.unit}`.replace('µ', 'u')));
+        }
+        // Find the ratio of the sizes to get the scaling factor.
+        const scale = sizes.map((i, k) => divide(i, minPhysicalSize[k]));
+        // Add in z dimension needed for Matrix4 scale API.
+        if (!scale[2]) {
+            scale[2] = 1;
+        }
+        // no need to store/use identity scaling
+        if (isEqual(scale, [1, 1, 1])) {
+            return meta;
+        }
+        // Make sure to scale the z direction by one.
+        const matrix = new Matrix4().scale([...scale]);
+        const newMeta = { ...meta };
+        newMeta.metadata = {
+            ...newMeta.metadata,
+            // We don't want to store matrix objects in the view config.
+            transform: { matrix: matrix.toArray() },
+        };
+        return newMeta;
+    });
+    return imageMetaWithTransform;
+}
+/**
+ * Return the midpoint of the global dimensions.
+ * @param {object} source PixelSource object from Viv
+ * @returns {object} The selection.
+ */
+function getDefaultGlobalSelection(source) {
+    const globalIndices = source.labels
+        .filter(dim => GLOBAL_LABELS.includes(dim));
+    const selection = {};
+    globalIndices.forEach((dim) => {
+        selection[dim] = Math.floor((source.shape[source.labels.indexOf(dim)] || 0) / 2);
+    });
+    return selection;
+}
+/**
+ * Create a default selection using the midpoint of the available global dimensions,
+ * and then the first four available selections from the first selectable channel.
+ * @param {object} source PixelSource object from Viv
+ * @returns {object} The selection.
+ */
+function buildDefaultSelection(source) {
+    const selection = [];
+    const globalSelection = getDefaultGlobalSelection(source);
+    // First non-global dimension with some sort of selectable values
+    const firstNonGlobalDimension = source.labels.filter(dim => !GLOBAL_LABELS.includes(dim)
+        && source.shape[source.labels.indexOf(dim)])[0];
+    for (let i = 0; i < Math.min(4, source.shape[source.labels.indexOf(firstNonGlobalDimension)]); i += 1) {
+        selection.push({
+            [firstNonGlobalDimension]: i,
+            ...globalSelection,
+        });
+    }
+    return selection;
+}
+/**
+ * @param {Array.<number>} shape loader shape
+ */
+export function isInterleaved(shape) {
+    const lastDimSize = shape[shape.length - 1];
+    return lastDimSize === 3 || lastDimSize === 4;
+}
+/**
+ * Initialize the channel selections for an individual layer.
+ * @param {object} loader A viv loader instance with channel names appended by Vitessce loaders
+ * of the form { data: (PixelSource[]|PixelSource), metadata: Object, channels }
+ * @returns {object[]} An array of selected channels with default
+ * domain/slider settings.
+ */
+export async function initializeLayerChannels(loader, use3d) {
+    const result = [];
+    const source = getSourceFromLoader(loader);
+    // Add channel automatically as the first avaialable value for each dimension.
+    let defaultSelection = buildDefaultSelection(source);
+    defaultSelection = isInterleaved(source.shape)
+        ? [{ ...defaultSelection[0], c: 0 }] : defaultSelection;
+    const stats = await getMultiSelectionStats({
+        loader: loader.data, selections: defaultSelection, use3d,
+    });
+    const domains = isRgb(loader, null)
+        ? [[0, 255], [0, 255], [0, 255]]
+        : stats.domains;
+    const colors = isRgb(loader, null)
+        ? [[255, 0, 0], [0, 255, 0], [0, 0, 255]]
+        : null;
+    const sliders = isRgb(loader, null)
+        ? [[0, 255], [0, 255], [0, 255]]
+        : stats.sliders;
+    defaultSelection.forEach((selection, i) => {
+        const domain = domains[i];
+        const slider = sliders[i];
+        const channel = {
+            selection,
+            // eslint-disable-next-line no-nested-ternary
+            color: colors ? colors[i]
+                : defaultSelection.length !== 1
+                    ? VIEWER_PALETTE[i] : [255, 255, 255],
+            visible: true,
+            slider: slider || domain,
+        };
+        result.push(channel);
+    });
+    return result;
+}
+/**
+ * Given a set of image layer loader creator functions,
+ * create loader objects for an initial layer or set of layers,
+ * which will be selected based on default values predefined in
+ * the image data file or otherwise by a heuristic
+ * (the midpoint of the layers array).
+ * @param {object[]} rasterLayers A list of layer metadata objects with
+ * shape { name, type, url, createLoader }.
+ * @param {(string[]|null)} rasterRenderLayers A list of default raster layers. Optional.
+ */
+export async function initializeRasterLayersAndChannels(rasterLayers, rasterRenderLayers, usePhysicalSizeScaling) {
+    const nextImageLoaders = [];
+    let nextImageMetaAndLayers = [];
+    const autoImageLayerDefPromises = [];
+    // Start all loader creators immediately.
+    // Reference: https://eslint.org/docs/rules/no-await-in-loop
+    const loaders = await Promise.all(rasterLayers.map(layer => layer.loaderCreator()));
+    for (let i = 0; i < rasterLayers.length; i++) {
+        const layer = rasterLayers[i];
+        const loader = loaders[i];
+        nextImageLoaders[i] = loader;
+        nextImageMetaAndLayers[i] = layer;
+    }
+    if (usePhysicalSizeScaling) {
+        nextImageMetaAndLayers = getMetaWithTransformMatrices(nextImageMetaAndLayers, nextImageLoaders);
+    }
+    // No layers were pre-defined so set up the default image layers.
+    if (!rasterRenderLayers) {
+        // Midpoint of images list as default image to show.
+        const layerIndex = Math.floor(rasterLayers.length / 2);
+        const loader = nextImageLoaders[layerIndex];
+        const autoImageLayerDefPromise = initializeLayerChannels(loader)
+            .then(channels => Promise.resolve({
+            type: nextImageMetaAndLayers[layerIndex]?.metadata?.isBitmask ? 'bitmask' : 'raster',
+            index: layerIndex,
+            ...DEFAULT_RASTER_LAYER_PROPS,
+            channels: channels.map((channel, j) => ({
+                ...channel,
+                ...(nextImageMetaAndLayers[layerIndex].channels
+                    ? nextImageMetaAndLayers[layerIndex].channels[j] : []),
+            })),
+            modelMatrix: nextImageMetaAndLayers[layerIndex]?.metadata?.transform?.matrix,
+            transparentColor: layerIndex > 0 ? [0, 0, 0] : null,
+        }));
+        autoImageLayerDefPromises.push(autoImageLayerDefPromise);
+    }
+    else {
+        // The renderLayers parameter is a list of layer names to show by default.
+        const globalIndicesOfRenderLayers = rasterRenderLayers
+            .map(imageName => rasterLayers.findIndex(image => image.name === imageName));
+        for (let i = 0; i < globalIndicesOfRenderLayers.length; i++) {
+            const layerIndex = globalIndicesOfRenderLayers[i];
+            const loader = nextImageLoaders[layerIndex];
+            const autoImageLayerDefPromise = initializeLayerChannels(loader)
+                // eslint-disable-next-line no-loop-func
+                .then(channels => Promise.resolve({
+                type: nextImageMetaAndLayers[layerIndex]?.metadata?.isBitmask ? 'bitmask' : 'raster',
+                index: layerIndex,
+                ...DEFAULT_RASTER_LAYER_PROPS,
+                channels: channels.map((channel, j) => ({
+                    ...channel,
+                    ...(nextImageMetaAndLayers[layerIndex].channels
+                        ? nextImageMetaAndLayers[layerIndex].channels[j] : []),
+                })),
+                domainType: 'Min/Max',
+                modelMatrix: nextImageMetaAndLayers[layerIndex]?.metadata?.transform?.matrix,
+                transparentColor: i > 0 ? [0, 0, 0] : null,
+            }));
+            autoImageLayerDefPromises.push(autoImageLayerDefPromise);
+        }
+    }
+    const autoImageLayerDefs = await Promise.all(autoImageLayerDefPromises);
+    return [autoImageLayerDefs, nextImageLoaders, nextImageMetaAndLayers];
+}

package/dist/spatial.test.js

@@ -0,0 +1,8 @@
+import { square } from './spatial';
+describe('Spatial.js', () => {
+    describe('square()', () => {
+        it('gives the right coordinates', () => {
+            expect(square(0, 0, 50)).toEqual([[0, 50], [50, 0], [0, -50], [-50, 0]]);
+        });
+    });
+});

package/dist/viv.js

@@ -0,0 +1,9 @@
+export {
+  ZarrPixelSource, loadOmeTiff, loadOmeZarr, XRLayer,
+  getChannelStats, RENDERING_MODES, MAX_CHANNELS,
+  getDefaultInitialViewState, ScaleBarLayer, MultiscaleImageLayer,
+  AdditiveColormapExtension, ColorPaletteExtension, ImageLayer, VolumeLayer,
+  AdditiveColormap3DExtensions, ColorPalette3DExtensions,
+  // TODO: deprecated
+  DTYPE_VALUES,
+} from '@hms-dbmi/viv';

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@vitessce/gl",
+  "version": "2.0.0-beta.0",
+  "author": "Gehlenborg Lab",
+  "homepage": "http://vitessce.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitessce/vitessce.git"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@deck.gl/aggregation-layers": "8.6.7",
+    "@deck.gl/core": "8.6.7",
+    "@deck.gl/extensions": "8.6.7",
+    "@deck.gl/geo-layers": "8.6.7",
+    "@deck.gl/layers": "8.6.7",
+    "@deck.gl/mesh-layers": "8.6.7",
+    "@deck.gl/react": "8.6.7",
+    "@hms-dbmi/viv": "~0.12.6",
+    "@loaders.gl/3d-tiles": "^3.0.0",
+    "@loaders.gl/core": "^3.0.0",
+    "@loaders.gl/images": "^3.0.0",
+    "@loaders.gl/loader-utils": "^3.0.0",
+    "@luma.gl/constants": "8.5.10",
+    "@luma.gl/core": "8.5.10",
+    "@luma.gl/engine": "8.5.10",
+    "@luma.gl/experimental": "8.5.10",
+    "@luma.gl/gltools": "8.5.10",
+    "@luma.gl/shadertools": "8.5.10",
+    "@luma.gl/webgl": "8.5.10",
+    "@math.gl/core": "^3.5.6",
+    "@nebula.gl/edit-modes": "0.23.8",
+    "@nebula.gl/layers": "0.23.8",
+    "@turf/area": "^6.5.0",
+    "@turf/boolean-contains": "^6.5.0",
+    "@turf/boolean-overlap": "^6.5.0",
+    "@turf/boolean-point-in-polygon": "^6.5.0",
+    "@turf/boolean-within": "^6.5.0",
+    "@turf/centroid": "^6.5.0",
+    "@turf/helpers": "^6.5.0",
+    "@vitessce/utils": "2.0.0-beta.0",
+    "deck.gl": "8.6.7",
+    "glslify": "^7.0.0",
+    "lodash": "^4.17.21",
+    "math.gl": "^3.5.6",
+    "mathjs": "^9.2.0",
+    "nebula.gl": "0.23.8"
+  },
+  "devDependencies": {
+    "glsl-colormap": "^1.0.1"
+  },
+  "scripts": {
+    "start": "tsc --watch",
+    "build": "tsc",
+    "test": "pnpm exec vitest --run -r ../../ --dir .",
+    "glslify": "cat src/glsl/colormaps.in.glsl | glslify > src/glsl/colormaps.out.glsl"
+  }
+}