@vitessce/spatial-utils 2.0.2 → 2.0.3

package/dist/raw.c3b45ab1.mjs

@@ -0,0 +1,11 @@
+import { B as BaseDecoder } from "./index.75f0a489.mjs";
+import "@vitessce/vit-s";
+import "react";
+class RawDecoder extends BaseDecoder {
+  decodeBlock(buffer) {
+    return buffer;
+  }
+}
+export {
+  RawDecoder as default
+};

package/dist/webimage.53b9bf75.mjs

@@ -0,0 +1,31 @@
+import { B as BaseDecoder } from "./index.75f0a489.mjs";
+import "@vitessce/vit-s";
+import "react";
+class WebImageDecoder extends BaseDecoder {
+  constructor() {
+    super();
+    if (typeof createImageBitmap === "undefined") {
+      throw new Error("Cannot decode WebImage as `createImageBitmap` is not available");
+    } else if (typeof document === "undefined" && typeof OffscreenCanvas === "undefined") {
+      throw new Error("Cannot decode WebImage as neither `document` nor `OffscreenCanvas` is not available");
+    }
+  }
+  async decode(fileDirectory, buffer) {
+    const blob = new Blob([buffer]);
+    const imageBitmap = await createImageBitmap(blob);
+    let canvas;
+    if (typeof document !== "undefined") {
+      canvas = document.createElement("canvas");
+      canvas.width = imageBitmap.width;
+      canvas.height = imageBitmap.height;
+    } else {
+      canvas = new OffscreenCanvas(imageBitmap.width, imageBitmap.height);
+    }
+    const ctx = canvas.getContext("2d");
+    ctx.drawImage(imageBitmap, 0, 0);
+    return ctx.getImageData(0, 0, imageBitmap.width, imageBitmap.height).data.buffer;
+  }
+}
+export {
+  WebImageDecoder as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vitessce/spatial-utils",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "author": "Gehlenborg Lab",
   "homepage": "http://vitessce.io",
   "repository": {
@@ -8,20 +8,20 @@
     "url": "git+https://github.com/vitessce/vitessce.git"
   },
   "license": "MIT",
-  "main": "dist/index.js",
+  "main": "dist/index.mjs",
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "dependencies": {
     "lodash": "^4.17.21",
     "math.gl": "^3.5.6",
     "mathjs": "^9.2.0",
-    "@vitessce/gl": "2.0.2",
-    "@vitessce/utils": "2.0.2"
+    "@vitessce/gl": "2.0.3",
+    "@vitessce/utils": "2.0.3"
   },
   "scripts": {
-    "start": "tsc --watch",
-    "build": "tsc",
+    "bundle": "pnpm exec vite build -c ../../../scripts/vite.config.js",
     "test": "pnpm exec vitest --run -r ../../../ --dir ."
   }
 }

package/src/index.js

@@ -0,0 +1,15 @@
+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,
+} from './spatial';

package/src/layer-controller.js

@@ -0,0 +1,129 @@
+import { Matrix4 } from 'math.gl';
+import { viv } from '@vitessce/gl';
+
+async function getSingleSelectionStats2D({ loader, selection }) {
+  const data = Array.isArray(loader) ? loader[loader.length - 1] : loader;
+  const raster = await data.getRaster({ selection });
+  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 { 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 },
+  });
+  const rasterMid = await lowResSource.getRaster({
+    selection: { ...selection, z: Math.floor(sizeZ / 2) },
+  });
+  const rasterTop = await lowResSource.getRaster({
+    selection: { ...selection, z: Math.max(0, sizeZ - 1) },
+  });
+  const stats0 = viv.getChannelStats(raster0.data);
+  const statsMid = viv.getChannelStats(rasterMid.data);
+  const statsTop = viv.getChannelStats(rasterTop.data);
+  return {
+    domain: [
+      Math.min(stats0.domain[0], statsMid.domain[0], statsTop.domain[0]),
+      Math.max(stats0.domain[1], statsMid.domain[1], statsTop.domain[1]),
+    ],
+    slider: [
+      Math.min(
+        stats0.contrastLimits[0],
+        statsMid.contrastLimits[0],
+        statsTop.contrastLimits[0],
+      ),
+      Math.max(
+        stats0.contrastLimits[1],
+        statsMid.contrastLimits[1],
+        statsTop.contrastLimits[1],
+      ),
+    ],
+  };
+}
+
+/**
+ * Get bounding cube for a given loader i.e [[0, width], [0, height], [0, depth]]
+ * @param {Object} loader PixelSource|PixelSource[]
+ * @param {[]} selection Selection for stats.
+ * @param {boolean} use3d Whether or not to get 3d stats.
+ * @returns {Object} { domains, sliders }
+ */
+export const getSingleSelectionStats = async ({ loader, selection, use3d }) => {
+  const getStats = use3d
+    ? getSingleSelectionStats3D
+    : getSingleSelectionStats2D;
+  return getStats({ loader, selection });
+};
+
+export const getMultiSelectionStats = async ({ loader, selections, use3d }) => {
+  const stats = await Promise.all(
+    selections.map(selection => getSingleSelectionStats({ loader, selection, use3d })),
+  );
+  const domains = stats.map(stat => stat.domain);
+  const sliders = stats.map(stat => stat.slider);
+  return { domains, sliders };
+};
+
+/**
+ * Get physical size scaling Matrix4
+ * @param {Object} loader PixelSource
+ * @returns {Object} matrix
+ */
+export function getPhysicalSizeScalingMatrix(loader) {
+  const { x, y, z } = loader?.meta?.physicalSizes ?? {};
+  if (x?.size && y?.size && z?.size) {
+    const min = Math.min(z.size, x.size, y.size);
+    const ratio = [x.size / min, y.size / min, z.size / min];
+    return new Matrix4().scale(ratio);
+  }
+  return new Matrix4().identity();
+}
+
+/**
+ * Get bounding cube for a given loader
+ * @param {Object} loader PixelSource|PixelSource[]
+ * @returns {Array} [0, width], [0, height], [0, depth]]
+ */
+export function getBoundingCube(loader) {
+  const source = Array.isArray(loader) ? loader[0] : loader;
+  const { shape, labels } = source;
+  const physicalSizeScalingMatrix = getPhysicalSizeScalingMatrix(source);
+  const xSlice = [0, physicalSizeScalingMatrix[0] * shape[labels.indexOf('x')]];
+  const ySlice = [0, physicalSizeScalingMatrix[5] * shape[labels.indexOf('y')]];
+  const zSlice = [
+    0,
+    physicalSizeScalingMatrix[10] * shape[labels.indexOf('z')],
+  ];
+  return [xSlice, ySlice, zSlice];
+}
+
+export function abbreviateNumber(value) {
+  // Return an abbreviated representation of value, in 5 characters or less.
+
+  const maxLength = 5;
+  let maxNaiveDigits = maxLength;
+
+  /* eslint-disable no-plusplus */
+  if (!Number.isInteger(value)) {
+    --maxNaiveDigits;
+  } // Wasted on "."
+  if (value < 1) {
+    --maxNaiveDigits;
+  } // Wasted on "0."
+  /* eslint-disable no-plusplus */
+
+  const naive = Intl.NumberFormat('en-US', {
+    maximumSignificantDigits: maxNaiveDigits,
+    useGrouping: false,
+  }).format(value);
+  if (naive.length <= maxLength) return naive;
+
+  // "e+9" consumes 3 characters, so if we even had two significant digits,
+  // it would take take us to six characters, including the decimal point.
+  return value.toExponential(0);
+}

package/src/spatial.js

@@ -0,0 +1,318 @@
+import isEqual from 'lodash/isEqual';
+import { Matrix4 } from 'math.gl';
+import { divide, compare, unit } from 'mathjs';
+import { VIEWER_PALETTE } from '@vitessce/utils';
+import { viv } from '@vitessce/gl';
+import { getMultiSelectionStats } from './layer-controller';
+
+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: viv.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/src/spatial.test.js

@@ -0,0 +1,9 @@
+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/layer-controller.js

@@ -1,109 +0,0 @@
-import { Matrix4 } from 'math.gl';
-import { viv } from '@vitessce/gl';
-async function getSingleSelectionStats2D({ loader, selection }) {
-    const data = Array.isArray(loader) ? loader[loader.length - 1] : loader;
-    const raster = await data.getRaster({ selection });
-    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 { 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 },
-    });
-    const rasterMid = await lowResSource.getRaster({
-        selection: { ...selection, z: Math.floor(sizeZ / 2) },
-    });
-    const rasterTop = await lowResSource.getRaster({
-        selection: { ...selection, z: Math.max(0, sizeZ - 1) },
-    });
-    const stats0 = viv.getChannelStats(raster0.data);
-    const statsMid = viv.getChannelStats(rasterMid.data);
-    const statsTop = viv.getChannelStats(rasterTop.data);
-    return {
-        domain: [
-            Math.min(stats0.domain[0], statsMid.domain[0], statsTop.domain[0]),
-            Math.max(stats0.domain[1], statsMid.domain[1], statsTop.domain[1]),
-        ],
-        slider: [
-            Math.min(stats0.contrastLimits[0], statsMid.contrastLimits[0], statsTop.contrastLimits[0]),
-            Math.max(stats0.contrastLimits[1], statsMid.contrastLimits[1], statsTop.contrastLimits[1]),
-        ],
-    };
-}
-/**
- * Get bounding cube for a given loader i.e [[0, width], [0, height], [0, depth]]
- * @param {Object} loader PixelSource|PixelSource[]
- * @param {[]} selection Selection for stats.
- * @param {boolean} use3d Whether or not to get 3d stats.
- * @returns {Object} { domains, sliders }
- */
-export const getSingleSelectionStats = async ({ loader, selection, use3d }) => {
-    const getStats = use3d
-        ? getSingleSelectionStats3D
-        : getSingleSelectionStats2D;
-    return getStats({ loader, selection });
-};
-export const getMultiSelectionStats = async ({ loader, selections, use3d }) => {
-    const stats = await Promise.all(selections.map(selection => getSingleSelectionStats({ loader, selection, use3d })));
-    const domains = stats.map(stat => stat.domain);
-    const sliders = stats.map(stat => stat.slider);
-    return { domains, sliders };
-};
-/**
- * Get physical size scaling Matrix4
- * @param {Object} loader PixelSource
- * @returns {Object} matrix
- */
-export function getPhysicalSizeScalingMatrix(loader) {
-    const { x, y, z } = loader?.meta?.physicalSizes ?? {};
-    if (x?.size && y?.size && z?.size) {
-        const min = Math.min(z.size, x.size, y.size);
-        const ratio = [x.size / min, y.size / min, z.size / min];
-        return new Matrix4().scale(ratio);
-    }
-    return new Matrix4().identity();
-}
-/**
- * Get bounding cube for a given loader
- * @param {Object} loader PixelSource|PixelSource[]
- * @returns {Array} [0, width], [0, height], [0, depth]]
- */
-export function getBoundingCube(loader) {
-    const source = Array.isArray(loader) ? loader[0] : loader;
-    const { shape, labels } = source;
-    const physicalSizeScalingMatrix = getPhysicalSizeScalingMatrix(source);
-    const xSlice = [0, physicalSizeScalingMatrix[0] * shape[labels.indexOf('x')]];
-    const ySlice = [0, physicalSizeScalingMatrix[5] * shape[labels.indexOf('y')]];
-    const zSlice = [
-        0,
-        physicalSizeScalingMatrix[10] * shape[labels.indexOf('z')],
-    ];
-    return [xSlice, ySlice, zSlice];
-}
-export function abbreviateNumber(value) {
-    // Return an abbreviated representation of value, in 5 characters or less.
-    const maxLength = 5;
-    let maxNaiveDigits = maxLength;
-    /* eslint-disable no-plusplus */
-    if (!Number.isInteger(value)) {
-        --maxNaiveDigits;
-    } // Wasted on "."
-    if (value < 1) {
-        --maxNaiveDigits;
-    } // Wasted on "0."
-    /* eslint-disable no-plusplus */
-    const naive = Intl.NumberFormat('en-US', {
-        maximumSignificantDigits: maxNaiveDigits,
-        useGrouping: false,
-    }).format(value);
-    if (naive.length <= maxLength)
-        return naive;
-    // "e+9" consumes 3 characters, so if we even had two significant digits,
-    // it would take take us to six characters, including the decimal point.
-    return value.toExponential(0);
-}