@aics/vole-core 3.12.4

package/es/types/View3d.d.ts

@@ -0,0 +1,357 @@
+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 { PerChannelCallback } from "./loaders/IVolumeLoader.js";
+import VolumeLoaderContext from "./workers/VolumeLoaderContext.js";
+export declare const RENDERMODE_RAYMARCH = RenderMode.RAYMARCH;
+export declare const RENDERMODE_PATHTRACE = RenderMode.PATHTRACE;
+export interface View3dOptions {
+    parentElement?: HTMLElement;
+    useWebGL2?: boolean;
+}
+/**
+ * @class
+ */
+export declare class View3d {
+    loaderContext?: VolumeLoaderContext;
+    private canvas3d;
+    private scene;
+    private backgroundColor;
+    private pixelSamplingRate;
+    private exposure;
+    private volumeRenderMode;
+    private renderUpdateListener?;
+    private loadErrorHandler?;
+    private image?;
+    private lights;
+    private lightContainer;
+    private ambientLight;
+    private spotLight;
+    private reflectedLight;
+    private fillLight;
+    private tweakpane;
+    /**
+     * @param {Object} options Optional options.
+     * @param {boolean} options.useWebGL2 Default true
+     * @param {HTMLElement} options.parentElement An optional element to which to append the viewer element on creation.
+     *   The viewer will attempt to fill this element if provided.
+     */
+    constructor(options?: View3dOptions);
+    preRender(): void;
+    private updateOrthoScaleBar;
+    private updatePerspectiveScaleBar;
+    private updateTimestepIndicator;
+    /**
+     * Capture the contents of this canvas to a data url
+     * @param {Object} dataurlcallback function to call when data url is ready; function accepts dataurl as string arg
+     */
+    capture(dataurlcallback: (name: string) => void): void;
+    getDOMElement(): HTMLDivElement;
+    getCameraState(): CameraState;
+    setCameraState(transform: Partial<CameraState>): void;
+    /**
+     * Force a redraw.
+     */
+    redraw(): 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)
+     * @param {Volume} volume
+     * @param {VolumeDisplayOptions} options
+     */
+    addVolume(volume: Volume, options?: VolumeDisplayOptions): void;
+    /**
+     * Apply a set of display options to a given channel of a volume
+     * @param {Volume} volume
+     * @param {number} channelIndex the channel index
+     * @param {VolumeChannelDisplayOptions} options
+     */
+    setVolumeChannelOptions(volume: Volume, channelIndex: number, options: VolumeChannelDisplayOptions): void;
+    /**
+     * Apply a set of display options to the given volume
+     * @param {Volume} volume
+     * @param {VolumeDisplayOptions} options
+     */
+    setVolumeDisplayOptions(volume: Volume, options: VolumeDisplayOptions): void;
+    /**
+     * Remove a volume image from the viewer.  This will clean up the View3D's resources for the current volume
+     * @param {Volume} volume
+     */
+    removeVolume(volume: Volume): void;
+    /**
+     * Remove all volume images from the viewer.
+     */
+    removeAllVolumes(): void;
+    /**
+     * @param {function} callback a function that will receive the number of render iterations when it changes
+     */
+    setRenderUpdateListener(callback: (iteration: number) => void): void;
+    onVolumeData(volume: Volume, channels: number[]): void;
+    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;
+    /**
+     * 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."
+     */
+    setScaleLevelBias(volume: Volume, scaleLevelBias: number): void;
+    /**
+     * Assign a channel index as a mask channel (will multiply its color against the entire visible volume)
+     * @param {Object} volume
+     * @param {number} maskChannelIndex
+     */
+    setVolumeChannelAsMask(volume: Volume, maskChannelIndex: number): void;
+    /**
+     * Set voxel dimensions - controls volume scaling. For example, the physical measurements of the voxels from a biological data set
+     * @param {Object} volume
+     * @param {number} values Array of x,y,z floating point values for the physical voxel size scaling
+     * @param {string} unit The unit of `values`, if different than previous
+     */
+    setVoxelSize(volume: Volume, values: number[], unit?: string): void;
+    setRayStepSizes(volume: Volume, primary: number, secondary: number): void;
+    setShowBoundingBox(volume: Volume, showBoundingBox: boolean): void;
+    setBoundingBoxColor(volume: Volume, color: [number, number, number]): void;
+    setBackgroundColor(color: [number, number, number]): void;
+    /**
+     * Is an isosurface already created for this channel?
+     * @param {Object} volume
+     * @param {number} channel
+     * @return true if there is currently a mesh isosurface for this channel
+     */
+    hasIsosurface(volume: Volume, channel: number): boolean;
+    /**
+     * Save a channel's isosurface as a triangle mesh to either STL or GLTF2 format.  File will be named automatically, using image name and channel name.
+     * @param {Object} volume
+     * @param {number} channelIndex
+     * @param {string} type Either 'GLTF' or 'STL'
+     */
+    saveChannelIsosurface(volume: Volume, channelIndex: number, type: string): void;
+    setImage(img: VolumeDrawable): VolumeDrawable | undefined;
+    onStartControls(): void;
+    onChangeControls(): void;
+    onEndControls(): void;
+    buildScene(): void;
+    /**
+     * Change the camera projection to look along an axis, or to view in a 3d perspective camera.
+     * @param {string} mode Mode can be "3D", or "XY" or "Z", or "YZ" or "X", or "XZ" or "Y".  3D is a perspective view, and all the others are orthographic projections
+     */
+    setCameraMode(mode: string): void;
+    setZSlice(volume: Volume, slice: number): boolean;
+    /**
+     * Enable or disable 3d axis display at lower left.
+     * @param {boolean} showAxis
+     */
+    setShowAxis(showAxis: boolean): void;
+    /**
+     * Enable or disable scale indicators.
+     * @param showScaleBar
+     */
+    setShowScaleBar(showScaleBar: boolean): void;
+    /**
+     * Enable or disable time indicator.
+     * @param showTimestepIndicator
+     */
+    setShowTimestepIndicator(showIndicator: boolean): void;
+    /**
+     * Set the position of the axis indicator, as a corner of the viewport and horizontal and vertical margins from the
+     * edge of the viewport.
+     * @param {number} marginX
+     * @param {number} marginY
+     * @param {string} [corner] The corner of the viewport in which the axis appears. Default: `"bottom_left"`.
+     *  TypeScript users should use the `ViewportCorner` enum. Otherwise, corner is one of: `"top_left"`, `"top_right"`,
+     *  `"bottom_left"`, `"bottom_right"`.
+     */
+    setAxisPosition(marginX: number, marginY: number, corner?: ViewportCorner): void;
+    /**
+     * Set the position of the scale bar, as a corner of the viewport and horizontal and vertical margins from the edge
+     * of the viewport.
+     * @param {number} marginX
+     * @param {number} marginY
+     * @param {string} [corner] The corner of the viewport in which the scale bar appears. Default: `"bottom_right"`.
+     *  TypeScript users should use the `ViewportCorner` enum. Otherwise, corner is one of: `"top_left"`, `"top_right"`,
+     *  `"bottom_left"`, `"bottom_right"`.
+     */
+    setScaleBarPosition(marginX: number, marginY: number, corner?: ViewportCorner): void;
+    /**
+     * Set the position of the time step indicator, as a corner of the viewport and horizontal and vertical margins from
+     * the edge of the viewport.
+     * @param {number} marginX
+     * @param {number} marginY
+     * @param {string} [corner] The corner of the viewport in which the scale bar appears. Default: `"bottom_right"`.
+     *  TypeScript users should use the `ViewportCorner` enum. Otherwise, corner is one of: `"top_left"`, `"top_right"`,
+     *  `"bottom_left"`, `"bottom_right"`.
+     */
+    setTimestepIndicatorPosition(marginX: number, marginY: number, corner?: ViewportCorner): void;
+    /**
+     * Enable or disable a turntable rotation mode. The display will continuously spin about the vertical screen axis.
+     * @param {boolean} autorotate
+     */
+    setAutoRotate(autorotate: boolean): void;
+    /**
+     * Set the unit symbol for the scale bar (e.g. µm)
+     * @param {string} unit
+     */
+    setScaleUnit(unit: string): void;
+    /**
+     * Invert axes of volume. -1 to invert, +1 NOT to invert.
+     * @param {Object} volume
+     * @param {number} flipX x axis sense
+     * @param {number} flipY y axis sense
+     * @param {number} flipZ z axis sense
+     */
+    setFlipVolume(volume: Volume, flipX: -1 | 1, flipY: -1 | 1, flipZ: -1 | 1): void;
+    setInterpolationEnabled(volume: Volume, active: boolean): void;
+    /**
+     * Notify the view that it has been resized.  This will automatically be connected to the window when the View3d is created.
+     * @param {HTMLElement=} comp Ignored.
+     * @param {number=} w Width, or parent element's offsetWidth if not specified.
+     * @param {number=} h Height, or parent element's offsetHeight if not specified.
+     * @param {number=} ow Ignored.
+     * @param {number=} oh Ignored.
+     * @param {Object=} eOpts Ignored.
+     */
+    resize(comp: HTMLElement | null, w?: number, h?: number, ow?: number, oh?: number, eOpts?: unknown): void;
+    /**
+     * Set the volume scattering density
+     * @param {Object} volume
+     * @param {number} density 0..1 UI slider value
+     */
+    updateDensity(volume: Volume, density: number): void;
+    /**
+     * Set the shading method - applies to pathtraced render mode only
+     * @param {Object} volume
+     * @param {number} isbrdf 0: brdf, 1: isotropic phase function, 2: mixed
+     */
+    updateShadingMethod(volume: Volume, isbrdf: boolean): void;
+    /**
+     * Set gamma levels: this affects the transparency and brightness of the single pass ray march volume render
+     * @param {Object} volume
+     * @param {number} gmin
+     * @param {number} glevel
+     * @param {number} gmax
+     */
+    setGamma(volume: Volume, gmin: number, glevel: number, gmax: number): void;
+    /**
+     * Set max projection on or off - applies to single pass raymarch render mode only
+     * @param {Object} volume
+     * @param {boolean} isMaxProject true for max project, false for regular volume ray march integration
+     */
+    setMaxProjectMode(volume: Volume, isMaxProject: boolean): void;
+    /**
+     * Notify the view that the set of active volume channels has been modified.
+     * @param {Object} volume
+     */
+    updateActiveChannels(_volume: Volume): void;
+    /**
+     * Notify the view that transfer function lookup table data has been modified.
+     * @param {Object} volume
+     */
+    updateLuts(_volume: Volume): void;
+    /**
+     * Notify the view that color and appearance settings have been modified.
+     * @param {Object} volume
+     */
+    updateMaterial(_volume: Volume): void;
+    /**
+     * Increase or decrease the overall brightness of the rendered image
+     * @param {number} e 0..1
+     */
+    updateExposure(e: number): void;
+    /**
+     * Set camera focus properties.
+     * @param {number} fov Vertical field of view in degrees
+     * @param {number} focalDistance view-space units for center of focus
+     * @param {number} apertureSize view-space units for radius of camera aperture
+     */
+    updateCamera(fov: number, focalDistance: number, apertureSize: number): void;
+    /**
+     * Set clipping range (between 0 and 1, relative to bounds) for the current volume.
+     * @param {Object} volume
+     * @param {number} xmin 0..1, should be less than xmax
+     * @param {number} xmax 0..1, should be greater than xmin
+     * @param {number} ymin 0..1, should be less than ymax
+     * @param {number} ymax 0..1, should be greater than ymin
+     * @param {number} zmin 0..1, should be less than zmax
+     * @param {number} zmax 0..1, should be greater than zmin
+     */
+    updateClipRegion(volume: Volume, xmin: number, xmax: number, ymin: number, ymax: number, zmin: number, zmax: number): void;
+    /**
+     * Set clipping range (between 0 and 1) for a given axis.
+     * Calling this allows the rendering to compensate for changes in thickness in orthographic views that affect how bright the volume is.
+     * @param {Object} volume
+     * @param {string} axis x, y, or z axis
+     * @param {number} minval 0..1, should be less than maxval
+     * @param {number} maxval 0..1, should be greater than minval
+     * @param {boolean} isOrthoAxis is this an orthographic projection or just a clipping of the range for perspective view
+     */
+    setAxisClip(volume: Volume, axis: "x" | "y" | "z", minval: number, maxval: number, isOrthoAxis: boolean): void;
+    /**
+     * Update lights
+     * @param {Array} state array of Lights
+     */
+    updateLights(state: Light[]): void;
+    /**
+     * Set a sampling rate to trade performance for quality.
+     * @param {number} value (+epsilon..1) 1 is max quality, ~0.1 for lowest quality and highest speed
+     */
+    updatePixelSamplingRate(value: number): void;
+    /**
+     * Set the opacity of the mask channel
+     * @param {Object} volume
+     * @param {number} value (0..1) 0 for full transparent, 1 for fully opaque
+     */
+    updateMaskAlpha(volume: Volume, value: number): void;
+    /**
+     * Show / hide volume channels
+     * @param {Object} volume
+     * @param {number} channel
+     * @param {boolean} enabled
+     */
+    setVolumeChannelEnabled(volume: Volume, channel: number, enabled: boolean): void;
+    /**
+     * Set the material for a channel
+     * @param {Object} volume
+     * @param {number} channelIndex
+     * @param {Array.<number>} colorrgb [r,g,b]
+     * @param {Array.<number>} specularrgb [r,g,b]
+     * @param {Array.<number>} emissivergb [r,g,b]
+     * @param {number} glossiness
+     */
+    updateChannelMaterial(volume: Volume, channelIndex: number, colorrgb: [number, number, number], specularrgb: [number, number, number], emissivergb: [number, number, number], glossiness: number): void;
+    /**
+     * Set the color for a channel
+     * @param {Object} volume
+     * @param {number} channelIndex
+     * @param {Array.<number>} colorrgb [r,g,b]
+     */
+    updateChannelColor(volume: Volume, channelIndex: number, colorrgb: [number, number, number]): void;
+    /**
+     * Switch between single pass ray-marched volume rendering and progressive path traced rendering.
+     * @param {RenderMode} mode RAYMARCH for single pass ray march, PATHTRACE for progressive path trace
+     */
+    setVolumeRenderMode(mode: RenderMode.PATHTRACE | RenderMode.RAYMARCH): void;
+    /**
+     *
+     * @param {Object} volume
+     * @param {Array.<number>} xyz
+     */
+    setVolumeTranslation(volume: Volume, xyz: [number, number, number]): void;
+    /**
+     *
+     * @param {Object} volume
+     * @param {Array.<number>} eulerXYZ
+     */
+    setVolumeRotation(volume: Volume, eulerXYZ: [number, number, number]): void;
+    setVolumeScale(volume: Volume, xyz: [number, number, number]): void;
+    /**
+     * Reset the camera to its default position
+     */
+    resetCamera(): void;
+    hasWebGL2(): boolean;
+    handleKeydown: (event: KeyboardEvent) => void;
+    removeEventListeners(): void;
+    private setupGui;
+}

package/es/types/Volume.d.ts

@@ -0,0 +1,152 @@
+import { Vector3 } from "three";
+import Channel from "./Channel.js";
+import Histogram from "./Histogram.js";
+import { Lut } from "./Lut.js";
+import { type IVolumeLoader, LoadSpec, type PerChannelCallback } from "./loaders/IVolumeLoader.js";
+import type { NumberType, TypedArray } from "./types.js";
+import { type ImageInfo, CImageInfo } from "./ImageInfo.js";
+interface VolumeDataObserver {
+    onVolumeData: (vol: Volume, batch: number[]) => void;
+    onVolumeChannelAdded: (vol: Volume, idx: number) => void;
+    onVolumeLoadError: (vol: Volume, error: unknown) => void;
+}
+/**
+ * A renderable multichannel volume image with 8-bits per channel intensity values.
+ * @class
+ * @param {ImageInfo} imageInfo
+ */
+export default class Volume {
+    imageInfo: CImageInfo;
+    loadSpec: Required<LoadSpec>;
+    loader?: IVolumeLoader;
+    /** `LoadSpec` representing the minimum data required to display what's in the viewer (subregion, channels, etc.).
+     * Used to intelligently issue load requests whenever required by a state change. Modify with `updateRequiredData`.
+     */
+    loadSpecRequired: Required<LoadSpec>;
+    channelLoadCallback?: PerChannelCallback;
+    imageMetadata: Record<string, unknown>;
+    name: string;
+    channels: Channel[];
+    numChannels: number;
+    channelNames: string[];
+    channelColorsDefault: [number, number, number][];
+    /** The maximum of the measurements of 3 axes in physical units (pixels*physicalSize) */
+    physicalScale: number;
+    /** The physical size of a voxel in the original level 0 volume */
+    physicalPixelSize: Vector3;
+    /** The physical dims of the whole volume (not accounting for subregion) */
+    physicalSize: Vector3;
+    /** Normalized physical size of the whole volume (not accounting for subregion) */
+    normPhysicalSize: Vector3;
+    normRegionSize: Vector3;
+    normRegionOffset: Vector3;
+    physicalUnitSymbol: string;
+    tickMarkPhysicalLength: number;
+    private volumeDataObservers;
+    private loaded;
+    constructor(imageInfo?: ImageInfo, loadSpec?: LoadSpec, loader?: IVolumeLoader);
+    private setUnloaded;
+    isLoaded(): boolean;
+    updateDimensions(): void;
+    /** Returns `true` iff differences between `loadSpec` and `loadSpecRequired` indicate new data *must* be loaded. */
+    private mustLoadNewData;
+    /**
+     * Returns `true` iff differences between `loadSpec` and `loadSpecRequired` indicate a new load *may* get a
+     * different scale level than is currently loaded.
+     *
+     * This checks for changes in properties that *can*, but do not *always*, change the scale level the loader picks.
+     * For example, a smaller `subregion` *may* mean a higher scale level will fit within memory constraints, or it may
+     * not. A higher `scaleLevelBias` *may* nudge the volume into a higher scale level, or we may already be at the max
+     * imposed by `multiscaleLevel`.
+     */
+    private mayLoadNewScaleLevel;
+    /** Call on any state update that may require new data to be loaded (subregion, enabled channels, time, etc.) */
+    updateRequiredData(required: Partial<LoadSpec>, onChannelLoaded?: PerChannelCallback): Promise<void>;
+    private loadScaleLevelDims;
+    /**
+     * Loads new data as specified in `this.loadSpecRequired`. Clones `loadSpecRequired` into `loadSpec` to indicate
+     * that the data that *must* be loaded is now the data that *has* been loaded.
+     */
+    private loadNewData;
+    setVoxelSize(size: Vector3): void;
+    setUnitSymbol(symbol: string): void;
+    /** Computes the center of the volume subset */
+    getContentCenter(): Vector3;
+    cleanup(): void;
+    getChannel(channelIndex: number): Channel;
+    onChannelLoaded(batch: number[]): void;
+    /**
+     * Assign volume data via a 2d array containing the z slices as tiles across it.  Assumes that the incoming data is consistent with the image's pre-existing imageInfo tile metadata.
+     * @param {number} channelIndex
+     * @param {Uint8Array} atlasdata
+     * @param {number} atlaswidth
+     * @param {number} atlasheight
+     */
+    setChannelDataFromAtlas(channelIndex: number, atlasdata: TypedArray<NumberType>, atlaswidth: number, atlasheight: number, range: [number, number], dtype?: NumberType): void;
+    /**
+     * Assign volume data as a 3d array ordered x,y,z. The xy size must be equal to tilewidth*tileheight from the imageInfo used to construct this Volume.  Assumes that the incoming data is consistent with the image's pre-existing imageInfo tile metadata.
+     * @param {number} channelIndex
+     * @param {Uint8Array} volumeData
+     */
+    setChannelDataFromVolume(channelIndex: number, volumeData: TypedArray<NumberType>, range: [number, number], dtype?: NumberType): void;
+    /**
+     * Add a new channel ready to receive data from one of the setChannelDataFrom* calls.
+     * Name and color will be defaulted if not provided. For now, leave imageInfo alone as the "original" data
+     * @param {string} name
+     * @param {Array.<number>} color [r,g,b]
+     */
+    appendEmptyChannel(name: string, color?: [number, number, number]): number;
+    /**
+     * Get a value from the volume data
+     * @return {number} the intensity value from the given channel at the given xyz location
+     * @param {number} c The channel index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    getIntensity(c: number, x: number, y: number, z: number): number;
+    /**
+     * Get the 256-bin histogram for the given channel
+     * @return {Histogram} the histogram
+     * @param {number} c The channel index
+     */
+    getHistogram(c: number): Histogram;
+    /**
+     * Set the lut for the given channel
+     * @param {number} c The channel index
+     * @param {Array.<number>} lut The lut as a 256 element array
+     */
+    setLut(c: number, lut: Lut): void;
+    /**
+     * Set the color palette for the given channel
+     * @param {number} c The channel index
+     * @param {Array.<number>} palette The colors as a 256 element array * RGBA
+     */
+    setColorPalette(c: number, palette: Uint8Array): void;
+    /**
+     * Set the color palette alpha multiplier for the given channel.
+     * This will blend between the ordinary color lut and this colorPalette lut.
+     * @param {number} c The channel index
+     * @param {number} alpha The alpha value as a number from 0 to 1
+     */
+    setColorPaletteAlpha(c: number, alpha: number): void;
+    /**
+     * Return the intrinsic rotation associated with this volume (radians)
+     * @return {Array.<number>} the xyz Euler angles (radians)
+     */
+    getRotation(): [number, number, number];
+    /**
+     * Return the intrinsic translation (pivot center delta) associated with this volume, in normalized volume units
+     * @return {Array.<number>} the xyz translation in normalized volume units
+     */
+    getTranslation(): [number, number, number];
+    /**
+     * Return a translation in normalized volume units, given a translation in image voxels
+     * @return {Array.<number>} the xyz translation in normalized volume units
+     */
+    voxelsToWorldSpace(xyz: [number, number, number]): [number, number, number];
+    addVolumeDataObserver(o: VolumeDataObserver): void;
+    removeVolumeDataObserver(o: VolumeDataObserver): void;
+    removeAllVolumeDataObservers(): void;
+}
+export {};

package/es/types/VolumeCache.d.ts

@@ -0,0 +1,43 @@
+export default class VolumeCache {
+    private entries;
+    readonly maxSize: number;
+    private currentSize;
+    private first;
+    private last;
+    constructor(maxSize?: number);
+    /** The size of all data arrays currently stored in this cache, in bytes. */
+    get size(): number;
+    /** The number of entries currently stored in this cache. */
+    get numberOfEntries(): number;
+    /**
+     * Removes an entry from a store but NOT the LRU list.
+     * Only call from a method with the word "evict" in it!
+     */
+    private removeEntryFromStore;
+    /**
+     * Removes an entry from the LRU list but NOT its store.
+     * Entry must be replaced in list or removed from store, or it will never be evicted!
+     */
+    private removeEntryFromList;
+    /** Adds an entry which is *not currently in the list* to the front of the list. */
+    private addEntryAsFirst;
+    /** Moves an entry which is *currently in the list* to the front of the list. */
+    private moveEntryToFirst;
+    /** Evicts the least recently used entry from the cache. */
+    private evictLast;
+    /** Evicts a specific entry from the cache. */
+    private evict;
+    /**
+     * Adds a new entry to the cache.
+     * @returns {boolean} a boolean indicating whether the insertion succeeded.
+     */
+    insert(key: string, data: ArrayBuffer): 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;
+    /** Clears all cache entries whose keys begin with the specified prefix. */
+    clearWithPrefix(prefix: string): void;
+    /** Clears all data from the cache. */
+    clear(): void;
+}

package/es/types/VolumeDims.d.ts

@@ -0,0 +1,28 @@
+import { type NumberType } from "./types.js";
+import { Vector3 } from "three";
+export type VolumeDims = {
+    shape: [number, number, number, number, number];
+    spacing: [number, number, number, number, number];
+    spaceUnit: string;
+    /**
+     * Symbol of temporal unit used by `spacing[0]`, e.g. "hr".
+     *
+     * If units match one of the following, the viewer will automatically format
+     * timestamps to a d:hh:mm:ss.sss format, truncated as an integer of the unit specified.
+     * See https://ngff.openmicroscopy.org/latest/index.html#axes-md for a list of valid time units.
+     * - "ms", "millisecond" for milliseconds: `d:hh:mm:ss.sss`
+     * - "s", "sec", "second", or "seconds" for seconds: `d:hh:mm:ss`
+     * - "m", "min", "minute", or "minutes" for minutes: `d:hh:mm`
+     * - "h", "hr", "hour", or "hours" for hours: `d:hh`
+     * - "d", "day", or "days" for days: `d`
+     *
+     * The maximum timestamp value is used to determine the maximum unit shown.
+     * For example, if the time unit is in seconds, and the maximum time is 90 seconds, the timestamp
+     * will be formatted as "{m:ss} (m:s)", and the day and hour segments will be omitted.
+     */
+    timeUnit: string;
+    dataType: NumberType;
+};
+export declare function defaultVolumeDims(): VolumeDims;
+export declare function volumeSize(volumeDims: VolumeDims): Vector3;
+export declare function physicalPixelSize(volumeDims: VolumeDims): Vector3;