copper3d 3.0.2 → 3.1.1

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

@@ -1,13 +1,21 @@
 import { nrrdSliceType, storeExportPaintImageType, loadingBarType } from "../../types/types";
 import { GUI } from "dat.gui";
-import { IMaskData, IDragOpts, IKeyBoardSettings, ToolMode, IGuiMeta } 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
@@ -17,38 +25,41 @@ import type { SphereType } from "./tools/SphereTool";
  * 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;
-    /**
-     * Set the Draw Display Canvas base size
-     * @param size number
-     */
-    setBaseDrawDisplayCanvasesSize(size: number): void;
-    setDisplaySliceIndexPanel(panel: HTMLDivElement): void;
+    private wireDrawCoreMethods;
     /**
-     * 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
@@ -56,407 +67,61 @@ export declare class NrrdTools extends DrawToolCore {
     setupGUI(gui: GUI): void;
     /**
      * Sync guiParameterSettings with current volume metadata.
-     * Called internally when slices are loaded or switched.
      */
     private syncGuiParameterSettings;
     /**
-     * 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;
-    /**
-     * Set the active sphere type for the SphereTool.
-     * Replaces direct mutation of `gui_states.activeSphereType`.
-     *
-     * @example
-     * ```ts
-     * nrrdTools.setActiveSphereType('nipple');
-     * ```
-     */
-    setActiveSphereType(type: SphereType): void;
-    /**
-     * Get the currently active sphere type.
-     */
-    getActiveSphereType(): SphereType;
-    /**
-     * Set the current tool mode. Handles deactivation of the previous mode
-     * and activation of the new mode, including all gui.ts side-effects.
-     *
-     * Replaces direct mutation of `guiSettings.value.guiState["pencil"]` etc.
-     * from Vue components.
+     * Set the current tool mode.
      */
     setMode(mode: ToolMode): void;
-    /**
-     * Get the current tool mode based on gui_states flags.
-     */
     getMode(): ToolMode;
-    /**
-     * Check if calculator mode is active.
-     */
     isCalculatorActive(): boolean;
-    /**
-     * Set mask overlay opacity.
-     * @param value Opacity value [0.1, 1]
-     */
     setOpacity(value: number): void;
-    /**
-     * Get the current mask overlay opacity.
-     */
     getOpacity(): number;
-    /**
-     * Set brush and eraser size, and trigger cursor update.
-     * @param size Brush size [5, 50]
-     */
     setBrushSize(size: number): void;
-    /**
-     * Get the current brush/eraser size.
-     */
     getBrushSize(): number;
-    /**
-     * Set window high (image contrast) value.
-     * Call finishWindowAdjustment() when the user finishes dragging.
-     */
     setWindowHigh(value: number): void;
-    /**
-     * Set window low (image center) value.
-     * Call finishWindowAdjustment() when the user finishes dragging.
-     */
     setWindowLow(value: number): void;
-    /**
-     * Finish a window/contrast adjustment (repaint all contrast slices).
-     */
     finishWindowAdjustment(): void;
-    /**
-     * Adjust contrast by delta, used for drag-based contrast adjustment.
-     * @param type "windowHigh" or "windowLow"
-     * @param delta Delta amount to adjust
-     */
     adjustContrast(type: "windowHigh" | "windowLow", delta: number): void;
-    /**
-     * Get slider metadata for UI configuration.
-     * @param key Slider key: "globalAlpha", "brushAndEraserSize", "windowHigh", "windowLow"
-     * @returns IGuiMeta with min, max, step, and current value
-     */
     getSliderMeta(key: string): IGuiMeta | null;
-    /**
-     * Set the pencil stroke color.
-     */
     setPencilColor(hex: string): void;
-    /**
-     * Get the current pencil stroke color.
-     */
     getPencilColor(): string;
-    /**
-     * Execute a named UI action.
-     * @param action Action name
-     *
-     * Renamed from original gui_states methods:
-     * - "clearActiveSliceMask" (was "clear") — clear annotations on current slice
-     * - "clearActiveLayerMask" (was "clearAll") — clear annotations on all slices for active layer
-     */
     executeAction(action: "undo" | "redo" | "clearActiveSliceMask" | "clearActiveLayerMask" | "resetZoom" | "downloadCurrentMask"): 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());
-     * ```
-     */
     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
-   
-     */
-    setAllSlices(allSlices: Array<nrrdSliceType>): void;
-    private loadingMaskByLayer;
-    setMasksData(masksData: storeExportPaintImageType, loadingBar?: loadingBarType): 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
+     * Core drawing entry point.
      */
-    setMasksFromNIfTI(layerVoxels: Map<string, Uint8Array>, loadingBar?: loadingBarType): void;
-    private setShowInMainArea;
-    getCurrentImageDimension(): number[];
-    getVoxelSpacing(): number[];
-    getSpaceOrigin(): number[];
-    getMaskData(): IMaskData;
+    draw(opts?: any): void;
     /**
-     * Programmatically place a calculator sphere at the given position.
-     *
-     * Replicates the full mouse-down → mouse-up flow (handleSphereClick + pointerup)
-     * so that backend-supplied sphere data is stored identically to a manual click.
-     *
-     * @param x - X coordinate in unscaled (original) image space
-     * @param y - Y coordinate in unscaled (original) image space
-     * @param sliceIndex - Target slice index (z-axis)
-     * @param cal_position - Sphere type to place
+     * Set the Draw Display Canvas base size
      */
-    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;
-    /**
-     * Reset the entire NrrdTools instance comprehensively.
-     * This clears ALL data across ALL layers globally, resets the Canvas visuals,
-     * undo/redo history, volume models, index parameters, and sphere overlays.
-     * Primarily used when switching cases/datasets or when a completely fresh state is needed.
-     * It is heavier than `clearActiveLayer` or `clearActiveSlice`.
-     */
-    reset(): 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/NrrdState").NrrdState;
@@ -467,109 +132,69 @@ export declare class NrrdTools extends DrawToolCore {
     };
     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 sizeFactor.
-     */
+    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;
+    setLayerOpacity(layerId: string, opacity: number): void;
+    getLayerOpacity(layerId: string): number;
+    getLayerOpacityMap(): Record<string, number>;
     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;
-    /**
-     * Clear all annotations on the currently active layer across its entire 3D volume.
-     * This resets all voxels globally for the active layer's `MaskVolume` (depth, width, height)
-     * and triggers the `onClearLayerVolume` event to sync the wiped volume to the backend.
-     * It also clears the undo/redo stack for the active layer ONLY.
-     * Other background layers are not impacted by this operation.
-     */
-    clearActiveLayer(): 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;
+    resetLayerCanvas(): void;
+    redrawMianPreOnDisplayCanvas(): void;
+    resizePaintArea(factor: number): void;
+    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;
     /**
-     * Clear masks on drawingCanvas layers.
+     * Refresh sphere canvas from sphereMaskVolume for the current slice/axis.
      */
-    resetLayerCanvas(): void;
+    private refreshSphereOverlay;
     /**
      * Enter sphere mode.
-     *
-     * Clears all layer canvases and the master composite canvas so that
-     * only the sphere overlay is visible. Does NOT touch MaskVolume data.
-     * Also disables drag mode to prevent slice dragging conflicts.
-     *
-     * Called when sphere mode is toggled on (keyboard shortcut or GUI).
      */
     enterSphereMode(): void;
     /**
      * Exit sphere mode.
-     *
-     * Clears sphere overlay, restores all layer MaskVolume data onto
-     * their canvases by temporarily lifting the sphere guard in
-     * reloadMasksFromVolume and calling it.
-     *
-     * Called when sphere mode is toggled off (keyboard shortcut or GUI).
      */
     exitSphereMode(): 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
-     */
-    private reloadMasksFromVolume;
-    /**
-     * 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.
-     */
-    flipDisplayImageByAxis(): void;
+    clearActiveLayer(): void;
+    reset(): void;
+    configMouseSliceWheel(): (e: WheelEvent) => void;
+    updateMouseWheelEvent(): void;
+    setIsDrawFalse(target: number): void;
+    private setShowInMainArea;
     private clearDictionary;
     /**
-     * Set the empty canvas width and height based on the axis (pixel distance not the mm), to reduce duplicate codes.
-     *
-     * @param axis
+     * Get the DrawToolCore's start() render loop callback.
+     * This is called by DragSliceTool's requestAnimationFrame loop.
      */
-    setEmptyCanvasSize(axis?: "x" | "y" | "z"): void;
-    /******************************** redraw display canvas  ***************************************/
+    get start(): () => void;
     /**
-     * Redraw current contrast image to display canvas.
-     * It is more related to change the contrast slice image's window width or center.
+     * Expose drawCalculatorSphereOnEachViews for external use.
      */
-    redrawDisplayCanvas(): void;
-    /**
-     * Config mouse slice wheel event.
-     */
-    configMouseSliceWheel(): (e: WheelEvent) => void;
-    /**
-     * Update mouse wheel event.
-     */
-    updateMouseWheelEvent(): void;
+    drawCalculatorSphereOnEachViews(axis: "x" | "y" | "z"): void;
 }