copper3d 2.2.3 → 3.0.0

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

@@ -0,0 +1,106 @@
+/**
+ * Core Type Definitions for MaskVolume
+ *
+ * Shared types for the 3D volumetric mask storage system.
+ */
+/**
+ * 3D volume dimensions in voxels.
+ *
+ * Coordinate convention:
+ *   x = left-right  (sagittal axis)
+ *   y = front-back  (coronal axis)
+ *   z = bottom-top  (axial axis / slice direction)
+ */
+export interface Dimensions {
+    width: number;
+    height: number;
+    depth: number;
+}
+/**
+ * RGBA color with each component in the range [0, 255].
+ */
+export interface RGBAColor {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/**
+ * Maps channel indices to RGBA colors.
+ */
+export type ChannelColorMap = Record<number, RGBAColor>;
+/**
+ * Rendering mode for slice extraction.
+ */
+export declare enum RenderMode {
+    /** Single channel as grayscale (original behavior). */
+    GRAYSCALE = "grayscale",
+    /** Single channel with predefined color. */
+    COLORED_SINGLE = "colored_single",
+    /** All channels composited with colors (last non-zero channel wins). */
+    COLORED_MULTI = "colored_multi",
+    /** All channels blended (additive). */
+    BLENDED = "blended"
+}
+/**
+ * Options for slice rendering via `getSliceImageData()`.
+ */
+export interface SliceRenderOptions {
+    /** Rendering mode (default: GRAYSCALE). */
+    mode?: RenderMode;
+    /** Specific channel to render (for GRAYSCALE / COLORED_SINGLE modes, default 0). */
+    channel?: number;
+    /** Custom color map (overrides the volume's default). */
+    colorMap?: ChannelColorMap;
+    /** Channel visibility mask (for COLORED_MULTI / BLENDED modes). */
+    visibleChannels?: boolean[];
+    /** Opacity multiplier 0.0 – 1.0 (default 1.0). */
+    opacity?: number;
+}
+/**
+ * Predefined color palette for mask channels.
+ *
+ * Based on common medical imaging conventions:
+ *
+ * | Channel | Role                      | Color    |
+ * |---------|---------------------------|----------|
+ * | 0       | Background                | transparent |
+ * | 1       | Primary / Tumor           | Green    |
+ * | 2       | Secondary / Edema         | Red      |
+ * | 3       | Tertiary / Necrosis       | Blue     |
+ * | 4       | Enhancement               | Yellow   |
+ * | 5       | Vessel / Boundary         | Magenta  |
+ * | 6       | Additional region         | Cyan     |
+ * | 7       | Auxiliary annotation       | Orange   |
+ * | 8       | Extended annotation        | Purple   |
+ */
+export declare const MASK_CHANNEL_COLORS: Readonly<ChannelColorMap>;
+/**
+ * CSS color strings for the default channel palette (for reference / UI).
+ */
+export declare const MASK_CHANNEL_CSS_COLORS: Readonly<Record<number, string>>;
+/**
+ * Layer identifier. Any string key is valid — layers are dynamically defined.
+ */
+export type LayerId = string;
+/**
+ * Channel value (0 = transparent/erased, 1-8 = annotation channels).
+ */
+export type ChannelValue = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+/**
+ * Convenience alias for MASK_CHANNEL_CSS_COLORS.
+ * Used by Vue components via `Copper.CHANNEL_COLORS[channel]`.
+ */
+export declare const CHANNEL_COLORS: Readonly<Record<number, string>>;
+/**
+ * Hex color strings for each channel (no alpha), used for fillColor/brushColor.
+ */
+export declare const CHANNEL_HEX_COLORS: Readonly<Record<number, string>>;
+/**
+ * Convert an RGBAColor to a hex string (no alpha), e.g. '#ff0000'.
+ */
+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;

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

@@ -63,16 +63,32 @@ interface IPaintImage {
     index: number;
     image: ImageData;
 }
-interface IStoredPaintImages {
-    label1: IPaintImages;
-    label2: IPaintImages;
-    label3: IPaintImages;
+/**
+ * Import MaskVolume from core module
+ * (imported where needed, not here to avoid circular deps)
+ */
+type MaskVolume = any;
+/**
+ * New mask data structure using MaskVolume for true 3D storage.
+ * Dynamic N-layer support: keyed by layer id (e.g. 'layer1', 'layer2', ...).
+ */
+type INewMaskData = Record<string, MaskVolume>;
+/**
+ * A paired canvas + 2D context for a single annotation layer.
+ * Stored atomically in IProtected.layerTargets to prevent canvas/ctx desync.
+ */
+interface ILayerRenderTarget {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
 }
+/**
+ * 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.
+ */
 type IMaskData = {
-    paintImagesLabel1: IPaintImages;
-    paintImagesLabel2: IPaintImages;
-    paintImagesLabel3: IPaintImages;
-    paintImages: IPaintImages;
+    volumes: INewMaskData;
 };
 interface IProtected {
     container: HTMLElement;
@@ -89,15 +105,14 @@ interface IProtected {
     axis: "x" | "y" | "z";
     maskData: IMaskData;
     previousDrawingImage?: ImageData;
+    /** 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;
-        drawingCanvasLayerOne: HTMLCanvasElement;
-        drawingCanvasLayerTwo: HTMLCanvasElement;
         drawingSphereCanvas: HTMLCanvasElement;
-        drawingCanvasLayerThree: HTMLCanvasElement;
         emptyCanvas: HTMLCanvasElement;
     };
     ctxes: {
@@ -106,9 +121,6 @@ interface IProtected {
         emptyCtx: CanvasRenderingContext2D;
         drawingSphereCtx: CanvasRenderingContext2D;
         drawingLayerMasterCtx: CanvasRenderingContext2D;
-        drawingLayerOneCtx: CanvasRenderingContext2D;
-        drawingLayerTwoCtx: CanvasRenderingContext2D;
-        drawingLayerThreeCtx: CanvasRenderingContext2D;
     };
 }
 interface IGUIStates {
@@ -118,12 +130,12 @@ interface IGUIStates {
     globalAlpha: number;
     lineWidth: number;
     color: string;
-    segmentation: true;
+    pencil: boolean;
     fillColor: string;
     brushColor: string;
     brushAndEraserSize: number;
     cursor: string;
-    label: string;
+    layer: string;
     cal_distance: "tumour" | "skin" | "nipple" | "ribcage";
     sphere: boolean;
     calculator: boolean;
@@ -133,12 +145,20 @@ interface IGUIStates {
     clear: () => void;
     clearAll: () => void;
     undo: () => void;
+    redo: () => void;
     downloadCurrentMask: () => void;
     resetZoom: () => void;
+    /** 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>>;
 }
 interface IKeyBoardSettings {
     draw: string;
     undo: string;
+    redo: string;
     contrast: string[];
     crosshair: string;
     mouseWheel: "Scroll:Zoom" | "Scroll:Slice";
@@ -164,7 +184,6 @@ interface INrrdStates {
     dimensions: number[];
     loadMaskJson: boolean;
     ratios: ICommXYZ;
-    sharedPlace: ICommXYZ;
     contrastNum: number;
     showContrast: boolean;
     enableCursorChoose: boolean;
@@ -191,10 +210,15 @@ interface INrrdStates {
     previousPanelL: number;
     previousPanelT: number;
     switchSliceFlag: boolean;
-    labels: ["label1", "label2", "label3"];
-    configKeyBoard: boolean;
-    keyboardSettings: IKeyBoardSettings;
-    getMask: (mask: ImageData, sliceId: number, label: string, width: number, height: number, clearAllFlag: boolean) => void;
+    layers: string[];
+    getMask: (sliceData: Uint8Array, layerId: string, channelId: number, sliceIndex: number, axis: "x" | "y" | "z", width: number, height: number, clearFlag: boolean) => void;
+    onClearLayerVolume: (layerId: string) => void;
+    onChannelColorChanged: (layerId: string, channel: number, color: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    }) => void;
     getSphere: (sphereOrigin: number[], sphereRadius: number) => void;
     getCalculateSpherePositions: (tumourSphereOrigin: ICommXYZ | null, skinSphereOrigin: ICommXYZ | null, ribSphereOrigin: ICommXYZ | null, nippleSphereOrigin: ICommXYZ | null, aixs: "x" | "y" | "z") => void;
     drawStartPos: ICommXY;
@@ -204,19 +228,11 @@ interface IDragOpts {
     getSliceNum?: (index: number, contrastNum: number) => void;
 }
 interface IDrawOpts {
-    getMaskData?: (mask: ImageData, sliceId: number, label: string, width: number, height: number, clearAllFlag?: boolean) => void;
+    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;
 }
-type UndoLayerType = {
-    label1: Array<HTMLImageElement>;
-    label2: Array<HTMLImageElement>;
-    label3: Array<HTMLImageElement>;
-};
-interface IUndoType {
-    sliceIndex: number;
-    layers: UndoLayerType;
-}
 interface ICursorPage {
     x: {
         cursorPageX: number;
@@ -244,7 +260,7 @@ interface IGuiParameterSettings {
         max: number;
         step: number;
     };
-    segmentation: {
+    pencil: {
         name: "Pencil";
         onChange: () => void;
     };
@@ -280,6 +296,9 @@ interface IGuiParameterSettings {
     undo: {
         name: "Undo";
     };
+    redo: {
+        name: "Redo";
+    };
     resetZoom: {
         name: "ResetZoom";
     };
@@ -302,9 +321,9 @@ interface IGuiParameterSettings {
         onFinished: () => void;
     };
     advance: {
-        label: {
-            name: "Label";
-            value: ["label1", "label2", "label3"];
+        layer: {
+            name: "Layer";
+            value: string[];
         };
         cursor: {
             name: "CursorIcon";
@@ -344,4 +363,4 @@ interface IGuiParameterSettings {
         };
     };
 }
-export { ICommXYZ, ICommXY, IDownloadImageConfig, IConvertObjType, IDragPrameters, IDrawingEvents, IContrastEvents, IProtected, IGUIStates, IDragOpts, IDrawOpts, INrrdStates, IPaintImage, IPaintImages, IStoredPaintImages, ISkipSlicesDictType, IMaskData, IUndoType, ICursorPage, IGuiParameterSettings };
+export { ICommXYZ, ICommXY, IDownloadImageConfig, IConvertObjType, IDragPrameters, IDrawingEvents, IContrastEvents, IProtected, IGUIStates, IDragOpts, IDrawOpts, INrrdStates, IPaintImage, IPaintImages, ISkipSlicesDictType, IMaskData, INewMaskData, ILayerRenderTarget, ICursorPage, IGuiParameterSettings, IKeyBoardSettings };

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

@@ -11,6 +11,7 @@ interface IConfigGUI {
     protectedData: IProtected;
     eraserUrls: string[];
     pencilUrls: string[];
+    getVolumeForLayer: (layer: string) => any;
     mainPreSlices: any;
     removeDragMode: () => void;
     configDragMode: () => void;
@@ -24,26 +25,15 @@ interface IConfigGUI {
     setSyncsliceNum: () => void;
     resetLayerCanvas: () => void;
     redrawDisplayCanvas: () => void;
-    reloadMaskToLabel: (paintImages: IPaintImages, ctx: CanvasRenderingContext2D) => void;
     flipDisplayImageByAxis: () => void;
-    filterDrawedImage: (axis: "x" | "y" | "z", sliceIndex: number, paintedImages: IPaintImages) => IPaintImage;
+    filterDrawedImage: (axis: "x" | "y" | "z", sliceIndex: number) => IPaintImage | undefined;
     setEmptyCanvasSize: (axis?: "x" | "y" | "z") => void;
-    storeAllImages: (index: number, label: string) => void;
+    storeAllImages: (index: number, layer: string) => void;
     drawImageOnEmptyImage: (canvas: HTMLCanvasElement) => void;
-    checkSharedPlaceSlice: (width: number, height: number, imageData: ImageData) => Uint8ClampedArray;
-    replaceArray: (mainArr: number[] | Uint8ClampedArray, replaceArr: number[] | Uint8ClampedArray) => void;
-    findSliceInSharedPlace: () => ImageData[];
-    sliceArrayH: (arr: Uint8ClampedArray, row: number, col: number) => Uint8ClampedArray[];
-    sliceArrayV: (arr: Uint8ClampedArray, row: number, col: number) => number[][];
-    storeImageToAxis: (index: number, paintedImages: IPaintImages, imageData: ImageData, axis?: "x" | "y" | "z") => void;
-    replaceVerticalColPixels: (paintImageArray: IPaintImage[], length: number, ratio: number, markedArr: number[][] | Uint8ClampedArray[], targetWidth: number, convertIndex: number) => void;
-    replaceHorizontalRowPixels: (paintImageArray: IPaintImage[], length: number, ratio: number, markedArr: number[][] | Uint8ClampedArray[], targetWidth: number, convertIndex: number) => void;
-    storeEachLayerImage: (index: number, label: string) => void;
-    storeImageToLabel: (index: number, canvas: HTMLCanvasElement, paintedImages: IPaintImages) => ImageData;
-    getRestLabel: () => ("label1" | "label2" | "label3")[];
+    storeEachLayerImage: (index: number, layer: string) => void;
+    storeImageToLayer: (index: number, canvas: HTMLCanvasElement, paintedImages: IPaintImages) => ImageData;
+    getRestLayer: () => string[];
     setIsDrawFalse: (target: number) => void;
-    initPaintImages: (dimensions: Array<number>) => void;
-    createEmptyPaintImage: (dimensions: Array<number>, paintImages: IPaintImages) => void;
 }
 declare function setupGui(configs: IConfigGUI): IGuiParameterSettings;
 declare function removeGuiFolderChilden(modeFolder: GUI): void;

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

@@ -0,0 +1,144 @@
+/**
+ * EventRouter - Centralized Event Management
+ *
+ * Consolidates keyboard, pointer, and wheel event handling from
+ * DrawToolCore.ts and DragOperator.ts into a single unified system.
+ *
+ * Features:
+ * - Single point of event registration/cleanup
+ * - Mode-based event routing (draw, drag, contrast, crosshair, etc.)
+ * - Prevents memory leaks through proper handler cleanup
+ * - Eliminates duplicate keyboard listeners between DrawToolCore and DragOperator
+ */
+import type { InteractionMode, GuiTool, KeyboardHandler, PointerHandler, WheelHandler, ModeChangeCallback, EventRouterConfig, KeyboardSettings, InteractionState } from './types';
+export declare class EventRouter {
+    private container;
+    private canvas;
+    private mode;
+    private guiTool;
+    private state;
+    private keyboardSettings;
+    /** When false, contrast key (Ctrl/Meta) is ignored for mode switching. */
+    private contrastEnabled;
+    private onModeChange?;
+    private modeChangeSubscribers;
+    private keydownHandler?;
+    private keyupHandler?;
+    private pointerDownHandler?;
+    private pointerMoveHandler?;
+    private pointerUpHandler?;
+    private pointerLeaveHandler?;
+    private wheelHandler?;
+    private boundKeyDown;
+    private boundKeyUp;
+    private boundPointerDown;
+    private boundPointerMove;
+    private boundPointerUp;
+    private boundPointerLeave;
+    private boundWheel;
+    private boundContextMenu;
+    private isBound;
+    constructor(config: EventRouterConfig);
+    /**
+     * Bind all event listeners to DOM elements.
+     * Call this after setting handlers.
+     */
+    bindAll(): void;
+    /**
+     * Remove all event listeners from DOM elements.
+     * Call this on cleanup to prevent memory leaks.
+     */
+    unbindAll(): void;
+    /**
+     * Get the current interaction mode.
+     */
+    getMode(): InteractionMode;
+    /**
+     * Set the interaction mode directly.
+     */
+    setMode(mode: InteractionMode): void;
+    /**
+     * Subscribe to mode change events.
+     * Returns an unsubscribe function.
+     */
+    subscribeModeChange(callback: ModeChangeCallback): () => void;
+    /**
+     * Get the current GUI tool selection.
+     */
+    getGuiTool(): GuiTool;
+    /**
+     * Set the GUI tool (from UI buttons).
+     */
+    setGuiTool(tool: GuiTool): void;
+    /**
+     * Toggle crosshair mode.
+     */
+    toggleCrosshair(): void;
+    /**
+     * Check if crosshair mode is enabled.
+     */
+    isCrosshairEnabled(): boolean;
+    /**
+     * Get current interaction state.
+     */
+    getState(): Readonly<InteractionState>;
+    isShiftHeld(): boolean;
+    isCtrlHeld(): boolean;
+    isLeftButtonDown(): boolean;
+    isRightButtonDown(): boolean;
+    /**
+     * Update keyboard settings.
+     */
+    setKeyboardSettings(settings: Partial<KeyboardSettings>): void;
+    getKeyboardSettings(): KeyboardSettings;
+    /**
+     * Enable or disable the contrast shortcut (Ctrl/Meta key).
+     *
+     * When disabled:
+     * - `ctrlHeld` state is never set to true
+     * - The mode will not be changed to `'contrast'` via key events
+     * - If the mode is currently `'contrast'` it is reset to `'idle'`
+     *
+     * The external keydown/keyup handlers are still called regardless
+     * of this flag so other Ctrl-based shortcuts (e.g. Ctrl+Z undo)
+     * continue to work normally.
+     */
+    setContrastEnabled(enabled: boolean): void;
+    /** Whether the contrast shortcut is currently enabled. */
+    isContrastEnabled(): boolean;
+    /**
+     * Register the keydown handler (from DrawToolCore/DragOperator).
+     */
+    setKeydownHandler(handler: KeyboardHandler): void;
+    /**
+     * Register the keyup handler.
+     */
+    setKeyupHandler(handler: KeyboardHandler): void;
+    /**
+     * Register pointer down handler.
+     */
+    setPointerDownHandler(handler: PointerHandler): void;
+    /**
+     * Register pointer move handler.
+     */
+    setPointerMoveHandler(handler: PointerHandler): void;
+    /**
+     * Register pointer up handler.
+     */
+    setPointerUpHandler(handler: PointerHandler): void;
+    /**
+     * Register pointer leave handler.
+     */
+    setPointerLeaveHandler(handler: PointerHandler): void;
+    /**
+     * Register wheel handler.
+     */
+    setWheelHandler(handler: WheelHandler): void;
+    private handleKeyDown;
+    private handleKeyUp;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handlePointerLeave;
+    private handleWheel;
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Event Router Module
+ *
+ * Exports centralized event handling components for the segmentation module.
+ */
+export { EventRouter } from './EventRouter';
+export type { InteractionMode, GuiTool, KeyboardHandler, PointerHandler, WheelHandler, ModeChangeCallback, EventRouterConfig, KeyboardSettings, InteractionState } from './types';

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

@@ -0,0 +1,70 @@
+/**
+ * Event Router Types
+ *
+ * Type definitions for centralized event handling in the segmentation module.
+ */
+/**
+ * Interaction modes representing the current operational state.
+ *
+ * - `idle`: Default state, allows navigation (drag slice, wheel zoom)
+ * - `draw`: Shift held, left-drag paints (pencil/brush/eraser)
+ * - `drag`: Left-drag changes slices
+ * - `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';
+/**
+ * GUI tool selection (set from UI buttons)
+ */
+export type GuiTool = 'pencil' | 'brush' | 'eraser' | 'sphere' | 'calculator';
+/**
+ * Keyboard event handler type
+ */
+export type KeyboardHandler = (ev: KeyboardEvent) => void;
+/**
+ * Pointer event handler type
+ */
+export type PointerHandler = (ev: PointerEvent) => void;
+/**
+ * Wheel event handler type
+ */
+export type WheelHandler = (ev: WheelEvent) => void;
+/**
+ * Mode change callback - called when interaction mode changes
+ */
+export type ModeChangeCallback = (prevMode: InteractionMode, newMode: InteractionMode) => void;
+/**
+ * Configuration for EventRouter initialization
+ */
+export interface EventRouterConfig {
+    /** Container element to attach keyboard events */
+    container: HTMLElement;
+    /** Canvas element to attach pointer/wheel events */
+    canvas: HTMLCanvasElement;
+    /** Optional callback when mode changes */
+    onModeChange?: ModeChangeCallback;
+}
+/**
+ * Keyboard settings from nrrd_states
+ */
+export interface KeyboardSettings {
+    draw: string;
+    undo: string;
+    redo: string;
+    contrast: string[];
+    crosshair: string;
+    mouseWheel: 'Scroll:Zoom' | 'Scroll:Slice';
+}
+/**
+ * State flags tracked by EventRouter
+ */
+export interface InteractionState {
+    shiftHeld: boolean;
+    ctrlHeld: boolean;
+    leftButtonDown: boolean;
+    rightButtonDown: boolean;
+    crosshairEnabled: boolean;
+}

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

@@ -0,0 +1,25 @@
+/**
+ * BaseTool - Abstract base for extracted DrawToolCore tools
+ *
+ * Provides shared access to the legacy state objects (nrrd_states,
+ * gui_states, protectedData) 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";
+/**
+ * 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;
+    protectedData: IProtected;
+    cursorPage: ICursorPage;
+}
+export declare abstract class BaseTool {
+    protected ctx: ToolContext;
+    constructor(ctx: ToolContext);
+    setContext(ctx: ToolContext): void;
+}

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

@@ -0,0 +1,26 @@
+/**
+ * ContrastTool - Contrast adjustment event handlers
+ *
+ * Extracted from DrawToolCore.ts:
+ * - setupConrastEvents
+ * - configContrastDragMode / removeContrastDragMode
+ * - updateSlicesContrast / repraintCurrentContrastSlice
+ */
+import { BaseTool } from "./BaseTool";
+import type { ToolContext } from "./BaseTool";
+import type { IContrastEvents } from "../coreTools/coreType";
+export interface ContrastCallbacks {
+    setIsDrawFalse: (target: number) => void;
+    setSyncsliceNum: () => void;
+}
+export declare class ContrastTool extends BaseTool {
+    private contrastEventPrameters;
+    private container;
+    private callbacks;
+    constructor(ctx: ToolContext, container: HTMLElement, contrastEventPrameters: IContrastEvents, callbacks: ContrastCallbacks);
+    setupConrastEvents(callback: (step: number, towards: "horizental" | "vertical") => void): void;
+    configContrastDragMode(): void;
+    removeContrastDragMode(): void;
+    updateSlicesContrast(value: number, flag: string): void;
+    repraintCurrentContrastSlice(): void;
+}

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

@@ -0,0 +1,30 @@
+/**
+ * CrosshairTool - Crosshair positioning and cursor point conversion
+ *
+ * Extracted from DrawToolCore.ts:
+ * - enableCrosshair
+ * - convertCursorPoint
+ * - setUpSphereOrigins
+ */
+import { BaseTool } from "./BaseTool";
+import type { IConvertObjType } from "../coreTools/coreType";
+export declare class CrosshairTool extends BaseTool {
+    enableCrosshair(): void;
+    /**
+     * Convert cursor point between axis views.
+     *
+     * MRI slices are generated from threejs based on mm, but displayed based on pixel distance.
+     * The index number on each axis is the slice's depth in mm distance.
+     * Width/height on screen is in pixel distance.
+     *
+     * When switching views, we convert depth to pixel distance and vice versa.
+     *
+     * @param from Current view axis
+     * @param to Target view axis
+     * @param cursorNumX Cursor X on current axis (pixel distance)
+     * @param cursorNumY Cursor Y on current axis (pixel distance)
+     * @param currentSliceIndex Current slice depth (mm distance)
+     */
+    convertCursorPoint(from: "x" | "y" | "z", to: "x" | "y" | "z", cursorNumX: number, cursorNumY: number, currentSliceIndex: number): IConvertObjType | undefined;
+    setUpSphereOrigins(mouseX: number, mouseY: number, sliceIndex: number): void;
+}