@aics/vole-core 3.12.4

package/es/types/VolumeDrawable.d.ts

@@ -0,0 +1,108 @@
+import { Vector3, Object3D, Euler, DepthTexture, OrthographicCamera, PerspectiveCamera, WebGLRenderer, Texture } from "three";
+import { Pane } from "tweakpane";
+import Volume from "./Volume.js";
+import type { VolumeDisplayOptions, VolumeChannelDisplayOptions } from "./types.js";
+import { RenderMode } from "./types.js";
+import { Light } from "./Light.js";
+import Channel from "./Channel.js";
+import { Axis } from "./VolumeRenderSettings.js";
+type ColorArray = [number, number, number];
+type ColorObject = {
+    r: number;
+    g: number;
+    b: number;
+};
+export type WithObjectColors<T extends Record<string, any>> = {
+    [K in keyof T]: T[K] extends ColorArray | undefined ? ColorObject : T[K];
+};
+export declare const colorArrayToObject: ([r, g, b]: ColorArray) => ColorObject;
+export declare const colorObjectToArray: ({ r, g, b }: ColorObject) => ColorArray;
+export default class VolumeDrawable {
+    volume: Volume;
+    private settings;
+    private onChannelDataReadyCallback?;
+    private viewMode;
+    private channelColors;
+    private channelOptions;
+    private fusion;
+    sceneRoot: Object3D;
+    private meshVolume;
+    private volumeRendering;
+    private renderMode;
+    private renderUpdateListener?;
+    constructor(volume: Volume, options: VolumeDisplayOptions);
+    /**
+     * 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.
+     * Calls `Volume.updateRequiredData` to update the list of required channels if necessary.
+     */
+    private updateChannelDataRequired;
+    setOptions(options: VolumeDisplayOptions): void;
+    setChannelOptions(channelIndex: number, options: VolumeChannelDisplayOptions): void;
+    setRayStepSizes(primary?: number, secondary?: number): void;
+    updateScale(): void;
+    setOrthoScale(value: number): void;
+    setResolution(x: number, y: number): void;
+    setAxisClip(axis: Axis, minval: number, maxval: number, isOrthoAxis?: boolean): void;
+    private modeStringToAxis;
+    /**
+     * Sets the camera mode of the VolumeDrawable.
+     * @param mode Mode can be "3D", or "XY" or "Z", or "YZ" or "X", or "XZ" or "Y".
+     */
+    setViewMode(mode: string, volumeRenderModeHint: RenderMode.PATHTRACE | RenderMode.RAYMARCH): void;
+    setIsOrtho(isOrtho: boolean): void;
+    setInterpolationEnabled(active: boolean): void;
+    setOrthoThickness(value: number): void;
+    setGamma(gmin: number, glevel: number, gmax: number): void;
+    setFlipAxes(flipX: -1 | 1, flipY: -1 | 1, flipZ: -1 | 1): void;
+    setMaxProjectMode(isMaxProject: boolean): void;
+    onAnimate(renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture | Texture): void;
+    getViewMode(): Axis;
+    getIsovalue(channel: number): number | undefined;
+    hasIsosurface(channel: number): boolean;
+    fuse(): void;
+    setRenderUpdateListener(callback?: (iteration: number) => void): void;
+    updateShadingMethod(isbrdf: boolean): void;
+    updateMaterial(): void;
+    updateLuts(): void;
+    setVoxelSize(values: Vector3): void;
+    cleanup(): void;
+    getChannel(channelIndex: number): Channel;
+    onChannelLoaded(batch: number[]): void;
+    onChannelAdded(newChannelIndex: number): void;
+    saveChannelIsosurface(channelIndex: number, type: string): void;
+    setVolumeChannelEnabled(channelIndex: number, enabled: boolean): void;
+    isVolumeChannelEnabled(channelIndex: number): boolean;
+    updateChannelColor(channelIndex: number, colorrgb: [number, number, number]): void;
+    updateMeshColors(): void;
+    getChannelColor(channelIndex: number): [number, number, number];
+    updateChannelMaterial(channelIndex: number, colorrgb: [number, number, number], specularrgb: [number, number, number], emissivergb: [number, number, number], glossiness: number): void;
+    setDensity(density: number): void;
+    /**
+     * Get the global density of the volume data
+     */
+    getDensity(): number;
+    setBrightness(brightness: number): void;
+    getBrightness(): number;
+    setChannelAsMask(channelIndex: number): void;
+    setMaskAlpha(maskAlpha: number): void;
+    setShowBoundingBox(showBoundingBox: boolean): void;
+    setBoundingBoxColor(color: [number, number, number]): void;
+    getIntensity(c: number, x: number, y: number, z: number): number;
+    onStartControls(): void;
+    onChangeControls(): void;
+    onEndControls(): void;
+    onResetCamera(): void;
+    onCameraChanged(fov: number, focalDistance: number, apertureSize: number): void;
+    updateClipRegion(xmin: number, xmax: number, ymin: number, ymax: number, zmin: number, zmax: number): void;
+    updateLights(state: Light[]): void;
+    setPixelSamplingRate(value: number): void;
+    setVolumeRendering(newRenderMode: RenderMode): void;
+    setTranslation(xyz: Vector3): void;
+    setRotation(eulerXYZ: Euler): void;
+    setScale(xyz: Vector3): void;
+    setupGui(pane: Pane): void;
+    setZSlice(slice: number): boolean;
+    get showBoundingBox(): boolean;
+}
+export {};

package/es/types/VolumeMaker.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Basic utility functions to create sample volume data
+ * @class
+ */
+export default class VolumeMaker {
+    /**
+     * Rasterize a signed distance function into a volume of vx * vy * vz dimensions. This is a binary filling operation.
+     * @param {number} vx
+     * @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.
+     */
+    static createVolume(vx: number, vy: number, vz: number, sdFunc: (px: number, py: number, pz: number) => number): Uint8Array;
+    /**
+     * Create a volume filled with a sphere in the center
+     * @param {number} vx
+     * @param {number} vy
+     * @param {number} vz
+     * @param {number} radius
+     */
+    static createSphere(vx: number, vy: number, vz: number, radius: number): Uint8Array;
+    /**
+     * Create a volume with a cylinder centered inside.
+     * @param {number} vx
+     * @param {number} vy
+     * @param {number} vz
+     * @param {number} hx width of cap (?)
+     * @param {number} hy depth of cap (?)
+     */
+    static createCylinder(vx: number, vy: number, vz: number, hx: number, hy: number): Uint8Array;
+    /**
+     * Create a volume with a torus centered inside
+     * @param {number} vx
+     * @param {number} vy
+     * @param {number} vz
+     * @param {number} tx inner radius
+     * @param {number} ty outer radius
+     */
+    static createTorus(vx: number, vy: number, vz: number, tx: number, ty: number): Uint8Array;
+    /**
+     * Create a volume with a cone centered inside.  cx, cy must be a 2d normalized pair...?
+     * @param {number} vx
+     * @param {number} vy
+     * @param {number} vz
+     * @param {number} cx base radius
+     * @param {number} cy height
+     */
+    static createCone(vx: number, vy: number, vz: number, cx: number, cy: number): Uint8Array;
+}

package/es/types/VolumeRenderImpl.d.ts

@@ -0,0 +1,22 @@
+import { DepthTexture, Object3D, OrthographicCamera, PerspectiveCamera, Texture, WebGLRenderer } from "three";
+import { SettingsFlags, VolumeRenderSettings } from "./VolumeRenderSettings.js";
+import type { FuseChannel } from "./types.js";
+import Channel from "./Channel.js";
+export interface VolumeRenderImpl {
+    /**
+     * Applies the given VolumeRenderSettings to this volume renderer.
+     * @param settings a VolumeRenderSettings object to update values from.
+     * @param dirtyFlags bitwise flag used to mark groups of changed settings in the
+     * provided `settings` object.
+     * If unset, forces recompute of all settings-based renderer configuration.
+     * See the `SettingsFlags` enum for recognized values.
+     */
+    updateSettings: (settings: VolumeRenderSettings, dirtyFlags?: number | SettingsFlags) => void;
+    get3dObject: () => Object3D;
+    doRender: (renderer: WebGLRenderer, camera: PerspectiveCamera | OrthographicCamera, depthTexture?: DepthTexture | Texture) => void;
+    updateVolumeDimensions: () => void;
+    cleanup: () => void;
+    viewpointMoved: () => void;
+    setRenderUpdateListener: (_listener?: (iteration: number) => void) => void;
+    updateActiveChannels: (channelcolors: FuseChannel[], channeldata: Channel[]) => void;
+}

package/es/types/VolumeRenderSettings.d.ts

@@ -0,0 +1,98 @@
+import { Euler, Vector2, Vector3 } from "three";
+import Volume from "./Volume.js";
+import type { Bounds } from "./types.js";
+/**
+ * Marks groups of related settings that may have changed.
+ */
+export declare enum SettingsFlags {
+    /** parameters: translation, rotation, scale, flipAxes */
+    TRANSFORM = 1,
+    /** parameters: gammaMin, gammaLevel, gammaMax, brightness*/
+    CAMERA = 2,
+    /** parameters: showBoundingBox, boundingBoxColor */
+    BOUNDING_BOX = 4,
+    /** parameters: bounds, zSlice */
+    ROI = 8,
+    /** parameters: maskAlpha */
+    MASK_ALPHA = 16,
+    /** parameters: density, diffuse, specular, emissive, glossiness */
+    MATERIAL = 32,
+    /** parameters: resolution, useInterpolation, pixelSamplingRate, primaryRayStepSize, secondaryRayStepSize*/
+    SAMPLING = 64,
+    /** parameters: isOrtho, orthoScale, viewAxis, visible, maxProjectMode */
+    VIEW = 128,
+    /** parameters: maskChannelIndex */
+    MASK_DATA = 256,
+    ALL = 1023
+}
+export declare enum Axis {
+    X = "x",
+    Y = "y",
+    Z = "z",
+    /** Alias for NONE, indicates 3D mode */
+    XYZ = "",
+    /** No current axis, indicates 3D mode */
+    NONE = ""
+}
+/**
+ * Holds shared settings for configuring `VolumeRenderImpl` instances.
+ */
+export declare class VolumeRenderSettings {
+    translation: Vector3;
+    rotation: Euler;
+    scale: Vector3;
+    flipAxes: Vector3;
+    isOrtho: boolean;
+    orthoScale: number;
+    viewAxis: Axis;
+    visible: boolean;
+    maxProjectMode: boolean;
+    gammaMin: number;
+    gammaLevel: number;
+    gammaMax: number;
+    brightness: number;
+    maskChannelIndex: number;
+    maskAlpha: number;
+    density: number;
+    diffuse: [number, number, number][];
+    specular: [number, number, number][];
+    emissive: [number, number, number][];
+    glossiness: number[];
+    bounds: Bounds;
+    zSlice: number;
+    showBoundingBox: boolean;
+    boundingBoxColor: [number, number, number];
+    resolution: Vector2;
+    useInterpolation: boolean;
+    pixelSamplingRate: number;
+    primaryRayStepSize: number;
+    secondaryRayStepSize: number;
+    /**
+     * Creates a new VolumeRenderSettings object with default fields.
+     * @param volume Optional volume data parameter used to initialize size-dependent settings.
+     */
+    constructor(volume?: Volume);
+    resizeWithVolume(volume: Volume): void;
+    /**
+     * Recursively compares two arrays.
+     * Non-array elements are compared using strict equality comparison.
+     */
+    private static compareArray;
+    /**
+     * Compares two VolumeRenderSettings objects.
+     * @returns true if both objects have identical settings.
+     */
+    isEqual(o2: VolumeRenderSettings): boolean;
+    /**
+     * Recursively creates and returns a deep copy of an array.
+     * Note: assumes values in the array are either primitives (numbers) or arrays of primitives.
+     */
+    private static deepCopyArray;
+    /**
+     * Creates a deep copy of this VolumeRenderSettings object.
+     * @param src The object to create a clone of.
+     * @returns a new VolumeRenderSettings object with identical fields that do not
+     * share references with the original settings object.
+     */
+    clone(): VolumeRenderSettings;
+}

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

@@ -0,0 +1,4 @@
+/** Passthrough vertex shader for rendering to a buffer with a fullscreen quad */
+export declare const renderToBufferVertShader = "\nprecision highp float;\nprecision highp int;\nout vec2 vUv;\n\nvoid main() {\n  vUv = uv;\n  gl_Position = vec4(position, 1.0);\n}\n";
+/** Basic fragment shader that samples its output directly from a texture */
+export declare const copyImageFragShader = "\nprecision highp float;\nprecision highp int;\nprecision highp sampler2D;\n\nin vec2 vUv;\nuniform sampler2D image;\n\nvoid main() {\n  gl_FragColor = texture2D(image, vUv);\n}\n";

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

@@ -0,0 +1,2 @@
+export declare const defaultColors: [number, number, number][];
+export declare const getColorByChannelIndex: (index: number) => [number, number, number];

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

@@ -0,0 +1,40 @@
+import { Vector2 } from "three";
+export declare const denoiseFragmentShaderSrc: string;
+export declare const denoiseShaderUniforms: () => {
+    gInvExposure: {
+        type: string;
+        value: number;
+    };
+    gDenoiseWindowRadius: {
+        type: string;
+        value: number;
+    };
+    gDenoiseNoise: {
+        type: string;
+        value: number;
+    };
+    gDenoiseInvWindowArea: {
+        type: string;
+        value: number;
+    };
+    gDenoiseWeightThreshold: {
+        type: string;
+        value: number;
+    };
+    gDenoiseLerpThreshold: {
+        type: string;
+        value: number;
+    };
+    gDenoiseLerpC: {
+        type: string;
+        value: number;
+    };
+    gDenoisePixelSize: {
+        type: string;
+        value: Vector2;
+    };
+    tTexture0: {
+        type: string;
+        value: null;
+    };
+};

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

@@ -0,0 +1,38 @@
+declare const _default: {
+    spotlightSettings: Readonly<{
+        angle: number;
+        castShadow: false;
+        color: 16777215;
+        intensity: 0.4;
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }>;
+    ambientLightSettings: Readonly<{
+        color: 16777215;
+        intensity: 0.6;
+    }>;
+    reflectedLightSettings: Readonly<{
+        castShadow: false;
+        color: 16746666;
+        intensity: 0.2;
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }>;
+    fillLightSettings: Readonly<{
+        castShadow: false;
+        color: 15258025;
+        intensity: 0.15;
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    }>;
+};
+export default _default;

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

@@ -0,0 +1,20 @@
+import { ShaderMaterial } from "three";
+export declare const fresnelShaderSettings: {
+    bias: number;
+    power: number;
+    scale: number;
+};
+export declare const defaultMaterialSettings: {
+    shininess: number;
+    specularColor: number;
+};
+export declare const transparentMaterialSettings: {
+    shininess: number;
+    specularColor: number;
+    transparency: {
+        bias: number;
+        power: number;
+        scale: number;
+    };
+};
+export declare function createShaderMaterial(id: string): ShaderMaterial;

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

@@ -0,0 +1,11 @@
+export declare const pathtraceOutputFragmentShaderSrc: string;
+export declare const pathtraceOutputShaderUniforms: () => {
+    gInvExposure: {
+        type: string;
+        value: number;
+    };
+    tTexture0: {
+        type: string;
+        value: null;
+    };
+};

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

@@ -0,0 +1,2 @@
+declare const scaleBarSVG = "\n<svg enable-background=\"new 0 0 150 75.3\" viewBox=\"0 0 150 75.3\" xmlns=\"http://www.w3.org/2000/svg\"\n  xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n  <linearGradient id=\"a\" gradientTransform=\"matrix(1 0 0 -1 0 76)\" gradientUnits=\"userSpaceOnUse\" x1=\".3035\"\n    x2=\"149.6965\" y1=\"19.59\" y2=\"19.59\">\n    <stop offset=\"0\" stop-color=\"currentColor\" stop-opacity=\"0\" />\n    <stop offset=\".16\" stop-color=\"currentColor\" />\n    <stop offset=\".84\" stop-color=\"currentColor\" />\n    <stop offset=\"1\" stop-color=\"currentColor\" stop-opacity=\"0\" />\n  </linearGradient>\n  <g fill=\"none\">\n    <path d=\"m.5 39.1 149 34.6\" stroke=\"url(#a)\" stroke-miterlimit=\"10\" stroke-width=\"4\" />\n    <path d=\"m101.5 73.6 11-8.5\" stroke=\"currentColor\" stroke-miterlimit=\"10\" stroke-width=\"4\" />\n    <path d=\"m25.1 55.7 11-8.5\" stroke=\"currentColor\" stroke-miterlimit=\"10\" stroke-width=\"4\" />\n    <path\n      d=\"m36.2 40c0-12 5.3-12.4 10.5-14.2 5-1.7 17.3 1.9 22.6 1.7s8-5 8.4-11.8c-.4 6.9 3.4 13.8 10 16.3 8 3 17.9 2.7 23.2 7.3 7 6 3.3 12.2 1.6 19.1\"\n      stroke=\"white\" stroke-dasharray=\"2 4\" stroke-linecap=\"round\" stroke-linejoin=\"round\" stroke-width=\"3\" />\n  </g>\n</svg>\n";
+export default scaleBarSVG;

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

@@ -0,0 +1,19 @@
+export declare const enum TimeUnit {
+    MILLISECOND = 0,
+    SECOND = 1,
+    MINUTE = 2,
+    HOUR = 3,
+    DAY = 4
+}
+/**
+ * Parses an OME-compatible time unit into a TimeUnit enum.
+ * @param unit string unit
+ * @returns
+ * - `TimeUnit.MILLISECOND` if unit is "ms", "millisecond", or "milliseconds"
+ * - `TimeUnit.SECOND` if unit is "s", "sec", "second", or "seconds"
+ * - `TimeUnit.MINUTE` if unit is "m", "min", "minute", or "minutes"
+ * - `TimeUnit.HOUR` if unit is "h", "hr", "hour", or "hours"
+ * - `TimeUnit.DAY` if unit is "d", "day", or "days"
+ * - `undefined` if unit is not recognized
+ */
+export declare function parseTimeUnit(unit: string): TimeUnit | undefined;

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

@@ -0,0 +1,137 @@
+import { Texture, Vector2, Vector3, Vector4 } from "three";
+import { Light } from "../Light.js";
+export declare const pathTracingFragmentShaderSrc: string;
+export declare const pathTracingUniforms: () => {
+    tPreviousTexture: {
+        type: string;
+        value: Texture;
+    };
+    uSampleCounter: {
+        type: string;
+        value: number;
+    };
+    uFrameCounter: {
+        type: string;
+        value: number;
+    };
+    uResolution: {
+        type: string;
+        value: Vector2;
+    };
+    gClippedAaBbMin: {
+        type: string;
+        value: Vector3;
+    };
+    gClippedAaBbMax: {
+        type: string;
+        value: Vector3;
+    };
+    gVolCenter: {
+        type: string;
+        value: Vector3;
+    };
+    gDensityScale: {
+        type: string;
+        value: number;
+    };
+    gStepSize: {
+        type: string;
+        value: number;
+    };
+    gStepSizeShadow: {
+        type: string;
+        value: number;
+    };
+    gInvAaBbMax: {
+        type: string;
+        value: Vector3;
+    };
+    gNChannels: {
+        type: string;
+        value: number;
+    };
+    gShadingType: {
+        type: string;
+        value: number;
+    };
+    gGradientDeltaX: {
+        type: string;
+        value: Vector3;
+    };
+    gGradientDeltaY: {
+        type: string;
+        value: Vector3;
+    };
+    gGradientDeltaZ: {
+        type: string;
+        value: Vector3;
+    };
+    gInvGradientDelta: {
+        type: string;
+        value: number;
+    };
+    gGradientFactor: {
+        type: string;
+        value: number;
+    };
+    gCamera: {
+        value: {
+            mFrom: Vector3;
+            mU: Vector3;
+            mV: Vector3;
+            mN: Vector3;
+            mScreen: Vector4;
+            mInvScreen: Vector2;
+            mFocalDistance: number;
+            mApertureSize: number;
+            mIsOrtho: number;
+        };
+    };
+    gLights: {
+        value: Light[];
+    };
+    volumeTexture: {
+        type: string;
+        value: Texture;
+    };
+    gLutTexture: {
+        type: string;
+        value: Texture;
+    };
+    gIntensityMax: {
+        type: string;
+        value: Vector4;
+    };
+    gIntensityMin: {
+        type: string;
+        value: Vector4;
+    };
+    gOpacity: {
+        type: string;
+        value: number[];
+    };
+    gEmissive: {
+        type: string;
+        value: Vector3[];
+    };
+    gDiffuse: {
+        type: string;
+        value: Vector3[];
+    };
+    gSpecular: {
+        type: string;
+        value: Vector3[];
+    };
+    gGlossiness: {
+        type: string;
+        value: number[];
+    };
+    uShowLights: {
+        type: string;
+        value: number;
+    };
+    flipVolume: {
+        type: string;
+        value: Vector3;
+    };
+};

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

@@ -0,0 +1,117 @@
+import { Vector2, Vector3, Matrix4, Texture } from "three";
+export declare const rayMarchingVertexShaderSrc: string;
+export declare const rayMarchingFragmentShaderSrc: string;
+export declare const rayMarchingShaderUniforms: () => {
+    iResolution: {
+        type: string;
+        value: Vector2;
+    };
+    CLIP_NEAR: {
+        type: string;
+        value: number;
+    };
+    CLIP_FAR: {
+        type: string;
+        value: number;
+    };
+    maskAlpha: {
+        type: string;
+        value: number;
+    };
+    BRIGHTNESS: {
+        type: string;
+        value: number;
+    };
+    DENSITY: {
+        type: string;
+        value: number;
+    };
+    GAMMA_MIN: {
+        type: string;
+        value: number;
+    };
+    GAMMA_MAX: {
+        type: string;
+        value: number;
+    };
+    GAMMA_SCALE: {
+        type: string;
+        value: number;
+    };
+    BREAK_STEPS: {
+        type: string;
+        value: number;
+    };
+    ATLAS_DIMS: {
+        type: string;
+        value: Vector2;
+    };
+    SLICES: {
+        type: string;
+        value: number;
+    };
+    isOrtho: {
+        type: string;
+        value: number;
+    };
+    orthoThickness: {
+        type: string;
+        value: number;
+    };
+    orthoScale: {
+        type: string;
+        value: number;
+    };
+    AABB_CLIP_MIN: {
+        type: string;
+        value: Vector3;
+    };
+    AABB_CLIP_MAX: {
+        type: string;
+        value: Vector3;
+    };
+    inverseModelViewMatrix: {
+        type: string;
+        value: Matrix4;
+    };
+    inverseProjMatrix: {
+        type: string;
+        value: Matrix4;
+    };
+    textureAtlas: {
+        type: string;
+        value: Texture;
+    };
+    textureAtlasMask: {
+        type: string;
+        value: Texture;
+    };
+    textureDepth: {
+        type: string;
+        value: Texture;
+    };
+    usingPositionTexture: {
+        type: string;
+        value: number;
+    };
+    maxProject: {
+        type: string;
+        value: number;
+    };
+    interpolationEnabled: {
+        type: string;
+        value: boolean;
+    };
+    flipVolume: {
+        type: string;
+        value: Vector3;
+    };
+    volumeScale: {
+        type: string;
+        value: Vector3;
+    };
+    textureRes: {
+        type: string;
+        value: Vector2;
+    };
+};