copper3d 3.0.2 → 3.1.0

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

@@ -7,31 +7,7 @@
  */
 import { BaseTool } from "./BaseTool";
 import type { ToolContext } from "./BaseTool";
-import type { MaskDelta } from "../core";
-/**
- * Callbacks DrawingTool needs from its host (DrawToolCore).
- */
-export interface DrawingCallbacks {
-    /** Get current layer's canvas and 2D context */
-    setCurrentLayer: () => {
-        ctx: CanvasRenderingContext2D;
-        canvas: HTMLCanvasElement;
-    };
-    /** Composite all layers to master canvas */
-    compositeAllLayers: () => void;
-    /** Sync layer slice data to MaskVolume */
-    syncLayerSliceData: (index: number, layer: string) => void;
-    /** Get stored image data for previous image redraw */
-    filterDrawedImage: (axis: "x" | "y" | "z", index: number) => {
-        image: ImageData;
-    } | undefined;
-    /** Get MaskVolume for a layer (undo snapshots) */
-    getVolumeForLayer: (layer: string) => any;
-    /** Push delta to UndoManager */
-    pushUndoDelta: (delta: MaskDelta) => void;
-    /** Get eraser icon URLs */
-    getEraserUrls: () => string[];
-}
+import type { DrawingHostDeps } from "./ToolHost";
 export declare class DrawingTool extends BaseTool {
     /** Left mouse button currently held (draw mode) */
     private leftClicked;
@@ -46,7 +22,7 @@ export declare class DrawingTool extends BaseTool {
     private preDrawAxis;
     private preDrawSliceIndex;
     private callbacks;
-    constructor(ctx: ToolContext, callbacks: DrawingCallbacks);
+    constructor(ctx: ToolContext, callbacks: DrawingHostDeps);
     /** Whether a draw operation is currently active */
     get isActive(): boolean;
     /** Whether paint strokes are being recorded */
@@ -77,6 +53,22 @@ export declare class DrawingTool extends BaseTool {
      * @returns true if drawing was in progress when leave occurred
      */
     onPointerLeave(): boolean;
+    /**
+     * Create a self-managing mouseover/mouseout/mousemove handler
+     * that tracks brush hover position for the preview circle.
+     *
+     * The returned function should be registered on drawingCanvas for
+     * "mouseover" and "mouseout" events.  It adds/removes a "mousemove"
+     * listener on itself to keep mouseOverX/Y up-to-date while the
+     * cursor is inside the canvas.
+     */
+    createBrushTrackingHandler(): (e: MouseEvent) => void;
+    /**
+     * Render brush circle preview on the drawing context.
+     * Called from the start() render loop when in draw mode and not
+     * actively painting.  Skipped in pencil/eraser mode.
+     */
+    renderBrushPreview(ctx: CanvasRenderingContext2D, width: number, height: number): void;
     /** Capture pre-draw slice snapshot for undo */
     private capturePreDrawSnapshot;
     /** Push delta to UndoManager after drawing completes */

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

@@ -8,13 +8,10 @@
  */
 import { BaseTool } from "./BaseTool";
 import type { ToolContext } from "./BaseTool";
-export interface ImageStoreCallbacks {
-    setEmptyCanvasSize: (axis?: "x" | "y" | "z") => void;
-    drawImageOnEmptyImage: (canvas: HTMLCanvasElement) => void;
-}
+import type { ImageStoreHostDeps } from "./ToolHost";
 export declare class ImageStoreHelper extends BaseTool {
     private callbacks;
-    constructor(ctx: ToolContext, callbacks: ImageStoreCallbacks);
+    constructor(ctx: ToolContext, callbacks: ImageStoreHostDeps);
     /**
      * Get MaskVolume for a specific layer.
      * Delegates to the volumes stored in protectedData.maskData.

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

@@ -0,0 +1,52 @@
+import { BaseTool } from "./BaseTool";
+import type { ToolContext } from "./BaseTool";
+import type { ChannelValue, RGBAColor, ChannelColorMap } from "../core";
+import type { SphereType } from "./SphereTool";
+import type { LayerChannelHostDeps } from "./ToolHost";
+/**
+ * Manages layer/channel state: active selection, visibility, and channel colors.
+ *
+ * Extracted from NrrdTools.ts to reduce its size.
+ * Follows the same BaseTool + ToolContext + Callbacks pattern as other tools.
+ */
+export declare class LayerChannelManager extends BaseTool {
+    private callbacks;
+    constructor(ctx: ToolContext, callbacks: LayerChannelHostDeps);
+    /****************************Active Layer/Channel****************************************************/
+    setActiveLayer(layerId: string): void;
+    getActiveLayer(): string;
+    setActiveChannel(channel: ChannelValue): void;
+    getActiveChannel(): number;
+    /**
+     * Set the active sphere type and sync brush/fill color.
+     *
+     * @example
+     * ```ts
+     * nrrdTools.setActiveSphereType('nipple');
+     * ```
+     */
+    setActiveSphereType(type: SphereType): void;
+    getActiveSphereType(): SphereType;
+    /****************************Visibility****************************************************/
+    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;
+    /****************************Channel Colors****************************************************/
+    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;
+    /****************************Private Helpers****************************************************/
+    /**
+     * Sync brush/fill color from the active layer's volume channel color.
+     * Falls back to global CHANNEL_HEX_COLORS if volume not available.
+     */
+    private syncBrushColor;
+}

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

@@ -6,13 +6,7 @@
  */
 import { BaseTool } from "./BaseTool";
 import type { ToolContext } from "./BaseTool";
-/**
- * Callbacks PanTool needs from its host (DrawToolCore).
- */
-export interface PanCallbacks {
-    /** Re-enable zoom wheel after pan ends in sphere mode */
-    zoomActionAfterDrawSphere: () => void;
-}
+import type { PanHostDeps } from "./ToolHost";
 export declare class PanTool extends BaseTool {
     /** Right mouse button currently held */
     private rightClicked;
@@ -26,7 +20,7 @@ export declare class PanTool extends BaseTool {
      * Arrow function preserves `this` binding.
      */
     private readonly boundPointerMove;
-    constructor(ctx: ToolContext, callbacks: PanCallbacks);
+    constructor(ctx: ToolContext, callbacks: PanHostDeps);
     /** Whether a pan drag is currently active */
     get isActive(): boolean;
     /**

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

@@ -0,0 +1,80 @@
+import { BaseTool } from "./BaseTool";
+import type { ToolContext } from "./BaseTool";
+import type { SliceRenderHostDeps } from "./ToolHost";
+/**
+ * Manages slice rendering pipeline: slice setup, canvas rendering, and view helpers.
+ *
+ * Extracted from NrrdTools.ts to reduce its size.
+ * Follows the same BaseTool + ToolContext + Callbacks pattern as other tools.
+ */
+export declare class SliceRenderPipeline extends BaseTool {
+    private callbacks;
+    private initState;
+    constructor(ctx: ToolContext, callbacks: SliceRenderHostDeps);
+    /**
+     * Reset initState to true (called from NrrdTools.reset() when switching datasets).
+     */
+    resetInitState(): void;
+    /****************************Slice Setup****************************************************/
+    setDisplaySlicesBaseOnAxis(): void;
+    private loadDisplaySlicesArray;
+    resetDisplaySlicesStatus(): void;
+    private setupConfigs;
+    private setMainPreSlice;
+    private setOriginCanvasAndPre;
+    afterLoadSlice(): void;
+    private updateMaxIndex;
+    /****************************Rendering****************************************************/
+    /**
+     * Phase 3: Reload all mask layers from MaskVolume using buffer reuse
+     * Replaces the old reloadMaskToLayer approach
+     */
+    reloadMasksFromVolume(): void;
+    /******************************** redraw display canvas  ***************************************/
+    /**
+     * Redraw current contrast image to display canvas.
+     * It is more related to change the contrast slice image's window width or center.
+     */
+    redrawDisplayCanvas(): void;
+    redrawMianPreOnDisplayCanvas(): 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.
+     */
+    flipDisplayImageByAxis(): void;
+    /**
+     * Set the empty canvas width and height based on the axis (pixel distance not the mm), to reduce duplicate codes.
+     *
+     * @param axis
+     */
+    setEmptyCanvasSize(axis?: "x" | "y" | "z"): void;
+    /**
+     * Clear masks on drawingCanvas layers.
+     */
+    resetLayerCanvas(): void;
+    /****************************View/Canvas Helpers****************************************************/
+    /**
+     * Resize the draw and display canvas size based on the input size factor number.
+     * @param factor number
+     */
+    resizePaintArea(factor: number): 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;
+    /**
+     * 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.
+     */
+    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;
+}

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

@@ -43,10 +43,11 @@
  * - drawSphereOnEachViews / drawCalculatorSphereOnEachViews
  * - storeSphereImages / setSphereCanvasSize
  * - drawCalculatorSphere / configMouseSphereWheel
- * - getSpherePosition / clearSpherePrintStoreImages
+ * - getSpherePosition
  */
 import { BaseTool } from "./BaseTool";
 import type { ToolContext } from "./BaseTool";
+import type { SphereHostDeps } from "./ToolHost";
 /** The 4 supported sphere marker types. */
 export type SphereType = 'tumour' | 'skin' | 'nipple' | 'ribcage';
 /**
@@ -72,22 +73,10 @@ export declare const SPHERE_CHANNEL_MAP: Record<SphereType, {
  * Calculator mode uses type-specific labels (1-4).
  */
 export declare const SPHERE_LABELS: Record<SphereType | 'default', number>;
-/**
- * Callbacks that DrawToolCore must provide for sphere operations.
- * These are internal canvas manipulation callbacks, NOT external data callbacks.
- *
- * External data output uses:
- * - annotationCallbacks.onSphereChanged(origin, radius) — sphere mode
- * - annotationCallbacks.onCalculatorPositionsChanged(...) — calculator mode
- */
-export interface SphereCallbacks {
-    setEmptyCanvasSize: (axis?: "x" | "y" | "z") => void;
-    drawImageOnEmptyImage: (canvas: HTMLCanvasElement) => void;
-}
 export declare class SphereTool extends BaseTool {
     private callbacks;
-    constructor(ctx: ToolContext, callbacks: SphereCallbacks);
-    setCallbacks(callbacks: SphereCallbacks): void;
+    constructor(ctx: ToolContext, callbacks: SphereHostDeps);
+    setCallbacks(callbacks: SphereHostDeps): void;
     /**
      * Get the channel number for a sphere type.
      *
@@ -189,12 +178,29 @@ export declare class SphereTool extends BaseTool {
      */
     drawCalculatorSphere(radius: number): void;
     /**
-     * Clear sphere overlay images.
+     * Handle left-click in sphere mode — record origin, draw preview.
+     *
+     * Performs all data operations for sphere placement:
+     * 1. Record sphere origin for current axis
+     * 2. Convert origin to all three axes via setUpSphereOrigins
+     * 3. Store origin for the active sphere type
+     * 4. Enable crosshair at click position
+     * 5. Draw calculator sphere preview
+     *
+     * Event binding (wheel, pointerup) stays in DrawToolCore as orchestration.
+     */
+    onSphereClick(e: MouseEvent): void;
+    /**
+     * Handle pointer-up in sphere mode — write to volume, fire callbacks.
+     *
+     * Performs:
+     * 1. Write all placed calculator spheres to sphereMaskVolume
+     * 2. Refresh sphere canvas overlay from volume
+     * 3. Fire onSphereChanged and onCalculatorPositionsChanged callbacks
      *
-     * No-op in current implementation — sphere data is rendered as overlay
-     * and stored in the dedicated sphereMaskVolume (not in layer volumes).
+     * Event cleanup (wheel, pointerup listener removal) stays in DrawToolCore.
      */
-    clearSpherePrintStoreImages(): void;
+    onSpherePointerUp(): void;
     /**
      * Convert canvas (mm-space) coordinates to 3D voxel coordinates.
      *

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

@@ -0,0 +1,74 @@
+/**
+ * ToolHost — Unified host interface for all tools.
+ *
+ * Replaces the 10 individual *Callbacks interfaces with a single definition.
+ * Each tool picks only the methods it needs via `Pick<ToolHost, ...>`.
+ *
+ * @see issue3_unify_callbacks_plan.md
+ */
+import type { MaskVolume, MaskDelta } from "../core";
+import type { RGBAColor } from "../core";
+/**
+ * Unified host interface — all methods that tools may call back into.
+ *
+ * Each tool picks only the methods it needs via `Pick<ToolHost, ...>`.
+ */
+export interface ToolHost {
+    setEmptyCanvasSize(axis?: "x" | "y" | "z"): void;
+    drawImageOnEmptyImage(canvas: HTMLCanvasElement): void;
+    compositeAllLayers(): void;
+    renderSliceToCanvas(layer: string, axis: "x" | "y" | "z", sliceIndex: number, buffer: ImageData, targetCtx: CanvasRenderingContext2D, scaledWidth: number, scaledHeight: number): void;
+    getOrCreateSliceBuffer(axis: "x" | "y" | "z"): ImageData | null;
+    flipDisplayImageByAxis(): void;
+    redrawDisplayCanvas(): void;
+    refreshSphereOverlay(): void;
+    reloadMasksFromVolume(): void;
+    getVolumeForLayer(layer: string): MaskVolume;
+    setIsDrawFalse(target: number): void;
+    setSyncsliceNum(): void;
+    resetPaintAreaUIPosition(l?: number, t?: number): void;
+    resizePaintArea(moveDistance: number): void;
+    resetZoom(): void;
+    invalidateSliceBuffer(): void;
+    clearUndoHistory(): void;
+    setCurrentLayer(): {
+        ctx: CanvasRenderingContext2D;
+        canvas: HTMLCanvasElement;
+    };
+    syncLayerSliceData(index: number, layer: string): void;
+    filterDrawedImage(axis: "x" | "y" | "z", index: number): {
+        image: ImageData;
+    } | undefined;
+    pushUndoDelta(delta: MaskDelta): void;
+    getEraserUrls(): string[];
+    enableCrosshair(): void;
+    setUpSphereOrigins(mouseX: number, mouseY: number, sliceIndex: number): void;
+    zoomActionAfterDrawSphere(): void;
+    setDisplaySlicesBaseOnAxis(): void;
+    afterLoadSlice(): void;
+    syncGuiParameterSettings(): void;
+    repraintCurrentContrastSlice(): void;
+    updateShowNumDiv(contrastNum: number): void;
+    updateCurrentContrastSlice(): void;
+    onChannelColorChanged(layerId: string, channel: number, color: RGBAColor): void;
+}
+/** ImageStoreHelper host dependencies */
+export type ImageStoreHostDeps = Pick<ToolHost, 'setEmptyCanvasSize' | 'drawImageOnEmptyImage'>;
+/** PanTool host dependencies */
+export type PanHostDeps = Pick<ToolHost, 'zoomActionAfterDrawSphere'>;
+/** ContrastTool host dependencies */
+export type ContrastHostDeps = Pick<ToolHost, 'setIsDrawFalse' | 'setSyncsliceNum'>;
+/** ZoomTool host dependencies */
+export type ZoomHostDeps = Pick<ToolHost, 'resetPaintAreaUIPosition' | 'resizePaintArea' | 'setIsDrawFalse'>;
+/** SphereTool host dependencies */
+export type SphereHostDeps = Pick<ToolHost, 'setEmptyCanvasSize' | 'drawImageOnEmptyImage' | 'enableCrosshair' | 'setUpSphereOrigins'>;
+/** DrawingTool host dependencies */
+export type DrawingHostDeps = Pick<ToolHost, 'setCurrentLayer' | 'compositeAllLayers' | 'syncLayerSliceData' | 'filterDrawedImage' | 'getVolumeForLayer' | 'pushUndoDelta' | 'getEraserUrls'>;
+/** DragSliceTool host dependencies */
+export type DragSliceHostDeps = Pick<ToolHost, 'setSyncsliceNum' | 'setIsDrawFalse' | 'flipDisplayImageByAxis' | 'setEmptyCanvasSize' | 'getOrCreateSliceBuffer' | 'renderSliceToCanvas' | 'refreshSphereOverlay'>;
+/** LayerChannelManager host dependencies */
+export type LayerChannelHostDeps = Pick<ToolHost, 'reloadMasksFromVolume' | 'getVolumeForLayer' | 'onChannelColorChanged'>;
+/** SliceRenderPipeline host dependencies */
+export type SliceRenderHostDeps = Pick<ToolHost, 'compositeAllLayers' | 'getOrCreateSliceBuffer' | 'renderSliceToCanvas' | 'getVolumeForLayer' | 'refreshSphereOverlay' | 'syncGuiParameterSettings' | 'repraintCurrentContrastSlice' | 'clearUndoHistory' | 'updateShowNumDiv' | 'updateCurrentContrastSlice'>;
+/** DataLoader host dependencies */
+export type DataLoaderHostDeps = Pick<ToolHost, 'invalidateSliceBuffer' | 'setDisplaySlicesBaseOnAxis' | 'afterLoadSlice' | 'setEmptyCanvasSize' | 'syncLayerSliceData' | 'reloadMasksFromVolume' | 'resetZoom'>;

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

@@ -6,15 +6,11 @@
  */
 import { BaseTool } from "./BaseTool";
 import type { ToolContext } from "./BaseTool";
-export interface ZoomCallbacks {
-    resetPaintAreaUIPosition: (l?: number, t?: number) => void;
-    resizePaintArea: (moveDistance: number) => void;
-    setIsDrawFalse: (target: number) => void;
-}
+import type { ZoomHostDeps } from "./ToolHost";
 export declare class ZoomTool extends BaseTool {
     private container;
     private mainAreaContainer;
     private callbacks;
-    constructor(ctx: ToolContext, container: HTMLElement, mainAreaContainer: HTMLDivElement, callbacks: ZoomCallbacks);
+    constructor(ctx: ToolContext, container: HTMLElement, mainAreaContainer: HTMLDivElement, callbacks: ZoomHostDeps);
     configMouseZoomWheel(): (e: WheelEvent) => void;
 }

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

@@ -8,19 +8,17 @@
  */
 export { BaseTool } from "./BaseTool";
 export type { ToolContext } from "./BaseTool";
+export type { ToolHost, ImageStoreHostDeps, PanHostDeps, ContrastHostDeps, ZoomHostDeps, SphereHostDeps, DrawingHostDeps, DragSliceHostDeps, LayerChannelHostDeps, SliceRenderHostDeps, DataLoaderHostDeps, } from "./ToolHost";
 export { EraserTool } from "./EraserTool";
 export { DrawingTool } from "./DrawingTool";
-export type { DrawingCallbacks } from "./DrawingTool";
 export { PanTool } from "./PanTool";
-export type { PanCallbacks } from "./PanTool";
 export { ZoomTool } from "./ZoomTool";
-export type { ZoomCallbacks } from "./ZoomTool";
 export { SphereTool, SPHERE_CHANNEL_MAP } from "./SphereTool";
-export type { SphereCallbacks, SphereType } from "./SphereTool";
+export type { SphereType } from "./SphereTool";
 export { CrosshairTool } from "./CrosshairTool";
 export { ContrastTool } from "./ContrastTool";
-export type { ContrastCallbacks } from "./ContrastTool";
 export { ImageStoreHelper } from "./ImageStoreHelper";
-export type { ImageStoreCallbacks } from "./ImageStoreHelper";
 export { DragSliceTool } from "./DragSliceTool";
-export type { DragSliceCallbacks } from "./DragSliceTool";
+export { LayerChannelManager } from "./LayerChannelManager";
+export { SliceRenderPipeline } from "./SliceRenderPipeline";
+export { DataLoader } from "./DataLoader";

package/dist/types/Utils/workers/reformatSaveDataWorker.d.ts

@@ -1,4 +1,4 @@
-import { IPaintImage } from "../segmentation/coreTools/coreType";
+import { IPaintImage } from "../segmentation/core/types";
 declare function pruningData(originArr: IPaintImage[]): Uint8ClampedArray[];
 declare function restructData(originArr: IPaintImage[], len: number, width: number, height: number): {
     sliceIndex: number;

package/dist/types/index.d.ts

@@ -17,13 +17,13 @@ import { Copper3dTrackballControls } from "./Controls/Copper3dTrackballControls"
 import { MeshNodeTool } from "./Utils/MeshNodeTool";
 import { removeGuiFolderChilden } from "./Utils/segmentation/coreTools/gui";
 import { nrrdMeshesType, nrrdSliceType, SensorDecodedValue_kiwrious, SensorReadResult_kiwrious, HeartRateResult_kiwrious, loadingBarType, exportPaintImageType, IOptVTKLoader } from "./types/types";
-import { IPaintImage, ICommXYZ, IGUIStates, IGuiParameterSettings, INrrdStates, IGuiMeta } from "./Utils/segmentation/coreTools/coreType";
+import { IPaintImage, ICommXYZ, IGUIStates, IGuiParameterSettings, INrrdStates, IGuiMeta } from "./Utils/segmentation/core/types";
 import { NrrdState } from "./Utils/segmentation/coreTools/NrrdState";
 import { GuiState } from "./Utils/segmentation/coreTools/GuiState";
-import type { ToolMode, IAnnotationCallbacks } from "./Utils/segmentation/coreTools/coreType";
+import type { ToolMode, IAnnotationCallbacks } from "./Utils/segmentation/core/types";
 import { CHANNEL_COLORS, CHANNEL_HEX_COLORS, rgbaToHex, rgbaToCss } from "./Utils/segmentation/core/index";
 import type { LayerId, ChannelValue } from "./Utils/segmentation/core/index";
 import "./css/style.css";
-export declare const REVISION = "v3.0.2-beta";
+export declare const REVISION = "v3.1.0-beta";
 export { copperRenderer, copperRendererOnDemond, copperMSceneRenderer, setHDRFilePath, addLabelToScene, convert3DPostoScreenPos, convertScreenPosto3DPos, addBoxHelper, fullScreenListenner, configKiwriousHeart, copperScene, copperSceneOnDemond, copperMScene, CameraViewPoint, kiwrious, NrrdTools, loading, Copper3dTrackballControls, createTexture2D_NRRD, MeshNodeTool, throttle, removeGuiFolderChilden, CHANNEL_COLORS, CHANNEL_HEX_COLORS, rgbaToHex, rgbaToCss, };
 export type { positionType, screenPosType, optsType, nrrdMeshesType, nrrdSliceType, SensorDecodedValue_kiwrious, SensorReadResult_kiwrious, HeartRateResult_kiwrious, loadingBarType, IPaintImage, exportPaintImageType, IOptVTKLoader, ICommXYZ, IGUIStates, IGuiParameterSettings, INrrdStates, NrrdState, GuiState, IGuiMeta, ToolMode, IAnnotationCallbacks, LayerId, ChannelValue, };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "copper3d",
   "description": "A 3d visualisation package base on threejs provides multiple scenes and Nrrd image load funtion.",
-  "version": "3.0.2",
+  "version": "3.1.0",
   "main": "dist/bundle.umd.js",
   "moudle": "dist/bundle.esm.js",
   "types": "dist/types/index.d.ts",

package/dist/Utils/segmentation/CommToolsData.d.ts

@@ -1,192 +0,0 @@
-import { IProtected, ICursorPage, IConvertObjType, INewMaskData, IKeyBoardSettings, IAnnotationCallbacks } from "./coreTools/coreType";
-import { NrrdState } from "./coreTools/NrrdState";
-import { GuiState } from "./coreTools/GuiState";
-import { MaskVolume } from "./core/index";
-export declare class CommToolsData {
-    baseCanvasesSize: number;
-    private _reusableSliceBuffer;
-    private _reusableBufferWidth;
-    private _reusableBufferHeight;
-    /** External annotation callbacks — set via draw() options */
-    protected annotationCallbacks: IAnnotationCallbacks;
-    /** Whether the keyboard-config dialog is open (suppresses all shortcuts). */
-    protected _configKeyBoard: boolean;
-    /** Active keyboard shortcut bindings. */
-    protected _keyboardSettings: IKeyBoardSettings;
-    protected nrrd_states: NrrdState;
-    protected cursorPage: ICursorPage;
-    protected gui_states: GuiState;
-    protected protectedData: IProtected;
-    constructor(container: HTMLElement, mainAreaContainer: HTMLElement, options?: {
-        layers?: string[];
-    });
-    /**
-     * Get MaskVolume for a specific layer
-     *
-     * @param layer - Layer name: "layer1", "layer2", or "layer3"
-     * @returns MaskVolume instance for the specified layer
-     *
-     * @example
-     * ```ts
-     * const volume = this.getVolumeForLayer("layer1");
-     * volume.setVoxel(x, y, z, 255);
-     * ```
-     */
-    getVolumeForLayer(layer: string): MaskVolume;
-    /**
-     * Get MaskVolume for the currently active layer
-     *
-     * @returns MaskVolume instance for the current layer
-     *
-     * @example
-     * ```ts
-     * const volume = this.getCurrentVolume();
-     * const slice = volume.getSliceImageData(50, 'z');
-     * ```
-     */
-    getCurrentVolume(): MaskVolume;
-    /**
-     * Get all three MaskVolume instances
-     *
-     * @returns Object containing all three layer volumes
-     *
-     * @example
-     * ```ts
-     * const { layer1, layer2, layer3 } = this.getAllVolumes();
-     * layer1.clear();
-     * ```
-     */
-    getAllVolumes(): INewMaskData;
-    private generateSystemCanvases;
-    private generateLayerTargets;
-    /**
-     * Rewrite this {clearActiveSlice} function under DrawToolCore
-     */
-    clearActiveSlice(): void;
-    /**
-     * Rewrite this {undoLastPainting} function under DrawToolCore
-     */
-    undoLastPainting(): void;
-    /**
-     * Rewrite this {redoLastPainting} function under DrawToolCore
-     */
-    redoLastPainting(): void;
-    /**
-     * Rewrite this {clearActiveLayer} function under NrrdTools
-     */
-    clearActiveLayer(): void;
-    /**
-     * Rewrite this {resizePaintArea} function under NrrdTools
-     */
-    resizePaintArea(factor: number): void;
-    /**
-     * Rewrite this {setIsDrawFalse} function under NrrdTools
-     */
-    setIsDrawFalse(target: number): void;
-    /**
-     * Rewrite this {updateOriginAndChangedWH} function under NrrdTools
-     */
-    updateOriginAndChangedWH(): void;
-    /**
-     * Rewrite this {flipDisplayImageByAxis} function under NrrdTools
-     */
-    flipDisplayImageByAxis(): void;
-    /**
-     * Rewrite this {resetPaintAreaUIPosition} function under NrrdTools
-     */
-    resetPaintAreaUIPosition(l?: number, t?: number): void;
-    /**
-     * Rewrite this {resetPaintAreaUIPosition} function under NrrdTools
-     */
-    setEmptyCanvasSize(axis?: "x" | "y" | "z"): void;
-    /**
-     * Rewrite this {convertCursorPoint} function under NrrdTools
-     */
-    convertCursorPoint(from: "x" | "y" | "z", to: "x" | "y" | "z", cursorNumX: number, cursorNumY: number, currentSliceIndex: number): IConvertObjType | undefined;
-    /**
-     * Rewrite this {resetLayerCanvas} function under NrrdTools
-     */
-    resetLayerCanvas(): void;
-    /**
-     * Enter sphere mode: clear all layer canvases (not MaskVolume),
-     * hide all mask data so sphere overlay is the only visible annotation.
-     * Rewrite this under NrrdTools.
-     */
-    enterSphereMode(): void;
-    /**
-     * Exit sphere mode: clear sphere canvas overlay, reload all layer
-     * MaskVolume data back onto canvases. Rewrite this under NrrdTools.
-     */
-    exitSphereMode(): void;
-    /**
-     * Rewrite this {setSyncsliceNum} function under NrrdTools
-     */
-    setSyncsliceNum(): void;
-    /**
-     * Rewrite this {redrawDisplayCanvas} function under NrrdTools
-     */
-    redrawDisplayCanvas(): void;
-    /**
-     * Get a painted mask image based on current axis and input slice index.
-     *
-     * Phase 3: Reads directly from MaskVolume.
-     *
-     * @param axis "x" | "y" | "z"
-     * @param sliceIndex number
-     * @returns Object with index and image, or undefined
-     */
-    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.
-     * The buffer is only reallocated when slice dimensions change (axis switch).
-     *
-     * @param axis - Axis: "x", "y", or "z"
-     * @returns Reusable ImageData buffer with correct dimensions
-     */
-    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.
-     * The caller should obtain the buffer via getOrCreateSliceBuffer() and reuse
-     * it across multiple layer renders.
-     *
-     * @param layer - Layer name: "layer1", "layer2", or "layer3"
-     * @param axis - Axis: "x", "y", or "z"
-     * @param sliceIndex - Slice index
-     * @param buffer - Reusable ImageData buffer (from getOrCreateSliceBuffer)
-     * @param targetCtx - Canvas context to draw the result onto
-     * @param scaledWidth - Target display width
-     * @param scaledHeight - Target display height
-     */
-    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).
-     * The buffer will be lazily recreated on next use.
-     */
-    invalidateSliceBuffer(): void;
-    /**
-     * Apply the same flip transform used by flipDisplayImageByAxis() to any
-     * canvas context.  This ensures mask overlays align with the flipped CT image.
-     *
-     * The flip is its own inverse (applying twice = identity), so it works for
-     * both directions: volume→display (rendering) and display→volume (storing).
-     *
-     * @param ctx    Target 2D context (must be wrapped in save/restore by caller).
-     * @param width  Canvas width in pixels.
-     * @param height Canvas height in pixels.
-     * @param axis   Current viewing axis.
-     */
-    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;
-}