@cornerstonejs/tools 2.8.6 → 2.10.0

package/dist/esm/eventDispatchers/shared/getToolsWithActionsForKeyboardEvents.js

@@ -19,7 +19,7 @@ export default function getToolsWithModesForKeyboardEvent(evt, toolModes) {
         if (!actions?.length || !toolModes.includes(tool.mode)) {
             continue;
         }
-        const action = actions.find((action) => action.bindings.some((binding) => binding.key === key));
+        const action = actions.find((action) => action.bindings?.some((binding) => binding.key === key));
         if (action) {
             toolsWithActions.set(tool, action);
         }

package/dist/esm/eventDispatchers/shared/getToolsWithActionsForMouseEvent.js

@@ -21,7 +21,7 @@ export default function getToolsWithActionsForMouseEvent(evt, toolModes) {
         if (!actions?.length || !toolModes.includes(tool.mode)) {
             continue;
         }
-        const action = actions.find((action) => action.bindings.length &&
+        const action = actions.find((action) => action.bindings?.length &&
             action.bindings.some((binding) => binding.mouseButton === mouseButton &&
                 binding.modifierKey === modifierKey));
         if (action) {

package/dist/esm/index.d.ts

@@ -9,7 +9,7 @@ import * as cursors from './cursors';
 import * as Types from './types';
 import * as annotation from './stateManagement/annotation';
 import * as segmentation from './stateManagement/segmentation';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool } from './tools';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
 import * as Enums from './enums';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, };

package/dist/esm/index.js

@@ -9,7 +9,7 @@ import * as cursors from './cursors';
 import * as Types from './types';
 import * as annotation from './stateManagement/annotation';
 import * as segmentation from './stateManagement/segmentation';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, } from './tools';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
 import * as Enums from './enums';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, };

package/dist/esm/stateManagement/segmentation/activeSegmentation.d.ts

@@ -1,4 +1,4 @@
 import type { Segmentation } from '../../types/SegmentationStateTypes';
 declare function getActiveSegmentation(viewportId: string): Segmentation;
-declare function setActiveSegmentation(viewportId: string, segmentationId: string, suppressEvent?: boolean): void;
+declare function setActiveSegmentation(viewportId: string, segmentationId: string): void;
 export { getActiveSegmentation, setActiveSegmentation, };

package/dist/esm/stateManagement/segmentation/activeSegmentation.js

@@ -3,7 +3,7 @@ import { setActiveSegmentation as _setActiveSegmentation } from './setActiveSegm
 function getActiveSegmentation(viewportId) {
     return _getActiveSegmentation(viewportId);
 }
-function setActiveSegmentation(viewportId, segmentationId, suppressEvent = false) {
+function setActiveSegmentation(viewportId, segmentationId) {
     _setActiveSegmentation(viewportId, segmentationId);
 }
 export { getActiveSegmentation, setActiveSegmentation, };

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

@@ -1,6 +1,7 @@
 import { removeContourRepresentation, removeLabelmapRepresentation, removeSegmentationRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations } from './removeSegmentationRepresentations';
 import { addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations } from './addSegmentationRepresentationsToViewport';
 import { addSegmentations } from './addSegmentations';
+import addRepresentationData from './internalAddRepresentationData';
 import { updateSegmentations } from './updateSegmentations';
 import * as activeSegmentation from './activeSegmentation';
 import * as segmentLocking from './segmentLocking';
@@ -15,6 +16,7 @@ import { clearSegmentValue } from './helpers/clearSegmentValue';
 import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
 import { removeSegment } from './removeSegment';
 import { getLabelmapImageIds } from './getLabelmapImageIds';
+import * as strategies from './../../tools/segmentation/strategies';
 import { removeAllSegmentations, removeSegmentation } from './removeSegmentation';
 declare const helpers: {
     clearSegmentValue: typeof clearSegmentValue;
@@ -22,4 +24,4 @@ declare const helpers: {
     computeVolumeLabelmapFromStack: typeof computeVolumeLabelmapFromStack;
     convertVolumeToStackLabelmap: typeof convertVolumeToStackLabelmap;
 };
-export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, removeSegment, getLabelmapImageIds, };
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, };

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

@@ -1,6 +1,7 @@
 import { removeContourRepresentation, removeLabelmapRepresentation, removeSegmentationRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentations, removeAllSegmentationRepresentations, } from './removeSegmentationRepresentations';
 import { addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, } from './addSegmentationRepresentationsToViewport';
 import { addSegmentations } from './addSegmentations';
+import addRepresentationData from './internalAddRepresentationData';
 import { updateSegmentations } from './updateSegmentations';
 import * as activeSegmentation from './activeSegmentation';
 import * as segmentLocking from './segmentLocking';
@@ -15,6 +16,7 @@ import { clearSegmentValue } from './helpers/clearSegmentValue';
 import { convertVolumeToStackLabelmap } from './helpers/computeStackLabelmapFromVolume';
 import { removeSegment } from './removeSegment';
 import { getLabelmapImageIds } from './getLabelmapImageIds';
+import * as strategies from './../../tools/segmentation/strategies';
 import { removeAllSegmentations, removeSegmentation, } from './removeSegmentation';
 const helpers = {
     clearSegmentValue,
@@ -22,4 +24,4 @@ const helpers = {
     computeVolumeLabelmapFromStack,
     convertVolumeToStackLabelmap,
 };
-export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, removeSegment, getLabelmapImageIds, };
+export { removeSegmentationRepresentation, removeContourRepresentation, removeLabelmapRepresentation, removeSurfaceRepresentation, removeAllSegmentations, removeSegmentation, removeSegmentationRepresentations, addLabelmapRepresentationToViewport, addLabelmapRepresentationToViewportMap, addSegmentationRepresentations, removeAllSegmentationRepresentations, addContourRepresentationToViewport, addContourRepresentationToViewportMap, addSurfaceRepresentationToViewport, addSurfaceRepresentationToViewportMap, addSegmentations, updateSegmentations, state, activeSegmentation, segmentLocking, config, segmentIndex, triggerSegmentationEvents, helpers, polySegManager as polySeg, removeSegment, getLabelmapImageIds, addRepresentationData, strategies, };

package/dist/esm/stateManagement/segmentation/internalAddSegmentationRepresentation.js

@@ -10,6 +10,7 @@ function internalAddSegmentationRepresentation(viewportId, representationInput)
     const { segmentationId, config } = representationInput;
     const renderingConfig = {
         colorLUTIndex: getColorLUTIndex(config),
+        ...config,
     };
     defaultSegmentationStateManager.addSegmentationRepresentation(viewportId, segmentationId, representationInput.type, renderingConfig);
     if (representationInput.type === SegmentationRepresentations.Contour) {

package/dist/esm/stateManagement/segmentation/polySeg/Contour/utils/createAndAddContourSegmentationsFromClippedSurfaces.js

@@ -46,7 +46,7 @@ export function createAndAddContourSegmentationsFromClippedSurfaces(rawContourDa
                     },
                 };
                 addAnnotation(contourSegmentationAnnotation, viewport.element);
-                const currentSet = annotationUIDsMap.get(segmentIndex) || new Set();
+                const currentSet = annotationUIDsMap?.get(segmentIndex) || new Set();
                 currentSet.add(contourSegmentationAnnotation.annotationUID);
                 annotationUIDsMap.set(segmentIndex, currentSet);
             }

package/dist/esm/stateManagement/segmentation/polySeg/Labelmap/labelmapComputationStrategies.js

@@ -35,7 +35,9 @@ export async function computeLabelmapData(segmentationId, options = {}) {
     return rawLabelmapData;
 }
 async function computeLabelmapFromContourSegmentation(segmentationId, options = {}) {
-    const isVolume = options.viewport instanceof VolumeViewport ?? true;
+    const isVolume = options.viewport
+        ? options.viewport instanceof VolumeViewport
+        : true;
     if (isVolume && !options.viewport) {
         throw new Error('Cannot compute labelmap from contour segmentation without providing the viewport');
     }
@@ -55,7 +57,7 @@ async function computeLabelmapFromContourSegmentation(segmentationId, options =
 }
 async function computeLabelmapFromSurfaceSegmentation(segmentationId, options = {}) {
     const { viewport } = options;
-    const isVolume = viewport instanceof VolumeViewport ?? true;
+    const isVolume = viewport ? viewport instanceof VolumeViewport : true;
     const segmentIndices = options.segmentIndices?.length
         ? options.segmentIndices
         : getUniqueSegmentIndices(segmentationId);

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

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
 import type { EventTypes, PublicToolProps, ToolProps } from '../../types';
 import GrowCutBaseTool from '../base/GrowCutBaseTool';
-import type { GrowCutToolData } from '../base/GrowCutBaseTool';
+import type { GrowCutToolData, RemoveIslandData } from '../base/GrowCutBaseTool';
 type RegionSegmentPlusToolData = GrowCutToolData & {
     worldPoint: Types.Point3;
 };
@@ -10,6 +10,7 @@ declare class RegionSegmentPlusTool extends GrowCutBaseTool {
     protected growCutData: RegionSegmentPlusToolData | null;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     preMouseDownCallback(evt: EventTypes.MouseDownActivateEventType): Promise<boolean>;
-    protected getGrowCutLabelmap(): Promise<Types.IImageVolume>;
+    protected getRemoveIslandData(growCutData: RegionSegmentPlusToolData): RemoveIslandData;
+    protected getGrowCutLabelmap(growCutData: any): Promise<Types.IImageVolume>;
 }
 export default RegionSegmentPlusTool;

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

@@ -1,4 +1,4 @@
-import { getRenderingEngine } from '@cornerstonejs/core';
+import { getRenderingEngine, utilities as csUtils } from '@cornerstonejs/core';
 import { growCut } from '../../utilities/segmentation';
 import GrowCutBaseTool from '../base/GrowCutBaseTool';
 class RegionSegmentPlusTool extends GrowCutBaseTool {
@@ -8,6 +8,9 @@ class RegionSegmentPlusTool extends GrowCutBaseTool {
             positiveSeedVariance: 0.4,
             negativeSeedVariance: 0.9,
             subVolumePaddingPercentage: 0.1,
+            islandRemoval: {
+                enabled: true,
+            },
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -16,24 +19,36 @@ class RegionSegmentPlusTool extends GrowCutBaseTool {
         const eventData = evt.detail;
         const { currentPoints } = eventData;
         const { world: worldPoint } = currentPoints;
-        super.preMouseDownCallback(evt);
+        await super.preMouseDownCallback(evt);
+        this.growCutData = csUtils.deepMerge(this.growCutData, {
+            worldPoint,
+            islandRemoval: {
+                worldIslandPoints: [worldPoint],
+            },
+        });
         this.growCutData.worldPoint = worldPoint;
+        this.growCutData.islandRemoval = {
+            worldIslandPoints: [worldPoint],
+        };
         this.runGrowCut();
         return true;
     }
-    async getGrowCutLabelmap() {
-        const { segmentation: { segmentIndex, referencedVolumeId }, renderingEngineId, viewportId, worldPoint, } = this.growCutData;
+    getRemoveIslandData(growCutData) {
+        const { worldPoint } = growCutData;
+        return {
+            worldIslandPoints: [worldPoint],
+        };
+    }
+    async getGrowCutLabelmap(growCutData) {
+        const { segmentation: { referencedVolumeId }, renderingEngineId, viewportId, worldPoint, options, } = growCutData;
         const renderingEngine = getRenderingEngine(renderingEngineId);
         const viewport = renderingEngine.getViewport(viewportId);
-        const { positiveSeedVariance, negativeSeedVariance, subVolumePaddingPercentage, } = this.configuration;
-        const options = {
-            positiveSeedValue: segmentIndex,
-            negativeSeedValue: 255,
-            positiveSeedVariance: positiveSeedVariance,
-            negativeSeedVariance: negativeSeedVariance,
-            subVolumePaddingPercentage: subVolumePaddingPercentage,
+        const { subVolumePaddingPercentage } = this.configuration;
+        const mergedOptions = {
+            ...options,
+            subVolumePaddingPercentage,
         };
-        return await growCut.runOneClickGrowCut(referencedVolumeId, worldPoint, viewport, options);
+        return growCut.runOneClickGrowCut(referencedVolumeId, worldPoint, viewport, mergedOptions);
     }
 }
 RegionSegmentPlusTool.toolName = 'RegionSegmentPlus';

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

@@ -13,7 +13,7 @@ declare class RegionSegmentTool extends GrowCutBaseTool {
     preMouseDownCallback(evt: EventTypes.MouseDownActivateEventType): Promise<boolean>;
     private _dragCallback;
     private _endCallback;
-    protected getGrowCutLabelmap(): Promise<Types.IImageVolume>;
+    protected getGrowCutLabelmap(growCutData: any): Promise<Types.IImageVolume>;
     private _activateDraw;
     private _deactivateDraw;
     renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): void;

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

@@ -9,7 +9,10 @@ import GrowCutBaseTool from '../base/GrowCutBaseTool';
 class RegionSegmentTool extends GrowCutBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
-        configuration: {},
+        configuration: {
+            positiveSeedVariance: 0.5,
+            negativeSeedVariance: 0.9,
+        },
     }) {
         super(toolProps, defaultToolProps);
         this._dragCallback = (evt) => {
@@ -44,7 +47,7 @@ class RegionSegmentTool extends GrowCutBaseTool {
         const { world: worldPoint } = currentPoints;
         const enabledElement = getEnabledElement(element);
         const { viewport, renderingEngine } = enabledElement;
-        super.preMouseDownCallback(evt);
+        await super.preMouseDownCallback(evt);
         Object.assign(this.growCutData, {
             circleCenterPoint: worldPoint,
             circleBorderPoint: worldPoint,
@@ -54,8 +57,8 @@ class RegionSegmentTool extends GrowCutBaseTool {
         triggerAnnotationRenderForViewportUIDs([viewport.id]);
         return true;
     }
-    async getGrowCutLabelmap() {
-        const { segmentation: { segmentIndex, referencedVolumeId }, renderingEngineId, viewportId, circleCenterPoint, circleBorderPoint, } = this.growCutData;
+    async getGrowCutLabelmap(growCutData) {
+        const { segmentation: { referencedVolumeId }, renderingEngineId, viewportId, circleCenterPoint, circleBorderPoint, options, } = growCutData;
         const renderingEngine = getRenderingEngine(renderingEngineId);
         const viewport = renderingEngine.getViewport(viewportId);
         const worldCircleRadius = vec3.len(vec3.sub(vec3.create(), circleCenterPoint, circleBorderPoint));
@@ -63,10 +66,6 @@ class RegionSegmentTool extends GrowCutBaseTool {
             center: circleCenterPoint,
             radius: worldCircleRadius,
         };
-        const options = {
-            positiveSeedValue: segmentIndex,
-            negativeSeedValue: 255,
-        };
         return growCut.runGrowCutForSphere(referencedVolumeId, sphereInfo, viewport, options);
     }
     _activateDraw(element) {

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

@@ -226,11 +226,17 @@ class SplineROITool extends ContourSegmentationBaseTool {
             }
             this.doneEditMemo();
             const eventDetail = evt.detail;
-            const { currentPoints } = eventDetail;
+            const { currentPoints, element } = eventDetail;
             const { canvas: canvasPoint, world: worldPoint } = currentPoints;
             let closeContour = data.handles.points.length >= 2 && doubleClick;
             let addNewPoint = true;
+            if (data.handles.points.length) {
+                this.createMemo(element, annotation, {
+                    newAnnotation: data.handles.points.length === 1,
+                });
+            }
             if (data.handles.points.length >= 3) {
+                this.createMemo(element, annotation);
                 const { instance: spline } = data.spline;
                 const closestControlPoint = spline.getClosestControlPointWithinDistance(canvasPoint, SPLINE_CLICK_CLOSE_CURVE_DIST);
                 if (closestControlPoint?.index === 0) {

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

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import type { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
-import type { GrowCutToolData } from '../base/GrowCutBaseTool';
+import type { GrowCutToolData, RemoveIslandData } from '../base/GrowCutBaseTool';
 import GrowCutBaseTool from '../base/GrowCutBaseTool';
 type HorizontalLine = [Types.Point3, Types.Point3];
 type WholeBodySegmentToolData = GrowCutToolData & {
@@ -14,7 +14,8 @@ declare class WholeBodySegmentTool extends GrowCutBaseTool {
     private _dragCallback;
     private _endCallback;
     renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): void;
-    protected getGrowCutLabelmap(): Promise<Types.IImageVolume>;
+    protected getGrowCutLabelmap(growCutData: any): Promise<Types.IImageVolume>;
+    protected getRemoveIslandData(): RemoveIslandData;
     private _activateDraw;
     private _deactivateDraw;
     private _projectWorldPointAcrossSlices;

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

@@ -6,11 +6,21 @@ import { Events } from '../../enums';
 import triggerAnnotationRenderForViewportUIDs from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { growCut } from '../../utilities/segmentation';
 import GrowCutBaseTool from '../base/GrowCutBaseTool';
+const NEGATIVE_PIXEL_RANGE = [-Infinity, -995];
+const POSITIVE_PIXEL_RANGE = [0, 1900];
+const ISLAND_PIXEL_RANGE = [1000, 1900];
 const { transformWorldToIndex, transformIndexToWorld } = csUtils;
 class WholeBodySegmentTool extends GrowCutBaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
-        configuration: {},
+        configuration: {
+            positivePixelRange: POSITIVE_PIXEL_RANGE,
+            negativePixelRange: NEGATIVE_PIXEL_RANGE,
+            islandRemoval: {
+                enabled: true,
+                islandPixelRange: ISLAND_PIXEL_RANGE,
+            },
+        },
     }) {
         super(toolProps, defaultToolProps);
         this._dragCallback = (evt) => {
@@ -47,7 +57,7 @@ class WholeBodySegmentTool extends GrowCutBaseTool {
         const enabledElement = getEnabledElement(element);
         const { viewport, renderingEngine } = enabledElement;
         const linePoints = this._getHorizontalLineWorldPoints(enabledElement, worldPoint);
-        super.preMouseDownCallback(evt);
+        await super.preMouseDownCallback(evt);
         this.growCutData.horizontalLines = [linePoints, linePoints];
         this._activateDraw(element);
         hideElementCursor(element);
@@ -89,8 +99,8 @@ class WholeBodySegmentTool extends GrowCutBaseTool {
             closePath: true,
         });
     }
-    async getGrowCutLabelmap() {
-        const { segmentation: { segmentIndex, referencedVolumeId }, renderingEngineId, viewportId, horizontalLines, } = this.growCutData;
+    async getGrowCutLabelmap(growCutData) {
+        const { segmentation: { segmentIndex, referencedVolumeId }, renderingEngineId, viewportId, horizontalLines, } = growCutData;
         const renderingEngine = getRenderingEngine(renderingEngineId);
         const viewport = renderingEngine.getViewport(viewportId);
         const [line1, line2] = horizontalLines;
@@ -105,12 +115,37 @@ class WholeBodySegmentTool extends GrowCutBaseTool {
                 ijkBottomRight,
             },
         };
+        const config = this.configuration;
         const options = {
             positiveSeedValue: segmentIndex,
             negativeSeedValue: 255,
+            negativePixelRange: config.negativePixelRange,
+            positivePixelRange: config.positivePixelRange,
         };
         return growCut.runGrowCutForBoundingBox(referencedVolumeId, boundingBoxInfo, options);
     }
+    getRemoveIslandData() {
+        const { segmentation: { segmentIndex, referencedVolumeId, labelmapVolumeId }, } = this.growCutData;
+        const referencedVolume = cache.getVolume(referencedVolumeId);
+        const labelmapVolume = cache.getVolume(labelmapVolumeId);
+        const referencedVolumeData = referencedVolume.voxelManager.getCompleteScalarDataArray();
+        const labelmapData = labelmapVolume.voxelManager.getCompleteScalarDataArray();
+        const { islandPixelRange } = this.configuration.islandRemoval;
+        const islandPointIndexes = [];
+        for (let i = 0, len = labelmapData.length; i < len; i++) {
+            if (labelmapData[i] !== segmentIndex) {
+                continue;
+            }
+            const pixelValue = referencedVolumeData[i];
+            if (pixelValue >= islandPixelRange[0] &&
+                pixelValue <= islandPixelRange[1]) {
+                islandPointIndexes.push(i);
+            }
+        }
+        return {
+            islandPointIndexes,
+        };
+    }
     _activateDraw(element) {
         element.addEventListener(Events.MOUSE_UP, this._endCallback);
         element.addEventListener(Events.MOUSE_DRAG, this._dragCallback);
@@ -184,5 +219,5 @@ class WholeBodySegmentTool extends GrowCutBaseTool {
         return [worldPoint1, worldPoint2];
     }
 }
-WholeBodySegmentTool.toolName = 'WholeBodySegmentTool';
+WholeBodySegmentTool.toolName = 'WholeBodySegment';
 export default WholeBodySegmentTool;

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

@@ -16,7 +16,8 @@ declare abstract class AnnotationTool extends AnnotationDisplayTool {
     mouseMoveCallback: (evt: EventTypes.MouseMoveEventType, filteredAnnotations?: Annotations) => boolean;
     getHandleNearImagePoint(element: HTMLDivElement, annotation: Annotation, canvasCoords: Types.Point2, proximity: number): ToolHandle | undefined;
     getLinkedTextBoxStyle(specifications: StyleSpecifier, annotation?: Annotation): Record<string, unknown>;
-    isSuvScaled(viewport: Types.IStackViewport | Types.IVolumeViewport, targetId: string, imageId?: string): boolean;
+    static isSuvScaled(viewport: Types.IStackViewport | Types.IVolumeViewport, targetId: string, imageId?: string): boolean;
+    isSuvScaled: typeof AnnotationTool.isSuvScaled;
     protected getAnnotationStyle(context: {
         annotation: Annotation;
         styleSpecifier: StyleSpecifier;

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

@@ -82,6 +82,7 @@ class AnnotationTool extends AnnotationDisplayTool {
             }
             return annotationsNeedToBeRedrawn;
         };
+        this.isSuvScaled = AnnotationTool.isSuvScaled;
         if (toolProps.configuration?.getTextLines) {
             this.configuration.getTextLines = toolProps.configuration.getTextLines;
         }
@@ -139,7 +140,7 @@ class AnnotationTool extends AnnotationDisplayTool {
             lineDash: this.getStyle('textBoxLinkLineDash', specifications, annotation),
         };
     }
-    isSuvScaled(viewport, targetId, imageId) {
+    static isSuvScaled(viewport, targetId, imageId) {
         if (viewport instanceof BaseVolumeViewport) {
             const volumeId = csUtils.getVolumeId(targetId);
             const volume = cache.getVolume(volumeId);
@@ -215,6 +216,8 @@ class AnnotationTool extends AnnotationDisplayTool {
         const annotationMemo = {
             restoreMemo: () => {
                 const newState = AnnotationTool.createAnnotationState(annotation, deleting);
+                const { viewport } = getEnabledElement(element) || {};
+                viewport?.setViewReference(annotation.metadata);
                 if (state.deleting === true) {
                     state.deleting = false;
                     Object.assign(annotation.data, state.data);
@@ -229,7 +232,7 @@ class AnnotationTool extends AnnotationDisplayTool {
                     state.data = newState.data;
                     addAnnotation(annotation, element);
                     setAnnotationSelected(annotation.annotationUID, true);
-                    getEnabledElement(element)?.viewport.render();
+                    viewport?.render();
                     return;
                 }
                 if (state.deleting === false) {
@@ -237,7 +240,7 @@ class AnnotationTool extends AnnotationDisplayTool {
                     state.data = newState.data;
                     setAnnotationSelected(annotation.annotationUID);
                     removeAnnotation(annotation.annotationUID);
-                    getEnabledElement(element)?.viewport.render();
+                    viewport?.render();
                     return;
                 }
                 const currentAnnotation = getAnnotation(annotationUID);

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

@@ -3,6 +3,7 @@ import type { ContourAnnotation } from '../../types/ToolSpecificAnnotationTypes'
 import type { StyleSpecifier } from '../../types/AnnotationStyle';
 import ContourBaseTool from './ContourBaseTool';
 declare abstract class ContourSegmentationBaseTool extends ContourBaseTool {
+    static PreviewSegmentIndex: number;
     constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
     protected isContourSegmentationTool(): boolean;
     protected createAnnotation(evt: EventTypes.InteractionEventType): ContourAnnotation;

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

@@ -13,6 +13,7 @@ import { getActiveSegmentIndex } from '../../stateManagement/segmentation/getAct
 import { getLockedSegmentIndices } from '../../stateManagement/segmentation/segmentLocking';
 import { getSVGStyleForSegment } from '../../utilities/segmentation/getSVGStyleForSegment';
 class ContourSegmentationBaseTool extends ContourBaseTool {
+    static { this.PreviewSegmentIndex = 255; }
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
         if (this.configuration.interpolation?.enabled) {

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

@@ -1,4 +1,4 @@
-import type { Types } from '@cornerstonejs/core';
+import { type Types } from '@cornerstonejs/core';
 import { BaseTool } from '../base';
 import type { EventTypes, PublicToolProps, ToolProps } from '../../types';
 type GrowCutToolData = {
@@ -11,17 +11,39 @@ type GrowCutToolData = {
         labelmapVolumeId: string;
         referencedVolumeId: string;
     };
+    islandRemoval?: {
+        worldIslandPoints: Types.Point3[];
+    };
     viewportId: string;
     renderingEngineId: string;
 };
+type RemoveIslandData = {
+    worldIslandPoints?: Types.Point3[];
+    ijkIslandPoints?: Types.Point3[];
+    islandPointIndexes?: number[];
+};
 declare class GrowCutBaseTool extends BaseTool {
     static toolName: any;
     protected growCutData: GrowCutToolData | null;
+    private static lastGrowCutCommand;
     constructor(toolProps: PublicToolProps, defaultToolProps: ToolProps);
     preMouseDownCallback(evt: EventTypes.MouseDownActivateEventType): Promise<boolean>;
-    protected getGrowCutLabelmap(): Promise<Types.IImageVolume>;
+    shrink(): void;
+    expand(): void;
+    refresh(): void;
+    protected getGrowCutLabelmap(_growCutData: GrowCutToolData): Promise<Types.IImageVolume>;
     protected runGrowCut(): Promise<void>;
     protected applyGrowCutLabelmap(segmentationId: string, segmentIndex: number, targetLabelmap: Types.IImageVolume, sourceLabelmap: Types.IImageVolume): void;
+    private _runLastCommand;
+    protected getLabelmapSegmentationData(viewport: Types.IViewport): Promise<{
+        segmentationId: string;
+        segmentIndex: number;
+        labelmapVolumeId: string;
+        referencedVolumeId: string;
+    }>;
+    protected _isOrthogonalView(viewport: Types.IViewport, referencedVolumeId: string): boolean;
+    protected getRemoveIslandData(_growCutData: GrowCutToolData): RemoveIslandData;
+    private _removeIslands;
     protected getSegmentStyle({ segmentationId, viewportId, segmentIndex }: {
         segmentationId: any;
         viewportId: any;
@@ -37,13 +59,6 @@ declare class GrowCutBaseTool extends BaseTool {
         };
         visibility: boolean;
     };
-    protected getLabelmapSegmentationData(viewport: Types.IViewport): {
-        segmentationId: string;
-        segmentIndex: number;
-        labelmapVolumeId: string;
-        referencedVolumeId: string;
-    };
-    protected _isOrthogonalView(viewport: Types.IViewport, referencedVolumeId: string): boolean;
 }
 export default GrowCutBaseTool;
-export type { GrowCutToolData };
+export type { GrowCutToolData, RemoveIslandData };