@fideus-labs/fidnii 0.1.0

package/dist/OMEZarrNVImage.d.ts

@@ -0,0 +1,545 @@
+import { NVImage } from "@niivue/niivue";
+import type { Niivue } from "@niivue/niivue";
+import type { Multiscales, Omero } from "@fideus-labs/ngff-zarr";
+import type { ClipPlane, ClipPlanes, OMEZarrNVImageOptions, SlabBufferState, SlabSliceType, VolumeBounds } from "./types.js";
+import { OMEZarrNVImageEventListener, OMEZarrNVImageEventListenerOptions, OMEZarrNVImageEventMap, PopulateTrigger } from "./events.js";
+/**
+ * OMEZarrNVImage extends NVImage to support rendering OME-Zarr images in NiiVue.
+ *
+ * Features:
+ * - Progressive loading: quick preview from lowest resolution, then target resolution
+ * - Arbitrary clip planes defined by point + normal (up to 6)
+ * - Dynamic buffer sizing to match fetched data exactly (no upsampling)
+ * - Request coalescing for efficient chunk fetching
+ * - Automatic metadata updates to reflect OME-Zarr coordinate transforms
+ */
+export declare class OMEZarrNVImage extends NVImage {
+    /** The OME-Zarr multiscales data */
+    readonly multiscales: Multiscales;
+    /** Maximum number of pixels to use */
+    readonly maxPixels: number;
+    /** Reference to NiiVue instance */
+    private readonly niivue;
+    /** Buffer manager for dynamically-sized pixel data */
+    private readonly bufferManager;
+    /** Region coalescer for efficient chunk fetching */
+    private readonly coalescer;
+    /** Decoded-chunk cache shared across 3D and 2D slab loads. */
+    private readonly _chunkCache;
+    /** Current clip planes in world space */
+    private _clipPlanes;
+    /** Target resolution level index (based on maxPixels) */
+    private targetLevelIndex;
+    /** Current resolution level index during progressive loading */
+    private currentLevelIndex;
+    /** True if currently loading data */
+    private isLoading;
+    /** Data type of the volume */
+    private readonly dtype;
+    /** Full volume bounds in world space */
+    private readonly _volumeBounds;
+    /** Current buffer bounds in world space (may differ from full volume when clipped) */
+    private _currentBufferBounds;
+    /** Previous clip plane change handler (to restore later) */
+    private previousOnClipPlaneChange?;
+    /** Debounce delay for clip plane updates (ms) */
+    private readonly clipPlaneDebounceMs;
+    /** Timeout handle for debounced clip plane refetch */
+    private clipPlaneRefetchTimeout;
+    /** Previous clip planes state for direction comparison */
+    private _previousClipPlanes;
+    /** Previous pixel count at current resolution (for direction comparison) */
+    private _previousPixelCount;
+    /** Cached/computed OMERO metadata for visualization (cal_min/cal_max) */
+    private _omero;
+    /** Active channel index for OMERO window selection (default: 0) */
+    private _activeChannel;
+    /** Resolution level at which OMERO was last computed (to track recomputation) */
+    private _omeroComputedForLevel;
+    /** Internal EventTarget for event dispatching (composition pattern) */
+    private readonly _eventTarget;
+    /** Pending populate request (latest wins - replaces any previous pending) */
+    private _pendingPopulateRequest;
+    /** Current populate trigger (set at start of populateVolume, used by events) */
+    private _currentPopulateTrigger;
+    /** Attached Niivue instances and their state */
+    private _attachedNiivues;
+    /** Per-slice-type slab buffers (lazily created) */
+    private _slabBuffers;
+    /** Debounce timeout for slab reload per slice type */
+    private _slabReloadTimeouts;
+    /** Whether viewport-aware resolution selection is enabled */
+    private _viewportAwareEnabled;
+    /**
+     * Viewport bounds for the 3D render volume (union of all RENDER/MULTIPLANAR NVs).
+     * Null = full volume, no viewport constraint.
+     */
+    private _viewportBounds3D;
+    /**
+     * Per-slab viewport bounds (from the NV instance that displays each slab).
+     * Null entry = full volume, no viewport constraint for that slab.
+     */
+    private _viewportBoundsPerSlab;
+    /** Timeout handle for debounced viewport update */
+    private _viewportUpdateTimeout;
+    /** Per-slab AbortController to cancel in-flight progressive loads */
+    private _slabAbortControllers;
+    /** Maximum 3D render zoom level for scroll-wheel zoom */
+    private readonly _max3DZoom;
+    /** Minimum 3D render zoom level for scroll-wheel zoom */
+    private readonly _min3DZoom;
+    /**
+     * Debounce delay for viewport-aware reloads (ms).
+     * Higher than clip plane debounce to avoid excessive reloads during
+     * continuous zoom/pan interactions.
+     */
+    private static readonly VIEWPORT_DEBOUNCE_MS;
+    /**
+     * Private constructor. Use OMEZarrNVImage.create() for instantiation.
+     */
+    private constructor();
+    /**
+     * Create a new OMEZarrNVImage instance.
+     *
+     * By default, the image is automatically added to NiiVue and progressive
+     * loading starts immediately (fire-and-forget). This enables progressive
+     * rendering where each resolution level is displayed as it loads.
+     *
+     * Set `autoLoad: false` for manual control over when loading starts.
+     * Listen to 'populateComplete' event to know when loading finishes.
+     *
+     * @param options - Options including multiscales, niivue reference, and optional maxPixels
+     * @returns Promise resolving to the OMEZarrNVImage instance
+     */
+    static create(options: OMEZarrNVImageOptions): Promise<OMEZarrNVImage>;
+    /**
+     * Initialize NVImage properties with placeholder values.
+     * Actual values will be set by loadResolutionLevel() after first data fetch.
+     */
+    private initializeNVImageProperties;
+    /**
+     * Populate the volume with data.
+     *
+     * Loading strategy:
+     * 1. Load lowest resolution first for quick preview (unless skipPreview is true)
+     * 2. Jump directly to target resolution (skip intermediate levels)
+     *
+     * If called while already loading, the request is queued. Only the latest
+     * queued request is kept (latest wins). When a queued request is replaced,
+     * a `loadingSkipped` event is emitted.
+     *
+     * @param skipPreview - If true, skip the preview load (used for clip plane updates)
+     * @param trigger - What triggered this population (default: 'initial')
+     */
+    populateVolume(skipPreview?: boolean, trigger?: PopulateTrigger): Promise<void>;
+    /**
+     * Process any pending populate request after current load completes.
+     * If no pending request, emits populateComplete.
+     */
+    private handlePendingPopulateRequest;
+    /**
+     * Load data at a specific resolution level.
+     *
+     * With dynamic buffer sizing:
+     * 1. Fetch data for the aligned region
+     * 2. Resize buffer to match fetched data exactly (no upsampling)
+     * 3. Update header with correct dimensions and voxel sizes
+     * 4. Refresh NiiVue
+     *
+     * @param levelIndex - Resolution level index
+     * @param requesterId - ID for request coalescing
+     */
+    private loadResolutionLevel;
+    /**
+     * Update NVImage header for a loaded region.
+     *
+     * With dynamic buffer sizing, the buffer dimensions equal the fetched dimensions.
+     * We set pixDims directly from the resolution level's voxel size (no upsampling correction).
+     * The affine translation is adjusted to account for the region offset.
+     *
+     * @param ngffImage - The NgffImage at the current resolution level
+     * @param region - The chunk-aligned region that was loaded
+     * @param fetchedShape - The shape of the fetched data [z, y, x]
+     */
+    private updateHeaderForRegion;
+    /**
+     * Update NiiVue clip planes from current _clipPlanes.
+     *
+     * Clip planes are converted relative to the CURRENT BUFFER bounds,
+     * not the full volume bounds. This is because NiiVue's shader works
+     * in texture coordinates of the currently loaded data.
+     */
+    private updateNiivueClipPlanes;
+    /**
+     * Apply OMERO window settings to NIfTI header cal_min/cal_max.
+     *
+     * Uses the active channel's window (start/end preferred over min/max).
+     * This sets the display intensity range for NiiVue rendering.
+     */
+    private applyOmeroToHeader;
+    /**
+     * Ensure OMERO metadata is available and applied.
+     *
+     * Strategy:
+     * - If OMERO exists in file metadata, use it (first time only)
+     * - If NOT present, compute dynamically:
+     *   - Compute at preview (lowest) resolution for quick initial display
+     *   - Recompute at target resolution for more accurate values
+     *   - Keep target values for consistency on subsequent clip plane changes
+     *
+     * @param ngffImage - The NgffImage at the current resolution level
+     * @param levelIndex - The resolution level index
+     */
+    private ensureOmeroMetadata;
+    /**
+     * Handle clip plane change from NiiVue.
+     * This is called when the user interacts with clip planes in NiiVue.
+     */
+    private onNiivueClipPlaneChange;
+    /**
+     * Set clip planes.
+     *
+     * Visual clipping is updated immediately for responsive feedback.
+     * Data refetch is debounced to avoid excessive reloading during slider interaction.
+     * Resolution changes are direction-aware: reducing volume may increase resolution,
+     * increasing volume may decrease resolution.
+     *
+     * @param planes - Array of clip planes (max 6). Empty array = full volume visible.
+     * @throws Error if more than 6 planes provided or if planes are invalid
+     */
+    setClipPlanes(planes: ClipPlanes): void;
+    /**
+     * Handle clip plane update after debounce delay.
+     * Implements direction-aware resolution selection.
+     *
+     * Only triggers a refetch when the resolution level needs to change.
+     * Visual clipping is handled by NiiVue clip planes (updated immediately in setClipPlanes).
+     */
+    private handleDebouncedClipPlaneUpdate;
+    /**
+     * Calculate pixel count for a chunk-aligned region.
+     */
+    private calculateAlignedPixelCount;
+    /**
+     * Create a deep copy of clip planes array.
+     */
+    private copyClipPlanes;
+    /**
+     * Get current clip planes.
+     *
+     * @returns Copy of current clip planes array
+     */
+    getClipPlanes(): ClipPlanes;
+    /**
+     * Add a single clip plane.
+     *
+     * @param plane - Clip plane to add
+     * @throws Error if already at maximum (6) clip planes
+     */
+    addClipPlane(plane: ClipPlane): void;
+    /**
+     * Remove a clip plane by index.
+     *
+     * @param index - Index of plane to remove
+     * @throws Error if index is out of bounds
+     */
+    removeClipPlane(index: number): void;
+    /**
+     * Clear all clip planes (show full volume).
+     */
+    clearClipPlanes(): void;
+    /**
+     * Get the current resolution level index.
+     */
+    getCurrentLevelIndex(): number;
+    /**
+     * Get the target resolution level index.
+     */
+    getTargetLevelIndex(): number;
+    /**
+     * Get the number of resolution levels.
+     */
+    getNumLevels(): number;
+    /**
+     * Get the volume bounds in world space.
+     */
+    getVolumeBounds(): VolumeBounds;
+    /**
+     * Enable or disable viewport-aware resolution selection.
+     *
+     * When enabled, pan/zoom/rotation interactions are monitored and the fetch
+     * region is constrained to the visible viewport area. This allows higher
+     * resolution within the same `maxPixels` budget when zoomed in.
+     *
+     * @param enabled - Whether to enable viewport-aware resolution
+     */
+    setViewportAware(enabled: boolean): void;
+    /**
+     * Get whether viewport-aware resolution selection is enabled.
+     */
+    get viewportAware(): boolean;
+    /**
+     * Get the current 3D viewport bounds (null if viewport-aware is disabled
+     * or no viewport constraint is active).
+     */
+    getViewportBounds(): VolumeBounds | null;
+    /**
+     * Hook viewport events (onMouseUp, onZoom3DChange, wheel) on a NV instance.
+     */
+    private _hookViewportEvents;
+    /**
+     * Unhook viewport events from a NV instance.
+     */
+    private _unhookViewportEvents;
+    /**
+     * Install a capturing-phase wheel listener on the NV canvas that overrides
+     * NiiVue's hardcoded 3D render zoom clamp ([0.5, 2.0]).
+     *
+     * The listener intercepts scroll events over 3D render tiles and applies
+     * zoom via `nv.setScale()` (which has no internal clamp), using the
+     * configurable `_min3DZoom` / `_max3DZoom` bounds instead.
+     *
+     * Clip-plane scrolling is preserved: when a clip plane is active
+     * (depth < 1.8), the event passes through to NiiVue's native handler.
+     */
+    private _hookZoomOverride;
+    /**
+     * Remove the 3D zoom override wheel listener from a NV instance.
+     */
+    private _unhookZoomOverride;
+    /**
+     * Called at the end of any viewport interaction (mouse up, touch end,
+     * zoom change, scroll wheel). Debounces the viewport bounds recomputation.
+     */
+    private _handleViewportInteractionEnd;
+    /**
+     * Recompute viewport bounds from all attached NV instances and trigger
+     * resolution reselection if bounds changed significantly.
+     */
+    private _recomputeViewportBounds;
+    /**
+     * Reload all active slabs (for all slice types that have buffers).
+     */
+    private _reloadAllSlabs;
+    /**
+     * Get whether the image is currently loading.
+     */
+    getIsLoading(): boolean;
+    /**
+     * Wait for all pending fetches to complete.
+     */
+    waitForIdle(): Promise<void>;
+    /**
+     * Get OMERO metadata (if available).
+     *
+     * Returns the existing OMERO metadata from the OME-Zarr file,
+     * or the computed OMERO metadata if none was present in the file.
+     *
+     * OMERO metadata includes per-channel visualization parameters:
+     * - window.min/max: The actual data range
+     * - window.start/end: The display window (based on quantiles)
+     * - color: Hex color for the channel
+     * - label: Channel name
+     *
+     * @returns OMERO metadata or undefined if not yet loaded/computed
+     */
+    getOmero(): Omero | undefined;
+    /**
+     * Get the active channel index used for OMERO window selection.
+     *
+     * For multi-channel images, this determines which channel's
+     * cal_min/cal_max values are applied to the NiiVue display.
+     *
+     * @returns Current active channel index (0-based)
+     */
+    getActiveChannel(): number;
+    /**
+     * Set the active channel for OMERO window selection.
+     *
+     * For multi-channel images, this determines which channel's
+     * window (cal_min/cal_max) values are applied to the NiiVue display.
+     *
+     * Changing the active channel immediately updates the display intensity
+     * range and refreshes the NiiVue rendering.
+     *
+     * @param index - Channel index (0-based)
+     * @throws Error if no OMERO metadata is available
+     * @throws Error if index is out of range
+     *
+     * @example
+     * ```typescript
+     * // Get number of channels
+     * const omero = image.getOmero();
+     * if (omero) {
+     *   console.log(`${omero.channels.length} channels available`);
+     *   // Switch to channel 1
+     *   image.setActiveChannel(1);
+     * }
+     * ```
+     */
+    setActiveChannel(index: number): void;
+    /**
+     * Attach a Niivue instance for slice-type-aware rendering.
+     *
+     * The image auto-detects the NV's current slice type and hooks into
+     * `onOptsChange` to track mode changes and `onLocationChange` to track
+     * crosshair/slice position changes.
+     *
+     * When the NV is in a 2D slice mode (Axial, Coronal, Sagittal), the image
+     * loads a slab (one chunk thick in the orthogonal direction) at the current
+     * slice position, using a 2D pixel budget for resolution selection.
+     *
+     * @param nv - The Niivue instance to attach
+     */
+    attachNiivue(nv: Niivue): void;
+    /**
+     * Detach a Niivue instance, restoring its original callbacks.
+     *
+     * @param nv - The Niivue instance to detach
+     */
+    detachNiivue(nv: Niivue): void;
+    /**
+     * Get the slab buffer state for a given slice type, if it exists.
+     * Useful for testing and inspection.
+     *
+     * @param sliceType - The slice type to query
+     * @returns The slab buffer state, or undefined if not yet created
+     */
+    getSlabBufferState(sliceType: SlabSliceType): SlabBufferState | undefined;
+    /**
+     * Get all attached Niivue instances.
+     */
+    getAttachedNiivues(): Niivue[];
+    /**
+     * Detect the current slice type of a Niivue instance.
+     */
+    private _detectSliceType;
+    /**
+     * Check if a slice type is one of the 2D slab types.
+     */
+    private _isSlabSliceType;
+    /**
+     * Get the orthogonal axis index for a slab slice type.
+     * Returns index in [z, y, x] order:
+     * - Axial: slicing through Z → orthogonal axis = 0 (Z)
+     * - Coronal: slicing through Y → orthogonal axis = 1 (Y)
+     * - Sagittal: slicing through X → orthogonal axis = 2 (X)
+     */
+    private _getOrthogonalAxis;
+    /**
+     * Handle a slice type change on an attached Niivue instance.
+     */
+    private _handleSliceTypeChange;
+    /**
+     * Handle location (crosshair) change on an attached Niivue instance.
+     * Checks if the current slice position has moved outside the loaded slab.
+     */
+    private _handleLocationChange;
+    /**
+     * Debounced slab reload to avoid excessive reloading during scrolling.
+     */
+    private _debouncedSlabReload;
+    /**
+     * Ensure a slab buffer exists and is loaded for the given NV + slice type.
+     * If needed, creates the slab buffer and triggers an initial load.
+     */
+    private _ensureSlabForNiivue;
+    /**
+     * Create a new slab buffer state for a slice type.
+     */
+    private _createSlabBuffer;
+    /**
+     * Swap the NVImage in a Niivue instance's volume list.
+     * Removes any existing volumes from this OMEZarrNVImage and adds the target.
+     */
+    private _swapVolumeInNiivue;
+    /**
+     * Load a slab for a 2D slice type at the given world position.
+     *
+     * The slab is one chunk thick in the orthogonal direction and uses
+     * the full in-plane extent (respecting clip planes).
+     *
+     * Loading follows a progressive strategy: preview (lowest res) then target.
+     * For viewport-triggered reloads, progressive rendering is skipped and
+     * only the target level is loaded (the user already sees the previous
+     * resolution, so a single jump is smoother).
+     *
+     * If a load is already in progress, the request is queued (latest-wins)
+     * and automatically drained when the current load finishes.
+     */
+    private _loadSlab;
+    /**
+     * Process any pending slab reload request after the current load completes.
+     * Mirrors populateVolume's handlePendingPopulateRequest pattern.
+     */
+    private _handlePendingSlabReload;
+    /**
+     * Load slab data at a specific resolution level.
+     */
+    private _loadSlabAtLevel;
+    /**
+     * Update NVImage header for a slab region.
+     */
+    private _updateSlabHeader;
+    /**
+     * Apply OMERO metadata to a slab NVImage header.
+     */
+    private _applyOmeroToSlabHeader;
+    /**
+     * Widen the display intensity range if the actual data exceeds the current
+     * cal_min/cal_max window (typically set from OMERO metadata).
+     *
+     * OMERO window settings may have been computed at a lower resolution where
+     * downsampling averaged out extreme voxels. At higher resolutions, individual
+     * bright/dark voxels can exceed the OMERO range, causing clipping artifacts
+     * (e.g., "banding" where bright structures clip to solid white).
+     *
+     * Widens cal_min/cal_max to global_min/global_max (actual data extremes at
+     * the current resolution level) so no data is clipped. The hdr.cal_min/
+     * cal_max values are NOT modified — they preserve the original OMERO values
+     * for reuse on subsequent slab reloads.
+     *
+     * Must be called AFTER updateGLVolume() so that calMinMax() has computed
+     * global_min/global_max from the actual slab data.
+     *
+     * @returns true if the display range was widened
+     */
+    private _widenCalRangeIfNeeded;
+    /**
+     * Add a type-safe event listener for OMEZarrNVImage events.
+     *
+     * @param type - Event type name
+     * @param listener - Event listener function
+     * @param options - Standard addEventListener options (once, signal, etc.)
+     *
+     * @example
+     * ```typescript
+     * image.addEventListener('resolutionChange', (event) => {
+     *   console.log('New level:', event.detail.currentLevel);
+     * });
+     *
+     * // One-time listener
+     * image.addEventListener('loadingComplete', handler, { once: true });
+     *
+     * // With AbortController
+     * const controller = new AbortController();
+     * image.addEventListener('loadingStart', handler, { signal: controller.signal });
+     * controller.abort(); // removes the listener
+     * ```
+     */
+    addEventListener<K extends keyof OMEZarrNVImageEventMap>(type: K, listener: OMEZarrNVImageEventListener<K>, options?: OMEZarrNVImageEventListenerOptions): void;
+    /**
+     * Remove a type-safe event listener for OMEZarrNVImage events.
+     *
+     * @param type - Event type name
+     * @param listener - Event listener function to remove
+     * @param options - Standard removeEventListener options
+     */
+    removeEventListener<K extends keyof OMEZarrNVImageEventMap>(type: K, listener: OMEZarrNVImageEventListener<K>, options?: OMEZarrNVImageEventListenerOptions): void;
+    /**
+     * Internal helper to emit events.
+     * Catches and logs any errors from event listeners to prevent breaking execution.
+     */
+    private _emitEvent;
+}
+//# sourceMappingURL=OMEZarrNVImage.d.ts.map

package/dist/OMEZarrNVImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OMEZarrNVImage.d.ts","sourceRoot":"","sources":["../src/OMEZarrNVImage.ts"],"names":[],"mappings":"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"}