@aics/vole-core 3.12.4

package/es/test/num_utils.test.js

@@ -0,0 +1,140 @@
+import { expect } from "chai";
+import { it } from "mocha";
+import { constrainToAxis, formatNumber, getTimestamp } from "../utils/num_utils";
+import { Axis } from "../VolumeRenderSettings.js";
+describe("num_utils", () => {
+  describe("formatNumber", () => {
+    it("stringifies integers with 4 or fewer digits", () => {
+      expect(formatNumber(4)).to.equal("4");
+      expect(formatNumber(-876)).to.equal("-876");
+      expect(formatNumber(1234)).to.equal("1234");
+      expect(formatNumber(9999)).to.equal("9999");
+      expect(formatNumber(-9999)).to.equal("-9999");
+    });
+    it("rounds decimals to 5 significant figures", () => {
+      expect(formatNumber(123.4567)).to.equal("123.46");
+      expect(formatNumber(-0.123456)).to.equal("-0.12346");
+    });
+    it("formats integers with 5 or more digits in scientific notation", () => {
+      expect(formatNumber(10000)).to.equal("1.00×10⁴");
+      expect(formatNumber(12345)).to.equal("1.23×10⁴");
+      expect(formatNumber(99999)).to.equal("1.00×10⁵");
+      expect(formatNumber(-12345)).to.equal("-1.23×10⁴");
+      expect(formatNumber(123456789012345)).to.equal("1.23×10¹⁴");
+    });
+    it("formats decimals below hundredths in scientific notation", () => {
+      expect(formatNumber(0.01)).to.equal("0.01");
+      expect(formatNumber(0.001)).to.equal("1.00×10⁻³");
+      expect(formatNumber(0.0009876)).to.equal("9.88×10⁻⁴");
+      expect(formatNumber(0.00000000000000123456789012345)).to.equal("1.23×10⁻¹⁵");
+    });
+    it("does not format zero in scientific notation", () => {
+      expect(formatNumber(0)).to.equal("0");
+    });
+    it("formats numbers which would round to 10000 in scientific notation", () => {
+      expect(formatNumber(9999.9)).to.equal("9999.9");
+      expect(formatNumber(9999.99)).to.equal("1.00×10⁴");
+    });
+    it("does not account for numbers which round up to 0.01 in scientific notation", () => {
+      expect(formatNumber(0.00999)).to.equal("9.99×10⁻³");
+      expect(formatNumber(0.009999)).to.equal("1.00×10⁻²"); // aw shucks
+    });
+    it("rounds off decimals to the specified number of significant figures", () => {
+      expect(formatNumber(123.4567, 3)).to.equal("123");
+      expect(formatNumber(123.4567, 4)).to.equal("123.5");
+      expect(formatNumber(123.4567, 6)).to.equal("123.457");
+      expect(formatNumber(123.4567, 2)).to.equal("123"); // oh well
+    });
+    it("rounds numbers in scientific notation to the specified number of significant figures", () => {
+      expect(formatNumber(12345, 3, 3)).to.equal("1.23×10⁴");
+      expect(formatNumber(12345, 4, 4)).to.equal("1.235×10⁴");
+      expect(formatNumber(12345, 6, 6)).to.equal("1.23450×10⁴");
+    });
+    it("rounds numbers in scientific notation to two fewer significant figures than decimals if unspecified", () => {
+      expect(formatNumber(12345, 5)).to.equal("1.23×10⁴");
+      expect(formatNumber(12345, 6)).to.equal("1.235×10⁴");
+      expect(formatNumber(12345, 8)).to.equal("1.23450×10⁴");
+    });
+  });
+  describe("getTimestamp", () => {
+    it("shows only milliseconds if total time units < 1000 ms", () => {
+      expect(getTimestamp(0, 999, "ms")).to.equal("0 / 999 ms");
+      expect(getTimestamp(41, 999, "ms")).to.equal("41 / 999 ms");
+      expect(getTimestamp(-50, 999, "ms")).to.equal("-50 / 999 ms");
+      expect(getTimestamp(999, 999, "ms")).to.equal("999 / 999 ms");
+    });
+    it("ignores decimal places in milliseconds", () => {
+      expect(getTimestamp(0.4, 100, "ms")).to.equal("0 / 100 ms");
+      expect(getTimestamp(9.9, 100, "ms")).to.equal("9 / 100 ms");
+    });
+    it("does not convert unrecognized time units", () => {
+      expect(getTimestamp(0, 999, "foo")).to.equal("0 / 999 foo");
+      expect(getTimestamp(41, 999, "bar")).to.equal("41 / 999 bar");
+      expect(getTimestamp(999, 999, "baz")).to.equal("999 / 999 baz");
+    });
+    it("shows seconds if total time is > 1000 ms", () => {
+      expect(getTimestamp(0, 1000, "ms")).to.equal("0.000 / 1.000 s");
+      expect(getTimestamp(999, 1000, "ms")).to.equal("0.999 / 1.000 s");
+      expect(getTimestamp(1, 4500, "ms")).to.equal("0.001 / 4.500 s");
+    });
+    it("does not show past three decimals for seconds", () => {
+      expect(getTimestamp(9.9, 1000, "ms")).to.equal("0.009 / 1.000 s");
+    });
+    it("ignores milliseconds when unit is seconds", () => {
+      expect(getTimestamp(0, 59, "s")).to.equal("0 / 59 s");
+      expect(getTimestamp(0.54, 59, "s")).to.equal("0 / 59 s");
+      expect(getTimestamp(12, 59, "s")).to.equal("12 / 59 s");
+    });
+    it("converts from seconds to minutes", () => {
+      expect(getTimestamp(0, 60, "s")).to.equal("0:00 / 1:00 m:s");
+    });
+    it("converts from seconds to other units", () => {
+      const minutesInSec = 60;
+      const hoursInSec = 60 * minutesInSec;
+      const daysInSec = 24 * hoursInSec;
+      let time = 1 * hoursInSec + 23 * minutesInSec + 45;
+      let total = 2 * hoursInSec + 30 * minutesInSec + 0;
+      expect(getTimestamp(time, total, "s")).to.equal("1:23:45 / 2:30:00 h:m:s");
+      time = 15 * hoursInSec + 0 * minutesInSec + 1;
+      total = 17 * hoursInSec + 0 * minutesInSec + 0;
+      expect(getTimestamp(time, total, "s")).to.equal("15:00:01 / 17:00:00 h:m:s");
+      time = 0;
+      total = 23 * hoursInSec + 59 * minutesInSec + 59;
+      expect(getTimestamp(time, total, "s")).to.equal("0:00:00 / 23:59:59 h:m:s");
+      time = 1 * daysInSec + 0 * hoursInSec + 0 * minutesInSec + 0;
+      total = 2 * daysInSec + 0 * hoursInSec + 0 * minutesInSec + 0;
+      expect(getTimestamp(time, total, "s")).to.equal("1:00:00:00 / 2:00:00:00 d:h:m:s");
+      time = 1 * daysInSec + 23 * hoursInSec + 59 * minutesInSec + 59;
+      total = 2 * daysInSec + 0 * hoursInSec + 0 * minutesInSec + 0;
+      expect(getTimestamp(time, total, "s")).to.equal("1:23:59:59 / 2:00:00:00 d:h:m:s");
+    });
+    it("can show full d:hh:mm:ss.sss timestamps", () => {
+      const secondsInMs = 1000;
+      const minutesInMs = 60 * secondsInMs;
+      const hoursInMs = 60 * minutesInMs;
+      const daysInMs = 24 * hoursInMs;
+      const time = 1 * daysInMs + 17 * hoursInMs + 23 * minutesInMs + 45 * secondsInMs + 678;
+      const total = 2 * daysInMs;
+      expect(getTimestamp(time, total, "ms")).to.equal("1:17:23:45.678 / 2:00:00:00.000 d:h:m:s");
+    });
+    it("ignores smaller units when time defined in hours", () => {
+      expect(getTimestamp(0, 123 * 24, "h")).to.equal("0:00 / 123:00 d:h");
+      expect(getTimestamp(23, 123 * 24, "h")).to.equal("0:23 / 123:00 d:h");
+      expect(getTimestamp(24 + 5, 123 * 24, "h")).to.equal("1:05 / 123:00 d:h");
+    });
+  });
+  describe("constrainToAxis", () => {
+    it("constrains to the X, Y, Z axis", () => {
+      const src = [1, 2, 3];
+      const target = [4, 5, 6];
+      expect(constrainToAxis(src, target, Axis.X)).to.eql([1, 5, 6]);
+      expect(constrainToAxis(src, target, Axis.Y)).to.eql([4, 2, 6]);
+      expect(constrainToAxis(src, target, Axis.Z)).to.eql([4, 5, 3]);
+    });
+    it("does nothing if Axis.None is specified", () => {
+      const src = [1, 2, 3];
+      const target = [4, 5, 6];
+      expect(constrainToAxis(src, target, Axis.NONE)).to.eql([1, 2, 3]);
+    });
+  });
+});

package/es/test/volume.test.js

@@ -0,0 +1,98 @@
+import { expect } from "chai";
+import Volume from "../Volume";
+import VolumeMaker from "../VolumeMaker";
+import { LUT_ARRAY_LENGTH } from "../Lut";
+import { CImageInfo } from "../ImageInfo";
+import { getDataRange } from "../utils/num_utils";
+
+// PREPARE SOME TEST DATA TO TRY TO DISPLAY A VOLUME.
+const testimgdata = {
+  name: "AICS-10_5_5",
+  atlasTileDims: [7, 10],
+  subregionSize: [204, 292, 65],
+  subregionOffset: [0, 0, 0],
+  combinedNumChannels: 9,
+  channelNames: ["DRAQ5", "EGFP", "Hoechst 33258", "TL Brightfield", "SEG_STRUCT", "SEG_Memb", "SEG_DNA", "CON_Memb", "CON_DNA"],
+  multiscaleLevel: 0,
+  multiscaleLevelDims: [{
+    shape: [1, 9, 65, 292, 204],
+    // original volume had 0.065 um pixels in x and y, 0.29 um pixels in z, and 65x494x306 voxels
+    spacing: [1, 1, 0.29, 0.065 * 494 / 292, 0.065 * 306 / 204],
+    spaceUnit: "",
+    timeUnit: "",
+    dataType: "uint8"
+  }],
+  transform: {
+    translation: [0, 0, 0],
+    rotation: [0, 0, 0],
+    scale: [1, 1, 1]
+  }
+};
+function checkVolumeConstruction(v, imgdata) {
+  expect(v).to.be.a("Object");
+  expect(v.isLoaded()).to.not.be.ok;
+  const {
+    originalSize,
+    physicalPixelSize
+  } = new CImageInfo(imgdata);
+  const physicalSize = originalSize.clone().multiply(physicalPixelSize);
+  expect(v.physicalSize.x).to.equal(physicalSize.x);
+  expect(v.physicalSize.y).to.equal(physicalSize.y);
+  expect(v.physicalSize.z).to.equal(physicalSize.z);
+  expect(v.channelNames.length).to.equal(imgdata.combinedNumChannels);
+  expect(v.channels.length).to.equal(imgdata.combinedNumChannels);
+  const mx = Math.max(Math.max(v.normPhysicalSize.x, v.normPhysicalSize.y), v.normPhysicalSize.z);
+  expect(mx).to.equal(1.0);
+}
+function checkChannelDataConstruction(c, index, imgdata) {
+  expect(c.loaded).to.be.true;
+  expect(c.name).to.equal(imgdata.channelNames[index]);
+  const atlasWidth = imgdata.atlasTileDims[0] * imgdata.subregionSize[0];
+  const atlasHeight = imgdata.atlasTileDims[1] * imgdata.subregionSize[1];
+  expect(c.imgData.width).to.equal(atlasWidth);
+  expect(c.imgData.height).to.equal(atlasHeight);
+  expect(c.imgData.data).to.be.a("Uint8Array");
+  expect(c.imgData.data.length).to.equal(atlasWidth * atlasHeight);
+  expect(c.lut.lut).to.be.a("Uint8Array");
+  expect(c.lut.lut.length).to.equal(LUT_ARRAY_LENGTH);
+}
+describe("test volume", () => {
+  describe("creation", () => {
+    const v = new Volume(testimgdata);
+    it("is created", () => {
+      checkVolumeConstruction(v, testimgdata);
+    });
+    it("loaded channel data", () => {
+      const size = v.imageInfo.subregionSize;
+      const conedata = VolumeMaker.createCone(size.x, size.y, size.z, size.x / 8, size.z);
+      v.setChannelDataFromVolume(0, conedata, getDataRange(conedata));
+      const c0 = v.getChannel(0);
+      checkChannelDataConstruction(c0, 0, testimgdata);
+      const spheredata = VolumeMaker.createSphere(size.x, size.y, size.z, size.z / 4);
+      v.setChannelDataFromVolume(1, spheredata, getDataRange(spheredata));
+      const c1 = v.getChannel(1);
+      checkChannelDataConstruction(c1, 1, testimgdata);
+      expect(v.getIntensity(1, Math.floor(size.x / 2), Math.floor(size.y / 2), Math.floor(size.z / 2))).to.equal(255);
+      expect(v.getIntensity(1, 0, 0, 0)).to.equal(0);
+    });
+  });
+  describe("property validation", () => {
+    it("has a correct value for normalizedPhysicalSize", () => {
+      // `Volume` formerly derived a `scale` property by a different means than `normPhysicalSize`, but depended
+      // on `scale` and `normPhysicalSize` being equal. With `scale` gone, this test ensures the equality stays.
+      const v = new Volume(testimgdata);
+      const {
+        originalSize,
+        physicalPixelSize
+      } = v.imageInfo;
+      const sizemax = Math.max(originalSize.x * physicalPixelSize.x, originalSize.y * physicalPixelSize.y, originalSize.z * physicalPixelSize.z);
+      const sx = physicalPixelSize.x * originalSize.x / sizemax;
+      const sy = physicalPixelSize.y * originalSize.y / sizemax;
+      const sz = physicalPixelSize.z * originalSize.z / sizemax;
+      const EPSILON = 0.000000001;
+      expect(v.normPhysicalSize.x).to.be.closeTo(sx, EPSILON);
+      expect(v.normPhysicalSize.y).to.be.closeTo(sy, EPSILON);
+      expect(v.normPhysicalSize.z).to.be.closeTo(sz, EPSILON);
+    });
+  });
+});

package/es/test/zarr_utils.test.js

@@ -0,0 +1,358 @@
+import { expect } from "chai";
+import * as zarr from "@zarrita/core";
+import WrappedStore from "../loaders/zarr_utils/WrappedStore";
+import { getDimensionCount, getScale, getSourceChannelNames, matchSourceScaleLevels, orderByDimension, orderByTCZYX, remapAxesToTCZYX } from "../loaders/zarr_utils/utils";
+
+/** Contains only the data required to produce a mock `ZarrSourceMeta` which is useful for testing */
+
+const createMockOmeroMetadata = (numChannels, channelNames) => ({
+  id: 0,
+  name: "0",
+  version: "0.0",
+  channels: (channelNames ?? Array.from({
+    length: numChannels
+  }, (_, i) => `channel ${i}`)).map(label => ({
+    label,
+    active: true,
+    coefficient: 1,
+    color: "ffffffff",
+    family: "linear",
+    inverted: false,
+    window: {
+      end: 1,
+      max: 1,
+      min: 0,
+      start: 0
+    }
+  }))
+});
+const createMockMultiscaleMetadata = (scales, paths) => ({
+  name: "0",
+  version: "0.0",
+  axes: [{
+    name: "t"
+  }, {
+    name: "c"
+  }, {
+    name: "z"
+  }, {
+    name: "y"
+  }, {
+    name: "x"
+  }],
+  datasets: scales.map((scale, idx) => ({
+    path: (paths && paths[idx]) ?? `${idx}`,
+    coordinateTransformations: [{
+      type: "scale",
+      scale
+    }]
+  }))
+});
+class MockStore {
+  get(_key, _opts) {
+    return undefined;
+  }
+}
+const MOCK_STORE = new WrappedStore(new MockStore());
+const createMockArrays = shapes => {
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  const promises = shapes.map(shape => zarr.create(MOCK_STORE, {
+    shape,
+    chunk_shape: shape,
+    data_type: "uint8"
+  }));
+  return Promise.all(promises);
+};
+const createOneMockSource = async (shapes, scales, channelOffset, paths, names) => ({
+  scaleLevels: await createMockArrays(shapes),
+  multiscaleMetadata: createMockMultiscaleMetadata(scales, paths),
+  omeroMetadata: createMockOmeroMetadata(shapes[0][1], names),
+  axesTCZYX: [0, 1, 2, 3, 4],
+  channelOffset
+});
+const createMockSources = specs => {
+  let channelOffset = 0;
+  const sourcePromises = specs.map(({
+    shapes,
+    scales,
+    paths
+  }) => {
+    if (!scales) {
+      scales = Array.from({
+        length: shapes.length
+      }, () => [1, 1, 1, 1, 1]);
+    }
+    const result = createOneMockSource(shapes, scales, channelOffset, paths);
+    channelOffset += shapes[0][1];
+    return result;
+  });
+  return Promise.all(sourcePromises);
+};
+const createTwoMockSourceArrs = specs => {
+  return Promise.all([createMockSources(specs), createMockSources(specs)]);
+};
+
+/** Chai's deep equality doesn't seem to work for zarr arrays */
+const expectSourcesEqual = (aArr, bArr) => {
+  expect(aArr.length).to.equal(bArr.length);
+  for (const [idx, a] of aArr.entries()) {
+    const b = bArr[idx];
+    expect(a.multiscaleMetadata).to.deep.equal(b.multiscaleMetadata);
+    expect(a.omeroMetadata).to.deep.equal(b.omeroMetadata);
+    expect(a.axesTCZYX).to.deep.equal(b.axesTCZYX);
+    expect(a.channelOffset).to.equal(b.channelOffset);
+    expect(a.scaleLevels.length).to.equal(b.scaleLevels.length);
+    for (const [idx, aLevel] of a.scaleLevels.entries()) {
+      const bLevel = b.scaleLevels[idx];
+      expect(aLevel.path).to.equal(bLevel.path);
+      expect(aLevel.shape).to.deep.equal(bLevel.shape);
+      expect(aLevel.chunks).to.deep.equal(bLevel.chunks);
+    }
+  }
+};
+describe("zarr_utils", () => {
+  describe("getSourceChannelNames", () => {
+    it("extracts a list of channel labels from the given source", async () => {
+      const names = ["foo", "bar", "baz"];
+      const source = await createOneMockSource([[1, 3, 1, 1, 1]], [[1, 1, 1, 1, 1]], 0, ["1", "2", "3"], names);
+      expect(getSourceChannelNames(source)).to.deep.equal(names);
+    });
+    it("does not resolve channel name collisions", async () => {
+      const names = ["foo", "bar", "foo"];
+      const source = await createOneMockSource([[1, 3, 1, 1, 1]], [[1, 1, 1, 1, 1]], 0, ["1", "2", "3"], names);
+      expect(getSourceChannelNames(source)).to.deep.equal(names);
+    });
+    it('applies default names of the form "Channel N" for missing labels', async () => {
+      const names = ["foo", "bar", undefined];
+      const source = await createOneMockSource([[1, 3, 1, 1, 1]], [[1, 1, 1, 1, 1]], 0, ["1", "2", "3"], names);
+      expect(getSourceChannelNames(source)).to.deep.equal(["foo", "bar", "Channel 2"]);
+    });
+    it("applies default names when `omeroMetadata` is missing entirely", async () => {
+      const source = await createOneMockSource([[1, 3, 1, 1, 1]], [[1, 1, 1, 1, 1]], 0);
+      delete source.omeroMetadata;
+      expect(getSourceChannelNames(source)).to.deep.equal(["Channel 0", "Channel 1", "Channel 2"]);
+    });
+    it("applies `channelOffset` to default names", async () => {
+      const source = await createOneMockSource([[1, 3, 1, 1, 1]], [[1, 1, 1, 1, 1]], 3);
+      delete source.omeroMetadata;
+      expect(getSourceChannelNames(source)).to.deep.equal(["Channel 3", "Channel 4", "Channel 5"]);
+    });
+  });
+  describe("getDimensionCount", () => {
+    it("returns 5 when all 5 dimension indices are positive", () => {
+      expect(getDimensionCount([1, 1, 1, 1, 1])).to.equal(5);
+    });
+    it("recognizes when T, C, or Z is missing", () => {
+      for (let dim = 0; dim < 3; dim++) {
+        const tczyx = [1, 1, 1, 1, 1];
+        tczyx[dim] = -1;
+        expect(getDimensionCount(tczyx)).to.equal(4);
+      }
+    });
+    it("returns 2 when all of T, C, and Z are missing", () => {
+      expect(getDimensionCount([-1, -1, -1, 1, 1])).to.equal(2);
+    });
+  });
+  describe("remapAxesToTCZYX", () => {
+    it("produces an array of indices in T, C, Z, Y, X order", () => {
+      const axes = [{
+        name: "t"
+      }, {
+        name: "c"
+      }, {
+        name: "x"
+      }, {
+        name: "y"
+      }, {
+        name: "z"
+      }];
+      expect(remapAxesToTCZYX(axes)).to.deep.equal([0, 1, 4, 3, 2]);
+    });
+    it("defaults to -1 for missing T, C, or Z axes", () => {
+      const axes = [{
+        name: "x"
+      }, {
+        name: "y"
+      }];
+      expect(remapAxesToTCZYX(axes)).to.deep.equal([-1, -1, -1, 1, 0]);
+    });
+    it("throws an error if it encounters an unrecognized (not t, c, z, y, or x) axis name", () => {
+      const axes = [{
+        name: "t"
+      }, {
+        name: "c"
+      }, {
+        name: "x"
+      }, {
+        name: "y"
+      }, {
+        name: "foo"
+      }];
+      expect(() => remapAxesToTCZYX(axes)).to.throw("Unrecognized axis");
+    });
+  });
+  // TODO: `pickLevelToLoad`
+
+  const VALS_TCZYX = [1, 2, 3, 4, 5];
+  describe("orderByDimension", () => {
+    it("orders an array in dimension order based on the given indices", () => {
+      const order = [3, 1, 4, 0, 2];
+      expect(orderByDimension(VALS_TCZYX, order)).to.deep.equal([4, 2, 5, 1, 3]);
+    });
+    it("excludes the T, C, or Z dimension if its index is negative", () => {
+      expect(orderByDimension(VALS_TCZYX, [-1, 0, 1, 3, 2])).to.deep.equal([2, 3, 5, 4]);
+      expect(orderByDimension(VALS_TCZYX, [0, -1, 1, 3, 2])).to.deep.equal([1, 3, 5, 4]);
+      expect(orderByDimension(VALS_TCZYX, [0, 1, -1, 3, 2])).to.deep.equal([1, 2, 5, 4]);
+    });
+    it("throws an error if an axis index is out of bounds", () => {
+      // Out of bounds for full-size array
+      expect(() => orderByDimension(VALS_TCZYX, [0, 1, 2, 3, 5])).to.throw("Unexpected axis index");
+      // Out of bounds for smaller array
+      expect(() => orderByDimension(VALS_TCZYX, [-1, -1, 0, 3, 1])).to.throw("Unexpected axis index");
+    });
+  });
+  const VALS_DIM = [16, 8, 4, 2, 1];
+  describe("orderByTCZYX", () => {
+    it("orders an array TCZYX based on the given indices", () => {
+      const order = [3, 1, 4, 0, 2];
+      expect(orderByTCZYX(VALS_DIM, order, 0)).to.deep.equal([2, 8, 1, 16, 4]);
+    });
+    it("fills in missing dimensions with a default value", () => {
+      const order = [3, 1, 4, -1, 2];
+      expect(orderByTCZYX(VALS_DIM, order, 3)).to.deep.equal([2, 8, 1, 3, 4]);
+    });
+    it("throws an error if an axis index is out of bounds", () => {
+      // Out of bounds for full-size array
+      expect(() => orderByTCZYX(VALS_DIM, [0, 1, 2, 5, 3], 0)).to.throw("Unexpected axis index");
+      // Out of bounds for smaller array
+      expect(() => orderByTCZYX(VALS_DIM.slice(2), [-1, 0, 1, 3, 2], 0)).to.throw("Unexpected axis index");
+    });
+  });
+  const MOCK_DATASET = {
+    path: "0",
+    coordinateTransformations: [{
+      type: "translation",
+      translation: [0, 0, 0, 0, 0]
+    }, {
+      type: "scale",
+      scale: [1, 2, 3, 4, 5]
+    }, {
+      type: "identity"
+    }]
+  };
+  describe("getScale", () => {
+    it("returns the scale transformation for a given dataset", () => {
+      expect(getScale(MOCK_DATASET, [0, 1, 2, 3, 4])).to.deep.equal([1, 2, 3, 4, 5]);
+    });
+    it("orders the scale transformation in TCZYX order", () => {
+      expect(getScale(MOCK_DATASET, [3, 1, 4, 0, 2])).to.deep.equal([4, 2, 5, 1, 3]);
+    });
+    it('defaults to `[1, 1, 1, 1, 1]` if no coordinate transformation of type "scale" is found', () => {
+      const dataset = {
+        ...MOCK_DATASET,
+        coordinateTransformations: MOCK_DATASET.coordinateTransformations.slice(0, 1)
+      };
+      expect(getScale(dataset, [0, 1, 2, 3, 4])).to.deep.equal([1, 1, 1, 1, 1]);
+    });
+    it("defaults to `[1, 1, 1, 1, 1]` if no coordinate transformations are present at all", () => {
+      expect(getScale({
+        path: "0"
+      }, [0, 1, 2, 3, 4])).to.deep.equal([1, 1, 1, 1, 1]);
+    });
+  });
+  describe("matchSourceScaleLevels", () => {
+    it("does nothing if passed only one source scale level", async () => {
+      const [testSource, refSource] = await createTwoMockSourceArrs([{
+        shapes: [[5, 5, 5, 5, 5]]
+      }]);
+      matchSourceScaleLevels(testSource);
+      expectSourcesEqual(testSource, refSource);
+    });
+    it("does nothing if all source scale levels are the same", async () => {
+      const spec = {
+        shapes: [[1, 1, 10, 10, 10], [1, 1, 5, 5, 5]]
+      };
+      const [testSource, refSource] = await createTwoMockSourceArrs([spec, spec]);
+      matchSourceScaleLevels(testSource);
+      expectSourcesEqual(testSource, refSource);
+    });
+    it("trims source scale levels which are outside the range of any other sources", async () => {
+      const baseSpec = {
+        shapes: [[1, 1, 10, 10, 10], [1, 1, 5, 5, 5]]
+      };
+
+      // Has all the same scale levels as `baseSpec`, plus one smaller
+      const specSmaller = {
+        shapes: [...baseSpec.shapes.slice(), [1, 1, 2, 2, 2]]
+      };
+      // Has all the same scale levels as `baseSpec`, plus one larger
+      const specLarger = {
+        shapes: [[1, 1, 20, 20, 20], ...baseSpec.shapes.slice()]
+      };
+      const refSourceSmaller = await createMockSources([baseSpec, baseSpec]);
+      // The largest source will have path "0", so we have to shift the paths to match
+      const refSourceLarger = await createMockSources([baseSpec, {
+        ...baseSpec,
+        paths: ["1", "2"]
+      }]);
+      const testSourceSmaller = await createMockSources([baseSpec, specSmaller]);
+      const testSourceLarger = await createMockSources([baseSpec, specLarger]);
+      matchSourceScaleLevels(testSourceSmaller);
+      matchSourceScaleLevels(testSourceLarger);
+      expectSourcesEqual(testSourceSmaller, refSourceSmaller);
+      expectSourcesEqual(testSourceLarger, refSourceLarger);
+    });
+    it("handles unmatched scale levels within the range of other sources", async () => {
+      // The only level shapes that all three of these sources have in common are [1, 1, 6, 6, 6] and [1, 1, 2, 2, 2]
+      const shapes1 = [[1, 1, 6, 6, 6], [1, 1, 5, 5, 5], [1, 1, 3, 3, 3], [1, 1, 2, 2, 2]];
+      const shapes2 = [[1, 1, 6, 6, 6], [1, 1, 5, 5, 5], [1, 1, 4, 4, 4], [1, 1, 2, 2, 2], [1, 1, 1, 1, 1]];
+      const shapes3 = [[1, 1, 7, 7, 7], [1, 1, 6, 6, 6], [1, 1, 4, 4, 4], [1, 1, 2, 2, 2]];
+      const testSources = await createMockSources([{
+        shapes: shapes1
+      }, {
+        shapes: shapes2
+      }, {
+        shapes: shapes3
+      }]);
+      matchSourceScaleLevels(testSources);
+      const shapes = [[1, 1, 6, 6, 6], [1, 1, 2, 2, 2]];
+      const refSources = await createMockSources([{
+        shapes,
+        paths: ["0", "3"]
+      }, {
+        shapes,
+        paths: ["0", "3"]
+      }, {
+        shapes,
+        paths: ["1", "3"]
+      }]);
+      expectSourcesEqual(testSources, refSources);
+    });
+    it("throws an error if the size of two scale levels are mismatched", async () => {
+      const sources = await createMockSources([{
+        shapes: [[1, 1, 2, 1, 1]]
+      }, {
+        shapes: [[1, 1, 1, 2, 1]]
+      }]);
+      expect(() => matchSourceScaleLevels(sources)).to.throw("Incompatible zarr arrays: pixel dimensions are mismatched");
+    });
+    it("Does not throw an error if two scale levels of the same size have different scale transformations", async () => {
+      const sources = await createMockSources([{
+        shapes: [[1, 1, 1, 1, 1]],
+        scales: [[1, 1, 2, 2, 2]]
+      }, {
+        shapes: [[1, 1, 1, 1, 1]],
+        scales: [[1, 1, 1, 1, 1]]
+      }]);
+      expect(() => matchSourceScaleLevels(sources)).to.not.throw("Incompatible zarr arrays: scale levels of equal size have different scale transformations");
+    });
+    it("Does not throw an error if two scale levels of the same size have a different number of timesteps", async () => {
+      const sources = await createMockSources([{
+        shapes: [[1, 1, 1, 1, 1]]
+      }, {
+        shapes: [[2, 1, 1, 1, 1]]
+      }]);
+      expect(() => matchSourceScaleLevels(sources)).to.not.throw("Incompatible zarr arrays: different numbers of timesteps");
+    });
+  });
+});

package/es/types/Atlas2DSlice.d.ts

@@ -0,0 +1,41 @@
+import { BufferGeometry, Group, Material, Mesh, OrthographicCamera, PerspectiveCamera, WebGLRenderer } from "three";
+import { Channel, Volume } from ".";
+import type { VolumeRenderImpl } from "./VolumeRenderImpl.js";
+import { SettingsFlags, VolumeRenderSettings } from "./VolumeRenderSettings.js";
+import type { FuseChannel } from "./types.js";
+/**
+ * Creates a plane that renders a 2D XY slice of volume atlas data.
+ */
+export default class Atlas2DSlice implements VolumeRenderImpl {
+    private settings;
+    volume: Volume;
+    private geometry;
+    protected geometryMesh: Mesh<BufferGeometry, Material>;
+    private geometryTransformNode;
+    private boxHelper;
+    private uniforms;
+    private channelData;
+    private sliceUpdateWaiting;
+    /**
+     * Creates a new Atlas2DSlice.
+     * @param volume The volume that this renderer should render data from.
+     * @param settings Optional settings object. If set, updates the renderer with
+     * the given settings. Otherwise, uses the default VolumeRenderSettings.
+     */
+    constructor(volume: Volume, settings?: VolumeRenderSettings);
+    /**
+     * Syncs `this.settings.zSlice` with the corresponding shader uniform, or defers syncing until the slice is loaded.
+     * @returns a boolean indicating whether the slice is out of bounds of the volume entirely.
+     */
+    private updateSlice;
+    updateVolumeDimensions(): void;
+    updateSettings(newSettings: VolumeRenderSettings, dirtyFlags?: number | SettingsFlags): void;
+    private createGeometry;
+    cleanup(): void;
+    viewpointMoved(): void;
+    doRender(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera): void;
+    get3dObject(): Group;
+    updateActiveChannels(channelcolors: FuseChannel[], channeldata: Channel[]): void;
+    private setUniform;
+    setRenderUpdateListener(_listener?: ((iteration: number) => void) | undefined): void;
+}

package/es/types/Channel.d.ts

@@ -0,0 +1,44 @@
+import { DataTexture, Vector3 } from "three";
+import Histogram from "./Histogram.js";
+import { Lut } from "./Lut.js";
+import { TypedArray, NumberType } from "./types.js";
+interface ChannelImageData {
+    /** Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255. */
+    readonly data: TypedArray<NumberType>;
+    /** Returns the actual dimensions of the data in the ImageData object, in pixels. */
+    readonly height: number;
+    /** Returns the actual dimensions of the data in the ImageData object, in pixels. */
+    readonly width: number;
+}
+export default class Channel {
+    loaded: boolean;
+    dtype: NumberType;
+    imgData: ChannelImageData;
+    volumeData: TypedArray<NumberType>;
+    name: string;
+    histogram: Histogram;
+    lut: Lut;
+    colorPalette: Uint8Array;
+    colorPaletteAlpha: number;
+    dims: [number, number, number];
+    dataTexture: DataTexture;
+    lutTexture: DataTexture;
+    rawMin: number;
+    rawMax: number;
+    constructor(name: string);
+    combineLuts(rgbColor: [number, number, number] | number, out?: Uint8Array): Uint8Array;
+    setRawDataRange(min: number, max: number): void;
+    getHistogram(): Histogram;
+    getIntensity(x: number, y: number, z: number): number;
+    normalizeRaw(val: number): number;
+    getIntensityFromAtlas(x: number, y: number, z: number): number;
+    private rebuildDataTexture;
+    setFromAtlas(bitsArray: TypedArray<NumberType>, w: number, h: number, dtype: NumberType, rawMin: number, rawMax: number, subregionSize: Vector3): void;
+    private unpackFromAtlas;
+    setFromVolumeData(bitsArray: TypedArray<NumberType>, vx: number, vy: number, vz: number, ax: number, ay: number, rawMin: number, rawMax: number, dtype: NumberType): void;
+    private packToAtlas;
+    setLut(lut: Lut): void;
+    setColorPalette(palette: Uint8Array): void;
+    setColorPaletteAlpha(alpha: number): void;
+}
+export {};