@aics/vole-core 3.13.0 → 3.14.0

package/es/loaders/VolumeLoadError.js

@@ -1,5 +1,5 @@
 import { errorConstructors } from "serialize-error";
-import { NodeNotFoundError, KeyError } from "@zarrita/core";
+import { NodeNotFoundError, KeyError } from "zarrita";
 // geotiff doesn't export its error types...
 
 /** Groups possible load errors into a few broad categories which we can give similar guidance to the user about. */

package/es/loaders/zarr_utils/ChunkPrefetchIterator.js

@@ -34,6 +34,13 @@ export default class ChunkPrefetchIterator {
       updateMinMax(chunk[4], extrema[3]);
     }
 
+    // Bail out if we have any non-finite values in the extrema (the iterator will be empty)
+    if (extrema.flat().some(val => !Number.isFinite(val))) {
+      this.directionStates = [];
+      this.priorityDirectionStates = [];
+      return;
+    }
+
     // Create `PrefetchDirectionState`s for each direction
     this.directionStates = [];
     this.priorityDirectionStates = [];

package/es/loaders/zarr_utils/validation.js

@@ -1,4 +1,11 @@
 import { VolumeLoadError, VolumeLoadErrorType } from "../VolumeLoadError.js";
+/**
+ * If `meta` is the top-level metadata of a zarr node formatted according to the OME-Zarr spec version 0.5, returns
+ * the object formatted according to v0.4 of the spec. For our purposes this just means flattening out the `ome` key.
+ *
+ * Return type is `unknown` because this does no actual validation; use `validateOMEZarrMetadata` for that.
+ */
+export const toOMEZarrMetaV4 = meta => meta.ome ?? meta;
 function isObjectWithProp(obj, prop) {
   return typeof obj === "object" && obj !== null && prop in obj;
 }
@@ -17,18 +24,22 @@ function assertPropIsArray(obj, prop, name = "zarr") {
   }
 }
 
+/** Intermediate stage of validation, before we've picked a single multiscale to validate */
+
+export function assertMetadataHasMultiscales(meta, name = "zarr") {
+  // data is an object with a key "multiscales", which is a non-empty array
+  assertMetadataHasProp(meta, "multiscales", name);
+  assertPropIsArray(meta, "multiscales", name);
+}
+
 /**
- * Validates that the `OMEZarrMetadata` record `data` has the minimal amount of data required to open a volume. Since
+ * Validates that the `OMEZarrMetadata` record `meta` has the minimal amount of data required to open a volume. Since
  * we only ever open one multiscale, we only validate the multiscale metadata record at index `multiscaleIdx` here.
  * `name` is used in error messages to identify the source of the metadata.
  */
-export function validateOMEZarrMetadata(data, multiscaleIdx = 0, name = "zarr") {
-  // data is an object with a key "multiscales", which is an array
-  assertMetadataHasProp(data, "multiscales", name);
-  assertPropIsArray(data, "multiscales", name);
-
+export function validateOMEZarrMetadata(meta, multiscaleIdx = 0, name = "zarr") {
   // check that a multiscale metadata entry exists at `multiscaleIdx`
-  const multiscaleMeta = data.multiscales[multiscaleIdx];
+  const multiscaleMeta = meta.multiscales[multiscaleIdx];
   if (!multiscaleMeta) {
     throw new VolumeLoadError(`${name} metadata does not have requested multiscale level ${multiscaleIdx}`, {
       type: VolumeLoadErrorType.INVALID_METADATA

package/es/loaders/zarr_utils/wrapArray.js

@@ -0,0 +1,39 @@
+import { isChunk } from "../../VolumeCache.js";
+export default function wrapArray(array, basePath, cache, queue) {
+  const path = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+  const keyBase = path + array.path + (array.path.endsWith("/") ? "" : "/");
+  const getChunk = async (coords, opts) => {
+    if (opts?.subscriber && opts.reportChunk) {
+      opts.reportChunk(coords, opts.subscriber);
+    }
+    const fullKey = keyBase + coords.join(",");
+    const cacheResult = cache?.get(fullKey);
+    if (cacheResult && isChunk(cacheResult)) {
+      return cacheResult;
+    }
+    let result;
+    if (queue && opts?.subscriber) {
+      result = await queue.addRequest(fullKey, opts?.subscriber, () => array.getChunk(coords, opts), opts.isPrefetch);
+    } else {
+      result = await array.getChunk(coords, opts);
+    }
+    cache?.insert(fullKey, result);
+    return result;
+  };
+  return new Proxy(array, {
+    get: (target, prop) => {
+      if (prop === "getChunk") {
+        return getChunk;
+      }
+
+      // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy#no_private_property_forwarding
+      const value = target[prop];
+      if (value instanceof Function) {
+        return function (...args) {
+          return value.apply(target, args);
+        };
+      }
+      return value;
+    }
+  });
+}

package/es/types/FusedChannelData.d.ts

@@ -11,12 +11,14 @@ export default class FusedChannelData {
     private fuseMaterialF;
     private fuseMaterialUI;
     private fuseMaterialI;
+    private fuseMaterialColorizeUI;
     private fuseMaterialProps;
     private fuseScene;
     private quadCamera;
     private fuseRenderTarget;
     constructor(atlasX: number, atlasY: number);
     private setupFuseMaterial;
+    private setupFuseColorizeMaterial;
     getFusedTexture(): Texture;
     cleanup(): void;
     private getShader;

package/es/types/PickVolume.d.ts

@@ -0,0 +1,43 @@
+import { DepthTexture, Group, OrthographicCamera, PerspectiveCamera, Texture, WebGLRenderer, WebGLRenderTarget } from "three";
+import { Volume } from "./index.js";
+import Channel from "./Channel.js";
+import type { VolumeRenderImpl } from "./VolumeRenderImpl.js";
+import type { FuseChannel } from "./types.js";
+import { VolumeRenderSettings, SettingsFlags } from "./VolumeRenderSettings.js";
+export default class PickVolume implements VolumeRenderImpl {
+    private settings;
+    volume: Volume;
+    private geometry;
+    private geometryMesh;
+    private geometryTransformNode;
+    private scene;
+    private uniforms;
+    private emptyPositionTex;
+    needRedraw: boolean;
+    private pickBuffer;
+    private channelToPick;
+    /**
+     * Creates a new PickVolume.
+     * @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);
+    setChannelToPick(channel: number): void;
+    getPickBuffer(): WebGLRenderTarget;
+    updateVolumeDimensions(): void;
+    viewpointMoved(): void;
+    updateSettings(newSettings: VolumeRenderSettings, dirtyFlags?: number | SettingsFlags): void;
+    /**
+     * Creates the geometry mesh and material for rendering the volume.
+     * @param uniforms object containing uniforms to pass to the shader material.
+     * @returns the new geometry and geometry mesh.
+     */
+    private createGeometry;
+    cleanup(): void;
+    doRender(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture | Texture | null): void;
+    get3dObject(): Group;
+    private setUniform;
+    updateActiveChannels(_channelcolors: FuseChannel[], _channeldata: Channel[]): void;
+    setRenderUpdateListener(_listener?: ((iteration: number) => void) | undefined): void;
+}

package/es/types/ThreeJsPanel.d.ts

@@ -1,4 +1,4 @@
-import { Color, Event, EventListener, OrthographicCamera, PerspectiveCamera, WebGLRenderer, Scene, DepthTexture } from "three";
+import { Color, DepthTexture, Event, EventListener, OrthographicCamera, PerspectiveCamera, Scene, WebGLRenderer, WebGLRenderTarget } from "three";
 import TrackballControls from "./TrackballControls.js";
 import { ViewportCorner } from "./types.js";
 export declare const VOLUME_LAYER = 0;
@@ -104,4 +104,5 @@ export declare class ThreeJsPanel {
     stopRenderLoop(): void;
     removeControlHandlers(): void;
     setControlHandlers(onstart: EventListener<Event, "start", TrackballControls>, onchange: EventListener<Event, "change", TrackballControls>, onend: EventListener<Event, "end", TrackballControls>): void;
+    hitTest(offsetX: number, offsetY: number, pickBuffer: WebGLRenderTarget | undefined): number;
 }

package/es/types/View3d.d.ts

@@ -2,7 +2,7 @@ import { CameraState } from "./ThreeJsPanel.js";
 import VolumeDrawable from "./VolumeDrawable.js";
 import { Light } from "./Light.js";
 import Volume from "./Volume.js";
-import { type VolumeChannelDisplayOptions, type VolumeDisplayOptions, ViewportCorner, RenderMode } from "./types.js";
+import { type ColorizeFeature, type VolumeChannelDisplayOptions, type VolumeDisplayOptions, ViewportCorner, RenderMode } from "./types.js";
 import { PerChannelCallback } from "./loaders/IVolumeLoader.js";
 import VolumeLoaderContext from "./workers/VolumeLoaderContext.js";
 export declare const RENDERMODE_RAYMARCH = RenderMode.RAYMARCH;
@@ -49,12 +49,16 @@ export declare class View3d {
      */
     capture(dataurlcallback: (name: string) => void): void;
     getDOMElement(): HTMLDivElement;
+    getCanvasDOMElement(): HTMLCanvasElement;
     getCameraState(): CameraState;
     setCameraState(transform: Partial<CameraState>): void;
     /**
      * Force a redraw.
+     * @param synchronous If true, the redraw will be done synchronously. If false (default), the
+     * redraw will be done asynchronously via `requestAnimationFrame`. Redraws should be done async
+     * whenever possible for the best performance.
      */
-    redraw(): void;
+    redraw(synchronous?: boolean): void;
     unsetImage(): VolumeDrawable | undefined;
     /**
      * Add a new volume image to the viewer.  (The viewer currently only supports a single image at a time - adding repeatedly, without removing in between, is a potential resource leak)
@@ -92,7 +96,7 @@ export declare class View3d {
     onVolumeChannelAdded(volume: Volume, newChannelIndex: number): void;
     onVolumeLoadError(volume: Volume, error: unknown): void;
     setLoadErrorHandler(handler: ((volume: Volume, error: unknown) => void) | undefined): void;
-    setTime(volume: Volume, time: number, onChannelLoaded?: PerChannelCallback): void;
+    setTime(volume: Volume, time: number, onChannelLoaded?: PerChannelCallback): Promise<void>;
     /**
      * Nudge the scale level loaded into this volume off the one chosen by the loader.
      * E.g. a bias of `1` will load 1 scale level lower than "ideal."
@@ -104,6 +108,13 @@ export declare class View3d {
      * @param {number} maskChannelIndex
      */
     setVolumeChannelAsMask(volume: Volume, maskChannelIndex: number): void;
+    /**
+     * @description Set the necessary data to colorize a segmentation channel, or turn off colorization.
+     * @param volume The volume to set the colorize feature for
+     * @param channelIndex The channel that will be colorized. This only makes sense for segmentation volumes.
+     * @param featureInfo A collection of all parameters necessary to colorize the channel. Pass null to turn off colorization.
+     */
+    setChannelColorizeFeature(volume: Volume, channelIndex: number, featureInfo: ColorizeFeature | null): void;
     /**
      * Set voxel dimensions - controls volume scaling. For example, the physical measurements of the voxels from a biological data set
      * @param {Object} volume
@@ -353,5 +364,26 @@ export declare class View3d {
     hasWebGL2(): boolean;
     handleKeydown: (event: KeyboardEvent) => void;
     removeEventListeners(): void;
+    /**
+     * @description Set the selected ID for a given channel.  This is used to change the appearance of the volume where that id is.
+     * @param volume the image to set the selected ID on
+     * @param channel the channel index where the selected ID is
+     * @param id the selected id
+     */
+    setSelectedID(volume: Volume, channel: number, id: number): void;
+    /**
+     * @description Enable or disable picking on a volume.  If enabled, the channelIndex is used to determine which channel to pick.
+     * @param volume the image to enable picking on
+     * @param enabled set true to enable, false to disable
+     * @param channelIndex if enabled is set to true, pass the pickable channel index here
+     */
+    enablePicking(volume: Volume, enabled: boolean, channelIndex?: number): void;
+    /**
+     * @description This function is used to determine if a mouse event occurred over a volume object.
+     * @param offsetX mouse event x coordinate
+     * @param offsetY mouse event y coordinate
+     * @returns id of object that is under offsetX, offsetY. -1 if none
+     */
+    hitTest(offsetX: number, offsetY: number): number;
     private setupGui;
 }

package/es/types/VolumeCache.d.ts

@@ -1,3 +1,6 @@
+import { Chunk, DataType } from "zarrita";
+export type CacheData = ArrayBuffer | Chunk<DataType>;
+export declare const isChunk: (data: CacheData) => data is Chunk<DataType>;
 export default class VolumeCache {
     private entries;
     readonly maxSize: number;
@@ -31,11 +34,11 @@ export default class VolumeCache {
      * Adds a new entry to the cache.
      * @returns {boolean} a boolean indicating whether the insertion succeeded.
      */
-    insert(key: string, data: ArrayBuffer): boolean;
+    insert(key: string, data: CacheData): boolean;
     /** Internal implementation of `get`. Returns all entry metadata, not just the raw data. */
     private getEntry;
     /** Attempts to get a single entry from the cache. */
-    get(key: string): ArrayBuffer | undefined;
+    get(key: string): CacheData | undefined;
     /** Clears all cache entries whose keys begin with the specified prefix. */
     clearWithPrefix(prefix: string): void;
     /** Clears all data from the cache. */

package/es/types/VolumeDrawable.d.ts

@@ -1,7 +1,7 @@
-import { Vector3, Object3D, Euler, DepthTexture, OrthographicCamera, PerspectiveCamera, WebGLRenderer, Texture } from "three";
+import { Vector3, Object3D, Euler, DepthTexture, OrthographicCamera, PerspectiveCamera, WebGLRenderer, WebGLRenderTarget, Texture } from "three";
 import { Pane } from "tweakpane";
 import Volume from "./Volume.js";
-import type { VolumeDisplayOptions, VolumeChannelDisplayOptions } from "./types.js";
+import type { VolumeDisplayOptions, VolumeChannelDisplayOptions, ColorizeFeature } from "./types.js";
 import { RenderMode } from "./types.js";
 import { Light } from "./Light.js";
 import Channel from "./Channel.js";
@@ -28,9 +28,11 @@ export default class VolumeDrawable {
     sceneRoot: Object3D;
     private meshVolume;
     private volumeRendering;
+    private pickRendering?;
     private renderMode;
     private renderUpdateListener?;
     constructor(volume: Volume, options: VolumeDisplayOptions);
+    getPickBuffer(): WebGLRenderTarget | undefined;
     /**
      * Updates whether a channel's data must be loaded for rendering,
      * based on if its volume or isosurface is enabled, or whether it is needed for masking.
@@ -57,9 +59,12 @@ export default class VolumeDrawable {
     setFlipAxes(flipX: -1 | 1, flipY: -1 | 1, flipZ: -1 | 1): void;
     setMaxProjectMode(isMaxProject: boolean): void;
     onAnimate(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture | Texture | null): void;
+    enablePicking(enabled: boolean, channelIndex: number): void;
+    fillPickBuffer(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture | Texture | null): void;
     getViewMode(): Axis;
     getIsovalue(channel: number): number | undefined;
     hasIsosurface(channel: number): boolean;
+    setSelectedID(channelIndex: number, id: number): boolean;
     fuse(): void;
     setRenderUpdateListener(callback?: (iteration: number) => void): void;
     updateShadingMethod(isbrdf: boolean): void;
@@ -85,6 +90,7 @@ export default class VolumeDrawable {
     setBrightness(brightness: number): void;
     getBrightness(): number;
     setChannelAsMask(channelIndex: number): void;
+    setChannelColorizeFeature(channelIndex: number, featureInfo: ColorizeFeature | null): void;
     setMaskAlpha(maskAlpha: number): void;
     setShowBoundingBox(showBoundingBox: boolean): void;
     setBoundingBoxColor(color: [number, number, number]): void;

package/es/types/constants/volumeRayMarchPickShader.d.ts

@@ -0,0 +1,85 @@
+import { Vector2, Vector3, Matrix4, Texture } from "three";
+export declare const pickVertexShaderSrc: string;
+export declare const pickFragmentShaderSrc: string;
+export declare const pickShaderUniforms: () => {
+    iResolution: {
+        type: string;
+        value: Vector2;
+    };
+    textureRes: {
+        type: string;
+        value: Vector2;
+    };
+    ATLAS_DIMS: {
+        type: string;
+        value: Vector2;
+    };
+    AABB_CLIP_MIN: {
+        type: string;
+        value: Vector3;
+    };
+    CLIP_NEAR: {
+        type: string;
+        value: number;
+    };
+    AABB_CLIP_MAX: {
+        type: string;
+        value: Vector3;
+    };
+    CLIP_FAR: {
+        type: string;
+        value: number;
+    };
+    textureAtlas: {
+        type: string;
+        value: Texture;
+    };
+    textureDepth: {
+        type: string;
+        value: Texture;
+    };
+    usingPositionTexture: {
+        type: string;
+        value: number;
+    };
+    BREAK_STEPS: {
+        type: string;
+        value: number;
+    };
+    SLICES: {
+        type: string;
+        value: number;
+    };
+    isOrtho: {
+        type: string;
+        value: number;
+    };
+    orthoThickness: {
+        type: string;
+        value: number;
+    };
+    orthoScale: {
+        type: string;
+        value: number;
+    };
+    maxProject: {
+        type: string;
+        value: number;
+    };
+    flipVolume: {
+        type: string;
+        value: Vector3;
+    };
+    volumeScale: {
+        type: string;
+        value: Vector3;
+    };
+    inverseModelViewMatrix: {
+        type: string;
+        value: Matrix4;
+    };
+    inverseProjMatrix: {
+        type: string;
+        value: Matrix4;
+    };
+};

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 { ViewportCorner } from "./types.js";
+import { type ColorizeFeature, ViewportCorner } from "./types.js";
 import { VolumeFileFormat, createVolumeLoader, PrefetchDirection } from "./loaders/index.js";
 import { LoadSpec } from "./loaders/IVolumeLoader.js";
 import { OMEZarrLoader } from "./loaders/OmeZarrLoader.js";
@@ -25,4 +25,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, 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, };
+export { Histogram, Lut, 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, };

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

@@ -1,5 +1,5 @@
-import * as zarr from "@zarrita/core";
-import type WrappedStore from "./WrappedStore.js";
+import * as zarr from "zarrita";
+import { AsyncReadable } from "@zarrita/storage";
 import type SubscribableRequestQueue from "../../utils/SubscribableRequestQueue.js";
 export type TCZYX<T> = [T, T, T, T, T];
 export type SubscriberId = ReturnType<SubscribableRequestQueue["addSubscriber"]>;
@@ -53,16 +53,16 @@ export type OMEMultiscale = {
 };
 /** https://ngff.openmicroscopy.org/latest/#omero-md */
 export type OmeroTransitionalMetadata = {
-    id: number;
-    name: string;
-    version: string;
+    id?: number;
+    name?: string;
+    version?: string;
     channels: {
-        active: boolean;
-        coefficient: number;
+        active?: boolean;
+        coefficient?: number;
         color: string;
-        family: string;
-        inverted: boolean;
-        label: string;
+        family?: string;
+        inverted?: boolean;
+        label?: string;
         window: {
             end: number;
             max: number;
@@ -73,9 +73,14 @@ export type OmeroTransitionalMetadata = {
 };
 export type OMEZarrMetadata = {
     multiscales: OMEMultiscale[];
-    omero: OmeroTransitionalMetadata;
+    omero?: OmeroTransitionalMetadata;
+};
+export type WrappedArrayOpts = {
+    subscriber?: SubscriberId;
+    reportChunk?: (coords: number[], subscriber: SubscriberId) => void;
+    isPrefetch?: boolean;
 };
-export type NumericZarrArray = zarr.Array<zarr.NumberDataType, WrappedStore<RequestInit>>;
+export type NumericZarrArray = zarr.Array<zarr.NumberDataType, AsyncReadable<RequestInit & WrappedArrayOpts>>;
 /** A record with everything we need to access and use a single remote source of multiscale OME-Zarr data. */
 export type ZarrSource = {
     /** Representations of each scale level in this zarr. We pick one and pass it to zarrita to load data. */

package/es/types/loaders/zarr_utils/validation.d.ts

@@ -1,7 +1,19 @@
 import { OMEZarrMetadata } from "./types.js";
 /**
- * Validates that the `OMEZarrMetadata` record `data` has the minimal amount of data required to open a volume. Since
+ * If `meta` is the top-level metadata of a zarr node formatted according to the OME-Zarr spec version 0.5, returns
+ * the object formatted according to v0.4 of the spec. For our purposes this just means flattening out the `ome` key.
+ *
+ * Return type is `unknown` because this does no actual validation; use `validateOMEZarrMetadata` for that.
+ */
+export declare const toOMEZarrMetaV4: (meta: unknown) => unknown;
+/** Intermediate stage of validation, before we've picked a single multiscale to validate */
+export type MultiscaleRecord = {
+    multiscales: unknown[];
+};
+export declare function assertMetadataHasMultiscales(meta: unknown, name?: string): asserts meta is MultiscaleRecord;
+/**
+ * Validates that the `OMEZarrMetadata` record `meta` has the minimal amount of data required to open a volume. Since
  * we only ever open one multiscale, we only validate the multiscale metadata record at index `multiscaleIdx` here.
  * `name` is used in error messages to identify the source of the metadata.
  */
-export declare function validateOMEZarrMetadata(data: unknown, multiscaleIdx?: number, name?: string): asserts data is OMEZarrMetadata;
+export declare function validateOMEZarrMetadata(meta: MultiscaleRecord, multiscaleIdx?: number, name?: string): asserts meta is OMEZarrMetadata;

package/es/types/loaders/zarr_utils/wrapArray.d.ts

@@ -0,0 +1,7 @@
+import type { Array as ZarrArray, AsyncReadable, DataType } from "zarrita";
+import VolumeCache from "../../VolumeCache.js";
+import type { WrappedArrayOpts } from "./types.js";
+import SubscribableRequestQueue from "../../utils/SubscribableRequestQueue.js";
+type AsyncReadableExt<Opts> = AsyncReadable<Opts & WrappedArrayOpts>;
+export default function wrapArray<T extends DataType, Opts = unknown, Store extends AsyncReadable<Opts> = AsyncReadable<Opts>>(array: ZarrArray<T, Store>, basePath: string, cache?: VolumeCache, queue?: SubscribableRequestQueue): ZarrArray<T, AsyncReadableExt<Opts>>;
+export {};

package/es/types/types.d.ts

@@ -1,4 +1,4 @@
-import { Camera, OrthographicCamera, PerspectiveCamera, Vector3 } from "three";
+import { Camera, Color, DataTexture, OrthographicCamera, PerspectiveCamera, Vector3 } from "three";
 export interface Bounds {
     bmin: Vector3;
     bmax: Vector3;
@@ -27,10 +27,26 @@ export declare const ARRAY_CONSTRUCTORS: {
     float32: Float32ArrayConstructor;
     float64: Float64ArrayConstructor;
 };
+export interface ColorizeFeature {
+    idsToFeatureValue: DataTexture;
+    featureValueToColor: DataTexture;
+    inRangeIds: DataTexture;
+    outlierData: DataTexture;
+    featureMin: number;
+    featureMax: number;
+    outlineColor: Color;
+    outlierColor: Color;
+    outOfRangeColor: Color;
+    outlierDrawMode: number;
+    outOfRangeDrawMode: number;
+    hideOutOfRange: boolean;
+}
 export interface FuseChannel {
     chIndex: number;
     lut: Uint8Array;
     rgbColor: [number, number, number] | number;
+    selectedID: number;
+    feature?: ColorizeFeature;
 }
 /** If `FuseChannel.rgbColor` is this value, it is disabled from fusion. */
 export declare const FUSE_DISABLED_RGB_COLOR = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aics/vole-core",
-  "version": "3.13.0",
+  "version": "3.14.0",
   "description": "volume renderer for 3d, 4d, or 5d imaging data with OME-Zarr support",
   "main": "es/index.js",
   "type": "module",
@@ -39,7 +39,7 @@
     "three": "^0.171.0",
     "throttled-queue": "^2.1.4",
     "tweakpane": "^3.1.9",
-    "zarrita": "^0.3.2"
+    "zarrita": "^0.4.0"
   },
   "devDependencies": {
     "@babel/cli": "^7.25.6",
@@ -74,8 +74,8 @@
     "typescript": "^4.3.5",
     "url-loader": "^4.1.1",
     "vite": "^6.0.6",
-    "vitest": "^2.1.8",
     "vite-plugin-glsl": "^1.3.1",
+    "vitest": "^3.0.8",
     "webpack": "^5.69.1",
     "webpack-cli": "^4.9.2",
     "webpack-dev-server": "^4.7.4"

package/es/loaders/zarr_utils/WrappedStore.js

@@ -1,51 +0,0 @@
-/**
- * `Readable` is zarrita's minimal abstraction for any source of data.
- * `WrappedStore` wraps another `Readable` and adds (optional) connections to `VolumeCache` and `RequestQueue`.
- */
-class WrappedStore {
-  constructor(baseStore, cache, queue) {
-    this.baseStore = baseStore;
-    this.cache = cache;
-    this.queue = queue;
-  }
-  // Dummy implementation to make this class easier to use in tests
-  set(_key, _value) {
-    return Promise.resolve();
-  }
-  async getAndCache(key, cacheKey, opts) {
-    const result = await this.baseStore.get(key, opts);
-    if (this.cache && result) {
-      this.cache.insert(cacheKey, result);
-    }
-    return result;
-  }
-  async get(key, opts) {
-    const ZARR_EXTS = [".zarray", ".zgroup", ".zattrs", "zarr.json"];
-    if (!this.cache || ZARR_EXTS.some(s => key.endsWith(s))) {
-      return this.baseStore.get(key, opts?.options);
-    }
-    if (opts?.reportKey) {
-      opts.reportKey(key, opts.subscriber);
-    }
-    let keyPrefix = this.baseStore.url ?? "";
-    if (keyPrefix !== "" && !(keyPrefix instanceof URL) && !keyPrefix.endsWith("/")) {
-      keyPrefix += "/";
-    }
-    const fullKey = keyPrefix + key.slice(1);
-
-    // Check the cache
-    const cacheResult = this.cache.get(fullKey);
-    if (cacheResult) {
-      return new Uint8Array(cacheResult);
-    }
-
-    // Not in cache; load the chunk and cache it
-    if (this.queue && opts) {
-      return this.queue.addRequest(fullKey, opts.subscriber, () => this.getAndCache(key, fullKey, opts?.options), opts.isPrefetch);
-    } else {
-      // Should we ever hit this code?  We should always have a request queue.
-      return this.getAndCache(key, fullKey, opts?.options);
-    }
-  }
-}
-export default WrappedStore;

package/es/types/loaders/zarr_utils/WrappedStore.d.ts

@@ -1,24 +0,0 @@
-import { AbsolutePath, AsyncMutable, Readable } from "@zarrita/storage";
-import SubscribableRequestQueue from "../../utils/SubscribableRequestQueue";
-import VolumeCache from "../../VolumeCache";
-import { SubscriberId } from "./types";
-type WrappedStoreOpts<Opts> = {
-    options?: Opts;
-    subscriber: SubscriberId;
-    reportKey?: (key: string, subscriber: SubscriberId) => void;
-    isPrefetch?: boolean;
-};
-/**
- * `Readable` is zarrita's minimal abstraction for any source of data.
- * `WrappedStore` wraps another `Readable` and adds (optional) connections to `VolumeCache` and `RequestQueue`.
- */
-declare class WrappedStore<Opts, S extends Readable<Opts> = Readable<Opts>> implements AsyncMutable<WrappedStoreOpts<Opts>> {
-    private baseStore;
-    private cache?;
-    private queue?;
-    constructor(baseStore: S, cache?: VolumeCache | undefined, queue?: SubscribableRequestQueue | undefined);
-    set(_key: AbsolutePath, _value: Uint8Array): Promise<void>;
-    private getAndCache;
-    get(key: AbsolutePath, opts?: WrappedStoreOpts<Opts> | undefined): Promise<Uint8Array | undefined>;
-}
-export default WrappedStore;