@vitessce/spatial-utils 3.1.3 → 3.2.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { D, e, a, b, c, d, G, n, l, m, h, i, f, j, k, o, s } from "./index-e86d2626.js";
+import { D, e, a, b, c, d, C, G, z, r, n, A, y, w, l, m, x, v, h, q, o, i, f, j, k, t, p, s, u } from "./index-ca4e31e3.js";
 import "react";
 export {
   D as DEFAULT_CELLS_LAYER,
@@ -7,15 +7,27 @@ export {
   b as DEFAULT_NEIGHBORHOODS_LAYER,
   c as DEFAULT_RASTER_DOMAIN_TYPE,
   d as DEFAULT_RASTER_LAYER_PROPS,
+  C as DOMAINS,
   G as GLOBAL_LABELS,
+  z as abbreviateNumber,
+  r as canLoadResolution,
   n as coordinateTransformationsToMatrix,
+  A as filterSelection,
+  y as getBoundingCube,
+  w as getMultiSelectionStats,
   l as getNgffAxes,
   m as getNgffAxesForTiff,
+  x as getPhysicalSizeScalingMatrix,
+  v as getSingleSelectionStats,
   h as getSourceFromLoader,
+  q as getStatsForResolution,
+  o as hexToRgb,
   i as initializeLayerChannels,
   f as initializeRasterLayersAndChannels,
   j as isInterleaved,
   k as isRgb,
-  o as normalizeCoordinateTransformations,
-  s as square
+  t as normalizeCoordinateTransformations,
+  p as physicalSizeToMatrix,
+  s as square,
+  u as toRgbUIString
 };

package/dist/{jpeg-03b93228.js → jpeg-76bff48f.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-e86d2626.js";
+import { B as BaseDecoder } from "./index-ca4e31e3.js";
 import "react";
 const dctZigZag = new Int32Array([
   0,

package/dist/{lerc-d5a641c1.js → lerc-1ad8fc7c.js}

@@ -1,5 +1,5 @@
 import { i as inflate_1 } from "./pako.esm-68f84e2a.js";
-import { g as getDefaultExportFromCjs, B as BaseDecoder } from "./index-e86d2626.js";
+import { g as getDefaultExportFromCjs, B as BaseDecoder } from "./index-ca4e31e3.js";
 import "react";
 const LercParameters = {
   Version: 0,

package/dist/{lzw-61ae68b2.js → lzw-c5e8dff0.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-e86d2626.js";
+import { B as BaseDecoder } from "./index-ca4e31e3.js";
 import "react";
 const MIN_BITS = 9;
 const CLEAR_CODE = 256;

package/dist/{packbits-b1d8eca2.js → packbits-ccf26149.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-e86d2626.js";
+import { B as BaseDecoder } from "./index-ca4e31e3.js";
 import "react";
 class PackbitsDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{raw-01deac62.js → raw-446b6beb.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-e86d2626.js";
+import { B as BaseDecoder } from "./index-ca4e31e3.js";
 import "react";
 class RawDecoder extends BaseDecoder {
   decodeBlock(buffer) {

package/dist/{webimage-f6e6dcb0.js → webimage-bf1c5425.js}

@@ -1,4 +1,4 @@
-import { B as BaseDecoder } from "./index-e86d2626.js";
+import { B as BaseDecoder } from "./index-ca4e31e3.js";
 import "react";
 class WebImageDecoder extends BaseDecoder {
   constructor() {

package/dist-tsc/constants.d.ts

@@ -0,0 +1,2 @@
+export const DOMAINS: {};
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.js"],"names":[],"mappings":"AAaA,yBAAoC"}

package/dist-tsc/constants.js

@@ -0,0 +1,12 @@
+import { viv } from '@vitessce/gl';
+function getDomains() {
+    const domains = {};
+    const needMin = ['Int8', 'Int16', 'Int32'];
+    Object.keys(viv.DTYPE_VALUES).forEach((dtype) => {
+        const { max } = viv.DTYPE_VALUES[dtype];
+        const min = needMin.includes(dtype) ? -(max + 1) : 0;
+        domains[dtype] = [min, max];
+    });
+    return domains;
+}
+export const DOMAINS = getDomains();

package/dist-tsc/index.d.ts

@@ -1,2 +1,4 @@
-export { GLOBAL_LABELS, DEFAULT_CELLS_LAYER, DEFAULT_MOLECULES_LAYER, DEFAULT_NEIGHBORHOODS_LAYER, DEFAULT_RASTER_DOMAIN_TYPE, DEFAULT_RASTER_LAYER_PROPS, DEFAULT_LAYER_TYPE_ORDERING, square, initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, normalizeCoordinateTransformations } from "./spatial.js";
+export { DOMAINS } from "./constants.js";
+export { GLOBAL_LABELS, DEFAULT_CELLS_LAYER, DEFAULT_MOLECULES_LAYER, DEFAULT_NEIGHBORHOODS_LAYER, DEFAULT_RASTER_DOMAIN_TYPE, DEFAULT_RASTER_LAYER_PROPS, DEFAULT_LAYER_TYPE_ORDERING, square, initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, physicalSizeToMatrix, hexToRgb, getStatsForResolution, canLoadResolution, normalizeCoordinateTransformations } from "./spatial.js";
+export { toRgbUIString, getSingleSelectionStats, getMultiSelectionStats, getPhysicalSizeScalingMatrix, getBoundingCube, abbreviateNumber, filterSelection } from "./layer-controller.js";
 //# sourceMappingURL=index.d.ts.map

package/dist-tsc/index.js

@@ -1 +1,3 @@
-export { GLOBAL_LABELS, DEFAULT_CELLS_LAYER, DEFAULT_MOLECULES_LAYER, DEFAULT_NEIGHBORHOODS_LAYER, DEFAULT_RASTER_DOMAIN_TYPE, DEFAULT_RASTER_LAYER_PROPS, DEFAULT_LAYER_TYPE_ORDERING, square, initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, normalizeCoordinateTransformations, } from './spatial.js';
+export { GLOBAL_LABELS, DEFAULT_CELLS_LAYER, DEFAULT_MOLECULES_LAYER, DEFAULT_NEIGHBORHOODS_LAYER, DEFAULT_RASTER_DOMAIN_TYPE, DEFAULT_RASTER_LAYER_PROPS, DEFAULT_LAYER_TYPE_ORDERING, square, initializeLayerChannels, initializeRasterLayersAndChannels, getSourceFromLoader, isInterleaved, isRgb, getNgffAxes, getNgffAxesForTiff, coordinateTransformationsToMatrix, physicalSizeToMatrix, hexToRgb, getStatsForResolution, canLoadResolution, normalizeCoordinateTransformations, } from './spatial.js';
+export { toRgbUIString, getSingleSelectionStats, getMultiSelectionStats, getPhysicalSizeScalingMatrix, getBoundingCube, abbreviateNumber, filterSelection, } from './layer-controller.js';
+export { DOMAINS, } from './constants.js';

package/dist-tsc/layer-controller.d.ts

@@ -1,3 +1,12 @@
+/**
+ * Ensure that the channel selection object does not have
+ * extra dimension keys, as this will cause Viv functions
+ * to throw errors about not being able to access the data.
+ * @param {*} loader
+ * @param {object} selection Mapping from dimension label to slice index.
+ * @returns {object} The filtered selection.
+ */
+export function filterSelection(loader: any, selection: object): object;
 /**
  * Get physical size scaling Matrix4
  * @param {Object} loader PixelSource
@@ -11,6 +20,7 @@ export function getPhysicalSizeScalingMatrix(loader: Object): Object;
  */
 export function getBoundingCube(loader: Object): any[];
 export function abbreviateNumber(value: any): any;
+export function toRgbUIString(on: any, arr: any, theme: any): string;
 export function getSingleSelectionStats({ loader, selection, use3d }: Object): Object;
 export function getMultiSelectionStats({ loader, selections, use3d }: {
     loader: any;

package/dist-tsc/layer-controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layer-controller.d.ts","sourceRoot":"","sources":["../src/layer-controller.js"],"names":[],"mappings":"AAuEA;;;;GAIG;AACH,qDAHW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;GAIG;AACH,wCAHW,MAAM,SAchB;AAED,kDAwBC;AAzEM,sEALI,MAAM,GAGJ,MAAM,CAOlB;AAEM;;;;;;;GAON"}
+{"version":3,"file":"layer-controller.d.ts","sourceRoot":"","sources":["../src/layer-controller.js"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AACH,wDAHW,MAAM,GACJ,MAAM,CASlB;AAwED;;;;GAIG;AACH,qDAHW,MAAM,GACJ,MAAM,CAUlB;AAED;;;;GAIG;AACH,wCAHW,MAAM,SAchB;AAED,kDAwBC;AAvJM,qEAKN;AAyEM,sEALI,MAAM,GAGJ,MAAM,CAOlB;AAEM;;;;;;;GAON"}

package/dist-tsc/layer-controller.js

@@ -1,25 +1,52 @@
-import { Matrix4 } from 'math.gl';
 import { viv } from '@vitessce/gl';
+import { fromEntries } from '@vitessce/utils';
+import { Matrix4 } from 'math.gl';
+// Returns an rgb string for display, and changes the color (arr)
+// to use a grey for light theme + white color or if the colormap is on.
+export const toRgbUIString = (on, arr, theme) => {
+    const color = on || (theme === 'light' && arr?.every(i => i === 255))
+        ? [220, 220, 220]
+        : arr;
+    return `rgb(${color})`;
+};
+/**
+ * Ensure that the channel selection object does not have
+ * extra dimension keys, as this will cause Viv functions
+ * to throw errors about not being able to access the data.
+ * @param {*} loader
+ * @param {object} selection Mapping from dimension label to slice index.
+ * @returns {object} The filtered selection.
+ */
+export function filterSelection(loader, selection) {
+    if (!selection) {
+        return selection;
+    }
+    const data = Array.isArray(loader) ? loader[loader.length - 1] : loader;
+    const { labels } = data;
+    return fromEntries(Object.entries(selection).filter(([key]) => labels.includes(key)));
+}
 async function getSingleSelectionStats2D({ loader, selection }) {
     const data = Array.isArray(loader) ? loader[loader.length - 1] : loader;
-    const raster = await data.getRaster({ selection });
+    const filteredSelection = filterSelection(loader, selection);
+    const raster = await data.getRaster({ selection: filteredSelection });
     const selectionStats = viv.getChannelStats(raster.data);
     const { domain, contrastLimits: slider } = selectionStats;
     return { domain, slider };
 }
 async function getSingleSelectionStats3D({ loader, selection }) {
     const lowResSource = loader[loader.length - 1];
+    const filteredSelection = filterSelection(lowResSource, selection);
     const { shape, labels } = lowResSource;
     // eslint-disable-next-line no-bitwise
     const sizeZ = shape[labels.indexOf('z')] >> (loader.length - 1);
     const raster0 = await lowResSource.getRaster({
-        selection: { ...selection, z: 0 },
+        selection: { ...filteredSelection, z: 0 },
     });
     const rasterMid = await lowResSource.getRaster({
-        selection: { ...selection, z: Math.floor(sizeZ / 2) },
+        selection: { ...filteredSelection, z: Math.floor(sizeZ / 2) },
     });
     const rasterTop = await lowResSource.getRaster({
-        selection: { ...selection, z: Math.max(0, sizeZ - 1) },
+        selection: { ...filteredSelection, z: Math.max(0, sizeZ - 1) },
     });
     const stats0 = viv.getChannelStats(raster0.data);
     const statsMid = viv.getChannelStats(rasterMid.data);

package/dist-tsc/layer-controller.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=layer-controller.test.d.ts.map

package/dist-tsc/layer-controller.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-controller.test.d.ts","sourceRoot":"","sources":["../src/layer-controller.test.js"],"names":[],"mappings":""}

package/dist-tsc/layer-controller.test.js

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import { toRgbUIString } from './layer-controller.js';
+const GREY = [220, 220, 220];
+describe('layer-controller/RasterChannelController.js', () => {
+    describe('toRgbUIString()', () => {
+        it('Maps color value to itself when colormap off and not white with dark theme', () => {
+            expect(toRgbUIString(false, [200, 200, 200], 'dark')).toEqual(`rgb(${[200, 200, 200]})`);
+        });
+        it('Maps color value to grey when colormap on with dark theme', () => {
+            expect(toRgbUIString(true, [200, 200, 200], 'dark')).toEqual(`rgb(${GREY})`);
+        });
+        it('Maps color value to grey when colormap on with light theme', () => {
+            expect(toRgbUIString(true, [200, 200, 200], 'light')).toEqual(`rgb(${GREY})`);
+        });
+        it('Maps color value to grey when colormap off and white with light theme', () => {
+            expect(toRgbUIString(false, [255, 255, 255], 'light')).toEqual(`rgb(${GREY})`);
+        });
+        it('Maps color value to grey when colormap off and white with light theme', () => {
+            expect(toRgbUIString(false, [200, 200, 200], 'light')).toEqual(`rgb(${[200, 200, 200]})`);
+        });
+    });
+});

package/dist-tsc/spatial.d.ts

@@ -13,6 +13,7 @@ export function getSourceFromLoader(loader: object, level?: number | undefined):
  * @param {array|null} channels
  */
 export function isRgb(loader: object, channels: array | null): boolean;
+export function physicalSizeToMatrix(xSize: any, ySize: any, zSize: any, xUnit: any, yUnit: any, zUnit: any): Matrix4;
 /**
  * @param {Array.<number>} shape loader shape
  */
@@ -44,13 +45,14 @@ export function getNgffAxesForTiff(dimOrder: any): any;
 /**
  * Convert an array of coordinateTransformations objects to a 16-element
  * plain JS array using Matrix4 linear algebra transformation functions.
- * @param {object[]} coordinateTransformations List of objects matching the
+ * @param {object[]|undefined} coordinateTransformations List of objects matching the
  * OME-NGFF v0.4 coordinateTransformations spec.
- * @param {object[]} axes Axes in OME-NGFF v0.4 format, objects
+ * @param {object[]|undefined} axes Axes in OME-NGFF v0.4 format, objects
  * with { type, name }.
- * @returns {Array<number>} Array of 16 numbers representing the Matrix4.
+ * @returns {Matrix4} Array of 16 numbers representing the Matrix4.
  */
-export function coordinateTransformationsToMatrix(coordinateTransformations: object[], axes: object[]): Array<number>;
+export function coordinateTransformationsToMatrix(coordinateTransformations: object[] | undefined, axes: object[] | undefined): Matrix4;
+export function hexToRgb(hex: any): number[];
 /**
  * Normalize coordinate transformations to the OME-NGFF v0.4 format,
  * despite potentially being in the new format proposed in
@@ -94,5 +96,13 @@ export namespace DEFAULT_NEIGHBORHOODS_LAYER {
     export { visible_3 as visible };
 }
 export const DEFAULT_LAYER_TYPE_ORDERING: string[];
+export function getStatsForResolution(loader: any, resolution: any): {
+    height: any;
+    width: any;
+    depthDownsampled: number;
+    totalBytes: number;
+};
+export function canLoadResolution(loader: any, resolution: any): boolean;
+import { Matrix4 } from ".pnpm/@math.gl+core@3.6.3/node_modules/@math.gl/core";
 import { viv } from "@vitessce/gl";
 //# sourceMappingURL=spatial.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"spatial.d.ts","sourceRoot":"","sources":["../src/spatial.js"],"names":[],"mappings":"AAOA,wDAEC;AAiCD;;;;;;GAMG;AACH,4CAJW,MAAM,UACN,MAAM,eACJ,MAAM,CAMlB;AAED;;;;GAIG;AACH,8BAHW,MAAM,YACN,QAAM,IAAI,WAiBpB;AAmHD;;GAEG;AACH,qCAFW,MAAO,MAAM,CAAC,WAKxB;AAED;;;;;;GAMG;AACH,gDALW,MAAM,eAEJ,MAAM,EAAE,CAuCpB;AAED;;;;;;;;;GASG;AACH,gEAJW,MAAM,EAAE,sBAER,CAAC,MAAM,EAAE,GAAC,IAAI,CAAC,+CAuEzB;AASD;;;IAuBC;AAED,uDAQC;AAED;;;;;;;;GAQG;AACH,6EANW,MAAM,EAAE,QAER,MAAM,EAAE,GAEN,MAAM,MAAM,CAAC,CA4CzB;AAED;;;;;;;;;GASG;AACH,8EANW,MAAM,EAAE,GAAC,SAAS,YAGlB,MAAM,EAAE,GACN,MAAM,EAAE,CAiDpB;AAjdD,qCAAwC;AAExC,mDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBpD,mDAKE"}
+{"version":3,"file":"spatial.d.ts","sourceRoot":"","sources":["../src/spatial.js"],"names":[],"mappings":"AAOA,wDAEC;AAiCD;;;;;;GAMG;AACH,4CAJW,MAAM,UACN,MAAM,eACJ,MAAM,CAMlB;AAoCD;;;;GAIG;AACH,8BAHW,MAAM,YACN,QAAM,IAAI,WAiBpB;AAID,sHAkCC;AAiHD;;GAEG;AACH,qCAFW,MAAO,MAAM,CAAC,WAKxB;AAED;;;;;;GAMG;AACH,gDALW,MAAM,eAEJ,MAAM,EAAE,CAuCpB;AAED;;;;;;;;;GASG;AACH,gEAJW,MAAM,EAAE,sBAER,CAAC,MAAM,EAAE,GAAC,IAAI,CAAC,+CAuEzB;AASD;;;IAuBC;AAED,uDAQC;AAED;;;;;;;;GAQG;AACH,6EANW,MAAM,EAAE,GAAC,SAAS,QAElB,MAAM,EAAE,GAAC,SAAS,GAEhB,OAAO,CA4CnB;AAED,6CAOC;AAED;;;;;;;;;GASG;AACH,8EANW,MAAM,EAAE,GAAC,SAAS,YAGlB,MAAM,EAAE,GACN,MAAM,EAAE,CAiDpB;AAhiBD,qCAAwC;AAExC,mDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBpD,mDAKE;AAeK;;;;;EAYN;AAEM,yEAkBN"}

package/dist-tsc/spatial.js

@@ -45,6 +45,31 @@ export function getSourceFromLoader(loader, level) {
     const source = Array.isArray(data) ? data[(level || data.length - 1)] : data;
     return source;
 }
+export const getStatsForResolution = (loader, resolution) => {
+    const { shape, labels } = loader[resolution];
+    const height = shape[labels.indexOf('y')];
+    const width = shape[labels.indexOf('x')];
+    const depth = shape[labels.indexOf('z')];
+    // eslint-disable-next-line no-bitwise
+    const depthDownsampled = Math.max(1, depth >> resolution);
+    // Check memory allocation limits for Float32Array (used in XR3DLayer for rendering)
+    const totalBytes = 4 * height * width * depthDownsampled;
+    return {
+        height, width, depthDownsampled, totalBytes,
+    };
+};
+export const canLoadResolution = (loader, resolution) => {
+    const { totalBytes, height, width, depthDownsampled, } = getStatsForResolution(loader, resolution);
+    const maxHeapSize = window.performance?.memory
+        && window.performance?.memory?.jsHeapSizeLimit / 2;
+    const maxSize = maxHeapSize || (2 ** 31) - 1;
+    // 2048 is a normal texture size limit although some browsers go larger.
+    return (totalBytes < maxSize
+        && height <= 2048
+        && depthDownsampled <= 2048
+        && width <= 2048
+        && depthDownsampled > 1);
+};
 /**
  * Helper method to determine whether pixel data is interleaved and rgb or not.
  * @param {object} loader
@@ -66,6 +91,39 @@ export function isRgb(loader, channels) {
     return false;
 }
 // From spatial/utils.js
+export function physicalSizeToMatrix(xSize, ySize, zSize, xUnit, yUnit, zUnit) {
+    const hasZPhyscialSize = Boolean(zSize) && Boolean(zUnit);
+    const hasYPhyscialSize = Boolean(ySize) && Boolean(yUnit);
+    const hasXPhyscialSize = Boolean(xSize) && Boolean(xUnit);
+    if (!hasXPhyscialSize || !hasYPhyscialSize) {
+        return (new Matrix4()).identity();
+    }
+    const sizes = [
+        unit(`${xSize} ${xUnit}`.replace('µ', 'u')),
+        unit(`${ySize} ${yUnit}`.replace('µ', 'u')),
+    ];
+    if (hasZPhyscialSize) {
+        sizes.push(unit(`${zSize} ${zUnit}`.replace('µ', 'u')));
+    }
+    // Find the ratio of the sizes to get the scaling factor.
+    const scale = sizes.map(i => divide(i, unit('1 um')));
+    // TODO: is this still needed
+    // sizes are special objects with own equals method - see `unit` in declaration
+    if (!sizes[0].equals(sizes[1])) {
+        // Handle scaling in the Y direction for non-square pixels
+        scale[1] = divide(sizes[1], sizes[0]);
+    }
+    // END TODO: is this still needed
+    // 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 (new Matrix4()).identity();
+    }
+    return new Matrix4().scale([...scale]);
+}
 function getMetaWithTransformMatrices(imageMeta, imageLoaders) {
     // Do not fill in transformation matrices if any of the layers specify one.
     const sources = imageLoaders.map(loader => getSourceFromLoader(loader));
@@ -328,11 +386,11 @@ export function getNgffAxesForTiff(dimOrder) {
 /**
  * Convert an array of coordinateTransformations objects to a 16-element
  * plain JS array using Matrix4 linear algebra transformation functions.
- * @param {object[]} coordinateTransformations List of objects matching the
+ * @param {object[]|undefined} coordinateTransformations List of objects matching the
  * OME-NGFF v0.4 coordinateTransformations spec.
- * @param {object[]} axes Axes in OME-NGFF v0.4 format, objects
+ * @param {object[]|undefined} axes Axes in OME-NGFF v0.4 format, objects
  * with { type, name }.
- * @returns {Array<number>} Array of 16 numbers representing the Matrix4.
+ * @returns {Matrix4} Array of 16 numbers representing the Matrix4.
  */
 export function coordinateTransformationsToMatrix(coordinateTransformations, axes) {
     let mat = (new Matrix4()).identity();
@@ -373,6 +431,14 @@ export function coordinateTransformationsToMatrix(coordinateTransformations, axe
     }
     return mat;
 }
+export function hexToRgb(hex) {
+    const result = /^#?([A-F\d]{2})([A-F\d]{2})([A-F\d]{2})$/i.exec(hex);
+    return [
+        parseInt(result[1].toLowerCase(), 16),
+        parseInt(result[2].toLowerCase(), 16),
+        parseInt(result[3].toLowerCase(), 16),
+    ];
+}
 /**
  * Normalize coordinate transformations to the OME-NGFF v0.4 format,
  * despite potentially being in the new format proposed in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitessce/spatial-utils",
-  "version": "3.1.3",
+  "version": "3.2.0",
   "author": "Gehlenborg Lab",
   "homepage": "http://vitessce.io",
   "repository": {
@@ -19,8 +19,8 @@
     "lodash-es": "^4.17.21",
     "math.gl": "^3.5.6",
     "mathjs": "^9.2.0",
-    "@vitessce/gl": "3.1.3",
-    "@vitessce/utils": "3.1.3"
+    "@vitessce/gl": "3.2.0",
+    "@vitessce/utils": "3.2.0"
   },
   "scripts": {
     "bundle": "pnpm exec vite build -c ../../../scripts/vite.config.js",

package/src/constants.js

@@ -0,0 +1,14 @@
+import { viv } from '@vitessce/gl';
+
+function getDomains() {
+  const domains = {};
+  const needMin = ['Int8', 'Int16', 'Int32'];
+  Object.keys(viv.DTYPE_VALUES).forEach((dtype) => {
+    const { max } = viv.DTYPE_VALUES[dtype];
+    const min = needMin.includes(dtype) ? -(max + 1) : 0;
+    domains[dtype] = [min, max];
+  });
+  return domains;
+}
+
+export const DOMAINS = getDomains();

package/src/index.js

@@ -15,5 +15,21 @@ export {
   getNgffAxes,
   getNgffAxesForTiff,
   coordinateTransformationsToMatrix,
+  physicalSizeToMatrix,
+  hexToRgb,
+  getStatsForResolution,
+  canLoadResolution,
   normalizeCoordinateTransformations,
 } from './spatial.js';
+export {
+  toRgbUIString,
+  getSingleSelectionStats,
+  getMultiSelectionStats,
+  getPhysicalSizeScalingMatrix,
+  getBoundingCube,
+  abbreviateNumber,
+  filterSelection,
+} from './layer-controller.js';
+export {
+  DOMAINS,
+} from './constants.js';

package/src/layer-controller.js

@@ -1,9 +1,37 @@
-import { Matrix4 } from 'math.gl';
 import { viv } from '@vitessce/gl';
+import { fromEntries } from '@vitessce/utils';
+import { Matrix4 } from 'math.gl';
+
+// Returns an rgb string for display, and changes the color (arr)
+// to use a grey for light theme + white color or if the colormap is on.
+export const toRgbUIString = (on, arr, theme) => {
+  const color = on || (theme === 'light' && arr?.every(i => i === 255))
+    ? [220, 220, 220]
+    : arr;
+  return `rgb(${color})`;
+};
+
+/**
+ * Ensure that the channel selection object does not have
+ * extra dimension keys, as this will cause Viv functions
+ * to throw errors about not being able to access the data.
+ * @param {*} loader
+ * @param {object} selection Mapping from dimension label to slice index.
+ * @returns {object} The filtered selection.
+ */
+export function filterSelection(loader, selection) {
+  if (!selection) {
+    return selection;
+  }
+  const data = Array.isArray(loader) ? loader[loader.length - 1] : loader;
+  const { labels } = data;
+  return fromEntries(Object.entries(selection).filter(([key]) => labels.includes(key)));
+}
 
 async function getSingleSelectionStats2D({ loader, selection }) {
   const data = Array.isArray(loader) ? loader[loader.length - 1] : loader;
-  const raster = await data.getRaster({ selection });
+  const filteredSelection = filterSelection(loader, selection);
+  const raster = await data.getRaster({ selection: filteredSelection });
   const selectionStats = viv.getChannelStats(raster.data);
   const { domain, contrastLimits: slider } = selectionStats;
   return { domain, slider };
@@ -11,17 +39,18 @@ async function getSingleSelectionStats2D({ loader, selection }) {
 
 async function getSingleSelectionStats3D({ loader, selection }) {
   const lowResSource = loader[loader.length - 1];
+  const filteredSelection = filterSelection(lowResSource, selection);
   const { shape, labels } = lowResSource;
   // eslint-disable-next-line no-bitwise
   const sizeZ = shape[labels.indexOf('z')] >> (loader.length - 1);
   const raster0 = await lowResSource.getRaster({
-    selection: { ...selection, z: 0 },
+    selection: { ...filteredSelection, z: 0 },
   });
   const rasterMid = await lowResSource.getRaster({
-    selection: { ...selection, z: Math.floor(sizeZ / 2) },
+    selection: { ...filteredSelection, z: Math.floor(sizeZ / 2) },
   });
   const rasterTop = await lowResSource.getRaster({
-    selection: { ...selection, z: Math.max(0, sizeZ - 1) },
+    selection: { ...filteredSelection, z: Math.max(0, sizeZ - 1) },
   });
   const stats0 = viv.getChannelStats(raster0.data);
   const statsMid = viv.getChannelStats(rasterMid.data);

package/src/layer-controller.test.js

@@ -0,0 +1,24 @@
+import { describe, it, expect } from 'vitest';
+import { toRgbUIString } from './layer-controller.js';
+
+const GREY = [220, 220, 220];
+
+describe('layer-controller/RasterChannelController.js', () => {
+  describe('toRgbUIString()', () => {
+    it('Maps color value to itself when colormap off and not white with dark theme', () => {
+      expect(toRgbUIString(false, [200, 200, 200], 'dark')).toEqual(`rgb(${[200, 200, 200]})`);
+    });
+    it('Maps color value to grey when colormap on with dark theme', () => {
+      expect(toRgbUIString(true, [200, 200, 200], 'dark')).toEqual(`rgb(${GREY})`);
+    });
+    it('Maps color value to grey when colormap on with light theme', () => {
+      expect(toRgbUIString(true, [200, 200, 200], 'light')).toEqual(`rgb(${GREY})`);
+    });
+    it('Maps color value to grey when colormap off and white with light theme', () => {
+      expect(toRgbUIString(false, [255, 255, 255], 'light')).toEqual(`rgb(${GREY})`);
+    });
+    it('Maps color value to grey when colormap off and white with light theme', () => {
+      expect(toRgbUIString(false, [200, 200, 200], 'light')).toEqual(`rgb(${[200, 200, 200]})`);
+    });
+  });
+});

package/src/spatial.js

@@ -53,6 +53,40 @@ export function getSourceFromLoader(loader, level) {
   return source;
 }
 
+export const getStatsForResolution = (loader, resolution) => {
+  const { shape, labels } = loader[resolution];
+  const height = shape[labels.indexOf('y')];
+  const width = shape[labels.indexOf('x')];
+  const depth = shape[labels.indexOf('z')];
+  // eslint-disable-next-line no-bitwise
+  const depthDownsampled = Math.max(1, depth >> resolution);
+  // Check memory allocation limits for Float32Array (used in XR3DLayer for rendering)
+  const totalBytes = 4 * height * width * depthDownsampled;
+  return {
+    height, width, depthDownsampled, totalBytes,
+  };
+};
+
+export const canLoadResolution = (loader, resolution) => {
+  const {
+    totalBytes, height, width, depthDownsampled,
+  } = getStatsForResolution(
+    loader,
+    resolution,
+  );
+  const maxHeapSize = window.performance?.memory
+    && window.performance?.memory?.jsHeapSizeLimit / 2;
+  const maxSize = maxHeapSize || (2 ** 31) - 1;
+  // 2048 is a normal texture size limit although some browsers go larger.
+  return (
+    totalBytes < maxSize
+    && height <= 2048
+    && depthDownsampled <= 2048
+    && width <= 2048
+    && depthDownsampled > 1
+  );
+};
+
 /**
  * Helper method to determine whether pixel data is interleaved and rgb or not.
  * @param {object} loader
@@ -77,6 +111,42 @@ export function isRgb(loader, channels) {
 
 // From spatial/utils.js
 
+export function physicalSizeToMatrix(xSize, ySize, zSize, xUnit, yUnit, zUnit) {
+  const hasZPhyscialSize = Boolean(zSize) && Boolean(zUnit);
+  const hasYPhyscialSize = Boolean(ySize) && Boolean(yUnit);
+  const hasXPhyscialSize = Boolean(xSize) && Boolean(xUnit);
+  if (!hasXPhyscialSize || !hasYPhyscialSize) {
+    return (new Matrix4()).identity();
+  }
+  const sizes = [
+    unit(`${xSize} ${xUnit}`.replace('µ', 'u')),
+    unit(`${ySize} ${yUnit}`.replace('µ', 'u')),
+  ];
+  if (hasZPhyscialSize) {
+    sizes.push(unit(`${zSize} ${zUnit}`.replace('µ', 'u')));
+  }
+  // Find the ratio of the sizes to get the scaling factor.
+  const scale = sizes.map(i => divide(i, unit('1 um')));
+
+  // TODO: is this still needed
+  // sizes are special objects with own equals method - see `unit` in declaration
+  if (!sizes[0].equals(sizes[1])) {
+    // Handle scaling in the Y direction for non-square pixels
+    scale[1] = divide(sizes[1], sizes[0]);
+  }
+  // END TODO: is this still needed
+
+  // 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 (new Matrix4()).identity();
+  }
+  return new Matrix4().scale([...scale]);
+}
+
 function getMetaWithTransformMatrices(imageMeta, imageLoaders) {
   // Do not fill in transformation matrices if any of the layers specify one.
   const sources = imageLoaders.map(loader => getSourceFromLoader(loader));
@@ -367,11 +437,11 @@ export function getNgffAxesForTiff(dimOrder) {
 /**
  * Convert an array of coordinateTransformations objects to a 16-element
  * plain JS array using Matrix4 linear algebra transformation functions.
- * @param {object[]} coordinateTransformations List of objects matching the
+ * @param {object[]|undefined} coordinateTransformations List of objects matching the
  * OME-NGFF v0.4 coordinateTransformations spec.
- * @param {object[]} axes Axes in OME-NGFF v0.4 format, objects
+ * @param {object[]|undefined} axes Axes in OME-NGFF v0.4 format, objects
  * with { type, name }.
- * @returns {Array<number>} Array of 16 numbers representing the Matrix4.
+ * @returns {Matrix4} Array of 16 numbers representing the Matrix4.
  */
 export function coordinateTransformationsToMatrix(coordinateTransformations, axes) {
   let mat = (new Matrix4()).identity();
@@ -417,6 +487,15 @@ export function coordinateTransformationsToMatrix(coordinateTransformations, axe
   return mat;
 }
 
+export function hexToRgb(hex) {
+  const result = /^#?([A-F\d]{2})([A-F\d]{2})([A-F\d]{2})$/i.exec(hex);
+  return [
+    parseInt(result[1].toLowerCase(), 16),
+    parseInt(result[2].toLowerCase(), 16),
+    parseInt(result[3].toLowerCase(), 16),
+  ];
+}
+
 /**
  * Normalize coordinate transformations to the OME-NGFF v0.4 format,
  * despite potentially being in the new format proposed in