@cornerstonejs/tools 2.5.3 → 2.6.0

package/dist/esm/enums/StrategyCallbacks.d.ts

@@ -9,6 +9,7 @@ declare enum StrategyCallbacks {
     CreateIsInThreshold = "createIsInThreshold",
     Initialize = "initialize",
     INTERNAL_setValue = "setValue",
+    AddPreview = "addPreview",
     ComputeInnerCircleRadius = "computeInnerCircleRadius",
     GetStatistics = "getStatistics"
 }

package/dist/esm/enums/StrategyCallbacks.js

@@ -10,6 +10,7 @@ var StrategyCallbacks;
     StrategyCallbacks["CreateIsInThreshold"] = "createIsInThreshold";
     StrategyCallbacks["Initialize"] = "initialize";
     StrategyCallbacks["INTERNAL_setValue"] = "setValue";
+    StrategyCallbacks["AddPreview"] = "addPreview";
     StrategyCallbacks["ComputeInnerCircleRadius"] = "computeInnerCircleRadius";
     StrategyCallbacks["GetStatistics"] = "getStatistics";
 })(StrategyCallbacks || (StrategyCallbacks = {}));

package/dist/esm/tools/annotation/DragProbeTool.js

@@ -2,6 +2,7 @@ import { getEnabledElement } from '@cornerstonejs/core';
 import { drawHandles as drawHandlesSvg, drawTextBox as drawTextBoxSvg, } from '../../drawingSvg';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import { hideElementCursor } from '../../cursors/elementCursor';
+import { ChangeTypes, Events } from '../../enums';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import ProbeTool from './ProbeTool';
 class DragProbeTool extends ProbeTool {
@@ -84,7 +85,7 @@ class DragProbeTool extends ProbeTool {
                 styleSpecifier,
             });
             if (!data.cachedStats[targetId] ||
-                data.cachedStats[targetId].value == null) {
+                data.cachedStats[targetId].value === null) {
                 data.cachedStats[targetId] = {
                     Modality: null,
                     index: null,

package/dist/esm/tools/annotation/LivewireContourTool.js

@@ -605,7 +605,7 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
         }
         super.renderAnnotationInstance(renderContext);
         if (!data.cachedStats[targetId] ||
-            data.cachedStats[targetId].areaUnit == null) {
+            data.cachedStats[targetId]?.areaUnit === null) {
             data.cachedStats[targetId] = {
                 Modality: null,
                 area: null,

package/dist/esm/tools/annotation/PlanarFreehandROITool.d.ts

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
-import type { EventTypes, ToolHandle, Annotation, Annotations, PublicToolProps, ToolProps, AnnotationRenderContext } from '../../types';
-import type { PlanarFreehandROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { EventTypes, ToolHandle, Annotations, PublicToolProps, ToolProps, AnnotationRenderContext } from '../../types';
+import type { ContourAnnotation, PlanarFreehandROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
 declare class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     static toolName: any;
@@ -30,7 +30,7 @@ declare class PlanarFreehandROITool extends ContourSegmentationBaseTool {
     filterInteractableAnnotationsForElement(element: HTMLDivElement, annotations: Annotations): Annotations | undefined;
     private filterAnnotationsWithinSlice;
     protected isContourSegmentationTool(): boolean;
-    protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation;
+    protected createAnnotation(evt: EventTypes.InteractionEventType): ContourAnnotation;
     protected getAnnotationStyle(context: any): any;
     protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
     _calculateStatsIfActive(annotation: PlanarFreehandROIAnnotation, targetId: string, viewport: any, renderingEngine: any, enabledElement: any): void;

package/dist/esm/tools/annotation/ProbeTool.d.ts

@@ -1,6 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
-import type { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../../types';
+import { ChangeTypes } from '../../enums';
+import type { EventTypes, ToolHandle, PublicToolProps, SVGDrawingHelper, Annotation } from '../../types';
 import type { ProbeAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 declare class ProbeTool extends AnnotationTool {
     static toolName: any;
@@ -15,7 +16,15 @@ declare class ProbeTool extends AnnotationTool {
     };
     isDrawing: boolean;
     isHandleOutsideImage: boolean;
-    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    static probeDefaults: {
+        supportedInteractionTypes: string[];
+        configuration: {
+            shadow: boolean;
+            preventHandleOutsideImage: boolean;
+            getTextLines: typeof defaultGetTextLines;
+        };
+    };
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: any);
     isPointNearTool(): boolean;
     toolSelectedCallback(): void;
     static hydrate: (viewportId: string, points: Types.Point3[], options?: {
@@ -30,6 +39,7 @@ declare class ProbeTool extends AnnotationTool {
     _activateModify: (element: any) => void;
     _deactivateModify: (element: any) => void;
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
-    _calculateCachedStats(annotation: any, renderingEngine: any, enabledElement: any): any;
+    _calculateCachedStats(annotation: any, renderingEngine: any, enabledElement: any, changeType?: ChangeTypes): any;
 }
+declare function defaultGetTextLines(data: any, targetId: any): string[];
 export default ProbeTool;

package/dist/esm/tools/annotation/ProbeTool.js

@@ -6,7 +6,7 @@ import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../st
 import { getCalibratedProbeUnitsAndValue } from '../../utilities/getCalibratedUnits';
 import { drawHandles as drawHandlesSvg, drawTextBox as drawTextBoxSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
-import { Events } from '../../enums';
+import { ChangeTypes, Events } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
@@ -14,15 +14,16 @@ import { getPixelValueUnits } from '../../utilities/getPixelValueUnits';
 import { isViewportPreScaled } from '../../utilities/viewport/isViewportPreScaled';
 const { transformWorldToIndex } = csUtils;
 class ProbeTool extends AnnotationTool {
-    constructor(toolProps = {}, defaultToolProps = {
+    static { this.probeDefaults = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
             shadow: true,
             preventHandleOutsideImage: false,
             getTextLines: defaultGetTextLines,
         },
-    }) {
-        super(toolProps, defaultToolProps);
+    }; }
+    constructor(toolProps = {}, defaultToolProps) {
+        super(toolProps, AnnotationTool.mergeDefaultProps(ProbeTool.probeDefaults, defaultToolProps));
         this.addNewAnnotation = (evt) => {
             const eventDetail = evt.detail;
             const { currentPoints, element } = eventDetail;
@@ -164,13 +165,13 @@ class ProbeTool extends AnnotationTool {
                     data.cachedStats = {};
                 }
                 if (!data.cachedStats[targetId] ||
-                    data.cachedStats[targetId].value == null) {
+                    data.cachedStats[targetId].value === null) {
                     data.cachedStats[targetId] = {
                         Modality: null,
                         index: null,
                         value: null,
                     };
-                    this._calculateCachedStats(annotation, renderingEngine, enabledElement);
+                    this._calculateCachedStats(annotation, renderingEngine, enabledElement, ChangeTypes.StatsUpdated);
                 }
                 else if (annotation.invalidated) {
                     this._calculateCachedStats(annotation, renderingEngine, enabledElement);
@@ -280,7 +281,7 @@ class ProbeTool extends AnnotationTool {
         triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         evt.preventDefault();
     }
-    _calculateCachedStats(annotation, renderingEngine, enabledElement) {
+    _calculateCachedStats(annotation, renderingEngine, enabledElement, changeType = ChangeTypes.StatsUpdated) {
         const data = annotation.data;
         const { renderingEngineId, viewport } = enabledElement;
         const { element } = viewport;
@@ -340,7 +341,7 @@ class ProbeTool extends AnnotationTool {
                 };
             }
             annotation.invalidated = false;
-            triggerAnnotationModified(annotation, element);
+            triggerAnnotationModified(annotation, element, changeType);
         }
         return cachedStats;
     }
@@ -348,7 +349,7 @@ class ProbeTool extends AnnotationTool {
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];
     const { index, value, modalityUnit } = cachedVolumeStats;
-    if (value === undefined) {
+    if (value === undefined || !index) {
         return;
     }
     const textLines = [];

package/dist/esm/tools/annotation/SplineROITool.d.ts

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import { ChangeTypes } from '../../enums';
 import type { Annotation, EventTypes, ToolHandle, PublicToolProps, ToolProps, AnnotationRenderContext } from '../../types';
-import type { SplineROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { ContourAnnotation, SplineROIAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 import ContourSegmentationBaseTool from '../base/ContourSegmentationBaseTool';
 declare enum SplineTypesEnum {
     Cardinal = "CARDINAL",
@@ -56,7 +56,7 @@ declare class SplineROITool extends ContourSegmentationBaseTool {
     protected isContourSegmentationTool(): boolean;
     protected renderAnnotationInstance(renderContext: AnnotationRenderContext): boolean;
     protected createInterpolatedSplineControl(annotation: any): void;
-    protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation;
+    protected createAnnotation(evt: EventTypes.InteractionEventType): ContourAnnotation;
     private _renderStats;
     addControlPointCallback: (evt: EventTypes.InteractionEventType, annotation: SplineROIAnnotation) => void;
     private _deleteControlPointByIndex;

package/dist/esm/tools/base/AnnotationDisplayTool.d.ts

@@ -1,12 +1,13 @@
 import type { Types } from '@cornerstonejs/core';
 import BaseTool from './BaseTool';
-import type { Annotation, Annotations, SVGDrawingHelper } from '../../types';
+import type { Annotation, Annotations, EventTypes, SVGDrawingHelper } from '../../types';
 import type { StyleSpecifier } from '../../types/AnnotationStyle';
 declare abstract class AnnotationDisplayTool extends BaseTool {
     static toolName: any;
     abstract renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): any;
     filterInteractableAnnotationsForElement(element: HTMLDivElement, annotations: Annotations): Annotations | undefined;
     onImageSpacingCalibrated: (evt: Types.EventTypes.ImageSpacingCalibratedEvent) => void;
+    protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation;
     protected getReferencedImageId(viewport: Types.IViewport, worldPos: Types.Point3, viewPlaneNormal: Types.Point3, viewUp?: Types.Point3): string;
     getStyle(property: string, specifications: StyleSpecifier, annotation?: Annotation): unknown;
 }

package/dist/esm/tools/base/AnnotationDisplayTool.js

@@ -1,4 +1,4 @@
-import { utilities, getEnabledElement, StackViewport, cache, VideoViewport, BaseVolumeViewport, } from '@cornerstonejs/core';
+import { utilities, getEnabledElement, cache, BaseVolumeViewport, } from '@cornerstonejs/core';
 import BaseTool from './BaseTool';
 import { getAnnotationManager } from '../../stateManagement/annotation/annotationState';
 import triggerAnnotationRender from '../../utilities/triggerAnnotationRender';
@@ -41,6 +41,45 @@ class AnnotationDisplayTool extends BaseTool {
         const { viewport } = enabledElement;
         return filterAnnotationsForDisplay(viewport, annotations);
     }
+    createAnnotation(evt) {
+        const eventDetail = evt.detail;
+        const { currentPoints, element } = eventDetail;
+        const { world: worldPos } = currentPoints;
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const camera = viewport.getCamera();
+        const { viewPlaneNormal, viewUp, position: cameraPosition } = camera;
+        const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
+        const viewReference = viewport.getViewReference({ points: [worldPos] });
+        return {
+            highlighted: true,
+            invalidated: true,
+            metadata: {
+                toolName: this.getToolName(),
+                ...viewReference,
+                referencedImageId,
+                viewUp,
+                cameraPosition,
+            },
+            data: {
+                cachedStats: {},
+                handles: {
+                    points: [],
+                    activeHandleIndex: null,
+                    textBox: {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    },
+                },
+            },
+        };
+    }
     getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp) {
         const targetId = this.getTargetId(viewport);
         let referencedImageId = targetId.split(/^[a-zA-Z]+:/)[1];

package/dist/esm/tools/base/BaseTool.d.ts

@@ -10,7 +10,17 @@ declare abstract class BaseTool {
     toolGroupId: string;
     mode: ToolModes;
     protected memo: utilities.HistoryMemo.Memo;
+    static defaults: {
+        configuration: {
+            strategies: {};
+            defaultStrategy: any;
+            activeStrategy: any;
+            strategyOptions: {};
+        };
+    };
     constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
+    static mergeDefaultProps(defaultProps?: {}, additionalProps?: any): any;
+    get toolName(): string;
     getToolName(): string;
     applyActiveStrategy(enabledElement: Types.IEnabledElement, operationData: unknown): any;
     applyActiveStrategyCallback(enabledElement: Types.IEnabledElement, operationData: unknown, callbackType: StrategyCallbacks | string, ...extraArgs: any[]): any;

package/dist/esm/tools/base/BaseTool.js

@@ -1,21 +1,33 @@
-import { utilities, BaseVolumeViewport } from '@cornerstonejs/core';
+import { utilities } from '@cornerstonejs/core';
 import ToolModes from '../../enums/ToolModes';
 const { DefaultHistoryMemo } = utilities.HistoryMemo;
 class BaseTool {
+    static { this.defaults = {
+        configuration: {
+            strategies: {},
+            defaultStrategy: undefined,
+            activeStrategy: undefined,
+            strategyOptions: {},
+        },
+    }; }
     constructor(toolProps, defaultToolProps) {
-        const initialProps = utilities.deepMerge(defaultToolProps, toolProps);
+        const mergedDefaults = BaseTool.mergeDefaultProps(BaseTool.defaults, defaultToolProps);
+        const initialProps = utilities.deepMerge(mergedDefaults, toolProps);
         const { configuration = {}, supportedInteractionTypes, toolGroupId, } = initialProps;
-        if (!configuration.strategies) {
-            configuration.strategies = {};
-            configuration.defaultStrategy = undefined;
-            configuration.activeStrategy = undefined;
-            configuration.strategyOptions = {};
-        }
         this.toolGroupId = toolGroupId;
         this.supportedInteractionTypes = supportedInteractionTypes || [];
         this.configuration = Object.assign({}, configuration);
         this.mode = ToolModes.Disabled;
     }
+    static mergeDefaultProps(defaultProps = {}, additionalProps) {
+        if (!additionalProps) {
+            return defaultProps;
+        }
+        return utilities.deepMerge(defaultProps, additionalProps);
+    }
+    get toolName() {
+        return this.getToolName();
+    }
     getToolName() {
         return this.constructor.toolName;
     }

package/dist/esm/tools/base/ContourBaseTool.d.ts

@@ -5,7 +5,7 @@ import type { ContourWindingDirection } from '../../types/ContourAnnotation';
 declare abstract class ContourBaseTool extends AnnotationTool {
     constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
     renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): boolean;
-    protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation;
+    protected createAnnotation(evt: EventTypes.InteractionEventType): ContourAnnotation;
     protected addAnnotation(annotation: Annotation, element: HTMLDivElement): string;
     protected cancelAnnotation(annotation: Annotation): void;
     protected moveAnnotation(annotation: Annotation, worldPosDelta: Types.Point3): void;

package/dist/esm/tools/base/ContourBaseTool.js

@@ -53,48 +53,18 @@ class ContourBaseTool extends AnnotationTool {
         return renderStatus;
     }
     createAnnotation(evt) {
-        const eventDetail = evt.detail;
-        const { currentPoints, element } = eventDetail;
-        const { world: worldPos } = currentPoints;
-        const enabledElement = getEnabledElement(element);
-        const { viewport } = enabledElement;
-        const camera = viewport.getCamera();
-        const { viewPlaneNormal, viewUp, position: cameraPosition } = camera;
-        const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
-        const viewReference = viewport.getViewReference({ points: [worldPos] });
-        return {
-            highlighted: true,
-            invalidated: true,
-            metadata: {
-                toolName: this.getToolName(),
-                ...viewReference,
-                referencedImageId,
-                viewUp,
-                cameraPosition,
-            },
-            data: {
-                handles: {
-                    points: [],
-                    activeHandleIndex: null,
-                    textBox: {
-                        hasMoved: false,
-                        worldPosition: [0, 0, 0],
-                        worldBoundingBox: {
-                            topLeft: [0, 0, 0],
-                            topRight: [0, 0, 0],
-                            bottomLeft: [0, 0, 0],
-                            bottomRight: [0, 0, 0],
-                        },
-                    },
-                },
-                contour: {
-                    polyline: [],
-                    closed: false,
-                },
+        const annotation = super.createAnnotation(evt);
+        Object.assign(annotation.data, {
+            contour: {
+                polyline: [],
+                closed: false,
             },
+        });
+        Object.assign(annotation, {
             interpolationUID: '',
             autoGenerated: false,
-        };
+        });
+        return annotation;
     }
     addAnnotation(annotation, element) {
         return addAnnotation(annotation, element);

package/dist/esm/tools/base/ContourSegmentationBaseTool.d.ts

@@ -1,10 +1,11 @@
 import type { Annotation, EventTypes, PublicToolProps, ToolProps, AnnotationRenderContext } from '../../types';
+import type { ContourAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 import type { StyleSpecifier } from '../../types/AnnotationStyle';
 import ContourBaseTool from './ContourBaseTool';
 declare abstract class ContourSegmentationBaseTool extends ContourBaseTool {
     constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
     protected isContourSegmentationTool(): boolean;
-    protected createAnnotation(evt: EventTypes.InteractionEventType): Annotation;
+    protected createAnnotation(evt: EventTypes.InteractionEventType): ContourAnnotation;
     protected addAnnotation(annotation: Annotation, element: HTMLDivElement): string;
     protected cancelAnnotation(annotation: Annotation): void;
     protected getAnnotationStyle(context: {

package/dist/esm/tools/base/ContourSegmentationBaseTool.js

@@ -1,5 +1,4 @@
 import { getEnabledElement, utilities } from '@cornerstonejs/core';
-import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
 import { SegmentationRepresentations } from '../../enums';
 import ContourBaseTool from './ContourBaseTool';
 import { triggerSegmentationDataModified } from '../../stateManagement/segmentation/triggerSegmentationEvents';

package/dist/esm/tools/displayTools/Labelmap/addLabelmapToElement.js

@@ -35,7 +35,7 @@ async function addLabelmapToElement(element, labelMapData, segmentationId) {
                 representationUID: `${segmentationId}-${SegmentationRepresentations.Labelmap}`,
             },
         ];
-        await addImageSlicesToViewports(renderingEngine, stackInputs, [viewportId]);
+        addImageSlicesToViewports(renderingEngine, stackInputs, [viewportId]);
     }
     triggerSegmentationDataModified(segmentationId);
 }

package/dist/esm/tools/segmentation/BrushTool.d.ts

@@ -1,127 +1,22 @@
 import type { Types } from '@cornerstonejs/core';
 import type { PublicToolProps, ToolProps, EventTypes, SVGDrawingHelper } from '../../types';
-import { BaseTool } from '../base';
-import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
-export type PreviewData = {
-    preview: unknown;
-    timer?: number;
-    timerStart: number;
-    startPoint: Types.Point2;
-    element: HTMLDivElement;
-    isDrag: boolean;
-};
-declare class BrushTool extends BaseTool {
+import LabelmapBaseTool from './LabelmapBaseTool';
+declare class BrushTool extends LabelmapBaseTool {
     static toolName: any;
-    private _editData;
-    private _hoverData?;
-    private _previewData?;
+    prg: any;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     onSetToolPassive: (evt: any) => void;
     onSetToolEnabled: () => void;
     onSetToolDisabled: (evt: any) => void;
     private disableCursor;
-    createEditData(element: any): {
-        volumeId: string;
-        referencedVolumeId: any;
-        segmentsLocked: number[] | [];
-        imageId?: undefined;
-        override?: undefined;
-    } | {
-        imageId: string;
-        segmentsLocked: number[] | [];
-        override: {
-            voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
-            imageData: vtkImageData;
-        };
-        volumeId?: undefined;
-        referencedVolumeId?: undefined;
-    } | {
-        imageId: string;
-        segmentsLocked: number[] | [];
-        volumeId?: undefined;
-        referencedVolumeId?: undefined;
-        override?: undefined;
-    };
     preMouseDownCallback: (evt: EventTypes.MouseDownActivateEventType) => boolean;
     mouseMoveCallback: (evt: EventTypes.InteractionEventType) => void;
     previewCallback: () => void;
-    private createHoverData;
-    private getActiveSegmentationData;
     protected updateCursor(evt: EventTypes.InteractionEventType): void;
     private _dragCallback;
-    protected getOperationData(element?: any): {
-        points: any;
-        segmentIndex: number;
-        previewColors: any;
-        viewPlaneNormal: any;
-        toolGroupId: string;
-        segmentationId: string;
-        viewUp: any;
-        strategySpecificConfiguration: any;
-        preview: unknown;
-        override: {
-            voxelManager: Types.IVoxelManager<number>;
-            imageData: vtkImageData;
-        };
-        segmentsLocked: number[];
-        imageId?: string;
-        imageIds?: string[];
-        volumeId?: string;
-        referencedVolumeId?: string;
-    } | {
-        points: any;
-        segmentIndex: number;
-        previewColors: any;
-        viewPlaneNormal: any;
-        toolGroupId: string;
-        segmentationId: string;
-        viewUp: any;
-        strategySpecificConfiguration: any;
-        preview: unknown;
-        volumeId: string;
-        referencedVolumeId: any;
-        segmentsLocked: number[] | [];
-        imageId?: undefined;
-        override?: undefined;
-    } | {
-        points: any;
-        segmentIndex: number;
-        previewColors: any;
-        viewPlaneNormal: any;
-        toolGroupId: string;
-        segmentationId: string;
-        viewUp: any;
-        strategySpecificConfiguration: any;
-        preview: unknown;
-        imageId: string;
-        segmentsLocked: number[] | [];
-        override: {
-            voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
-            imageData: vtkImageData;
-        };
-        volumeId?: undefined;
-        referencedVolumeId?: undefined;
-    } | {
-        points: any;
-        segmentIndex: number;
-        previewColors: any;
-        viewPlaneNormal: any;
-        toolGroupId: string;
-        segmentationId: string;
-        viewUp: any;
-        strategySpecificConfiguration: any;
-        preview: unknown;
-        imageId: string;
-        segmentsLocked: number[] | [];
-        volumeId?: undefined;
-        referencedVolumeId?: undefined;
-        override?: undefined;
-    };
     private _calculateCursor;
     private _endCallback;
     getStatistics(element: any, segmentIndices?: any): any;
-    rejectPreview(element?: HTMLDivElement): void;
-    acceptPreview(element?: HTMLDivElement): void;
     private _activateDraw;
     private _deactivateDraw;
     invalidateBrushCursor(): void;

package/dist/esm/tools/segmentation/BrushTool.js

@@ -1,20 +1,15 @@
-import { utilities as csUtils, cache, getEnabledElement, StackViewport, eventTarget, Enums, BaseVolumeViewport, volumeLoader, } from '@cornerstonejs/core';
+import { getEnabledElement } from '@cornerstonejs/core';
 import { vec3, vec2 } from 'gl-matrix';
-import { BaseTool } from '../base';
 import { fillInsideSphere, thresholdInsideSphere, thresholdInsideSphereIsland, } from './strategies/fillSphere';
 import { eraseInsideSphere } from './strategies/eraseSphere';
 import { thresholdInsideCircle, fillInsideCircle, } from './strategies/fillCircle';
 import { eraseInsideCircle } from './strategies/eraseCircle';
-import { Events, ToolModes, SegmentationRepresentations, StrategyCallbacks, } from '../../enums';
+import { Events, ToolModes, StrategyCallbacks } from '../../enums';
 import { drawCircle as drawCircleSvg } from '../../drawingSvg';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
-import { getCurrentLabelmapImageIdForViewport, getSegmentation, getStackSegmentationImageIdsForViewport, } from '../../stateManagement/segmentation/segmentationState';
-import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
-import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
-import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
-import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
-class BrushTool extends BaseTool {
+import LabelmapBaseTool from './LabelmapBaseTool';
+class BrushTool extends LabelmapBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -57,14 +52,6 @@ class BrushTool extends BaseTool {
         },
     }) {
         super(toolProps, defaultToolProps);
-        this._previewData = {
-            preview: null,
-            element: null,
-            timerStart: 0,
-            timer: null,
-            startPoint: [NaN, NaN],
-            isDrag: false,
-        };
         this.onSetToolPassive = (evt) => {
             this.disableCursor();
         };
@@ -183,144 +170,6 @@ class BrushTool extends BaseTool {
         this._hoverData = undefined;
         this.rejectPreview();
     }
-    createEditData(element) {
-        const enabledElement = getEnabledElement(element);
-        const { viewport } = enabledElement;
-        const activeSegmentation = getActiveSegmentation(viewport.id);
-        if (!activeSegmentation) {
-            const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
-                detail: {
-                    type: 'Segmentation',
-                    message: 'No active segmentation detected, create a segmentation representation before using the brush tool',
-                },
-                cancelable: true,
-            });
-            eventTarget.dispatchEvent(event);
-            return null;
-        }
-        const { segmentationId } = activeSegmentation;
-        const segmentsLocked = getLockedSegmentIndices(segmentationId);
-        const { representationData } = getSegmentation(segmentationId);
-        if (viewport instanceof BaseVolumeViewport) {
-            const { volumeId } = representationData[SegmentationRepresentations.Labelmap];
-            const actors = viewport.getActors();
-            const isStackViewport = viewport instanceof StackViewport;
-            if (isStackViewport) {
-                const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
-                    detail: {
-                        type: 'Segmentation',
-                        message: 'Cannot perform brush operation on the selected viewport',
-                    },
-                    cancelable: true,
-                });
-                eventTarget.dispatchEvent(event);
-                return null;
-            }
-            const volumes = actors.map((actorEntry) => cache.getVolume(actorEntry.referencedId));
-            const segmentationVolume = cache.getVolume(volumeId);
-            const referencedVolumeIdToThreshold = volumes.find((volume) => csUtils.isEqual(volume.dimensions, segmentationVolume.dimensions))?.volumeId || volumes[0]?.volumeId;
-            return {
-                volumeId,
-                referencedVolumeId: this.configuration.thresholdVolumeId ?? referencedVolumeIdToThreshold,
-                segmentsLocked,
-            };
-        }
-        else {
-            const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
-            if (!segmentationImageId) {
-                return;
-            }
-            if (this.configuration.activeStrategy.includes('SPHERE')) {
-                const referencedImageIds = viewport.getImageIds();
-                const isValidVolumeForSphere = csUtils.isValidVolume(referencedImageIds);
-                if (!isValidVolumeForSphere) {
-                    throw new Error('Volume is not reconstructable for sphere manipulation');
-                }
-                const volumeId = `${segmentationId}_${viewport.id}`;
-                const volume = cache.getVolume(volumeId);
-                if (volume) {
-                    return {
-                        imageId: segmentationImageId,
-                        segmentsLocked,
-                        override: {
-                            voxelManager: volume.voxelManager,
-                            imageData: volume.imageData,
-                        },
-                    };
-                }
-                else {
-                    const labelmapImageIds = getStackSegmentationImageIdsForViewport(viewport.id, segmentationId);
-                    if (!labelmapImageIds || labelmapImageIds.length === 1) {
-                        return {
-                            imageId: segmentationImageId,
-                            segmentsLocked,
-                        };
-                    }
-                    const volume = volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, labelmapImageIds);
-                    return {
-                        imageId: segmentationImageId,
-                        segmentsLocked,
-                        override: {
-                            voxelManager: volume.voxelManager,
-                            imageData: volume.imageData,
-                        },
-                    };
-                }
-            }
-            else {
-                return {
-                    imageId: segmentationImageId,
-                    segmentsLocked,
-                };
-            }
-        }
-    }
-    createHoverData(element, centerCanvas) {
-        const enabledElement = getEnabledElement(element);
-        const { viewport } = enabledElement;
-        const camera = viewport.getCamera();
-        const { viewPlaneNormal, viewUp } = camera;
-        const viewportIdsToRender = [viewport.id];
-        const { segmentIndex, segmentationId, segmentColor } = this.getActiveSegmentationData(viewport) || {};
-        const brushCursor = {
-            metadata: {
-                viewPlaneNormal: [...viewPlaneNormal],
-                viewUp: [...viewUp],
-                FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
-                referencedImageId: '',
-                toolName: this.getToolName(),
-                segmentColor,
-            },
-            data: {},
-        };
-        return {
-            brushCursor,
-            centerCanvas,
-            segmentIndex,
-            viewport,
-            segmentationId,
-            segmentColor,
-            viewportIdsToRender,
-        };
-    }
-    getActiveSegmentationData(viewport) {
-        const viewportId = viewport.id;
-        const activeRepresentation = getActiveSegmentation(viewportId);
-        if (!activeRepresentation) {
-            return;
-        }
-        const { segmentationId } = activeRepresentation;
-        const segmentIndex = getActiveSegmentIndex(segmentationId);
-        if (!segmentIndex) {
-            return;
-        }
-        const segmentColor = getSegmentIndexColor(viewportId, segmentationId, segmentIndex);
-        return {
-            segmentIndex,
-            segmentationId,
-            segmentColor,
-        };
-    }
     updateCursor(evt) {
         const eventData = evt.detail;
         const { element } = eventData;
@@ -333,27 +182,6 @@ class BrushTool extends BaseTool {
         }
         triggerAnnotationRenderForViewportUIDs(this._hoverData.viewportIdsToRender);
     }
-    getOperationData(element) {
-        const editData = this._editData || this.createEditData(element);
-        const { segmentIndex, segmentationId, brushCursor } = this._hoverData || this.createHoverData(element);
-        const { data, metadata = {} } = brushCursor || {};
-        const { viewPlaneNormal, viewUp } = metadata;
-        const operationData = {
-            ...editData,
-            points: data?.handles?.points,
-            segmentIndex,
-            previewColors: this.configuration.preview.enabled
-                ? this.configuration.preview.previewColors
-                : null,
-            viewPlaneNormal,
-            toolGroupId: this.toolGroupId,
-            segmentationId,
-            viewUp,
-            strategySpecificConfiguration: this.configuration.strategySpecificConfiguration,
-            preview: this._previewData?.preview,
-        };
-        return operationData;
-    }
     _calculateCursor(element, centerCanvas) {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
@@ -410,24 +238,6 @@ class BrushTool extends BaseTool {
         const stats = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.GetStatistics, segmentIndices);
         return stats;
     }
-    rejectPreview(element = this._previewData.element) {
-        if (!element || !this._previewData.preview) {
-            return;
-        }
-        const enabledElement = getEnabledElement(element);
-        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.RejectPreview);
-        this._previewData.preview = null;
-        this._previewData.isDrag = false;
-    }
-    acceptPreview(element = this._previewData.element) {
-        if (!element) {
-            return;
-        }
-        const enabledElement = getEnabledElement(element);
-        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AcceptPreview);
-        this._previewData.isDrag = false;
-        this._previewData.preview = null;
-    }
     invalidateBrushCursor() {
         if (this._hoverData === undefined) {
             return;

package/dist/esm/tools/segmentation/LabelmapBaseTool.d.ts

@@ -0,0 +1,155 @@
+import type { Types } from '@cornerstonejs/core';
+import { BaseTool } from '../base';
+import type vtkImageData from '@kitware/vtk.js/Common/DataModel/ImageData';
+export type PreviewData = {
+    preview: unknown;
+    timer?: number;
+    timerStart: number;
+    startPoint: Types.Point2;
+    element: HTMLDivElement;
+    isDrag: boolean;
+};
+export default class LabelmapBaseTool extends BaseTool {
+    protected _editData: {
+        override: {
+            voxelManager: Types.IVoxelManager<number>;
+            imageData: vtkImageData;
+        };
+        segmentsLocked: number[];
+        imageId?: string;
+        imageIds?: string[];
+        volumeId?: string;
+        referencedVolumeId?: string;
+    } | null;
+    protected _hoverData?: {
+        brushCursor: any;
+        segmentationId: string;
+        segmentIndex: number;
+        segmentColor: [number, number, number, number];
+        viewportIdsToRender: string[];
+        centerCanvas?: Array<number>;
+        viewport: Types.IViewport;
+    };
+    protected _previewData?: PreviewData;
+    constructor(toolProps: any, defaultToolProps: any);
+    createMemo(segmentId: string, segmentationVoxelManager: any, preview: any): void;
+    createEditData(element: any): {
+        volumeId: string;
+        referencedVolumeId: any;
+        segmentsLocked: number[] | [];
+        imageId?: undefined;
+        override?: undefined;
+    } | {
+        imageId: string;
+        segmentsLocked: number[] | [];
+        override: {
+            voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+            imageData: vtkImageData;
+        };
+        volumeId?: undefined;
+        referencedVolumeId?: undefined;
+    } | {
+        imageId: string;
+        segmentsLocked: number[] | [];
+        volumeId?: undefined;
+        referencedVolumeId?: undefined;
+        override?: undefined;
+    };
+    protected createHoverData(element: any, centerCanvas?: any): {
+        brushCursor: {
+            metadata: {
+                viewPlaneNormal: Types.Point3;
+                viewUp: Types.Point3;
+                FrameOfReferenceUID: string;
+                referencedImageId: string;
+                toolName: string;
+                segmentColor: Types.Color;
+            };
+            data: {};
+        };
+        centerCanvas: any;
+        segmentIndex: number;
+        viewport: Types.IStackViewport | import("@cornerstonejs/core").VolumeViewport;
+        segmentationId: string;
+        segmentColor: Types.Color;
+        viewportIdsToRender: string[];
+    };
+    protected getActiveSegmentationData(viewport: any): {
+        segmentIndex: number;
+        segmentationId: string;
+        segmentColor: Types.Color;
+    };
+    protected getOperationData(element?: any): {
+        points: any;
+        segmentIndex: number;
+        previewColors: any;
+        viewPlaneNormal: any;
+        toolGroupId: string;
+        segmentationId: string;
+        viewUp: any;
+        strategySpecificConfiguration: any;
+        preview: unknown;
+        override: {
+            voxelManager: Types.IVoxelManager<number>;
+            imageData: vtkImageData;
+        };
+        segmentsLocked: number[];
+        imageId?: string;
+        imageIds?: string[];
+        volumeId?: string;
+        referencedVolumeId?: string;
+    } | {
+        points: any;
+        segmentIndex: number;
+        previewColors: any;
+        viewPlaneNormal: any;
+        toolGroupId: string;
+        segmentationId: string;
+        viewUp: any;
+        strategySpecificConfiguration: any;
+        preview: unknown;
+        volumeId: string;
+        referencedVolumeId: any;
+        segmentsLocked: number[] | [];
+        imageId?: undefined;
+        override?: undefined;
+    } | {
+        points: any;
+        segmentIndex: number;
+        previewColors: any;
+        viewPlaneNormal: any;
+        toolGroupId: string;
+        segmentationId: string;
+        viewUp: any;
+        strategySpecificConfiguration: any;
+        preview: unknown;
+        imageId: string;
+        segmentsLocked: number[] | [];
+        override: {
+            voxelManager: Types.IVoxelManager<number> | Types.IVoxelManager<Types.RGB>;
+            imageData: vtkImageData;
+        };
+        volumeId?: undefined;
+        referencedVolumeId?: undefined;
+    } | {
+        points: any;
+        segmentIndex: number;
+        previewColors: any;
+        viewPlaneNormal: any;
+        toolGroupId: string;
+        segmentationId: string;
+        viewUp: any;
+        strategySpecificConfiguration: any;
+        preview: unknown;
+        imageId: string;
+        segmentsLocked: number[] | [];
+        volumeId?: undefined;
+        referencedVolumeId?: undefined;
+        override?: undefined;
+    };
+    addPreview(element?: HTMLDivElement, options?: {
+        acceptReject: boolean;
+    }): unknown;
+    rejectPreview(element?: HTMLDivElement): void;
+    acceptPreview(element?: HTMLDivElement): void;
+}

package/dist/esm/tools/segmentation/LabelmapBaseTool.js

@@ -0,0 +1,218 @@
+import { getEnabledElement, cache, utilities as csUtils, Enums, eventTarget, BaseVolumeViewport, volumeLoader, } from '@cornerstonejs/core';
+import { BaseTool } from '../base';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+import { getActiveSegmentation } from '../../stateManagement/segmentation/getActiveSegmentation';
+import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
+import { getSegmentation } from '../../stateManagement/segmentation/getSegmentation';
+import { getClosestImageIdForStackViewport } from '../../utilities/annotationHydration';
+import { getCurrentLabelmapImageIdForViewport } from '../../stateManagement/segmentation/getCurrentLabelmapImageIdForViewport';
+import { getStackSegmentationImageIdsForViewport } from '../../stateManagement/segmentation/getStackSegmentationImageIdsForViewport';
+import { getSegmentIndexColor } from '../../stateManagement/segmentation/config/segmentationColor';
+import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getActiveSegmentIndex';
+import { StrategyCallbacks } from '../../enums';
+export default class LabelmapBaseTool extends BaseTool {
+    constructor(toolProps, defaultToolProps) {
+        super(toolProps, defaultToolProps);
+        this._previewData = {
+            preview: null,
+            element: null,
+            timerStart: 0,
+            timer: null,
+            startPoint: [NaN, NaN],
+            isDrag: false,
+        };
+    }
+    createMemo(segmentId, segmentationVoxelManager, preview) {
+        console.warn('LabelmapBaseTool.createMemo not implemented yet');
+    }
+    createEditData(element) {
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const activeSegmentation = getActiveSegmentation(viewport.id);
+        if (!activeSegmentation) {
+            const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
+                detail: {
+                    type: 'Segmentation',
+                    message: 'No active segmentation detected, create a segmentation representation before using the brush tool',
+                },
+                cancelable: true,
+            });
+            eventTarget.dispatchEvent(event);
+            return null;
+        }
+        const { segmentationId } = activeSegmentation;
+        const segmentsLocked = getLockedSegmentIndices(segmentationId);
+        const { representationData } = getSegmentation(segmentationId);
+        if (viewport instanceof BaseVolumeViewport) {
+            const { volumeId } = representationData[SegmentationRepresentations.Labelmap];
+            const actors = viewport.getActors();
+            const isStackViewport = viewport instanceof getClosestImageIdForStackViewport;
+            if (isStackViewport) {
+                const event = new CustomEvent(Enums.Events.ERROR_EVENT, {
+                    detail: {
+                        type: 'Segmentation',
+                        message: 'Cannot perform brush operation on the selected viewport',
+                    },
+                    cancelable: true,
+                });
+                eventTarget.dispatchEvent(event);
+                return null;
+            }
+            const volumes = actors.map((actorEntry) => cache.getVolume(actorEntry.referencedId));
+            const segmentationVolume = cache.getVolume(volumeId);
+            const referencedVolumeIdToThreshold = volumes.find((volume) => csUtils.isEqual(volume.dimensions, segmentationVolume.dimensions))?.volumeId || volumes[0]?.volumeId;
+            return {
+                volumeId,
+                referencedVolumeId: this.configuration.thresholdVolumeId ?? referencedVolumeIdToThreshold,
+                segmentsLocked,
+            };
+        }
+        else {
+            const segmentationImageId = getCurrentLabelmapImageIdForViewport(viewport.id, segmentationId);
+            if (!segmentationImageId) {
+                return;
+            }
+            if (this.configuration.activeStrategy.includes('SPHERE')) {
+                const referencedImageIds = viewport.getImageIds();
+                const isValidVolumeForSphere = csUtils.isValidVolume(referencedImageIds);
+                if (!isValidVolumeForSphere) {
+                    throw new Error('Volume is not reconstructable for sphere manipulation');
+                }
+                const volumeId = `${segmentationId}_${viewport.id}`;
+                const volume = cache.getVolume(volumeId);
+                if (volume) {
+                    return {
+                        imageId: segmentationImageId,
+                        segmentsLocked,
+                        override: {
+                            voxelManager: volume.voxelManager,
+                            imageData: volume.imageData,
+                        },
+                    };
+                }
+                else {
+                    const labelmapImageIds = getStackSegmentationImageIdsForViewport(viewport.id, segmentationId);
+                    if (!labelmapImageIds || labelmapImageIds.length === 1) {
+                        return {
+                            imageId: segmentationImageId,
+                            segmentsLocked,
+                        };
+                    }
+                    const volume = volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, labelmapImageIds);
+                    return {
+                        imageId: segmentationImageId,
+                        segmentsLocked,
+                        override: {
+                            voxelManager: volume.voxelManager,
+                            imageData: volume.imageData,
+                        },
+                    };
+                }
+            }
+            else {
+                return {
+                    imageId: segmentationImageId,
+                    segmentsLocked,
+                };
+            }
+        }
+    }
+    createHoverData(element, centerCanvas) {
+        const enabledElement = getEnabledElement(element);
+        const { viewport } = enabledElement;
+        const camera = viewport.getCamera();
+        const { viewPlaneNormal, viewUp } = camera;
+        const viewportIdsToRender = [viewport.id];
+        const { segmentIndex, segmentationId, segmentColor } = this.getActiveSegmentationData(viewport) || {};
+        const brushCursor = {
+            metadata: {
+                viewPlaneNormal: [...viewPlaneNormal],
+                viewUp: [...viewUp],
+                FrameOfReferenceUID: viewport.getFrameOfReferenceUID(),
+                referencedImageId: '',
+                toolName: this.getToolName(),
+                segmentColor,
+            },
+            data: {},
+        };
+        return {
+            brushCursor,
+            centerCanvas,
+            segmentIndex,
+            viewport,
+            segmentationId,
+            segmentColor,
+            viewportIdsToRender,
+        };
+    }
+    getActiveSegmentationData(viewport) {
+        const viewportId = viewport.id;
+        const activeRepresentation = getActiveSegmentation(viewportId);
+        if (!activeRepresentation) {
+            return;
+        }
+        const { segmentationId } = activeRepresentation;
+        const segmentIndex = getActiveSegmentIndex(segmentationId);
+        if (!segmentIndex) {
+            return;
+        }
+        const segmentColor = getSegmentIndexColor(viewportId, segmentationId, segmentIndex);
+        return {
+            segmentIndex,
+            segmentationId,
+            segmentColor,
+        };
+    }
+    getOperationData(element) {
+        const editData = this._editData || this.createEditData(element);
+        const { segmentIndex, segmentationId, brushCursor } = this._hoverData || this.createHoverData(element);
+        const { data, metadata = {} } = brushCursor || {};
+        const { viewPlaneNormal, viewUp } = metadata;
+        const operationData = {
+            ...editData,
+            points: data?.handles?.points,
+            segmentIndex,
+            previewColors: this.configuration.preview?.enabled || this._previewData.preview
+                ? this.configuration.preview.previewColors
+                : null,
+            viewPlaneNormal,
+            toolGroupId: this.toolGroupId,
+            segmentationId,
+            viewUp,
+            strategySpecificConfiguration: this.configuration.strategySpecificConfiguration,
+            preview: this._previewData?.preview,
+        };
+        return operationData;
+    }
+    addPreview(element = this._previewData.element, options) {
+        const acceptReject = options?.acceptReject;
+        if (acceptReject === true) {
+            this.acceptPreview(element);
+        }
+        else if (acceptReject === false) {
+            this.rejectPreview(element);
+        }
+        const enabledElement = getEnabledElement(element);
+        this._previewData.preview = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AddPreview);
+        this._previewData.isDrag = true;
+        return this._previewData.preview;
+    }
+    rejectPreview(element = this._previewData.element) {
+        if (!element || !this._previewData.preview) {
+            return;
+        }
+        const enabledElement = getEnabledElement(element);
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.RejectPreview);
+        this._previewData.preview = null;
+        this._previewData.isDrag = false;
+    }
+    acceptPreview(element = this._previewData.element) {
+        if (!element) {
+            return;
+        }
+        const enabledElement = getEnabledElement(element);
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.AcceptPreview);
+        this._previewData.isDrag = false;
+        this._previewData.preview = null;
+    }
+}

package/dist/esm/tools/segmentation/strategies/BrushStrategy.d.ts

@@ -76,6 +76,7 @@ export default class BrushStrategy {
         setValue: (brushStrategy: any, func: any) => void;
         preview: (brushStrategy: any, func: any) => void;
         computeInnerCircleRadius: (brushStrategy: any, func: any) => void;
+        addPreview: (brushStrategy: any, func: any) => void;
         getStatistics: (brushStrategy: any, func: any) => void;
         compositions: any;
     };
@@ -92,6 +93,7 @@ export default class BrushStrategy {
     onInteractionStart: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => void;
     onInteractionEnd: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => void;
     rejectPreview: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => void;
+    addPreview: (enabledElement: any, operationData: LabelmapToolOperationDataAny) => any;
     acceptPreview: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => void;
     preview: (enabledElement: Types.IEnabledElement, operationData: LabelmapToolOperationDataAny) => unknown;
     setValue: (operationData: InitializedOperationData, data: any) => void;

package/dist/esm/tools/segmentation/strategies/BrushStrategy.js

@@ -17,6 +17,7 @@ export default class BrushStrategy {
         [StrategyCallbacks.INTERNAL_setValue]: addSingletonMethod(StrategyCallbacks.INTERNAL_setValue),
         [StrategyCallbacks.Preview]: addSingletonMethod(StrategyCallbacks.Preview, false),
         [StrategyCallbacks.ComputeInnerCircleRadius]: addListMethod(StrategyCallbacks.ComputeInnerCircleRadius),
+        [StrategyCallbacks.AddPreview]: addListMethod(StrategyCallbacks.AddPreview),
         [StrategyCallbacks.GetStatistics]: addSingletonMethod(StrategyCallbacks.GetStatistics),
         compositions: null,
     }; }
@@ -58,6 +59,13 @@ export default class BrushStrategy {
             }
             this._onInteractionStart.forEach((func) => func.call(this, initializedData));
         };
+        this.addPreview = (enabledElement, operationData) => {
+            const initializedData = this.initialize(enabledElement, operationData, StrategyCallbacks.AddPreview);
+            if (!initializedData) {
+                return;
+            }
+            return initializedData.preview || initializedData;
+        };
         this.configurationName = name;
         this.compositions = initializers;
         initializers.forEach((initializer) => {

package/dist/esm/tools/segmentation/strategies/compositions/determineSegmentIndex.js

@@ -11,13 +11,25 @@ export default {
         }
     },
     [StrategyCallbacks.OnInteractionStart]: (operationData) => {
-        const { segmentIndex, previewSegmentIndex, segmentationVoxelManager, centerIJK, strategySpecificConfiguration, imageVoxelManager, segmentationImageData, preview, } = operationData;
+        const { segmentIndex, previewSegmentIndex, segmentationVoxelManager, centerIJK, strategySpecificConfiguration, viewPlaneNormal, segmentationImageData, preview, } = operationData;
         if (!strategySpecificConfiguration?.useCenterSegmentIndex) {
             return;
         }
         delete strategySpecificConfiguration.centerSegmentIndex;
         let hasSegmentIndex = false;
         let hasPreviewIndex = false;
+        const nestedBounds = [
+            ...segmentationVoxelManager.getBoundsIJK(),
+        ];
+        if (Math.abs(viewPlaneNormal[0]) > 0.8) {
+            nestedBounds[0] = [centerIJK[0], centerIJK[0]];
+        }
+        else if (Math.abs(viewPlaneNormal[1]) > 0.8) {
+            nestedBounds[1] = [centerIJK[1], centerIJK[1]];
+        }
+        else if (Math.abs(viewPlaneNormal[2]) > 0.8) {
+            nestedBounds[2] = [centerIJK[2], centerIJK[2]];
+        }
         const callback = ({ value }) => {
             hasSegmentIndex ||= value === segmentIndex;
             hasPreviewIndex ||= value === previewSegmentIndex;
@@ -25,6 +37,7 @@ export default {
         segmentationVoxelManager.forEach(callback, {
             imageData: segmentationImageData,
             isInObject: operationData.isInObject,
+            boundsIJK: nestedBounds,
         });
         if (!hasSegmentIndex && !hasPreviewIndex) {
             return;

package/dist/esm/types/AnnotationTypes.d.ts

@@ -2,6 +2,7 @@ import type { Types } from '@cornerstonejs/core';
 type Annotation = {
     annotationUID?: string;
     parentAnnotationUID?: string;
+    interpolationUID?: string;
     childAnnotationUIDs?: string[];
     highlighted?: boolean;
     isLocked?: boolean;
@@ -31,7 +32,7 @@ type Annotation = {
             [key: string]: unknown;
         };
         [key: string]: unknown;
-        cachedStats?: unknown;
+        cachedStats?: Record<string, unknown>;
     };
 };
 type Annotations = Array<Annotation>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "2.5.3",
+  "version": "2.6.0",
   "description": "Cornerstone3D Tools",
   "types": "./dist/esm/index.d.ts",
   "module": "./dist/esm/index.js",
@@ -104,7 +104,7 @@
     "canvas": "^2.11.2"
   },
   "peerDependencies": {
-    "@cornerstonejs/core": "^2.5.3",
+    "@cornerstonejs/core": "^2.6.0",
     "@kitware/vtk.js": "32.1.1",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -123,5 +123,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "f2996db78ea77e524dabd88d176177064a0f2ef3"
+  "gitHead": "d5c8036b08e8927a3fbbc1af6a0557687fc0645c"
 }