copper3d 3.0.1 → 3.1.0

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

@@ -104,3 +104,387 @@ export declare function rgbaToHex(color: RGBAColor): string;
  * Convert an RGBAColor to a CSS rgba() string, e.g. 'rgba(255,0,0,1.00)'.
  */
 export declare function rgbaToCss(color: RGBAColor): string;
+import type { MaskVolume } from './MaskVolume';
+export interface ICommXYZ {
+    x: any;
+    y: any;
+    z: any;
+}
+export interface ICommXY {
+    x: any;
+    y: any;
+}
+export interface ISkipSlicesDictType {
+    [key: string]: any;
+}
+/** Tool mode types for segmentation tools */
+export type ToolMode = "pencil" | "brush" | "eraser" | "sphere" | "calculator";
+export interface IDragPrameters {
+    move: number;
+    y: number;
+    h: number;
+    sensivity: number;
+    handleOnDragMouseUp: (ev: MouseEvent) => void;
+    handleOnDragMouseDown: (ev: MouseEvent) => void;
+    handleOnDragMouseMove: (ev: MouseEvent) => void;
+}
+export interface IDrawingEvents {
+    handleOnDrawingMouseDown: (ev: MouseEvent) => void;
+    handleOnDrawingMouseMove: (ev: MouseEvent) => void;
+    handleOnPanMouseMove: (ev: MouseEvent) => void;
+    handleOnDrawingMouseUp: (ev: MouseEvent) => void;
+    handleOnDrawingMouseLeave: (ev: MouseEvent) => void;
+    handleOnDrawingBrushCricleMove: (ev: MouseEvent) => void;
+    handleMouseZoomSliceWheel: (e: WheelEvent) => void;
+    handleSphereWheel: (e: WheelEvent) => void;
+}
+export interface IContrastEvents {
+    move_x: number;
+    move_y: number;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    handleOnContrastMouseDown: (ev: MouseEvent) => void;
+    handleOnContrastMouseMove: (ev: MouseEvent) => void;
+    handleOnContrastMouseUp: (ev: MouseEvent) => void;
+    handleOnContrastMouseLeave: (ev: MouseEvent) => void;
+}
+export interface IPaintImages {
+    x: Array<IPaintImage>;
+    y: Array<IPaintImage>;
+    z: Array<IPaintImage>;
+}
+export interface IPaintImage {
+    index: number;
+    image: ImageData;
+}
+/**
+ * A paired canvas + 2D context for a single annotation layer.
+ * Stored atomically in IProtected.layerTargets to prevent canvas/ctx desync.
+ */
+export interface ILayerRenderTarget {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+}
+export interface IDownloadImageConfig {
+    axis: "x" | "y" | "z";
+    currentSliceIndex: number;
+    drawingCanvas: HTMLCanvasElement;
+    originWidth: number;
+    originHeight: number;
+}
+/**
+ * New mask data structure using MaskVolume for true 3D storage.
+ * Dynamic N-layer support: keyed by layer id (e.g. 'layer1', 'layer2', ...).
+ */
+export type INewMaskData = Record<string, MaskVolume>;
+/**
+ * Mask data storage using volumetric MaskVolume (Phase 3)
+ *
+ * Phase 2 legacy ImageData storage has been removed.
+ * All mask data now stored in 3D volumes for memory efficiency.
+ */
+export type IMaskData = {
+    volumes: INewMaskData;
+};
+export interface IProtected {
+    container: HTMLElement;
+    mainAreaContainer: HTMLElement;
+    allSlicesArray: Array<ICommXYZ>;
+    displaySlices: Array<any>;
+    backUpDisplaySlices: Array<any>;
+    skipSlicesDic: ISkipSlicesDictType;
+    currentShowingSlice: any;
+    mainPreSlices: any;
+    isDrawing: boolean;
+    axis: "x" | "y" | "z";
+    maskData: IMaskData;
+    /** Dynamic per-layer canvas+ctx pairs. Replaces hardcoded LayerOne/Two/Three fields. */
+    layerTargets: Map<string, ILayerRenderTarget>;
+    canvases: {
+        originCanvas: HTMLCanvasElement | any;
+        drawingCanvas: HTMLCanvasElement;
+        displayCanvas: HTMLCanvasElement;
+        drawingCanvasLayerMaster: HTMLCanvasElement;
+        drawingSphereCanvas: HTMLCanvasElement;
+        emptyCanvas: HTMLCanvasElement;
+    };
+    ctxes: {
+        displayCtx: CanvasRenderingContext2D;
+        drawingCtx: CanvasRenderingContext2D;
+        emptyCtx: CanvasRenderingContext2D;
+        drawingSphereCtx: CanvasRenderingContext2D;
+        drawingLayerMasterCtx: CanvasRenderingContext2D;
+    };
+}
+/** Tool mode flags — which tool is currently active */
+export interface IToolModeState {
+    pencil: boolean;
+    eraser: boolean;
+    sphere: boolean;
+    activeSphereType: "tumour" | "skin" | "nipple" | "ribcage";
+}
+/** Drawing configuration — brush/pencil appearance and behavior */
+export interface IDrawingConfig {
+    globalAlpha: number;
+    lineWidth: number;
+    color: string;
+    fillColor: string;
+    brushColor: string;
+    brushAndEraserSize: number;
+}
+/** View configuration — UI layout and interaction parameters */
+export interface IViewConfig {
+    mainAreaSize: number;
+    dragSensitivity: number;
+    cursor: string;
+    defaultPaintCursor: string;
+    max_sensitive: number;
+    readyToUpdate: boolean;
+}
+/** Layer/channel state — active layer, channel, and visibility */
+export interface ILayerChannelState {
+    layer: string;
+    /** Currently active channel (1-8). Channel 0 is transparent/erased. */
+    activeChannel: number;
+    /** Layer visibility state: { layer1: true, layer2: true, layer3: true } */
+    layerVisibility: Record<string, boolean>;
+    /** Per-layer channel visibility: { layer1: { 1: true, ..., 8: true }, ... } */
+    channelVisibility: Record<string, Record<number, boolean>>;
+}
+export interface IGUIStates extends IToolModeState, IDrawingConfig, IViewConfig, ILayerChannelState {
+}
+/** Metadata for a GUI slider/control — used by Vue components to configure slider UI */
+export interface IGuiMeta {
+    min: number;
+    max: number;
+    step: number;
+    value: number;
+}
+export interface IGuiParameterSettings {
+    globalAlpha: {
+        name: "Opacity";
+        min: number;
+        max: number;
+        step: number;
+    };
+    pencil: {
+        name: "Pencil";
+        onChange: () => void;
+    };
+    sphere: {
+        name: "Sphere";
+        onChange: () => void;
+    };
+    brushAndEraserSize: {
+        name: "BrushAndEraserSize";
+        min: number;
+        max: number;
+        step: number;
+        onChange: () => void;
+    };
+    eraser: {
+        name: "Eraser";
+        onChange: () => void;
+    };
+    activeSphereType: {
+        name: "CalculatorDistance";
+        onChange: (val: "tumour" | "skin" | "ribcage" | "nipple") => void;
+    };
+    clear: {
+        name: "Clear";
+    };
+    clearAll: {
+        name: "ClearAll";
+    };
+    undo: {
+        name: "Undo";
+    };
+    redo: {
+        name: "Redo";
+    };
+    resetZoom: {
+        name: "ResetZoom";
+    };
+    windowHigh: {
+        name: "ImageContrast";
+        value: null;
+        min: number;
+        max: number;
+        step: number;
+        onChange: (value: number) => void;
+        onFinished: () => void;
+    };
+    windowLow: {
+        name: "WindowLow";
+        value: null;
+        min: number;
+        max: number;
+        step: number;
+        onChange: (value: number) => void;
+        onFinished: () => void;
+    };
+    advance: {
+        layer: {
+            name: "Layer";
+            value: string[];
+        };
+        cursor: {
+            name: "CursorIcon";
+            value: ["crosshair", "pencil", "dot"];
+        };
+        mainAreaSize: {
+            name: "Zoom";
+            min: number;
+            max: number;
+            step: number;
+            onFinished: null;
+        };
+        dragSensitivity: {
+            name: "DragSensitivity";
+            min: number;
+            max: number;
+            step: number;
+        };
+        pencilSettings: {
+            lineWidth: {
+                name: "OuterLineWidth";
+                min: number;
+                max: number;
+                step: number;
+            };
+            color: {
+                name: "Color";
+            };
+            fillColor: {
+                name: "FillColor";
+            };
+        };
+        BrushSettings: {
+            brushColor: {
+                name: "BrushColor";
+            };
+        };
+    };
+}
+/** Image metadata — set once during NRRD loading, read-only at runtime */
+export interface IImageMetadata {
+    originWidth: number;
+    originHeight: number;
+    nrrd_x_mm: number;
+    nrrd_y_mm: number;
+    nrrd_z_mm: number;
+    nrrd_x_pixel: number;
+    nrrd_y_pixel: number;
+    nrrd_z_pixel: number;
+    dimensions: number[];
+    voxelSpacing: number[];
+    spaceOrigin: number[];
+    RSARatio: number;
+    ratios: ICommXYZ;
+    layers: string[];
+}
+/** View state — runtime display/navigation state */
+export interface IViewState {
+    changedWidth: number;
+    changedHeight: number;
+    currentSliceIndex: number;
+    preSliceIndex: number;
+    maxIndex: number;
+    minIndex: number;
+    contrastNum: number;
+    sizeFactor: number;
+    showContrast: boolean;
+    switchSliceFlag: boolean;
+    previousPanelL: number;
+    previousPanelT: number;
+}
+/** Interaction state — mouse/cursor tracking */
+export interface IInteractionState {
+    mouseOverX: number;
+    mouseOverY: number;
+    mouseOver: boolean;
+    cursorPageX: number;
+    cursorPageY: number;
+    isCursorSelect: boolean;
+    drawStartPos: ICommXY;
+}
+/** Sphere state — SphereTool-specific data */
+export interface ISphereState {
+    sphereOrigin: ICommXYZ;
+    tumourSphereOrigin: ICommXYZ | null;
+    skinSphereOrigin: ICommXYZ | null;
+    ribSphereOrigin: ICommXYZ | null;
+    nippleSphereOrigin: ICommXYZ | null;
+    /** Dedicated MaskVolume for SphereTool 3D sphere data. Type is `any` to avoid circular deps. */
+    sphereMaskVolume: any;
+    sphereRadius: number;
+}
+/** Internal flags — transient operational flags */
+export interface IInternalFlags {
+    stepClear: number;
+    clearAllFlag: boolean;
+    loadingMaskData: boolean;
+}
+/** Legacy flat interface — kept for backward compatibility during migration */
+export interface INrrdStates extends IImageMetadata, IViewState, IInteractionState, ISphereState, IInternalFlags {
+}
+/** Callbacks for external notification of annotation data changes */
+export interface IAnnotationCallbacks {
+    onMaskChanged(sliceData: Uint8Array, layerId: string, channelId: number, sliceIndex: number, axis: "x" | "y" | "z", width: number, height: number, clearFlag: boolean): void;
+    onSphereChanged(sphereOrigin: number[], sphereRadius: number): void;
+    onCalculatorPositionsChanged(tumour: ICommXYZ | null, skin: ICommXYZ | null, rib: ICommXYZ | null, nipple: ICommXYZ | null, axis: "x" | "y" | "z"): void;
+    onLayerVolumeCleared(layerId: string): void;
+    onChannelColorChanged(layerId: string, channel: number, color: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    }): void;
+}
+export interface IConvertObjType {
+    currentNewSliceIndex: number;
+    preSliceIndex: number;
+    convertCursorNumX: number;
+    convertCursorNumY: number;
+}
+export interface ICursorPage {
+    x: {
+        cursorPageX: number;
+        cursorPageY: number;
+        index: number;
+        updated: boolean;
+    };
+    y: {
+        cursorPageX: number;
+        cursorPageY: number;
+        index: number;
+        updated: boolean;
+    };
+    z: {
+        cursorPageX: number;
+        cursorPageY: number;
+        index: number;
+        updated: boolean;
+    };
+}
+export interface IDragOpts {
+    showNumber?: boolean;
+    getSliceNum?: (index: number, contrastNum: number) => void;
+}
+export interface IDrawOpts {
+    getMaskData?: (sliceData: Uint8Array, layerId: string, channelId: number, sliceIndex: number, axis: "x" | "y" | "z", width: number, height: number, clearFlag?: boolean) => void;
+    onClearLayerVolume?: (layerId: string) => void;
+    getSphereData?: (sphereOrigin: number[], sphereRadius: number) => void;
+    getCalculateSpherePositionsData?: (tumourSphereOrigin: ICommXYZ | null, skinSphereOrigin: ICommXYZ | null, ribSphereOrigin: ICommXYZ | null, nippleSphereOrigin: ICommXYZ | null, aixs: "x" | "y" | "z") => void;
+}
+export interface IKeyBoardSettings {
+    draw: string;
+    undo: string;
+    redo: string;
+    contrast: string[];
+    crosshair: string;
+    sphere: string;
+    mouseWheel: "Scroll:Zoom" | "Scroll:Slice";
+}

package/dist/types/Utils/segmentation/coreTools/GuiState.d.ts

@@ -0,0 +1,22 @@
+/**
+ * GuiState — Grouped state management for GUI configuration.
+ *
+ * Replaces the flat IGUIStates object with 4 semantic sub-groups:
+ * - mode:         Tool mode flags (pencil/eraser/sphere)
+ * - drawing:      Brush/pencil appearance and behavior
+ * - viewConfig:   UI layout and interaction parameters
+ * - layerChannel: Active layer, channel, and visibility
+ */
+import type { IToolModeState, IDrawingConfig, IViewConfig, ILayerChannelState } from "../core/types";
+export declare class GuiState {
+    readonly mode: IToolModeState;
+    readonly drawing: IDrawingConfig;
+    readonly viewConfig: IViewConfig;
+    readonly layerChannel: ILayerChannelState;
+    constructor(options?: {
+        defaultPaintCursor?: string;
+        defaultFillColor?: string;
+        defaultBrushColor?: string;
+        layers?: string[];
+    });
+}

package/dist/types/Utils/segmentation/coreTools/NrrdState.d.ts

@@ -0,0 +1,25 @@
+/**
+ * NrrdState — Grouped state management for NRRD annotation data.
+ *
+ * Replaces the flat INrrdStates object with 5 semantic sub-groups:
+ * - image:       Read-mostly metadata set during NRRD loading
+ * - view:        Runtime display/navigation state
+ * - interaction: Mouse/cursor tracking
+ * - sphere:      SphereTool-specific data
+ * - flags:       Internal operational flags
+ *
+ * Phase 4 of the State Management Refactor.
+ */
+import type { IImageMetadata, IViewState, IInteractionState, ISphereState, IInternalFlags } from "../core/types";
+export declare class NrrdState {
+    readonly image: IImageMetadata;
+    readonly view: IViewState;
+    readonly interaction: IInteractionState;
+    readonly sphere: ISphereState;
+    readonly flags: IInternalFlags;
+    constructor(baseCanvasesSize?: number, layers?: string[]);
+    /** Set zoom factor with clamping [1, 8] */
+    setZoomFactor(factor: number): void;
+    /** Reset all sphere state to defaults */
+    resetSphereState(): void;
+}

package/dist/types/Utils/segmentation/coreTools/divControlTools.d.ts

@@ -1,4 +1,4 @@
-import { IDownloadImageConfig } from "./coreType";
+import { IDownloadImageConfig } from "../core/types";
 /**
  * A div for show the slice and contrast numbers on
  * the top of container.

package/dist/types/Utils/segmentation/coreTools/gui.d.ts

@@ -1,11 +1,13 @@
 import { GUI } from "dat.gui";
-import { IDrawingEvents, IGUIStates, IProtected, INrrdStates, IGuiParameterSettings } from "./coreType";
+import { IDrawingEvents, IProtected, IGuiParameterSettings } from "../core/types";
+import type { GuiState } from "./GuiState";
+import { NrrdState } from "./NrrdState";
 import { DragOperator } from "../DragOperator";
 interface IConfigGUI {
     modeFolder: GUI;
     dragOperator: DragOperator;
-    nrrd_states: INrrdStates;
-    gui_states: IGUIStates;
+    nrrd_states: NrrdState;
+    gui_states: GuiState;
     drawingCanvas: HTMLCanvasElement;
     drawingPrameters: IDrawingEvents;
     protectedData: IProtected;
@@ -15,8 +17,8 @@ interface IConfigGUI {
     mainPreSlices: any;
     removeDragMode: () => void;
     configDragMode: () => void;
-    clearPaint: () => void;
-    clearStoreImages: () => void;
+    clearActiveSlice: () => void;
+    clearActiveLayer: () => void;
     updateSlicesContrast: (value: number, flag: string) => void;
     setMainAreaSize: (factor: number) => void;
     resetPaintAreaUIPosition: () => void;
@@ -26,17 +28,15 @@ interface IConfigGUI {
     resetLayerCanvas: () => void;
     redrawDisplayCanvas: () => void;
     flipDisplayImageByAxis: () => void;
-    filterDrawedImage: (axis: "x" | "y" | "z", sliceIndex: number) => {
-        index: number;
-        image: ImageData;
-    } | undefined;
     setEmptyCanvasSize: (axis?: "x" | "y" | "z") => void;
-    storeAllImages: (index: number, layer: string) => void;
+    syncLayerSliceData: (index: number, layer: string) => void;
     drawImageOnEmptyImage: (canvas: HTMLCanvasElement) => void;
-    storeEachLayerImage: (index: number, layer: string) => void;
-    storeImageToLayer: (index: number, canvas: HTMLCanvasElement) => ImageData;
     getRestLayer: () => string[];
     setIsDrawFalse: (target: number) => void;
+    undoLastPainting: () => void;
+    redoLastPainting: () => void;
+    resetZoom: () => void;
+    downloadCurrentMask: () => void;
 }
 declare function setupGui(configs: IConfigGUI): IGuiParameterSettings;
 declare function removeGuiFolderChilden(modeFolder: GUI): void;

package/dist/types/Utils/segmentation/eventRouter/EventRouter.d.ts

@@ -72,7 +72,8 @@ export declare class EventRouter {
     setGuiTool(tool: GuiTool): void;
     /**
      * Toggle crosshair mode.
-     * Blocked when draw or contrast mode is active (mutual exclusion).
+     * Allowed in drawing tools AND sphere mode.
+     * Blocked when draw or contrast mode is active, or left button is held (mutual exclusion).
      */
     toggleCrosshair(): void;
     /**

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

@@ -12,14 +12,13 @@
  * - `contrast`: Ctrl held, left-drag adjusts window/level
  * - `crosshair`: Crosshair mode enabled (C key toggle)
  * - `sphere`: Sphere placement tool active
- * - `calculator`: Distance calculator tool active
  * - `pan`: Right-drag panning the canvas
  */
-export type InteractionMode = 'idle' | 'draw' | 'drag' | 'contrast' | 'crosshair' | 'sphere' | 'calculator' | 'pan';
+export type InteractionMode = 'idle' | 'draw' | 'drag' | 'contrast' | 'crosshair' | 'sphere' | 'pan';
 /**
  * GUI tool selection (set from UI buttons)
  */
-export type GuiTool = 'pencil' | 'brush' | 'eraser' | 'sphere' | 'calculator';
+export type GuiTool = 'pencil' | 'brush' | 'eraser' | 'sphere';
 /**
  * Keyboard event handler type
  */
@@ -56,6 +55,7 @@ export interface KeyboardSettings {
     redo: string;
     contrast: string[];
     crosshair: string;
+    sphere: string;
     mouseWheel: 'Scroll:Zoom' | 'Scroll:Slice';
 }
 /**

package/dist/types/Utils/segmentation/tools/BaseTool.d.ts

@@ -1,23 +1,26 @@
 /**
  * BaseTool - Abstract base for extracted DrawToolCore tools
  *
- * Provides shared access to the legacy state objects (nrrd_states,
- * gui_states, protectedData) via a ToolContext interface.
+ * Provides shared access to state objects via a ToolContext interface.
  *
  * NOTE: This is for the OLD DrawToolCore system.
  * The new SegmentationManager system has its own tools in manager/tools/.
  */
-import type { INrrdStates, IGUIStates, IProtected, ICursorPage } from "../coreTools/coreType";
+import type { IProtected, ICursorPage, IAnnotationCallbacks } from "../core/types";
+import type { NrrdState } from "../coreTools/NrrdState";
+import type { GuiState } from "../coreTools/GuiState";
 import type { EventRouter } from "../eventRouter/EventRouter";
 /**
  * Shared context injected into every legacy tool.
  * References are shared (not copied), so tools see the same state.
  */
 export interface ToolContext {
-    nrrd_states: INrrdStates;
-    gui_states: IGUIStates;
+    nrrd_states: NrrdState;
+    gui_states: GuiState;
     protectedData: IProtected;
     cursorPage: ICursorPage;
+    /** External annotation callbacks (Phase 2) */
+    callbacks: IAnnotationCallbacks;
     /** EventRouter reference for mode/state queries. Set after initDrawToolCore(). */
     eventRouter?: EventRouter;
 }

package/dist/types/Utils/segmentation/tools/ContrastTool.d.ts

@@ -8,16 +8,13 @@
  */
 import { BaseTool } from "./BaseTool";
 import type { ToolContext } from "./BaseTool";
-import type { IContrastEvents } from "../coreTools/coreType";
-export interface ContrastCallbacks {
-    setIsDrawFalse: (target: number) => void;
-    setSyncsliceNum: () => void;
-}
+import type { IContrastEvents } from "../core/types";
+import type { ContrastHostDeps } from "./ToolHost";
 export declare class ContrastTool extends BaseTool {
     private contrastEventPrameters;
     private container;
     private callbacks;
-    constructor(ctx: ToolContext, container: HTMLElement, contrastEventPrameters: IContrastEvents, callbacks: ContrastCallbacks);
+    constructor(ctx: ToolContext, container: HTMLElement, contrastEventPrameters: IContrastEvents, callbacks: ContrastHostDeps);
     setupConrastEvents(callback: (step: number, towards: "horizental" | "vertical") => void): void;
     configContrastDragMode(): void;
     removeContrastDragMode(): void;

package/dist/types/Utils/segmentation/tools/CrosshairTool.d.ts

@@ -7,7 +7,7 @@
  * - setUpSphereOrigins
  */
 import { BaseTool } from "./BaseTool";
-import type { IConvertObjType } from "../coreTools/coreType";
+import type { IConvertObjType } from "../core/types";
 export declare class CrosshairTool extends BaseTool {
     enableCrosshair(): void;
     /**
@@ -26,5 +26,15 @@ export declare class CrosshairTool extends BaseTool {
      * @param currentSliceIndex Current slice depth (mm distance)
      */
     convertCursorPoint(from: "x" | "y" | "z", to: "x" | "y" | "z", cursorNumX: number, cursorNumY: number, currentSliceIndex: number): IConvertObjType | undefined;
+    /**
+     * Render crosshair lines on the drawing context.
+     * Called from the start() render loop when crosshair mode is active.
+     *
+     * @param ctx - The drawing canvas 2D context
+     * @param width - Canvas width (changedWidth)
+     * @param height - Canvas height (changedHeight)
+     */
+    renderCrosshair(ctx: CanvasRenderingContext2D, width: number, height: number): void;
+    private drawLine;
     setUpSphereOrigins(mouseX: number, mouseY: number, sliceIndex: number): void;
 }

package/dist/types/Utils/segmentation/tools/DataLoader.d.ts

@@ -0,0 +1,33 @@
+import { BaseTool } from "./BaseTool";
+import type { ToolContext } from "./BaseTool";
+import type { nrrdSliceType, storeExportPaintImageType, loadingBarType } from "../../../types/types";
+import type { DataLoaderHostDeps } from "./ToolHost";
+/**
+ * Handles data loading for NRRD slices and mask volumes.
+ *
+ * Extracted from NrrdTools.ts to reduce its size.
+ * Follows the same BaseTool + ToolContext + Callbacks pattern as other tools.
+ */
+export declare class DataLoader extends BaseTool {
+    private callbacks;
+    constructor(ctx: ToolContext, callbacks: DataLoaderHostDeps);
+    /****************************Slice Loading****************************************************/
+    /**
+     * Load all NRRD contrast slices and initialize MaskVolumes with real dimensions.
+     */
+    setAllSlices(allSlices: Array<nrrdSliceType>): void;
+    /****************************Legacy Mask Loading****************************************************/
+    private loadingMaskByLayer;
+    setMasksData(masksData: storeExportPaintImageType, loadingBar?: loadingBarType): void;
+    /****************************NIfTI Mask Loading****************************************************/
+    /**
+     * 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
+     */
+    setMasksFromNIfTI(layerVoxels: Map<string, Uint8Array>, loadingBar?: loadingBarType): void;
+}

package/dist/types/Utils/segmentation/tools/DragSliceTool.d.ts

@@ -10,15 +10,8 @@
  */
 import { BaseTool } from "./BaseTool";
 import type { ToolContext } from "./BaseTool";
-import type { ILayerRenderTarget } from "../coreTools/coreType";
-export interface DragSliceCallbacks {
-    setSyncsliceNum: () => void;
-    setIsDrawFalse: (target: number) => void;
-    flipDisplayImageByAxis: () => void;
-    setEmptyCanvasSize: (axis?: "x" | "y" | "z") => void;
-    getOrCreateSliceBuffer: (axis: "x" | "y" | "z") => ImageData | null;
-    renderSliceToCanvas: (layer: string, axis: "x" | "y" | "z", sliceIndex: number, buffer: ImageData, targetCtx: CanvasRenderingContext2D, scaledWidth: number, scaledHeight: number) => void;
-}
+import type { ILayerRenderTarget } from "../core/types";
+import type { DragSliceHostDeps } from "./ToolHost";
 interface IDragEffectCanvases {
     drawingCanvasLayerMaster: HTMLCanvasElement;
     displayCanvas: HTMLCanvasElement;
@@ -29,7 +22,7 @@ export declare class DragSliceTool extends BaseTool {
     private callbacks;
     private showDragNumberDiv;
     private dragEffectCanvases;
-    constructor(ctx: ToolContext, callbacks: DragSliceCallbacks, showDragNumberDiv: HTMLDivElement, dragEffectCanvases: IDragEffectCanvases);
+    constructor(ctx: ToolContext, callbacks: DragSliceHostDeps, showDragNumberDiv: HTMLDivElement, dragEffectCanvases: IDragEffectCanvases);
     setShowDragNumberDiv(div: HTMLDivElement): void;
     updateIndex(move: number): void;
     private drawDragSlice;