@cornerstonejs/tools 2.2.19 → 2.3.0

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

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

package/dist/esm/enums/StrategyCallbacks.js

@@ -11,5 +11,6 @@ var StrategyCallbacks;
     StrategyCallbacks["Initialize"] = "initialize";
     StrategyCallbacks["INTERNAL_setValue"] = "setValue";
     StrategyCallbacks["ComputeInnerCircleRadius"] = "computeInnerCircleRadius";
+    StrategyCallbacks["GetStatistics"] = "getStatistics";
 })(StrategyCallbacks || (StrategyCallbacks = {}));
 export default StrategyCallbacks;

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationDataModified.d.ts

@@ -1 +1 @@
-export declare function triggerSegmentationDataModified(segmentationId: string, modifiedSlicesToUse?: number[]): void;
+export declare function triggerSegmentationDataModified(segmentationId: string, modifiedSlicesToUse?: number[], segmentIndex?: number): void;

package/dist/esm/stateManagement/segmentation/events/triggerSegmentationDataModified.js

@@ -1,10 +1,11 @@
 import { triggerEvent, eventTarget } from '@cornerstonejs/core';
 import { Events } from '../../../enums';
 import { setSegmentationDirty } from '../../../utilities/segmentation/utilities';
-export function triggerSegmentationDataModified(segmentationId, modifiedSlicesToUse) {
+export function triggerSegmentationDataModified(segmentationId, modifiedSlicesToUse, segmentIndex) {
     const eventDetail = {
         segmentationId,
         modifiedSlicesToUse,
+        segmentIndex,
     };
     setSegmentationDirty(segmentationId);
     triggerEvent(eventTarget, Events.SEGMENTATION_DATA_MODIFIED, eventDetail);

package/dist/esm/stateManagement/segmentation/helpers/getSegmentationActor.d.ts

@@ -2,3 +2,4 @@ export declare function getLabelmapActorUID(viewportId: string, segmentationId:
 export declare function getLabelmapActorEntry(viewportId: string, segmentationId: string): import("packages/core/dist/esm/types").ActorEntry;
 export declare function getSurfaceActorEntry(viewportId: string, segmentationId: string, segmentIndex?: number | string): import("packages/core/dist/esm/types").ActorEntry;
 export declare function getSurfaceActorUID(viewportId: string, segmentationId: string, segmentIndex?: number | string): string | undefined;
+export declare function getSurfaceRepresentationUID(segmentationId: string, segmentIndex?: number | string): string;

package/dist/esm/stateManagement/segmentation/helpers/getSegmentationActor.js

@@ -21,10 +21,13 @@ export function getLabelmapActorEntry(viewportId, segmentationId) {
     return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${SegmentationRepresentations.Labelmap}`));
 }
 export function getSurfaceActorEntry(viewportId, segmentationId, segmentIndex) {
-    return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${SegmentationRepresentations.Surface}-${segmentIndex}`));
+    return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID?.startsWith(getSurfaceRepresentationUID(segmentationId, segmentIndex)));
 }
 export function getSurfaceActorUID(viewportId, segmentationId, segmentIndex) {
     const segIndex = segmentIndex ? segmentIndex.toString() : '';
     const actorEntry = getSurfaceActorEntry(viewportId, segmentationId, segIndex);
     return actorEntry?.uid;
 }
+export function getSurfaceRepresentationUID(segmentationId, segmentIndex) {
+    return `${segmentationId}-${SegmentationRepresentations.Surface}-${segmentIndex}`;
+}

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

@@ -32,5 +32,8 @@ declare class CircleROITool extends AnnotationTool {
     renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
     _calculateCachedStats: (annotation: any, viewport: any, renderingEngine: any, enabledElement: any) => any;
     _isInsideVolume: (index1: any, index2: any, dimensions: any) => boolean;
+    static hydrate: (viewportId: string, points: Types.Point3[], options?: {
+        annotationUID?: string;
+    }) => CircleROIAnnotation;
 }
 export default CircleROITool;

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

@@ -1,5 +1,5 @@
 import { AnnotationTool } from '../base';
-import { getEnabledElement, VolumeViewport, utilities as csUtils, } from '@cornerstonejs/core';
+import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { getCalibratedAspect, getCalibratedLengthUnitsAndScale, } from '../../utilities/getCalibratedUnits';
 import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
@@ -557,6 +557,52 @@ class CircleROITool extends AnnotationTool {
         };
         this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
     }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const instance = new this();
+        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const annotation = {
+            annotationUID: options?.annotationUID || csUtils.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                    textBox: {
+                        hasMoved: false,
+                        worldPosition: [0, 0, 0],
+                        worldBoundingBox: {
+                            topLeft: [0, 0, 0],
+                            topRight: [0, 0, 0],
+                            bottomLeft: [0, 0, 0],
+                            bottomRight: [0, 0, 0],
+                        },
+                    },
+                    activeHandleIndex: null,
+                },
+                label: '',
+                cachedStats: {},
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: false,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        addAnnotation(annotation, viewport.element);
+        triggerAnnotationRenderForViewportIds([viewport.id]);
+    }; }
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];

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

@@ -16,6 +16,9 @@ declare class LengthTool extends AnnotationTool {
     isDrawing: boolean;
     isHandleOutsideImage: boolean;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    static hydrate: (viewportId: string, points: Types.Point3[], options?: {
+        annotationUID?: string;
+    }) => LengthAnnotation;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => LengthAnnotation;
     isPointNearTool: (element: HTMLDivElement, annotation: LengthAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
     toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: LengthAnnotation) => void;

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

@@ -1,5 +1,5 @@
 import { Events } from '../../enums';
-import { getEnabledElement, utilities as csUtils } from '@cornerstonejs/core';
+import { getEnabledElement, utilities as csUtils, utilities, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
 import { AnnotationTool } from '../base';
 import throttle from '../../utilities/throttle';
@@ -29,7 +29,7 @@ class LengthTool extends AnnotationTool {
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             hideElementCursor(element);
             this.isDrawing = true;
             const { viewPlaneNormal, viewUp, position: cameraPosition, } = viewport.getCamera();
@@ -344,6 +344,39 @@ class LengthTool extends AnnotationTool {
         };
         this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
     }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const instance = new this();
+        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const annotation = {
+            annotationUID: options?.annotationUID || utilities.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                },
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: false,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        addAnnotation(annotation, viewport.element);
+        triggerAnnotationRenderForViewportIds([viewport.id]);
+    }; }
     handleSelectedCallback(evt, annotation, handle) {
         const eventDetail = evt.detail;
         const { element } = eventDetail;

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

@@ -18,6 +18,9 @@ declare class ProbeTool extends AnnotationTool {
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     isPointNearTool(): boolean;
     toolSelectedCallback(): void;
+    static hydrate: (viewportId: string, points: Types.Point3[], options?: {
+        annotationUID?: string;
+    }) => ProbeAnnotation;
     addNewAnnotation: (evt: EventTypes.InteractionEventType) => ProbeAnnotation;
     getHandleNearImagePoint(element: HTMLDivElement, annotation: ProbeAnnotation, canvasCoords: Types.Point2, proximity: number): ToolHandle | undefined;
     handleSelectedCallback(evt: EventTypes.InteractionEventType, annotation: ProbeAnnotation): void;

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

@@ -1,5 +1,5 @@
 import { vec2, vec3 } from 'gl-matrix';
-import { getEnabledElement, VolumeViewport, utilities as csUtils, } from '@cornerstonejs/core';
+import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
@@ -220,6 +220,39 @@ class ProbeTool extends AnnotationTool {
         return false;
     }
     toolSelectedCallback() { }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const instance = new this();
+        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const annotation = {
+            annotationUID: options?.annotationUID || csUtils.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                },
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: false,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        addAnnotation(annotation, viewport.element);
+        triggerAnnotationRenderForViewportIds([viewport.id]);
+    }; }
     getHandleNearImagePoint(element, annotation, canvasCoords, proximity) {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;

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

@@ -36,5 +36,8 @@ declare class RectangleROITool extends AnnotationTool {
     };
     _calculateCachedStats: (annotation: any, viewPlaneNormal: any, viewUp: any, renderingEngine: any, enabledElement: any) => any;
     _isInsideVolume: (index1: any, index2: any, dimensions: any) => boolean;
+    static hydrate: (viewportId: string, points: Types.Point3[], options?: {
+        annotationUID?: string;
+    }) => RectangleROIAnnotation;
 }
 export default RectangleROITool;

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

@@ -1,5 +1,5 @@
 import { AnnotationTool } from '../base';
-import { getEnabledElement, VolumeViewport, utilities as csUtils, } from '@cornerstonejs/core';
+import { getEnabledElement, VolumeViewport, utilities as csUtils, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { getCalibratedLengthUnitsAndScale } from '../../utilities/getCalibratedUnits';
 import throttle from '../../utilities/throttle';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement';
@@ -529,6 +529,42 @@ class RectangleROITool extends AnnotationTool {
         };
         this._throttledCalculateCachedStats = throttle(this._calculateCachedStats, 100, { trailing: true });
     }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const instance = new this();
+        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const annotation = {
+            annotationUID: options?.annotationUID || csUtils.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                    activeHandleIndex: null,
+                },
+                label: '',
+                cachedStats: {},
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: false,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        addAnnotation(annotation, viewport.element);
+        triggerAnnotationRenderForViewportIds([viewport.id]);
+    }; }
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];

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

@@ -65,5 +65,9 @@ declare class SplineROITool extends ContourSegmentationBaseTool {
     private _getSplineConfig;
     private _updateSplineInstance;
     private _calculateCachedStats;
+    static hydrate: (viewportId: string, points: Types.Point3[], options?: {
+        annotationUID?: string;
+        splineType?: SplineTypesEnum;
+    }) => SplineROIAnnotation;
 }
 export default SplineROITool;

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

@@ -1,6 +1,6 @@
-import { getEnabledElement, eventTarget, triggerEvent, utilities, } from '@cornerstonejs/core';
+import { getEnabledElement, eventTarget, triggerEvent, utilities, getEnabledElementByViewportId, } from '@cornerstonejs/core';
 import { vec3 } from 'gl-matrix';
-import { getChildAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
+import { addAnnotation, getChildAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { drawHandles as drawHandlesSvg, drawPolyline as drawPolylineSvg, drawLinkedTextBox as drawLinkedTextBoxSvg, } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { Events, MouseBindings, KeyboardBindings, ChangeTypes, } from '../../enums';
@@ -116,8 +116,6 @@ class SplineROITool extends ContourSegmentationBaseTool {
                 viewportIdsToRender,
                 movingTextBox: false,
             };
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             this._activateModify(element);
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             evt.preventDefault();
@@ -711,6 +709,61 @@ class SplineROITool extends ContourSegmentationBaseTool {
         }
         return spline;
     }
+    static { this.hydrate = (viewportId, points, options) => {
+        const enabledElement = getEnabledElementByViewportId(viewportId);
+        if (!enabledElement) {
+            return;
+        }
+        if (points.length < SPLINE_MIN_POINTS) {
+            console.warn('Spline requires at least 3 control points');
+            return;
+        }
+        const { viewport } = enabledElement;
+        const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const instance = new this();
+        const referencedImageId = instance.getReferencedImageId(viewport, points[0], viewPlaneNormal, viewUp);
+        const splineType = options?.splineType || SplineTypesEnum.CatmullRom;
+        const splineConfig = instance._getSplineConfig(splineType);
+        const SplineClass = splineConfig.Class;
+        const splineInstance = new SplineClass();
+        const canvasPoints = points.map((point) => viewport.worldToCanvas(point));
+        splineInstance.setControlPoints(canvasPoints);
+        const splinePolylineCanvas = splineInstance.getPolylinePoints();
+        const splinePolylineWorld = splinePolylineCanvas.map((point) => viewport.canvasToWorld(point));
+        const annotation = {
+            annotationUID: options?.annotationUID || utilities.uuidv4(),
+            data: {
+                handles: {
+                    points,
+                },
+                label: '',
+                cachedStats: {},
+                spline: {
+                    type: splineType,
+                    instance: splineInstance,
+                },
+                contour: {
+                    closed: true,
+                    polyline: splinePolylineWorld,
+                },
+            },
+            highlighted: false,
+            autoGenerated: false,
+            invalidated: true,
+            isLocked: false,
+            isVisible: true,
+            metadata: {
+                toolName: instance.getToolName(),
+                viewPlaneNormal,
+                FrameOfReferenceUID,
+                referencedImageId,
+                ...options,
+            },
+        };
+        addAnnotation(annotation, viewport.element);
+        triggerAnnotationRenderForViewportIds([viewport.id]);
+    }; }
 }
 function defaultGetTextLines(data, targetId) {
     const cachedVolumeStats = data.cachedStats[targetId];

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

@@ -11,7 +11,7 @@ declare abstract class BaseTool {
     constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
     getToolName(): string;
     applyActiveStrategy(enabledElement: Types.IEnabledElement, operationData: unknown): any;
-    applyActiveStrategyCallback(enabledElement: Types.IEnabledElement, operationData: unknown, callbackType: StrategyCallbacks | string): any;
+    applyActiveStrategyCallback(enabledElement: Types.IEnabledElement, operationData: unknown, callbackType: StrategyCallbacks | string, ...extraArgs: any[]): any;
     setConfiguration(newConfiguration: Record<string, any>): void;
     setActiveStrategy(strategyName: string): void;
     protected getTargetImageData(targetId: string): Types.IImageData | Types.CPUIImageData;

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

@@ -22,12 +22,12 @@ class BaseTool {
         const { strategies, activeStrategy } = this.configuration;
         return strategies[activeStrategy]?.call(this, enabledElement, operationData);
     }
-    applyActiveStrategyCallback(enabledElement, operationData, callbackType) {
+    applyActiveStrategyCallback(enabledElement, operationData, callbackType, ...extraArgs) {
         const { strategies, activeStrategy } = this.configuration;
         if (!strategies[activeStrategy]) {
             throw new Error(`applyActiveStrategyCallback: active strategy ${activeStrategy} not found, check tool configuration or spellings`);
         }
-        return strategies[activeStrategy][callbackType]?.call(this, enabledElement, operationData);
+        return strategies[activeStrategy][callbackType]?.call(this, enabledElement, operationData, ...extraArgs);
     }
     setConfiguration(newConfiguration) {
         this.configuration = utilities.deepMerge(this.configuration, newConfiguration);

package/dist/esm/tools/displayTools/Surface/addOrUpdateSurfaceToElement.js

@@ -4,11 +4,10 @@ import vtkMapper from '@kitware/vtk.js/Rendering/Core/Mapper';
 import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
 import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
-import { getSurfaceActorEntry, getSurfaceActorUID, } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
+import { getSurfaceActorEntry, getSurfaceRepresentationUID, } from '../../../stateManagement/segmentation/helpers/getSegmentationActor';
 function addOrUpdateSurfaceToElement(element, surface, segmentationId) {
     const enabledElement = getEnabledElement(element);
     const { viewport } = enabledElement;
-    const representationUID = getSurfaceActorUID(viewport.id, segmentationId, surface.segmentIndex);
     const surfaceActorEntry = getSurfaceActorEntry(viewport.id, segmentationId, surface.segmentIndex);
     const surfaceActor = surfaceActorEntry?.actor;
     if (surfaceActor) {
@@ -49,6 +48,7 @@ function addOrUpdateSurfaceToElement(element, surface, segmentationId) {
     actor.setMapper(mapper);
     actor.getProperty().setColor(color[0] / 255, color[1] / 255, color[2] / 255);
     actor.getProperty().setLineWidth(2);
+    const representationUID = getSurfaceRepresentationUID(segmentationId, surface.segmentIndex);
     viewport.addActor({
         uid: utilities.uuidv4(),
         actor: actor,

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

@@ -119,6 +119,7 @@ declare class BrushTool extends BaseTool {
     };
     private _calculateCursor;
     private _endCallback;
+    getStatistics(element: any, segmentIndices?: any): any;
     rejectPreview(element?: HTMLDivElement): void;
     acceptPreview(element?: HTMLDivElement): void;
     private _activateDraw;

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

@@ -1,7 +1,7 @@
 import { utilities as csUtils, cache, getEnabledElement, StackViewport, eventTarget, Enums, BaseVolumeViewport, volumeLoader, } from '@cornerstonejs/core';
 import { vec3, vec2 } from 'gl-matrix';
 import { BaseTool } from '../base';
-import { fillInsideSphere, thresholdInsideSphere, } from './strategies/fillSphere';
+import { fillInsideSphere, thresholdInsideSphere, thresholdInsideSphereIsland, } from './strategies/fillSphere';
 import { eraseInsideSphere } from './strategies/eraseSphere';
 import { thresholdInsideCircle, fillInsideCircle, } from './strategies/fillCircle';
 import { eraseInsideCircle } from './strategies/eraseCircle';
@@ -25,6 +25,7 @@ class BrushTool extends BaseTool {
                 ERASE_INSIDE_SPHERE: eraseInsideSphere,
                 THRESHOLD_INSIDE_CIRCLE: thresholdInsideCircle,
                 THRESHOLD_INSIDE_SPHERE: thresholdInsideSphere,
+                THRESHOLD_INSIDE_SPHERE_WITH_ISLAND_REMOVAL: thresholdInsideSphereIsland,
             },
             strategySpecificConfiguration: {
                 THRESHOLD: {
@@ -52,14 +53,6 @@ class BrushTool extends BaseTool {
                         },
                     ],
                 },
-                [StrategyCallbacks.RejectPreview]: {
-                    method: StrategyCallbacks.RejectPreview,
-                    bindings: [
-                        {
-                            key: 'Escape',
-                        },
-                    ],
-                },
             },
         },
     }) {
@@ -401,7 +394,7 @@ class BrushTool extends BaseTool {
         ];
         const activeStrategy = this.configuration.activeStrategy;
         const strategy = this.configuration.strategies[activeStrategy];
-        if (typeof strategy.computeInnerCircleRadius === 'function') {
+        if (typeof strategy?.computeInnerCircleRadius === 'function') {
             strategy.computeInnerCircleRadius({
                 configuration: this.configuration,
                 viewport,
@@ -409,6 +402,14 @@ class BrushTool extends BaseTool {
         }
         data.invalidated = false;
     }
+    getStatistics(element, segmentIndices) {
+        if (!element) {
+            return;
+        }
+        const enabledElement = getEnabledElement(element);
+        const stats = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), StrategyCallbacks.GetStatistics, segmentIndices);
+        return stats;
+    }
     rejectPreview(element = this._previewData.element) {
         if (!element || !this._previewData.preview) {
             return;

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

@@ -59,6 +59,11 @@ export default class BrushStrategy {
         threshold: {
             createIsInThreshold: (operationData: InitializedOperationData) => (index: any) => boolean;
         };
+        labelmapStatistics: {
+            getStatistics: (enabledElement: any, operationData: InitializedOperationData, options?: {
+                indices?: number | number[];
+            }) => import("../../../types").NamedStatistics;
+        };
     };
     protected static childFunctions: {
         onInteractionStart: (brushStrategy: any, func: any) => void;
@@ -71,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;
+        getStatistics: (brushStrategy: any, func: any) => void;
         compositions: any;
     };
     compositions: Composition[];

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.GetStatistics]: addSingletonMethod(StrategyCallbacks.GetStatistics),
         compositions: null,
     }; }
     constructor(name, ...initializers) {
@@ -36,8 +37,9 @@ export default class BrushStrategy {
                 strategySpecificConfiguration.centerIJK = centerIJK;
             }
             this._fill.forEach((func) => func(initializedData));
-            const { segmentationVoxelManager, previewVoxelManager, previewSegmentIndex, } = initializedData;
-            triggerSegmentationDataModified(initializedData.segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices());
+            const { segmentationVoxelManager, previewVoxelManager, previewSegmentIndex, segmentIndex, } = initializedData;
+            const isPreview = previewSegmentIndex && previewVoxelManager.modifiedSlices.size;
+            triggerSegmentationDataModified(initializedData.segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices(), isPreview ? previewSegmentIndex : segmentIndex);
             if (!previewSegmentIndex || !previewVoxelManager.modifiedSlices.size) {
                 segmentationVoxelManager.resetModifiedSlices();
                 return null;
@@ -134,9 +136,9 @@ function addSingletonMethod(name, isInitialized = true) {
         }
         brushStrategy[name] = isInitialized
             ? func
-            : (enabledElement, operationData) => {
+            : (enabledElement, operationData, ...args) => {
                 operationData.enabledElement = enabledElement;
-                return func.call(brushStrategy, operationData);
+                return func.call(brushStrategy, operationData, ...args);
             };
     };
 }

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

@@ -22,7 +22,7 @@ export default {
             hasSegmentIndex ||= value === segmentIndex;
             hasPreviewIndex ||= value === previewSegmentIndex;
         };
-        imageVoxelManager.forEach(callback, {
+        segmentationVoxelManager.forEach(callback, {
             imageData: segmentationImageData,
             isInObject: operationData.isInObject,
         });

package/dist/esm/tools/segmentation/strategies/compositions/index.d.ts

@@ -32,5 +32,10 @@ declare const _default: {
     threshold: {
         createIsInThreshold: (operationData: import("../BrushStrategy").InitializedOperationData) => (index: any) => boolean;
     };
+    labelmapStatistics: {
+        getStatistics: (enabledElement: any, operationData: import("../BrushStrategy").InitializedOperationData, options?: {
+            indices?: number | number[];
+        }) => import("../../../../types").NamedStatistics;
+    };
 };
 export default _default;

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

@@ -6,6 +6,7 @@ import preview from './preview';
 import regionFill from './regionFill';
 import setValue from './setValue';
 import threshold from './threshold';
+import labelmapStatistics from './labelmapStatistics';
 export default {
     determineSegmentIndex,
     dynamicThreshold,
@@ -15,4 +16,5 @@ export default {
     regionFill,
     setValue,
     threshold,
+    labelmapStatistics,
 };

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

@@ -118,6 +118,6 @@ export default {
                 }
             }
         }
-        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices());
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices(), previewSegmentIndex);
     },
 };

package/dist/esm/tools/segmentation/strategies/compositions/labelmapStatistics.d.ts

@@ -0,0 +1,7 @@
+import type { InitializedOperationData } from '../BrushStrategy';
+declare const _default: {
+    getStatistics: (enabledElement: any, operationData: InitializedOperationData, options?: {
+        indices?: number | number[];
+    }) => import("../../../../types").NamedStatistics;
+};
+export default _default;

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

@@ -0,0 +1,32 @@
+import StrategyCallbacks from '../../../../enums/StrategyCallbacks';
+import VolumetricCalculator from '../../../../utilities/segmentation/VolumetricCalculator';
+import { getActiveSegmentIndex } from '../../../../stateManagement/segmentation/getActiveSegmentIndex';
+import { getStrategyData } from '../utils/getStrategyData';
+export default {
+    [StrategyCallbacks.GetStatistics]: function (enabledElement, operationData, options) {
+        const { viewport } = enabledElement;
+        let { indices } = options;
+        const { segmentationId } = operationData;
+        if (!indices) {
+            indices = [getActiveSegmentIndex(segmentationId)];
+        }
+        else if (!Array.isArray(indices)) {
+            indices = [indices, 255];
+        }
+        const indicesArr = indices;
+        const { segmentationVoxelManager, imageVoxelManager, segmentationImageData, } = getStrategyData({
+            operationData,
+            viewport,
+        });
+        const spacing = segmentationImageData.getSpacing();
+        segmentationVoxelManager.forEach((voxel) => {
+            const { value, pointIJK } = voxel;
+            if (indicesArr.indexOf(value) === -1) {
+                return;
+            }
+            const imageValue = imageVoxelManager.getAtIJKPoint(pointIJK);
+            VolumetricCalculator.statsCallback({ value: imageValue });
+        });
+        return VolumetricCalculator.getStatistics({ spacing });
+    },
+};

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

@@ -66,7 +66,7 @@ export default {
             }
         };
         tracking.forEach(callback, {});
-        triggerSegmentationDataModified(operationData.segmentationId, tracking.getArrayOfModifiedSlices());
+        triggerSegmentationDataModified(operationData.segmentationId, tracking.getArrayOfModifiedSlices(), preview.segmentIndex);
         tracking.clear();
     },
     [StrategyCallbacks.RejectPreview]: (operationData) => {
@@ -78,7 +78,7 @@ export default {
             segmentationVoxelManager.setAtIndex(index, value);
         };
         previewVoxelManager.forEach(callback);
-        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices());
+        triggerSegmentationDataModified(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices(), 0);
         previewVoxelManager.clear();
     },
 };

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

@@ -61,8 +61,8 @@ function createPointInEllipse(worldInfo) {
     const { precalculated } = precalculatePointInEllipse(ellipseObj, {});
     return precalculated;
 }
-const CIRCLE_STRATEGY = new BrushStrategy('Circle', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.preview);
-const CIRCLE_THRESHOLD_STRATEGY = new BrushStrategy('CircleThreshold', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.dynamicThreshold, compositions.threshold, compositions.preview, compositions.islandRemoval);
+const CIRCLE_STRATEGY = new BrushStrategy('Circle', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics);
+const CIRCLE_THRESHOLD_STRATEGY = new BrushStrategy('CircleThreshold', compositions.regionFill, compositions.setValue, initializeCircle, compositions.determineSegmentIndex, compositions.dynamicThreshold, compositions.threshold, compositions.preview, compositions.islandRemoval, compositions.labelmapStatistics);
 const fillInsideCircle = CIRCLE_STRATEGY.strategyFunction;
 const thresholdInsideCircle = CIRCLE_THRESHOLD_STRATEGY.strategyFunction;
 export function fillOutsideCircle() {

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

@@ -2,5 +2,6 @@ import BrushStrategy from './BrushStrategy';
 declare const SPHERE_STRATEGY: BrushStrategy;
 declare const fillInsideSphere: (enabledElement: any, operationData: any) => unknown;
 declare const thresholdInsideSphere: (enabledElement: any, operationData: any) => unknown;
+declare const thresholdInsideSphereIsland: (enabledElement: any, operationData: any) => unknown;
 export declare function fillOutsideSphere(): void;
-export { fillInsideSphere, thresholdInsideSphere, SPHERE_STRATEGY };
+export { fillInsideSphere, thresholdInsideSphere, SPHERE_STRATEGY, thresholdInsideSphereIsland, };

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

@@ -28,11 +28,13 @@ const sphereComposition = {
         });
     },
 };
-const SPHERE_STRATEGY = new BrushStrategy('Sphere', compositions.regionFill, compositions.setValue, sphereComposition, compositions.determineSegmentIndex, compositions.preview);
+const SPHERE_STRATEGY = new BrushStrategy('Sphere', compositions.regionFill, compositions.setValue, sphereComposition, compositions.determineSegmentIndex, compositions.preview, compositions.labelmapStatistics);
 const fillInsideSphere = SPHERE_STRATEGY.strategyFunction;
 const SPHERE_THRESHOLD_STRATEGY = new BrushStrategy('SphereThreshold', ...SPHERE_STRATEGY.compositions, compositions.dynamicThreshold, compositions.threshold, compositions.islandRemoval);
+const SPHERE_THRESHOLD_STRATEGY_ISLAND = new BrushStrategy('SphereThreshold', ...SPHERE_STRATEGY.compositions, compositions.dynamicThreshold, compositions.threshold, compositions.islandRemoval);
 const thresholdInsideSphere = SPHERE_THRESHOLD_STRATEGY.strategyFunction;
+const thresholdInsideSphereIsland = SPHERE_THRESHOLD_STRATEGY_ISLAND.strategyFunction;
 export function fillOutsideSphere() {
     throw new Error('fill outside sphere not implemented');
 }
-export { fillInsideSphere, thresholdInsideSphere, SPHERE_STRATEGY };
+export { fillInsideSphere, thresholdInsideSphere, SPHERE_STRATEGY, thresholdInsideSphereIsland, };

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

@@ -108,6 +108,7 @@ type ContourAnnotationCompletedEventDetail = AnnotationCompletedEventDetail & {
 type SegmentationDataModifiedEventDetail = {
     segmentationId: string;
     modifiedSlicesToUse?: number[];
+    segmentIndex?: number;
 };
 type SegmentationRenderedEventDetail = {
     viewportId: string;

package/dist/esm/utilities/math/basic/BasicStatsCalculator.js

@@ -24,7 +24,9 @@ export default class BasicStatsCalculator extends Calculator {
             this.runMean.push(0, 0);
             this.m2.push(this.m2[0], this.m2[0]);
         }
-        this.pointsInShape?.push(pointLPS);
+        if (this.pointsInShape && pointLPS) {
+            this.pointsInShape?.push(pointLPS);
+        }
         const newArray = Array.isArray(newValue) ? newValue : [newValue];
         this.count += 1;
         this.max.map((it, idx) => {

package/dist/esm/utilities/segmentation/VolumetricCalculator.d.ts

@@ -0,0 +1,8 @@
+import type { NamedStatistics } from '../../types';
+import { BasicStatsCalculator } from '../math/basic';
+export default class VolumetricCalculator extends BasicStatsCalculator {
+    static getStatistics(options: {
+        spacing?: number;
+        unit?: string;
+    }): NamedStatistics;
+}

package/dist/esm/utilities/segmentation/VolumetricCalculator.js

@@ -0,0 +1,18 @@
+import { BasicStatsCalculator } from '../math/basic';
+export default class VolumetricCalculator extends BasicStatsCalculator {
+    static getStatistics(options) {
+        const { spacing } = options;
+        const stats = BasicStatsCalculator.getStatistics();
+        const volumeUnit = spacing ? 'mm\xb3' : 'voxels\xb3';
+        const volumeScale = spacing ? spacing[0] * spacing[1] * spacing[2] : 1;
+        stats.volume = {
+            value: Array.isArray(stats.count.value)
+                ? stats.count.value.map((v) => v * volumeScale)
+                : stats.count.value * volumeScale,
+            unit: volumeUnit,
+            name: 'volume',
+        };
+        stats.array.push(stats.volume);
+        return stats;
+    }
+}

package/dist/esm/utilities/segmentation/index.d.ts

@@ -6,6 +6,7 @@ import { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId }
 import floodFill from './floodFill';
 import { getBrushSizeForToolGroup, setBrushSizeForToolGroup } from './brushSizeForToolGroup';
 import { getBrushThresholdForToolGroup, setBrushThresholdForToolGroup } from './brushThresholdForToolGroup';
+import VolumetricCalculator from './VolumetricCalculator';
 import thresholdSegmentationByRange from './thresholdSegmentationByRange';
 import contourAndFindLargestBidirectional from './contourAndFindLargestBidirectional';
 import createBidirectionalToolData from './createBidirectionalToolData';
@@ -16,4 +17,4 @@ import { getSegmentIndexAtWorldPoint } from './getSegmentIndexAtWorldPoint';
 import { getSegmentIndexAtLabelmapBorder } from './getSegmentIndexAtLabelmapBorder';
 import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
 import { getBrushToolInstances } from './getBrushToolInstances';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };

package/dist/esm/utilities/segmentation/index.js

@@ -6,6 +6,7 @@ import { triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, }
 import floodFill from './floodFill';
 import { getBrushSizeForToolGroup, setBrushSizeForToolGroup, } from './brushSizeForToolGroup';
 import { getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, } from './brushThresholdForToolGroup';
+import VolumetricCalculator from './VolumetricCalculator';
 import thresholdSegmentationByRange from './thresholdSegmentationByRange';
 import contourAndFindLargestBidirectional from './contourAndFindLargestBidirectional';
 import createBidirectionalToolData from './createBidirectionalToolData';
@@ -16,4 +17,4 @@ import { getSegmentIndexAtWorldPoint } from './getSegmentIndexAtWorldPoint';
 import { getSegmentIndexAtLabelmapBorder } from './getSegmentIndexAtLabelmapBorder';
 import { getHoveredContourSegmentationAnnotation } from './getHoveredContourSegmentationAnnotation';
 import { getBrushToolInstances } from './getBrushToolInstances';
-export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };
+export { thresholdVolumeByRange, createMergedLabelmapForIndex, createLabelmapVolumeForViewport, rectangleROIThresholdVolumeByRange, triggerSegmentationRender, triggerSegmentationRenderBySegmentationId, floodFill, getBrushSizeForToolGroup, setBrushSizeForToolGroup, getBrushThresholdForToolGroup, setBrushThresholdForToolGroup, VolumetricCalculator, thresholdSegmentationByRange, contourAndFindLargestBidirectional, createBidirectionalToolData, segmentContourAction, invalidateBrushCursor, getUniqueSegmentIndices, getSegmentIndexAtWorldPoint, getSegmentIndexAtLabelmapBorder, getHoveredContourSegmentationAnnotation, getBrushToolInstances, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "2.2.19",
+  "version": "2.3.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.2.19",
+    "@cornerstonejs/core": "^2.3.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": "b824311a645c0da9f10c76c3a71e965741a4c466"
+  "gitHead": "bb71a514486a519a45468b1f474b5c2c0bb25575"
 }