@aics/vole-core 4.0.0 → 4.2.0

package/es/ImageInfo.js

@@ -6,7 +6,7 @@ export function defaultImageInfo() {
     atlasTileDims: [1, 1],
     subregionSize: [1, 1, 1],
     subregionOffset: [0, 0, 0],
-    combinedNumChannels: 1,
+    numChannelsPerSource: [1],
     channelNames: ["0"],
     channelColors: [[255, 255, 255]],
     multiscaleLevel: 0,
@@ -34,7 +34,12 @@ export class CImageInfo {
 
   /** Number of channels in the image */
   get numChannels() {
-    return this.imageInfo.combinedNumChannels;
+    return this.imageInfo.numChannelsPerSource.reduce((a, b) => a + b, 0);
+  }
+
+  /** Number of channels per source, ordered by source index */
+  get numChannelsPerSource() {
+    return this.imageInfo.numChannelsPerSource;
   }
 
   /** XYZ size of the *original* (not downsampled) volume, in pixels */

package/es/VolumeDrawable.js

@@ -45,7 +45,9 @@ export default class VolumeDrawable {
     this.viewMode = Axis.NONE; // 3D mode
 
     this.channelColors = this.volume.channelColorsDefault.slice();
-    this.channelOptions = new Array(this.volume.imageInfo.numChannels).fill({});
+    this.channelOptions = Array.from({
+      length: this.volume.imageInfo.numChannels
+    }, () => ({}));
     this.fusion = this.channelColors.map((col, index) => {
       let rgbColor;
       // take copy of original channel color

package/es/VolumeMaker.js

@@ -1,3 +1,5 @@
+import { ARRAY_CONSTRUCTORS } from "./types.js";
+
 /**
  * Basic utility functions to create sample volume data
  * @class
@@ -9,9 +11,11 @@ export default class VolumeMaker {
    * @param {number} vy
    * @param {number} vz
    * @param {function} sdFunc A function f(x,y,z) that returns a distance. f < 0 will be the interior of the volume, and f>=0 will be outside.
+   * @param {NumberType} dtype The data type for the output array
    */
-  static createVolume(vx, vy, vz, sdFunc) {
-    const data = new Uint8Array(vx * vy * vz).fill(0);
+  static createVolume(vx, vy, vz, sdFunc, dtype = "uint8") {
+    const ctor = ARRAY_CONSTRUCTORS[dtype];
+    const data = new ctor(vx * vy * vz).fill(0);
     const cx = vx / 2;
     const cy = vy / 2;
     const cz = vz / 2;
@@ -40,11 +44,12 @@ export default class VolumeMaker {
    * @param {number} vy
    * @param {number} vz
    * @param {number} radius
+   * @param {NumberType} dtype The data type for the output array
    */
-  static createSphere(vx, vy, vz, radius) {
+  static createSphere(vx, vy, vz, radius, dtype = "uint8") {
     return VolumeMaker.createVolume(vx, vy, vz, (px, py, pz) => {
       return Math.sqrt(px * px + py * py + pz * pz) - radius;
-    });
+    }, dtype);
   }
 
   /**
@@ -54,8 +59,9 @@ export default class VolumeMaker {
    * @param {number} vz
    * @param {number} hx width of cap (?)
    * @param {number} hy depth of cap (?)
+   * @param {NumberType} dtype The data type for the output array
    */
-  static createCylinder(vx, vy, vz, hx, hy) {
+  static createCylinder(vx, vy, vz, hx, hy, dtype = "uint8") {
     let dx, dy, mdx, mdy;
     return VolumeMaker.createVolume(vx, vy, vz, (px, py, pz) => {
       dx = Math.abs(Math.sqrt(px * px + pz * pz)) - hx;
@@ -63,7 +69,7 @@ export default class VolumeMaker {
       mdx = Math.max(dx, 0.0);
       mdy = Math.max(dy, 0.0);
       return Math.min(Math.max(dx, dy), 0.0) + Math.sqrt(mdx * mdx + mdy * mdy);
-    });
+    }, dtype);
   }
 
   /**
@@ -73,14 +79,15 @@ export default class VolumeMaker {
    * @param {number} vz
    * @param {number} tx inner radius
    * @param {number} ty outer radius
+   * @param {NumberType} dtype The data type for the output array
    */
-  static createTorus(vx, vy, vz, tx, ty) {
+  static createTorus(vx, vy, vz, tx, ty, dtype = "uint8") {
     let qx, qy;
     return VolumeMaker.createVolume(vx, vy, vz, (px, py, pz) => {
       qx = Math.sqrt(px * px + pz * pz) - tx;
       qy = py;
       return Math.sqrt(qx * qx + qy * qy) - ty;
-    });
+    }, dtype);
   }
 
   /**
@@ -90,12 +97,30 @@ export default class VolumeMaker {
    * @param {number} vz
    * @param {number} cx base radius
    * @param {number} cy height
+   * @param {NumberType} dtype The data type for the output array
    */
-  static createCone(vx, vy, vz, cx, cy) {
+  static createCone(vx, vy, vz, cx, cy, dtype = "uint8") {
     let q;
     return VolumeMaker.createVolume(vx, vy, vz, (px, py, pz) => {
       q = Math.sqrt(px * px + py * py);
       return cx * q + cy * pz;
-    });
+    }, dtype);
+  }
+
+  // take a list of TypedArrays and concatenate them into a single TypedArray of the same Type:
+  static concatenateArrays(arrays, dtype) {
+    if (arrays.length === 0) {
+      throw new Error("Cannot concatenate empty array list");
+    }
+    const totalLength = arrays.reduce((acc, arr) => acc + arr.length, 0);
+
+    // Create a new array of the same type as the input arrays
+    const result = new ARRAY_CONSTRUCTORS[dtype](totalLength);
+    let offset = 0;
+    for (const arr of arrays) {
+      result.set(arr, offset);
+      offset += arr.length;
+    }
+    return result;
   }
 }

package/es/loaders/JsonImageInfoLoader.js

@@ -29,7 +29,7 @@ const convertImageInfo = json => {
     atlasTileDims: [json.cols, json.rows],
     subregionSize: [json.tile_width, json.tile_height, json.tiles],
     subregionOffset: [0, 0, 0],
-    combinedNumChannels: json.channels,
+    numChannelsPerSource: json.images.map(image => image.channels.length),
     channelNames: json.channel_names,
     channelColors: json.channel_colors,
     multiscaleLevel: 0,

package/es/loaders/OmeZarrLoader.js

@@ -247,12 +247,14 @@ class OMEZarrLoader extends ThreadableVolumeLoader {
     const levelToLoad = pickLevelToLoad(loadSpec, this.getLevelShapesZYX());
     const shapeLv = source0.scaleLevels[levelToLoad].shape;
     const [spatialUnit, timeUnit] = this.getUnitSymbols();
+    const numChannelsPerSource = [];
+    for (let i = 0; i < this.sources.length; i++) {
+      const source = this.sources[i];
+      const cIndex = source.axesTCZYX[1];
+      const sourceChannelCount = cIndex > -1 ? source.scaleLevels[levelToLoad].shape[cIndex] : 1;
+      numChannelsPerSource.push(sourceChannelCount);
+    }
 
-    // Now we care about other sources: # of channels is the `channelOffset` of the last source plus its # of channels
-    const sourceLast = this.sources[this.sources.length - 1];
-    const cLast = sourceLast.axesTCZYX[1];
-    const lastHasC = cLast > -1;
-    const numChannels = sourceLast.channelOffset + (lastHasC ? sourceLast.scaleLevels[levelToLoad].shape[cLast] : 1);
     // we need to make sure that the corresponding matched shapes
     // use the min size of T
     let times = 1;
@@ -310,7 +312,7 @@ class OMEZarrLoader extends ThreadableVolumeLoader {
       atlasTileDims: [atlasTileDims.x, atlasTileDims.y],
       subregionSize: [pxSizeLv.x, pxSizeLv.y, pxSizeLv.z],
       subregionOffset: [0, 0, 0],
-      combinedNumChannels: numChannels,
+      numChannelsPerSource,
       channelNames,
       multiscaleLevel: levelToLoad,
       multiscaleLevelDims: alldims,
@@ -423,9 +425,10 @@ class OMEZarrLoader extends ThreadableVolumeLoader {
     const updatedImageInfo = this.updateImageInfoForLoad(imageInfo, loadSpec);
     onUpdateMetadata(updatedImageInfo);
     const {
-      combinedNumChannels,
+      numChannelsPerSource,
       multiscaleLevel
     } = updatedImageInfo;
+    const combinedNumChannels = numChannelsPerSource.reduce((a, b) => a + b, 0);
     const channelIndexes = loadSpec.channels ?? Array.from({
       length: combinedNumChannels
     }, (_, i) => i);

package/es/loaders/OpenCellLoader.js

@@ -24,7 +24,7 @@ class OpenCellLoader extends ThreadableVolumeLoader {
       atlasTileDims: [27, 1],
       subregionSize: [600, 600, 27],
       subregionOffset: [0, 0, 0],
-      combinedNumChannels: numChannels,
+      numChannelsPerSource: [numChannels],
       channelNames: chnames,
       multiscaleLevel: 0,
       multiscaleLevelDims: [{

package/es/loaders/RawArrayLoader.js

@@ -1,6 +1,7 @@
 import { Box3, Vector3 } from "three";
 import { ThreadableVolumeLoader } from "./IVolumeLoader.js";
 import { computePackedAtlasDims } from "./VolumeLoaderUtils.js";
+import { ARRAY_CONSTRUCTORS } from "../types.js";
 import { getDataRange } from "../utils/num_utils.js";
 
 // this is the form in which a 4D numpy array arrives as converted
@@ -9,7 +10,25 @@ import { getDataRange } from "../utils/num_utils.js";
 
 // minimal metadata for visualization
 
-const convertImageInfo = json => {
+function getBytesPerPixel(dtype) {
+  switch (dtype) {
+    case "uint8":
+    case "int8":
+      return 1;
+    case "uint16":
+    case "int16":
+      return 2;
+    case "uint32":
+    case "int32":
+    case "float32":
+      return 4;
+    case "float64":
+      return 8;
+    default:
+      throw new Error(`Unsupported dtype: ${dtype}`);
+  }
+}
+const convertImageInfo = (json, dtype) => {
   const atlasTileDims = computePackedAtlasDims(json.sizeZ, json.sizeX, json.sizeY);
   return {
     name: json.name,
@@ -18,7 +37,7 @@ const convertImageInfo = json => {
     atlasTileDims: [atlasTileDims.x, atlasTileDims.y],
     subregionSize: [json.sizeX, json.sizeY, json.sizeZ],
     subregionOffset: [0, 0, 0],
-    combinedNumChannels: json.sizeC,
+    numChannelsPerSource: [json.sizeC],
     channelNames: json.channelNames,
     channelColors: undefined,
     multiscaleLevel: 0,
@@ -27,7 +46,7 @@ const convertImageInfo = json => {
       spacing: [1, 1, json.physicalPixelSize[2], json.physicalPixelSize[1], json.physicalPixelSize[0]],
       spaceUnit: json.spatialUnit || "μm",
       timeUnit: "s",
-      dataType: "uint8"
+      dataType: dtype
     }],
     transform: {
       translation: [0, 0, 0],
@@ -53,14 +72,14 @@ class RawArrayLoader extends ThreadableVolumeLoader {
       shape: [1, jsonInfo.sizeC, jsonInfo.sizeZ, jsonInfo.sizeY, jsonInfo.sizeX],
       spacing: [1, 1, jsonInfo.physicalPixelSize[2], jsonInfo.physicalPixelSize[1], jsonInfo.physicalPixelSize[0]],
       spaceUnit: jsonInfo.spatialUnit || "μm",
-      dataType: "uint8",
+      dataType: this.data.dtype,
       timeUnit: "s" // time unit not specified
     };
     return [d];
   }
   async createImageInfo(loadSpec) {
     return {
-      imageInfo: convertImageInfo(this.jsonInfo),
+      imageInfo: convertImageInfo(this.jsonInfo, this.data.dtype),
       loadSpec
     };
   }
@@ -73,15 +92,17 @@ class RawArrayLoader extends ThreadableVolumeLoader {
       multiscaleLevel: 0
     };
     onUpdateMetadata(undefined, adjustedLoadSpec);
-    for (let chindex = 0; chindex < imageInfo.combinedNumChannels; ++chindex) {
+    const totalChannels = imageInfo.numChannelsPerSource.reduce((a, b) => a + b, 0);
+    for (let chindex = 0; chindex < totalChannels; ++chindex) {
       if (requestedChannels && requestedChannels.length > 0 && !requestedChannels.includes(chindex)) {
         continue;
       }
-      const volSizeBytes = this.data.shape[3] * this.data.shape[2] * this.data.shape[1]; // x*y*z pixels * 1 byte/pixel
-      const channelData = new Uint8Array(this.data.buffer.buffer, chindex * volSizeBytes, volSizeBytes);
+      // x*y*z pixels
+      const volSizePixels = this.data.shape[3] * this.data.shape[2] * this.data.shape[1];
+      const ctor = ARRAY_CONSTRUCTORS[this.data.dtype];
+      const channelData = new ctor(this.data.buffer.buffer, chindex * volSizePixels * getBytesPerPixel(this.data.dtype), volSizePixels);
       const range = getDataRange(channelData);
-      // all data coming from this loader is natively 8-bit
-      onData([chindex], ["uint8"], [channelData], [range]);
+      onData([chindex], [this.data.dtype], [channelData], [range]);
     }
     return Promise.resolve();
   }

package/es/loaders/TiffLoader.js

@@ -157,13 +157,13 @@ class TiffLoader extends ThreadableVolumeLoader {
     const tilesizey = Math.floor(targetSize / atlasDims.y);
 
     // load tiff and check metadata
-
+    const numChannelsPerSource = this.url.length > 1 ? Array(this.url.length).fill(1) : [dims.sizec];
     const imgdata = {
       name: "TEST",
       atlasTileDims: [atlasDims.x, atlasDims.y],
       subregionSize: [tilesizex, tilesizey, dims.sizez],
       subregionOffset: [0, 0, 0],
-      combinedNumChannels: dims.sizec,
+      numChannelsPerSource,
       channelNames: dims.channelnames,
       multiscaleLevel: 0,
       multiscaleLevelDims: [{
@@ -194,41 +194,44 @@ class TiffLoader extends ThreadableVolumeLoader {
     const volumeSize = cimageinfo.volumeSize;
     const channelProms = [];
     // do each channel on a worker?
-    for (let channel = 0; channel < imageInfo.combinedNumChannels; ++channel) {
-      const thisChannelProm = new Promise((resolve, reject) => {
-        const params = {
-          channel: channel,
-          // these are target xy sizes for the in-memory volume data
-          // they may or may not be the same size as original xy sizes
-          tilesizex: volumeSize.x,
-          tilesizey: volumeSize.y,
-          sizec: imageInfo.combinedNumChannels,
-          sizez: volumeSize.z,
-          dimensionOrder: dims.dimensionorder,
-          bytesPerSample: getBytesPerSample(dims.pixeltype),
-          url: this.url.length > 1 ? this.url[channel] : this.url[0] // if multiple urls, use the channel index to select the right one
-        };
-        const worker = new Worker(new URL("../workers/FetchTiffWorker", import.meta.url), {
-          type: "module"
+    for (let source = 0; source < imageInfo.numChannelsPerSource.length; ++source) {
+      const numChannels = imageInfo.numChannelsPerSource[source];
+      for (let channel = 0; channel < numChannels; ++channel) {
+        const thisChannelProm = new Promise((resolve, reject) => {
+          const params = {
+            channel: channel,
+            // these are target xy sizes for the in-memory volume data
+            // they may or may not be the same size as original xy sizes
+            tilesizex: volumeSize.x,
+            tilesizey: volumeSize.y,
+            sizec: numChannels,
+            sizez: volumeSize.z,
+            dimensionOrder: dims.dimensionorder,
+            bytesPerSample: getBytesPerSample(dims.pixeltype),
+            url: this.url[source]
+          };
+          const worker = new Worker(new URL("../workers/FetchTiffWorker", import.meta.url), {
+            type: "module"
+          });
+          worker.onmessage = e => {
+            if (e.data.isError) {
+              reject(deserializeError(e.data.error));
+              return;
+            }
+            const {
+              data,
+              dtype,
+              channel,
+              range
+            } = e.data;
+            onData([channel], [dtype], [data], [range]);
+            worker.terminate();
+            resolve();
+          };
+          worker.postMessage(params);
         });
-        worker.onmessage = e => {
-          if (e.data.isError) {
-            reject(deserializeError(e.data.error));
-            return;
-          }
-          const {
-            data,
-            dtype,
-            channel,
-            range
-          } = e.data;
-          onData([channel], [dtype], [data], [range]);
-          worker.terminate();
-          resolve();
-        };
-        worker.postMessage(params);
-      });
-      channelProms.push(thisChannelProm);
+        channelProms.push(thisChannelProm);
+      }
     }
 
     // waiting for all channels to load allows errors to propagate to the caller via this promise

package/es/loaders/VolumeLoaderUtils.js

@@ -211,7 +211,8 @@ export function buildDefaultMetadata(rawImageInfo) {
   };
   metadata["Multiresolution levels"] = rawImageInfo.multiscaleLevelDims;
   // TODO decide???? combined or not?
-  metadata["Channels"] = rawImageInfo.combinedNumChannels; //imageInfo.numChannels;
+  const totalChannels = imageInfo.numChannelsPerSource.reduce((a, b) => a + b, 0);
+  metadata["Channels"] = totalChannels;
   metadata["Time series frames"] = imageInfo.times || 1;
   // don't add User data if it's empty
   if (rawImageInfo.userData && !isEmpty(rawImageInfo.userData)) {

package/es/types/ImageInfo.d.ts

@@ -3,20 +3,17 @@ import { Vector3, Vector2 } from "three";
 export type ImageInfo = Readonly<{
     name: string;
     /**
-     * XY dimensions of the texture atlas used by `RayMarchedAtlasVolume` and `Atlas2DSlice`, in number of z-slice
-     * tiles (not pixels). Chosen by the loader to lay out the 3D volume in the squarest possible 2D texture atlas.
+     * XY dimensions of the texture atlas used by `RayMarchedAtlasVolume` and
+     * `Atlas2DSlice`, in number of z-slice tiles (not pixels). Chosen by the
+     * loader to lay out the 3D volume in the squarest possible 2D texture atlas.
      */
     atlasTileDims: [number, number];
     /** Size of the currently loaded subregion, in pixels, in XYZ order */
     subregionSize: [number, number, number];
     /** Offset of the loaded subregion into the total volume, in pixels, in XYZ order */
     subregionOffset: [number, number, number];
-    /** Number of channels in the image, accounting for convergence of multiple sources.
-     * Because of multiple sources, which is not accounted for in ImageInfo,
-     * that this could be different than the number of channels in the multiscaleLevelDims.
-     * NOTE Currently there is one ImageInfo per Volume, not per source.
-     */
-    combinedNumChannels: number;
+    /** The number of channels in each source, in source order. */
+    numChannelsPerSource: number[];
     /** The names of each channel */
     channelNames: string[];
     /** Optional overrides to default channel colors, in 0-255 range, RGB order */
@@ -26,9 +23,9 @@ export type ImageInfo = Readonly<{
     /** The scale level from which this image was loaded, between `0` and `numMultiscaleLevels-1` */
     multiscaleLevel: number;
     /**
-     * An *optional* transform which may be supplied by image metadata. It is *not* applied by
-     * default, but may be read and fed to `View3d` methods: `setVolumeTransform`,
-     * `setVolumeRotation`, `setVolumeScale`.
+     * An *optional* transform which may be supplied by image metadata. It is
+     * *not* applied by default, but may be read and fed to `View3d` methods:
+     * `setVolumeTransform`, `setVolumeRotation`, `setVolumeScale`.
      */
     transform: {
         /** Translation of the volume from the center of space, in volume voxels in XYZ order */
@@ -48,6 +45,8 @@ export declare class CImageInfo {
     get currentLevelDims(): VolumeDims;
     /** Number of channels in the image */
     get numChannels(): number;
+    /** Number of channels per source, ordered by source index */
+    get numChannelsPerSource(): number[];
     /** XYZ size of the *original* (not downsampled) volume, in pixels */
     get originalSize(): Vector3;
     /** Size of the volume, in pixels */

package/es/types/VolumeMaker.d.ts

@@ -1,3 +1,4 @@
+import { type NumberType, type TypedArray } from "./types.js";
 /**
  * Basic utility functions to create sample volume data
  * @class
@@ -9,16 +10,18 @@ export default class VolumeMaker {
      * @param {number} vy
      * @param {number} vz
      * @param {function} sdFunc A function f(x,y,z) that returns a distance. f < 0 will be the interior of the volume, and f>=0 will be outside.
+     * @param {NumberType} dtype The data type for the output array
      */
-    static createVolume(vx: number, vy: number, vz: number, sdFunc: (px: number, py: number, pz: number) => number): Uint8Array;
+    static createVolume(vx: number, vy: number, vz: number, sdFunc: (px: number, py: number, pz: number) => number, dtype?: NumberType): TypedArray<NumberType>;
     /**
      * Create a volume filled with a sphere in the center
      * @param {number} vx
      * @param {number} vy
      * @param {number} vz
      * @param {number} radius
+     * @param {NumberType} dtype The data type for the output array
      */
-    static createSphere(vx: number, vy: number, vz: number, radius: number): Uint8Array;
+    static createSphere(vx: number, vy: number, vz: number, radius: number, dtype?: NumberType): TypedArray<NumberType>;
     /**
      * Create a volume with a cylinder centered inside.
      * @param {number} vx
@@ -26,8 +29,9 @@ export default class VolumeMaker {
      * @param {number} vz
      * @param {number} hx width of cap (?)
      * @param {number} hy depth of cap (?)
+     * @param {NumberType} dtype The data type for the output array
      */
-    static createCylinder(vx: number, vy: number, vz: number, hx: number, hy: number): Uint8Array;
+    static createCylinder(vx: number, vy: number, vz: number, hx: number, hy: number, dtype?: NumberType): TypedArray<NumberType>;
     /**
      * Create a volume with a torus centered inside
      * @param {number} vx
@@ -35,8 +39,9 @@ export default class VolumeMaker {
      * @param {number} vz
      * @param {number} tx inner radius
      * @param {number} ty outer radius
+     * @param {NumberType} dtype The data type for the output array
      */
-    static createTorus(vx: number, vy: number, vz: number, tx: number, ty: number): Uint8Array;
+    static createTorus(vx: number, vy: number, vz: number, tx: number, ty: number, dtype?: NumberType): TypedArray<NumberType>;
     /**
      * Create a volume with a cone centered inside.  cx, cy must be a 2d normalized pair...?
      * @param {number} vx
@@ -44,6 +49,8 @@ export default class VolumeMaker {
      * @param {number} vz
      * @param {number} cx base radius
      * @param {number} cy height
+     * @param {NumberType} dtype The data type for the output array
      */
-    static createCone(vx: number, vy: number, vz: number, cx: number, cy: number): Uint8Array;
+    static createCone(vx: number, vy: number, vz: number, cx: number, cy: number, dtype?: NumberType): TypedArray<NumberType>;
+    static concatenateArrays(arrays: TypedArray<NumberType>[], dtype: NumberType): TypedArray<NumberType>;
 }

package/es/types/index.d.ts

@@ -8,7 +8,7 @@ import RequestQueue from "./utils/RequestQueue.js";
 import SubscribableRequestQueue from "./utils/SubscribableRequestQueue.js";
 import Histogram from "./Histogram.js";
 import { Lut, remapControlPoints } from "./Lut.js";
-import { type ColorizeFeature, ViewportCorner } from "./types.js";
+import { type ColorizeFeature, type NumberType, ViewportCorner } from "./types.js";
 import { VolumeFileFormat, createVolumeLoader, PrefetchDirection } from "./loaders/index.js";
 import { LoadSpec } from "./loaders/IVolumeLoader.js";
 import { OMEZarrLoader } from "./loaders/OmeZarrLoader.js";
@@ -26,4 +26,4 @@ export type { CreateLoaderOptions } from "./loaders/index.js";
 export type { IVolumeLoader, PerChannelCallback, ThreadableVolumeLoader } from "./loaders/IVolumeLoader.js";
 export type { ZarrLoaderFetchOptions } from "./loaders/OmeZarrLoader.js";
 export type { WorkerLoader } from "./workers/VolumeLoaderContext.js";
-export { Histogram, Lut, Line3d, remapControlPoints, View3d, Volume, VolumeDrawable, LoadSpec, VolumeMaker, VolumeCache, RequestQueue, SubscribableRequestQueue, PrefetchDirection, OMEZarrLoader, JsonImageInfoLoader, RawArrayLoader, type RawArrayData, type RawArrayInfo, type RawArrayLoaderOptions, TiffLoader, VolumeLoaderContext, VolumeLoadError, VolumeLoadErrorType, VolumeFileFormat, createVolumeLoader, Channel, Light, ViewportCorner, AREA_LIGHT, RENDERMODE_PATHTRACE, RENDERMODE_RAYMARCH, SKY_LIGHT, type CameraState, type ColorizeFeature, };
+export { Histogram, Lut, Line3d, remapControlPoints, View3d, Volume, VolumeDrawable, LoadSpec, VolumeMaker, VolumeCache, RequestQueue, SubscribableRequestQueue, PrefetchDirection, OMEZarrLoader, JsonImageInfoLoader, RawArrayLoader, type RawArrayData, type RawArrayInfo, type RawArrayLoaderOptions, TiffLoader, VolumeLoaderContext, VolumeLoadError, VolumeLoadErrorType, VolumeFileFormat, createVolumeLoader, Channel, Light, ViewportCorner, AREA_LIGHT, RENDERMODE_PATHTRACE, RENDERMODE_RAYMARCH, SKY_LIGHT, type CameraState, type ColorizeFeature, type NumberType, };

package/es/types/loaders/RawArrayLoader.d.ts

@@ -1,9 +1,9 @@
 import { ThreadableVolumeLoader, type LoadSpec, type RawChannelDataCallback, type LoadedVolumeInfo } from "./IVolumeLoader.js";
 import type { ImageInfo } from "../ImageInfo.js";
 import type { VolumeDims } from "../VolumeDims.js";
-import { Uint8 } from "../types.js";
+import { NumberType } from "../types.js";
 export type RawArrayData = {
-    dtype: Uint8;
+    dtype: NumberType;
     shape: [number, number, number, number];
     buffer: DataView;
 };

package/es/types/types.d.ts

@@ -96,28 +96,26 @@ export interface FuseChannel {
 }
 /** If `FuseChannel.rgbColor` is this value, it is disabled from fusion. */
 export declare const FUSE_DISABLED_RGB_COLOR = 0;
-/**
- * Provide options to control the visual appearance of a Volume
- * @typedef {Object} VolumeChannelDisplayOptions
- * @property {boolean} enabled array of boolean per channel
- * @property {Array.<number>} color array of rgb per channel
- * @property {Array.<number>} specularColor array of rgb per channel
- * @property {Array.<number>} emissiveColor array of rgb per channel
- * @property {number} glossiness array of float per channel
- * @property {boolean} isosurfaceEnabled array of boolean per channel
- * @property {number} isovalue array of number per channel
- * @property {number} isosurfaceOpacity array of number per channel
- * @example let options = {
-   };
- */
 export interface VolumeChannelDisplayOptions {
+    /** Whether the channel's volume data should be rendered for this channel. */
     enabled?: boolean;
+    /** RGB color array, with values in the range of [0, 255]. */
     color?: [number, number, number];
+    /** RGB color array for specular (highlight) color, with values in the range of [0, 255]. */
     specularColor?: [number, number, number];
+    /** RGB color array for emissive (glow) color, with values in the range of [0, 255]. */
     emissiveColor?: [number, number, number];
+    /** Exponent factor controlling the glossiness ("shininess") of the material. 0 is default. */
     glossiness?: number;
+    /** Whether the isosurface mesh should be rendered for this channel. */
     isosurfaceEnabled?: boolean;
+    /**
+     * Isovalue used to calculate the isosurface mesh, in a [0, 255] range.
+     * Isosurface is found at the set of all boundaries between voxels whose
+     * intensities span across this isovalue.
+     */
     isovalue?: number;
+    /** Opacity of the isosurface, in a [0, 1] range. */
     isosurfaceOpacity?: number;
 }
 export declare enum RenderMode {

package/es/types.js

@@ -18,22 +18,6 @@ export function isFloatTypeArray(array) {
 }
 /** If `FuseChannel.rgbColor` is this value, it is disabled from fusion. */
 export const FUSE_DISABLED_RGB_COLOR = 0;
-
-/**
- * Provide options to control the visual appearance of a Volume
- * @typedef {Object} VolumeChannelDisplayOptions
- * @property {boolean} enabled array of boolean per channel
- * @property {Array.<number>} color array of rgb per channel
- * @property {Array.<number>} specularColor array of rgb per channel
- * @property {Array.<number>} emissiveColor array of rgb per channel
- * @property {number} glossiness array of float per channel
- * @property {boolean} isosurfaceEnabled array of boolean per channel
- * @property {number} isovalue array of number per channel
- * @property {number} isosurfaceOpacity array of number per channel
- * @example let options = {
-   };
- */
-
 export let RenderMode = /*#__PURE__*/function (RenderMode) {
   RenderMode[RenderMode["RAYMARCH"] = 0] = "RAYMARCH";
   RenderMode[RenderMode["PATHTRACE"] = 1] = "PATHTRACE";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aics/vole-core",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "description": "volume renderer for 3d, 4d, or 5d imaging data with OME-Zarr support",
   "main": "es/index.js",
   "type": "module",