copper3d 3.0.1 → 3.1.0

package/dist/types/Utils/segmentation/NrrdTools.d.ts

@@ -1,12 +1,21 @@
 import { nrrdSliceType, storeExportPaintImageType, loadingBarType } from "../../types/types";
 import { GUI } from "dat.gui";
-import { IMaskData, IDragOpts, IGuiParameterSettings, IKeyBoardSettings } from "./coreTools/coreType";
+import { IMaskData, IDragOpts, IKeyBoardSettings, ToolMode, IGuiMeta } from "./core/types";
 import { DragOperator } from "./DragOperator";
-import { DrawToolCore } from "./DrawToolCore";
 import type { ChannelValue, RGBAColor, ChannelColorMap } from "./core";
+import type { SphereType } from "./tools/SphereTool";
 /**
  * Core NRRD annotation tool for medical image segmentation.
  *
+ * Acts as a **Facade** that delegates to composed modules:
+ * - {@link CanvasState} — pure state container
+ * - {@link DrawToolCore} — tool orchestration, event routing
+ * - {@link LayerChannelManager} — layer/channel/sphere-type management
+ * - {@link SliceRenderPipeline} — slice rendering, canvas flip, mask reload
+ * - {@link DataLoader} — NRRD slice loading, legacy mask loading, NIfTI loading
+ *
+ * No longer extends DrawToolCore — uses composition instead.
+ *
  * @example
  * ```ts
  * // Default 3 layers: layer1, layer2, layer3
@@ -16,418 +25,173 @@ import type { ChannelValue, RGBAColor, ChannelColorMap } from "./core";
  * const tools = new NrrdTools(container, { layers: ["layer1", "layer2"] });
  * ```
  */
-export declare class NrrdTools extends DrawToolCore {
+export declare class NrrdTools {
     container: HTMLDivElement;
+    /** Shared state container. */
+    private state;
+    /** Core drawing tool orchestrator. */
+    private drawCore;
+    /** Drag operator for slice navigation. */
     dragOperator: DragOperator;
-    private paintedImage;
-    private initState;
     private preTimer;
     private guiParameterSettings;
     private _sliceRAFId;
     private _pendingSliceStep;
+    /** Whether calculator mode is active (not part of gui_states interface) */
+    private _calculatorActive;
+    /** Layer/channel management (extracted module) */
+    private layerChannelManager;
+    /** Slice rendering pipeline (extracted module) */
+    private sliceRenderPipeline;
+    /** Data loading (extracted module) */
+    private dataLoader;
+    /** Stored closure callbacks from gui.ts setupGui() */
+    private guiCallbacks;
     constructor(container: HTMLDivElement, options?: {
         layers?: string[];
     });
     /**
-     * core function for drag slices
-     * @param opts
+     * Wire DrawToolCore's overridable methods to NrrdTools implementations.
+     * This replaces the old inheritance approach.
      */
-    drag(opts?: IDragOpts): void;
+    private wireDrawCoreMethods;
     /**
-     * Set the Draw Display Canvas base size
-     * @param size number
-     */
-    setBaseDrawDisplayCanvasesSize(size: number): void;
-    setDisplaySliceIndexPanel(panel: HTMLDivElement): void;
-    /**
-     * Enable the drag function for contrast images window center and window high.
-     * @param callback
+     * A initialise function for nrrd_tools
      */
-    enableContrastDragEvents(callback: (step: number, towards: "horizental" | "vertical") => void): void;
+    private init;
+    private initNrrdToolsModules;
     /**
      * Set up GUI for drawing panel
      * @param gui GUI
      */
     setupGUI(gui: GUI): void;
-    getGuiSettings(): {
-        guiState: import("./coreTools/coreType").IGUIStates;
-        guiSetting: IGuiParameterSettings | undefined;
-    };
-    /**
-     * Set the active layer and update fillColor/brushColor to match the active channel.
-     */
-    setActiveLayer(layerId: string): void;
-    /**
-     * Set the active channel (1-8) and update fillColor/brushColor.
-     */
-    setActiveChannel(channel: ChannelValue): void;
-    /**
-     * Sync brush/fill color from the active layer's volume color map.
-     * Falls back to global CHANNEL_HEX_COLORS if volume not available.
-     */
-    private syncBrushColor;
-    /**
-     * Get the currently active layer id.
-     */
-    getActiveLayer(): string;
-    /**
-     * Get the currently active channel value.
-     */
-    getActiveChannel(): number;
-    /**
-     * Set visibility of a layer and re-render.
-     */
-    setLayerVisible(layerId: string, visible: boolean): void;
-    /**
-     * Check if a layer is visible.
-     */
-    isLayerVisible(layerId: string): boolean;
-    /**
-     * Set visibility of a specific channel within a layer and re-render.
-     */
-    setChannelVisible(layerId: string, channel: ChannelValue, visible: boolean): void;
-    /**
-     * Check if a specific channel within a layer is visible.
-     */
-    isChannelVisible(layerId: string, channel: ChannelValue): boolean;
-    /**
-     * Get the full layer visibility map.
-     */
-    getLayerVisibility(): Record<string, boolean>;
     /**
-     * Get the full channel visibility map.
-     */
-    getChannelVisibility(): Record<string, Record<number, boolean>>;
-    /**
-     * Check if a specific layer contains any non-zero mask data.
-     *
-     * This is useful for determining if a layer has actual annotations
-     * before saving or exporting to avoid processing empty layers.
-     *
-     * @param layerId - The layer to check ('layer1', 'layer2', or 'layer3')
-     * @returns True if the layer has any non-zero voxel data, false if empty
-     *
-     * @example
-     * ```ts
-     * if (nrrdTools.hasLayerData('layer1')) {
-     *   await useSaveMasks(caseId, 'layer1');
-     * }
-     * ```
-     */
-    hasLayerData(layerId: string): boolean;
-    /**
-     * Set a custom color for a specific channel in a specific layer.
-     * Only affects this layer; other layers remain unchanged.
-     *
-     * @param layerId  Layer to customize (e.g. 'layer1', 'layer2')
-     * @param channel  Channel label (1-8)
-     * @param color    RGBAColor object { r, g, b, a } (each 0-255)
-     *
-     * @example
-     * ```ts
-     * // Make channel 2 in layer2 orange
-     * nrrdTools.setChannelColor('layer2', 2, { r: 255, g: 128, b: 0, a: 255 });
-     * ```
-     */
-    setChannelColor(layerId: string, channel: number, color: RGBAColor): void;
-    /**
-     * Get the current color for a specific channel in a specific layer.
-     *
-     * @param layerId  Layer to query
-     * @param channel  Channel label (1-8)
-     * @returns RGBAColor object (copy, safe to mutate)
-     */
-    getChannelColor(layerId: string, channel: number): RGBAColor;
-    /**
-     * Get a hex color string for a channel in a layer (e.g. '#ff8000').
-     */
-    getChannelHexColor(layerId: string, channel: number): string;
-    /**
-     * Get a CSS rgba() color string for a channel in a layer.
-     */
-    getChannelCssColor(layerId: string, channel: number): string;
-    /**
-     * Batch-set multiple channel colors for a single layer (single re-render).
-     *
-     * @param layerId  Layer to customize
-     * @param colorMap Partial map of channel -> RGBAColor
-     *
-     * @example
-     * ```ts
-     * nrrdTools.setChannelColors('layer2', {
-     *   2: { r: 255, g: 128, b: 0, a: 255 },
-     *   3: { r: 100, g: 200, b: 50, a: 255 },
-     * });
-     * ```
-     */
-    setChannelColors(layerId: string, colorMap: Partial<ChannelColorMap>): void;
-    /**
-     * Set the same color for a specific channel across ALL layers (single re-render).
-     *
-     * @param channel  Channel label (1-8)
-     * @param color    RGBAColor object
-     */
-    setAllLayersChannelColor(channel: number, color: RGBAColor): void;
-    /**
-     * Reset channel colors to system defaults.
-     *
-     * @param layerId  Optional. If omitted, resets all layers.
-     * @param channel  Optional. If omitted, resets all channels in the layer(s).
-     *
-     * @example
-     * ```ts
-     * nrrdTools.resetChannelColors('layer2', 2);  // Reset only ch2 in layer2
-     * nrrdTools.resetChannelColors('layer2');       // Reset all channels in layer2
-     * nrrdTools.resetChannelColors();               // Reset all layers
-     * ```
-     */
-    resetChannelColors(layerId?: string, channel?: number): void;
-    /**
-     * Programmatically trigger an undo operation.
-     *
-     * Equivalent to pressing Ctrl+Z. Reverts the most recent drawing stroke
-     * on the currently active layer and syncs the result to the backend via
-     * the `getMask` callback.
-     *
-     * @example
-     * ```ts
-     * undoBtn.addEventListener('click', () => nrrdTools.undo());
-     * ```
-     */
+     * Sync guiParameterSettings with current volume metadata.
+     */
+    private syncGuiParameterSettings;
+    /**
+     * Set the current tool mode.
+     */
+    setMode(mode: ToolMode): void;
+    getMode(): ToolMode;
+    isCalculatorActive(): boolean;
+    setOpacity(value: number): void;
+    getOpacity(): number;
+    setBrushSize(size: number): void;
+    getBrushSize(): number;
+    setWindowHigh(value: number): void;
+    setWindowLow(value: number): void;
+    finishWindowAdjustment(): void;
+    adjustContrast(type: "windowHigh" | "windowLow", delta: number): void;
+    getSliderMeta(key: string): IGuiMeta | null;
+    setPencilColor(hex: string): void;
+    getPencilColor(): string;
+    executeAction(action: "undo" | "redo" | "clearActiveSliceMask" | "clearActiveLayerMask" | "resetZoom" | "downloadCurrentMask"): void;
     undo(): void;
-    /**
-     * Programmatically trigger a redo operation.
-     *
-     * Equivalent to pressing Ctrl+Y. Re-applies the most recently undone
-     * drawing stroke on the currently active layer and syncs the result to
-     * the backend via the `getMask` callback.
-     *
-     * @example
-     * ```ts
-     * redoBtn.addEventListener('click', () => nrrdTools.redo());
-     * ```
-     */
     redo(): void;
-    /**
-     * Enter keyboard-configuration mode.
-     *
-     * While active, every keydown/keyup handler in DrawToolCore and DragOperator
-     * is suppressed so the user can press arbitrary keys in the settings dialog
-     * without accidentally triggering drawing, undo, or contrast shortcuts.
-     *
-     * Always pair with {@link exitKeyboardConfig} when the dialog closes.
-     *
-     * @example
-     * ```ts
-     * dialog.addEventListener('open', () => nrrdTools.enterKeyboardConfig());
-     * ```
-     */
     enterKeyboardConfig(): void;
-    /**
-     * Exit keyboard-configuration mode and resume normal shortcut handling.
-     *
-     * @example
-     * ```ts
-     * dialog.addEventListener('close', () => nrrdTools.exitKeyboardConfig());
-     * ```
-     */
     exitKeyboardConfig(): void;
-    /**
-     * Enable or disable the contrast window/level shortcut (Ctrl/Meta key).
-     *
-     * When disabled:
-     * - Holding Ctrl no longer enters contrast mode
-     * - If contrast mode is currently active it is immediately exited
-     * - All other Ctrl-based shortcuts (Ctrl+Z undo, Ctrl+Y redo) are
-     *   unaffected because they are checked in the keydown handler before
-     *   the contrast guard runs
-     *
-     * @param enabled - Pass `false` to disable, `true` to re-enable.
-     *
-     * @example
-     * ```ts
-     * // Disable contrast when sphere tool is active
-     * nrrdTools.setContrastShortcutEnabled(false);
-     *
-     * // Re-enable when returning to draw mode
-     * nrrdTools.setContrastShortcutEnabled(true);
-     * ```
-     */
     setContrastShortcutEnabled(enabled: boolean): void;
-    /**
-     * Returns whether the contrast shortcut is currently enabled.
-     */
     isContrastShortcutEnabled(): boolean;
-    /**
-     * Update keyboard shortcut bindings.
-     *
-     * Synchronises both the internal class field (read by every keydown handler)
-     * and the EventRouter's internal copy (used for modifier-key mode tracking)
-     * so the two never drift apart.  If `mouseWheel` is changed the wheel event
-     * listener is automatically re-bound via {@link updateMouseWheelEvent}.
-     *
-     * Only the fields you supply are updated; omitted fields keep their
-     * current values.
-     *
-     * @param settings - Partial keyboard settings to override.
-     *
-     * @example
-     * ```ts
-     * nrrdTools.setKeyboardSettings({
-     *   undo: 'z',
-     *   redo: 'y',
-     *   crosshair: 'c',
-     *   mouseWheel: 'Scroll:Slice',
-     * });
-     * ```
-     */
     setKeyboardSettings(settings: Partial<IKeyBoardSettings>): void;
-    /**
-     * Get a snapshot of the current keyboard shortcut bindings.
-     *
-     * Returns a shallow copy so callers cannot accidentally mutate internal
-     * state. To update settings use {@link setKeyboardSettings} instead.
-     *
-     * @returns Current keyboard settings.
-     *
-     * @example
-     * ```ts
-     * const { undo, redo } = nrrdTools.getKeyboardSettings();
-     * console.log(`Undo: Ctrl+${undo}, Redo: Ctrl+${redo}`);
-     * ```
-     */
     getKeyboardSettings(): IKeyBoardSettings;
+    drag(opts?: IDragOpts): void;
     /**
-     * A initialise function for nrrd_tools
-     */
-    private init;
-    /**
-     *
-     * entry function
-     *   * {
-     *    x:slice,
-     *    y:slice,
-     *    z:slice
-     * }
-     *
-     * @param allSlices - all nrrd contrast slices
-   
+     * Core drawing entry point.
      */
-    setAllSlices(allSlices: Array<nrrdSliceType>): void;
-    private loadingMaskByLayer;
-    setMasksData(masksData: storeExportPaintImageType, loadingBar?: loadingBarType): void;
+    draw(opts?: any): void;
     /**
-     * Load raw voxel data into MaskVolume layers.
-     *
-     * Expects pre-extracted voxel bytes (e.g. from useNiftiVoxelData).
-     *
-     * @param layerVoxels Map of layer ID to raw voxel Uint8Array
-     *   Keys should be 'layer1', 'layer2', 'layer3'
-     * @param loadingBar Optional loading bar UI
+     * Set the Draw Display Canvas base size
      */
-    setMasksFromNIfTI(layerVoxels: Map<string, Uint8Array>, loadingBar?: loadingBarType): void;
-    private setShowInMainArea;
-    getCurrentImageDimension(): number[];
-    getVoxelSpacing(): number[];
-    getSpaceOrigin(): number[];
-    getMaskData(): IMaskData;
-    setCalculateDistanceSphere(x: number, y: number, sliceIndex: number, cal_position: "tumour" | "skin" | "nipple" | "ribcage"): void;
+    setBaseDrawDisplayCanvasesSize(size: number): void;
+    setDisplaySliceIndexPanel(panel: HTMLDivElement): void;
+    enableContrastDragEvents(callback: (step: number, towards: "horizental" | "vertical") => void): void;
+    setEraserUrls(urls: string[]): void;
+    setPencilIconUrls(urls: string[]): void;
     /**
      * Switch all contrast slices' orientation
-     * @param {string} aixs:"x" | "y" | "z"
-     *  */
+     */
     setSliceOrientation(axisTo: "x" | "y" | "z"): void;
     addSkip(index: number): void;
     removeSkip(index: number): void;
-    clear(): void;
     setSliceMoving(step: number): void;
     setMainAreaSize(factor: number): void;
+    switchAllSlicesArrayData(allSlices: Array<nrrdSliceType>): void;
+    appendLoadingbar(loadingbar: HTMLDivElement): void;
+    getCurrentImageDimension(): number[];
+    getVoxelSpacing(): number[];
+    getSpaceOrigin(): number[];
+    getMaskData(): IMaskData;
     getContainer(): HTMLElement;
     getDrawingCanvas(): HTMLCanvasElement;
-    getNrrdToolsSettings(): import("./coreTools/coreType").INrrdStates;
+    getNrrdToolsSettings(): import("./coreTools/NrrdState").NrrdState;
     getMaxSliceNum(): number[];
     getCurrentSlicesNumAndContrastNum(): {
-        currentIndex: number;
+        currentSliceIndex: number;
         contrastIndex: number;
     };
     getCurrentSliceIndex(): number;
     getIsShowContrastState(): boolean;
-    /**
-     * Give a delay time to finish the last drawing before upcoming interrupt opreations.
-     * Give a delay time number (ms) to disable the draw function,
-     * After your interrupt opeartion, you should enable the draw fucntion.
-     * @param target number
-     */
-    setIsDrawFalse(target: number): void;
-    private setDisplaySlicesBaseOnAxis;
-    private loadDisplaySlicesArray;
-    switchAllSlicesArrayData(allSlices: Array<nrrdSliceType>): void;
-    private resetDisplaySlicesStatus;
-    private setupConfigs;
-    private setMainPreSlice;
-    private setOriginCanvasAndPre;
-    private afterLoadSlice;
-    private updateMaxIndex;
-    /**
-     * Update the original canvas size, allow set to threejs load one (pixel distance not the mm).
-     * Then update the changedWidth and changedHeight based on the sizeFoctor.
-     */
+    setActiveLayer(layerId: string): void;
+    getActiveLayer(): string;
+    setActiveChannel(channel: ChannelValue): void;
+    getActiveChannel(): number;
+    setActiveSphereType(type: SphereType): void;
+    getActiveSphereType(): SphereType;
+    setLayerVisible(layerId: string, visible: boolean): void;
+    isLayerVisible(layerId: string): boolean;
+    setChannelVisible(layerId: string, channel: ChannelValue, visible: boolean): void;
+    isChannelVisible(layerId: string, channel: ChannelValue): boolean;
+    getLayerVisibility(): Record<string, boolean>;
+    getChannelVisibility(): Record<string, Record<number, boolean>>;
+    hasLayerData(layerId: string): boolean;
+    setChannelColor(layerId: string, channel: number, color: RGBAColor): void;
+    getChannelColor(layerId: string, channel: number): RGBAColor;
+    getChannelHexColor(layerId: string, channel: number): string;
+    getChannelCssColor(layerId: string, channel: number): string;
+    setChannelColors(layerId: string, colorMap: Partial<ChannelColorMap>): void;
+    setAllLayersChannelColor(channel: number, color: RGBAColor): void;
+    resetChannelColors(layerId?: string, channel?: number): void;
     updateOriginAndChangedWH(): void;
-    /**
-     * Keep all contrast slice index to same.
-     * Synchronize the slice indexes of all the contrasts so that they are consistent with the main slice's index.
-     */
     setSyncsliceNum(): void;
-    appendLoadingbar(loadingbar: HTMLDivElement): void;
-    clearStoreImages(): void;
-    /**
-     * Reset the draw and display canvases layout after mouse pan.
-     * If no params in, then center the draw and display canvases.
-     * @param l number, Offset to the left
-     * @param t number, Offset to the top
-     */
     resetPaintAreaUIPosition(l?: number, t?: number): void;
-    /**
-     * Clear masks on drawingCanvas layers.
-     */
     resetLayerCanvas(): void;
     redrawMianPreOnDisplayCanvas(): void;
-    /**
-     * Resize the draw and display canvas size based on the input size factor number.
-     * @param factor number
-     */
     resizePaintArea(factor: number): void;
-    /**
-     * Phase 3: Reload all mask layers from MaskVolume using buffer reuse
-     * Replaces the old reloadMaskToLayer approach
-     */
+    flipDisplayImageByAxis(): void;
+    setEmptyCanvasSize(axis?: "x" | "y" | "z"): void;
+    redrawDisplayCanvas(): void;
     private reloadMasksFromVolume;
+    setAllSlices(allSlices: Array<nrrdSliceType>): void;
+    setMasksData(masksData: storeExportPaintImageType, loadingBar?: loadingBarType): void;
+    setMasksFromNIfTI(layerVoxels: Map<string, Uint8Array>, loadingBar?: loadingBarType): void;
+    setCalculateDistanceSphere(x: number, y: number, sliceIndex: number, cal_position: "tumour" | "skin" | "nipple" | "ribcage"): void;
     /**
-     * flip the canvas to a correct position.
-     * This is because the slice canvas from threejs is not in a correct 2D postion.
-     * Thus, everytime when we redraw the display canvas, we need to flip to draw the origin canvas from threejs.
-     * Under different axis(sagittal, Axial, Coronal), the flip orientation is different.
+     * Refresh sphere canvas from sphereMaskVolume for the current slice/axis.
      */
-    flipDisplayImageByAxis(): void;
-    private clearDictionary;
+    private refreshSphereOverlay;
     /**
-     * Set the empty canvas width and height based on the axis (pixel distance not the mm), to reduce duplicate codes.
-     *
-     * @param axis
+     * Enter sphere mode.
      */
-    setEmptyCanvasSize(axis?: "x" | "y" | "z"): void;
-    /******************************** redraw display canvas  ***************************************/
+    enterSphereMode(): void;
     /**
-     * Redraw current contrast image to display canvas.
-     * It is more related to change the contrast slice image's window width or center.
+     * Exit sphere mode.
      */
-    redrawDisplayCanvas(): void;
+    exitSphereMode(): void;
+    clearActiveLayer(): void;
+    reset(): void;
+    configMouseSliceWheel(): (e: WheelEvent) => void;
+    updateMouseWheelEvent(): void;
+    setIsDrawFalse(target: number): void;
+    private setShowInMainArea;
+    private clearDictionary;
     /**
-     * Config mouse slice wheel event.
+     * Get the DrawToolCore's start() render loop callback.
+     * This is called by DragSliceTool's requestAnimationFrame loop.
      */
-    configMouseSliceWheel(): (e: WheelEvent) => void;
+    get start(): () => void;
     /**
-     * Update mouse wheel event.
+     * Expose drawCalculatorSphereOnEachViews for external use.
      */
-    updateMouseWheelEvent(): void;
+    drawCalculatorSphereOnEachViews(axis: "x" | "y" | "z"): void;
 }

package/dist/types/Utils/segmentation/RenderingUtils.d.ts

@@ -0,0 +1,73 @@
+import type { INewMaskData } from "./core/types";
+import type { MaskVolume } from "./core/index";
+import type { CanvasState } from "./CanvasState";
+/**
+ * RenderingUtils — Rendering / slice-buffer helper methods.
+ *
+ * Extracted from CommToolsData.  All methods operate on the shared
+ * {@link CanvasState} reference — no independent state is held here
+ * except the reusable ImageData slice buffer.
+ *
+ * The `setEmptyCanvasSize` callback is injected by the owner (DrawToolCore
+ * or NrrdTools) because it lives in SliceRenderPipeline, not here.
+ */
+export declare class RenderingUtils {
+    private state;
+    /** Injected callback — set by owner after construction. */
+    setEmptyCanvasSize: (axis?: "x" | "y" | "z") => void;
+    private _reusableSliceBuffer;
+    private _reusableBufferWidth;
+    private _reusableBufferHeight;
+    constructor(state: CanvasState);
+    /**
+     * Get MaskVolume for a specific layer
+     *
+     * @param layer - Layer name: "layer1", "layer2", or "layer3"
+     * @returns MaskVolume instance for the specified layer
+     */
+    getVolumeForLayer(layer: string): MaskVolume;
+    /**
+     * Get MaskVolume for the currently active layer
+     */
+    getCurrentVolume(): MaskVolume;
+    /**
+     * Get all MaskVolume instances
+     */
+    getAllVolumes(): INewMaskData;
+    /**
+     * Get a painted mask image based on current axis and input slice index.
+     *
+     * Reads directly from MaskVolume.
+     */
+    filterDrawedImage(axis: "x" | "y" | "z", sliceIndex: number): {
+        index: number;
+        image: ImageData;
+    } | undefined;
+    /**
+     * Get or create a reusable ImageData buffer for the given axis.
+     *
+     * Reuses the same buffer across multiple slice renders to avoid
+     * allocating a new ImageData per layer per slice switch.
+     */
+    getOrCreateSliceBuffer(axis: "x" | "y" | "z"): ImageData | null;
+    /**
+     * Render a layer's slice into a reusable buffer and draw to the target canvas.
+     *
+     * Uses MaskVolume.renderLabelSliceInto() for zero-allocation rendering.
+     */
+    renderSliceToCanvas(layer: string, axis: "x" | "y" | "z", sliceIndex: number, buffer: ImageData, targetCtx: CanvasRenderingContext2D, scaledWidth: number, scaledHeight: number): void;
+    /**
+     * Invalidate the reusable buffer (e.g. when switching datasets).
+     */
+    invalidateSliceBuffer(): void;
+    /**
+     * Apply the same flip transform used by flipDisplayImageByAxis() to any
+     * canvas context.
+     */
+    applyMaskFlipForAxis(ctx: CanvasRenderingContext2D, width: number, height: number, axis: "x" | "y" | "z"): void;
+    /**
+     * Composite all layer canvases to the master display canvas.
+     * Only draws layers whose visibility is enabled.
+     */
+    compositeAllLayers(): void;
+}

package/dist/types/Utils/segmentation/core/UndoManager.d.ts

@@ -40,7 +40,7 @@ export declare class UndoManager {
     redo(): MaskDelta | undefined;
     canUndo(): boolean;
     canRedo(): boolean;
-    /** Clear undo and redo stacks for a specific layer (called on clearStoreImages). */
+    /** Clear undo and redo stacks for a specific layer (called on clearActiveLayer). */
     clearLayer(layer: string): void;
     /** Clear all stacks for all layers (called on full dataset reload). */
     clearAll(): void;

package/dist/types/Utils/segmentation/core/index.d.ts

@@ -67,10 +67,8 @@
  * const legacy = convertVolumeToIPaintImages(volume);
  * ```
  */
-export type { Dimensions, RGBAColor, ChannelColorMap, SliceRenderOptions, LayerId, ChannelValue, } from './types';
+export type { Dimensions, RGBAColor, ChannelColorMap, SliceRenderOptions, LayerId, ChannelValue, ICommXYZ, ICommXY, ISkipSlicesDictType, ToolMode, IDragPrameters, IDrawingEvents, IContrastEvents, IPaintImages, IPaintImage, ILayerRenderTarget, IDownloadImageConfig, INewMaskData, IMaskData, IProtected, IToolModeState, IDrawingConfig, IViewConfig, ILayerChannelState, IGUIStates, IGuiMeta, IGuiParameterSettings, IImageMetadata, IViewState, IInteractionState, ISphereState, IInternalFlags, INrrdStates, IAnnotationCallbacks, IConvertObjType, ICursorPage, IDragOpts, IDrawOpts, IKeyBoardSettings, } from './types';
 export { RenderMode, MASK_CHANNEL_COLORS, MASK_CHANNEL_CSS_COLORS, CHANNEL_COLORS, CHANNEL_HEX_COLORS, rgbaToHex, rgbaToCss, } from './types';
 export { MaskVolume } from './MaskVolume';
-export type { IPaintImage, IPaintImages } from './MigrationUtils';
-export { convertIPaintImagesToVolume, convertVolumeToIPaintImages, } from './MigrationUtils';
 export type { MaskDelta } from './UndoManager';
 export { UndoManager } from './UndoManager';