copper3d 3.0.2 → 3.1.0

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/MaskVolume.d.ts

@@ -317,7 +317,7 @@ export declare class MaskVolume {
      *
      * @example
      * ```ts
-     * vol.reset();
+     * vol.clear();
      * vol.getVoxel(256, 256, 50); // 0
      * ```
      */

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

@@ -67,7 +67,7 @@
  * 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 { MaskDelta } from './UndoManager';

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

@@ -7,7 +7,7 @@
  * - viewConfig:   UI layout and interaction parameters
  * - layerChannel: Active layer, channel, and visibility
  */
-import type { IToolModeState, IDrawingConfig, IViewConfig, ILayerChannelState } from "./coreType";
+import type { IToolModeState, IDrawingConfig, IViewConfig, ILayerChannelState } from "../core/types";
 export declare class GuiState {
     readonly mode: IToolModeState;
     readonly drawing: IDrawingConfig;

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

@@ -10,7 +10,7 @@
  *
  * Phase 4 of the State Management Refactor.
  */
-import type { IImageMetadata, IViewState, IInteractionState, ISphereState, IInternalFlags } from "./coreType";
+import type { IImageMetadata, IViewState, IInteractionState, ISphereState, IInternalFlags } from "../core/types";
 export declare class NrrdState {
     readonly image: IImageMetadata;
     readonly view: IViewState;

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,5 +1,5 @@
 import { GUI } from "dat.gui";
-import { IDrawingEvents, IProtected, IGuiParameterSettings } from "./coreType";
+import { IDrawingEvents, IProtected, IGuiParameterSettings } from "../core/types";
 import type { GuiState } from "./GuiState";
 import { NrrdState } from "./NrrdState";
 import { DragOperator } from "../DragOperator";

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

@@ -6,7 +6,7 @@
  * NOTE: This is for the OLD DrawToolCore system.
  * The new SegmentationManager system has its own tools in manager/tools/.
  */
-import type { IProtected, ICursorPage, IAnnotationCallbacks } 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";

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,17 +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;
-    /** Refresh sphere overlay from sphereMaskVolume after slice change. */
-    refreshSphereOverlay?: () => void;
-}
+import type { ILayerRenderTarget } from "../core/types";
+import type { DragSliceHostDeps } from "./ToolHost";
 interface IDragEffectCanvases {
     drawingCanvasLayerMaster: HTMLCanvasElement;
     displayCanvas: HTMLCanvasElement;
@@ -31,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;