@ohif/app 3.10.0-beta.2 → 3.10.0-beta.20

package/dist/{149.bundle.b8d177954628f4631fc0.js → 3022.bundle.51a7056ea0e39b06e095.js}

@@ -1,4 +1,4 @@
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[149],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[3022],{
 
 /***/ 97181:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -1959,14 +1959,17 @@ function wheelListener(evt) {
 
 /***/ }),
 
-/***/ 82107:
+/***/ 97:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Q: () => (/* binding */ checkAndDefineTextBoxProperty),
-/* harmony export */   d: () => (/* binding */ checkAndDefineCachedStatsProperty)
-/* harmony export */ });
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  c: () => (/* binding */ resetAnnotationManager)
+});
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/utilities/defineProperties.js
 const checkAndDefineTextBoxProperty = (annotation) => {
     if (!annotation.data) {
         annotation.data = {};
@@ -1990,6 +1993,37 @@ const checkAndDefineCachedStatsProperty = (annotation) => {
 };
 
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/annotationLocking.js
+var annotationLocking = __webpack_require__(2076);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/annotationVisibility.js
+var annotationVisibility = __webpack_require__(29601);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/FrameOfReferenceSpecificAnnotationManager.js
+var FrameOfReferenceSpecificAnnotationManager = __webpack_require__(67013);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/annotationState.js
+var annotationState = __webpack_require__(82056);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/resetAnnotationManager.js
+
+
+
+
+
+const defaultManager = FrameOfReferenceSpecificAnnotationManager/* defaultFrameOfReferenceSpecificAnnotationManager */.H;
+const preprocessingFn = (annotation) => {
+    annotation = checkAndDefineTextBoxProperty(annotation);
+    annotation = checkAndDefineCachedStatsProperty(annotation);
+    const uid = annotation.annotationUID;
+    const isLocked = (0,annotationLocking.checkAndSetAnnotationLocked)(uid);
+    annotation.isLocked = isLocked;
+    const isVisible = (0,annotationVisibility.checkAndSetAnnotationVisibility)(uid);
+    annotation.isVisible = isVisible;
+    return annotation;
+};
+defaultManager.setPreprocessingFn(preprocessingFn);
+(0,annotationState.setAnnotationManager)(defaultManager);
+function resetAnnotationManager() {
+    (0,annotationState.setAnnotationManager)(defaultManager);
+}
+
 
 /***/ }),
 
@@ -2007,6 +2041,8 @@ const checkAndDefineCachedStatsProperty = (annotation) => {
 /* harmony import */ var _annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2076);
 /* harmony import */ var _annotation_annotationSelection__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(17343);
 /* harmony import */ var _annotation_annotationState__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(82056);
+/* harmony import */ var _annotation_resetAnnotationManager__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(97);
+
 
 
 
@@ -2096,7 +2132,7 @@ function triggerSegmentationRepresentationModified(viewportId, segmentationId, t
         type,
         viewportId,
     };
-    (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.eventTarget, _enums__WEBPACK_IMPORTED_MODULE_1__.Events.SEGMENTATION_REPRESENTATION_ADDED, eventDetail);
+    (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.eventTarget, _enums__WEBPACK_IMPORTED_MODULE_1__.Events.SEGMENTATION_REPRESENTATION_MODIFIED, eventDetail);
 }
 
 
@@ -2125,18 +2161,35 @@ function triggerSegmentationRepresentationRemoved(viewportId, segmentationId, ty
 
 /***/ }),
 
-/***/ 33283:
+/***/ 50409:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   B: () => (/* binding */ getColorLUT)
+/* harmony export */ });
+/* harmony import */ var _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59475);
+
+function getColorLUT(index) {
+    const segmentationStateManager = _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__/* .defaultSegmentationStateManager */ ._6;
+    return segmentationStateManager.getColorLUT(index);
+}
+
+
+/***/ }),
+
+/***/ 70906:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   T: () => (/* binding */ getSegmentation)
+/* harmony export */   u: () => (/* binding */ getNextColorLUTIndex)
 /* harmony export */ });
 /* harmony import */ var _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59475);
 
-function getSegmentation(segmentationId) {
+function getNextColorLUTIndex() {
     const segmentationStateManager = _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__/* .defaultSegmentationStateManager */ ._6;
-    return segmentationStateManager.getSegmentation(segmentationId);
+    return segmentationStateManager.getNextColorLUTIndex();
 }
 
 
@@ -2248,6 +2301,7 @@ async function convertStackToVolumeLabelmap(args) {
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   DU: () => (/* binding */ getSurfaceRepresentationUID),
 /* harmony export */   Qe: () => (/* binding */ getLabelmapActorUID),
 /* harmony export */   Th: () => (/* binding */ getSurfaceActorEntry),
 /* harmony export */   jU: () => (/* binding */ getSurfaceActorUID),
@@ -2278,13 +2332,16 @@ function getLabelmapActorEntry(viewportId, segmentationId) {
     return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${_enums__WEBPACK_IMPORTED_MODULE_1__.SegmentationRepresentations.Labelmap}`));
 }
 function getSurfaceActorEntry(viewportId, segmentationId, segmentIndex) {
-    return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID?.startsWith(`${segmentationId}-${_enums__WEBPACK_IMPORTED_MODULE_1__.SegmentationRepresentations.Surface}-${segmentIndex}`));
+    return getActorEntry(viewportId, segmentationId, (actor) => actor.representationUID?.startsWith(getSurfaceRepresentationUID(segmentationId, segmentIndex)));
 }
 function getSurfaceActorUID(viewportId, segmentationId, segmentIndex) {
     const segIndex = segmentIndex ? segmentIndex.toString() : '';
     const actorEntry = getSurfaceActorEntry(viewportId, segmentationId, segIndex);
     return actorEntry?.uid;
 }
+function getSurfaceRepresentationUID(segmentationId, segmentIndex) {
+    return `${segmentationId}-${_enums__WEBPACK_IMPORTED_MODULE_1__.SegmentationRepresentations.Surface}-${segmentIndex}`;
+}
 
 
 /***/ }),
@@ -3029,7 +3086,8 @@ async function computeLabelmapFromSurfaceSegmentation(segmentationId, options =
     let segmentationVolume;
     if (isVolume) {
         const volumeId = viewport.getVolumeId();
-        segmentationVolume = await esm.volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId);
+        segmentationVolume =
+            esm.volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId);
     }
     else {
         const imageIds = options.viewport.getImageIds();
@@ -3141,7 +3199,7 @@ function filterToolsWithAnnotationsForElement(element, tools) {
         if (typeof tool.filterInteractableAnnotationsForElement === 'function') {
             annotations = tool.filterInteractableAnnotationsForElement(element, annotations);
         }
-        if (annotations.length > 0) {
+        if (annotations?.length > 0) {
             result.push({ tool, annotations });
         }
     }
@@ -3352,6 +3410,7 @@ function activateClosedContourEdit(evt, annotation, viewportIdsToRender) {
         editCanvasPoints: [canvasPos],
         startCrossingIndex: undefined,
         editIndex: 0,
+        annotation,
     };
     this.commonData = {
         annotation,
@@ -3386,9 +3445,10 @@ function mouseDragClosedContourEditCallback(evt) {
     const worldPos = currentPoints.world;
     const canvasPos = currentPoints.canvas;
     const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
-    const { renderingEngine, viewport } = enabledElement;
+    const { viewport } = enabledElement;
     const { viewportIdsToRender, xDir, yDir, spacing } = this.commonData;
-    const { editIndex, editCanvasPoints, startCrossingIndex } = this.editData;
+    const { editIndex, editCanvasPoints, startCrossingIndex, annotation } = this.editData;
+    this.createMemo(element, annotation);
     const lastCanvasPoint = editCanvasPoints[editCanvasPoints.length - 1];
     const lastWorldPoint = viewport.canvasToWorld(lastCanvasPoint);
     const worldPosDiff = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
@@ -3443,6 +3503,7 @@ function finishEditAndStartNewEdit(evt) {
         startCrossingIndex: undefined,
         editIndex: 0,
         snapIndex: undefined,
+        annotation,
     };
     (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)(viewportIdsToRender);
 }
@@ -3528,8 +3589,9 @@ function mouseUpClosedContourEditCallback(evt) {
 }
 function completeClosedContourEdit(element) {
     const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
-    const { viewport, renderingEngine } = enabledElement;
+    const { viewport } = enabledElement;
     const { annotation, viewportIdsToRender } = this.commonData;
+    this.doneEditMemo();
     const { fusedCanvasPoints, prevCanvasPoints } = this.editData;
     if (fusedCanvasPoints) {
         const updatedPoints = (0,_utilities_planarFreehandROITool_smoothPoints__WEBPACK_IMPORTED_MODULE_7__/* .shouldSmooth */ .Q)(this.configuration, annotation)
@@ -3631,6 +3693,7 @@ function activateDraw(evt, annotation, viewportIdsToRender) {
         canvasPoints: [canvasPos],
         polylineIndex: 0,
         contourHoleProcessingEnabled,
+        newAnnotation: true,
     };
     this.commonData = {
         annotation,
@@ -3665,9 +3728,10 @@ function mouseDragDrawCallback(evt) {
     const worldPos = currentPoints.world;
     const canvasPos = currentPoints.canvas;
     const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
-    const { renderingEngine, viewport } = enabledElement;
+    const { viewport } = enabledElement;
     const { annotation, viewportIdsToRender, xDir, yDir, spacing, movingTextBox, } = this.commonData;
-    const { polylineIndex, canvasPoints } = this.drawData;
+    const { polylineIndex, canvasPoints, newAnnotation } = this.drawData;
+    this.createMemo(element, annotation, { newAnnotation });
     const lastCanvasPoint = canvasPoints[canvasPoints.length - 1];
     const lastWorldPoint = viewport.canvasToWorld(lastCanvasPoint);
     const worldPosDiff = gl_matrix__WEBPACK_IMPORTED_MODULE_4__/* .vec3.create */ .eR.create();
@@ -3707,6 +3771,8 @@ function mouseUpDrawCallback(evt) {
     const lastPoint = canvasPoints[canvasPoints.length - 1];
     const eventDetail = evt.detail;
     const { element } = eventDetail;
+    this.doneEditMemo();
+    this.drawData.newAnnotation = false;
     if (allowOpenContours &&
         !pointsAreWithinCloseContourProximity(firstPoint, lastPoint, this.configuration.closeContourProximity)) {
         this.completeDrawOpenContour(element, { contourHoleProcessingEnabled });
@@ -4137,6 +4203,7 @@ function activateOpenContourEdit(evt, annotation, viewportIdsToRender) {
     const canvasPos = currentPoints.canvas;
     const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
     const { viewport } = enabledElement;
+    this.doneEditMemo();
     const prevCanvasPoints = annotation.data.contour.polyline.map(viewport.worldToCanvas);
     const { spacing, xDir, yDir } = getSubPixelSpacingAndXYDirections(viewport, this.configuration.subPixelResolution);
     this.editData = {
@@ -4178,12 +4245,13 @@ function mouseDragOpenContourEditCallback(evt) {
     const worldPos = currentPoints.world;
     const canvasPos = currentPoints.canvas;
     const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
-    const { renderingEngine, viewport } = enabledElement;
+    const { viewport } = enabledElement;
     const { viewportIdsToRender, xDir, yDir, spacing } = this.commonData;
     const { editIndex, editCanvasPoints, startCrossingIndex } = this.editData;
     const lastCanvasPoint = editCanvasPoints[editCanvasPoints.length - 1];
     const lastWorldPoint = viewport.canvasToWorld(lastCanvasPoint);
     const worldPosDiff = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    this.createMemo(element, this.commonData.annotation);
     gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(worldPosDiff, worldPos, lastWorldPoint);
     const xDist = Math.abs(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(worldPosDiff, xDir));
     const yDist = Math.abs(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(worldPosDiff, yDir));
@@ -4232,6 +4300,7 @@ function openContourEditOverwriteEnd(evt) {
     this.isEditingOpen = false;
     this.editData = undefined;
     this.commonData = undefined;
+    this.doneEditMemo();
     this.deactivateOpenContourEdit(element);
     this.activateOpenContourEndEdit(evt, annotation, viewportIdsToRender, null);
 }
@@ -4382,8 +4451,9 @@ function mouseUpOpenContourEditCallback(evt) {
 }
 function completeOpenContourEdit(element) {
     const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
-    const { viewport, renderingEngine } = enabledElement;
+    const { viewport } = enabledElement;
     const { annotation, viewportIdsToRender } = this.commonData;
+    this.doneEditMemo();
     const { fusedCanvasPoints, prevCanvasPoints } = this.editData;
     if (fusedCanvasPoints) {
         const updatedPoints = (0,_utilities_planarFreehandROITool_smoothPoints__WEBPACK_IMPORTED_MODULE_6__/* .shouldSmooth */ .Q)(this.configuration)
@@ -5446,6 +5516,11 @@ class LinearSpline extends _CardinalSpline__WEBPACK_IMPORTED_MODULE_0__/* .Cardi
 /* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(29601);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(82056);
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(44049);
+/* harmony import */ var _enums_ChangeTypes__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(75183);
+/* harmony import */ var _stateManagement_annotation_annotationSelection__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(17343);
+/* harmony import */ var _utilities_contourSegmentation__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(64843);
+
+
 
 
 
@@ -5453,6 +5528,9 @@ class LinearSpline extends _CardinalSpline__WEBPACK_IMPORTED_MODULE_0__/* .Cardi
 
 
 
+
+const { DefaultHistoryMemo } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.HistoryMemo;
+const { PointsManager } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
 class AnnotationTool extends _AnnotationDisplayTool__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A {
     static createAnnotation(...annotationBaseData) {
         let annotation = {
@@ -5625,6 +5703,85 @@ class AnnotationTool extends _AnnotationDisplayTool__WEBPACK_IMPORTED_MODULE_2__
             return true;
         }
     }
+    static createAnnotationState(annotation, deleting) {
+        const { data, annotationUID } = annotation;
+        const cloneData = {
+            ...data,
+            cachedStats: {},
+        };
+        delete cloneData.contour;
+        delete cloneData.spline;
+        const state = {
+            annotationUID,
+            data: structuredClone(cloneData),
+            deleting,
+        };
+        const contour = data.contour;
+        if (contour) {
+            state.data.contour = {
+                ...contour,
+                polyline: null,
+                pointsManager: PointsManager.create3(contour.polyline.length, contour.polyline),
+            };
+        }
+        return state;
+    }
+    static createAnnotationMemo(element, annotation, options) {
+        if (!annotation) {
+            return;
+        }
+        const { newAnnotation, deleting = newAnnotation ? false : undefined } = options || {};
+        const { annotationUID } = annotation;
+        const state = AnnotationTool.createAnnotationState(annotation, deleting);
+        const annotationMemo = {
+            restoreMemo: () => {
+                const newState = AnnotationTool.createAnnotationState(annotation, deleting);
+                if (state.deleting === true) {
+                    state.deleting = false;
+                    Object.assign(annotation.data, state.data);
+                    if (annotation.data.contour) {
+                        const annotationData = annotation.data;
+                        annotationData.contour.polyline = state.data.contour.pointsManager.points;
+                        delete state.data.contour.pointsManager;
+                        if (annotationData.segmentation) {
+                            (0,_utilities_contourSegmentation__WEBPACK_IMPORTED_MODULE_9__.addContourSegmentationAnnotation)(annotation);
+                        }
+                    }
+                    state.data = newState.data;
+                    (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.addAnnotation)(annotation, element);
+                    (0,_stateManagement_annotation_annotationSelection__WEBPACK_IMPORTED_MODULE_8__.setAnnotationSelected)(annotation.annotationUID, true);
+                    (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element)?.viewport.render();
+                    return;
+                }
+                if (state.deleting === false) {
+                    state.deleting = true;
+                    state.data = newState.data;
+                    (0,_stateManagement_annotation_annotationSelection__WEBPACK_IMPORTED_MODULE_8__.setAnnotationSelected)(annotation.annotationUID);
+                    (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.removeAnnotation)(annotation.annotationUID);
+                    (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element)?.viewport.render();
+                    return;
+                }
+                const currentAnnotation = (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.getAnnotation)(annotationUID);
+                if (!currentAnnotation) {
+                    console.warn('No current annotation');
+                    return;
+                }
+                Object.assign(currentAnnotation.data, state.data);
+                if (currentAnnotation.data.contour) {
+                    currentAnnotation.data
+                        .contour.polyline = state.data.contour.pointsManager.points;
+                }
+                state.data = newState.data;
+                currentAnnotation.invalidated = true;
+                (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_6__/* .triggerAnnotationModified */ .XF)(currentAnnotation, element, _enums_ChangeTypes__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .A.History);
+            },
+        };
+        DefaultHistoryMemo.push(annotationMemo);
+        return annotationMemo;
+    }
+    createMemo(element, annotation, options) {
+        this.memo ||= AnnotationTool.createAnnotationMemo(element, annotation, options);
+    }
 }
 AnnotationTool.toolName = 'AnnotationTool';
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (AnnotationTool);
@@ -5646,8 +5803,6 @@ __webpack_require__.d(__webpack_exports__, {
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js
 var esm = __webpack_require__(81985);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentation.js
-var getSegmentation = __webpack_require__(33283);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/index.js + 2 modules
 var enums = __webpack_require__(99737);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/annotationState.js
@@ -5716,48 +5871,18 @@ class ContourBaseTool extends AnnotationTool/* default */.A {
         return renderStatus;
     }
     createAnnotation(evt) {
-        const eventDetail = evt.detail;
-        const { currentPoints, element } = eventDetail;
-        const { world: worldPos } = currentPoints;
-        const enabledElement = (0,esm.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 (0,annotationState.addAnnotation)(annotation, element);
@@ -5823,24 +5948,18 @@ var contourSegmentation = __webpack_require__(64843);
 var triggerAnnotationRenderForToolGroupIds = __webpack_require__(94779);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/store/ToolGroupManager/index.js + 7 modules
 var ToolGroupManager = __webpack_require__(7754);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/config/segmentationColor.js
-var segmentationColor = __webpack_require__(93733);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentationRepresentation.js
 var getSegmentationRepresentation = __webpack_require__(93210);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getActiveSegmentation.js
 var getActiveSegmentation = __webpack_require__(67165);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentationRepresentationVisibility.js
-var getSegmentationRepresentationVisibility = __webpack_require__(33658);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getViewportIdsWithSegmentation.js
 var getViewportIdsWithSegmentation = __webpack_require__(58859);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getActiveSegmentIndex.js
 var getActiveSegmentIndex = __webpack_require__(60740);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/segmentLocking.js
 var segmentLocking = __webpack_require__(26795);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/SegmentationStyle.js
-var SegmentationStyle = __webpack_require__(92686);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/helpers/internalGetHiddenSegmentIndices.js
-var internalGetHiddenSegmentIndices = __webpack_require__(47098);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/getSVGStyleForSegment.js
+var getSVGStyleForSegment = __webpack_require__(86644);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/base/ContourSegmentationBaseTool.js
 
 
@@ -5856,10 +5975,6 @@ var internalGetHiddenSegmentIndices = __webpack_require__(47098);
 
 
 
-
-
-
-
 class ContourSegmentationBaseTool extends ContourBaseTool {
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
@@ -5957,54 +6072,12 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
         const { autoGenerated } = annotation;
         const segmentsLocked = (0,segmentLocking.getLockedSegmentIndices)(segmentationId);
         const annotationLocked = segmentsLocked.includes(segmentIndex);
-        const segmentColor = (0,segmentationColor.getSegmentIndexColor)(context.styleSpecifier.viewportId, segmentationId, segmentIndex);
-        const segmentationVisible = (0,getSegmentationRepresentationVisibility/* getSegmentationRepresentationVisibility */.I)(viewportId, {
-            segmentationId,
-            type: enums.SegmentationRepresentations.Contour,
-        });
-        const activeSegmentation = (0,getActiveSegmentation/* getActiveSegmentation */.T)(viewportId);
-        const isActive = activeSegmentation?.segmentationId === segmentationId;
-        const style = SegmentationStyle/* segmentationStyle */.Y.getStyle({
-            viewportId,
+        const { color, fillColor, lineWidth, fillOpacity, lineDash, visibility } = (0,getSVGStyleForSegment/* getSVGStyleForSegment */.u)({
             segmentationId,
-            type: enums.SegmentationRepresentations.Contour,
             segmentIndex,
+            viewportId,
+            autoGenerated,
         });
-        const mergedConfig = style;
-        let lineWidth = 1;
-        let lineDash = undefined;
-        let lineOpacity = 1;
-        let fillOpacity = 0;
-        if (autoGenerated) {
-            lineWidth = mergedConfig.outlineWidthAutoGenerated ?? lineWidth;
-            lineDash = mergedConfig.outlineDashAutoGenerated ?? lineDash;
-            lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
-            fillOpacity = mergedConfig.fillAlphaAutoGenerated ?? fillOpacity;
-        }
-        else if (isActive) {
-            lineWidth = mergedConfig.outlineWidth ?? lineWidth;
-            lineDash = mergedConfig.outlineDash ?? lineDash;
-            lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
-            fillOpacity = mergedConfig.fillAlpha ?? fillOpacity;
-        }
-        else {
-            lineWidth = mergedConfig.outlineWidthInactive ?? lineWidth;
-            lineDash = mergedConfig.outlineDashInactive ?? lineDash;
-            lineOpacity = mergedConfig.outlineOpacityInactive ?? lineOpacity;
-            fillOpacity = mergedConfig.fillAlphaInactive ?? fillOpacity;
-        }
-        if ((0,getActiveSegmentIndex/* getActiveSegmentIndex */.Q)(segmentationId) === segmentIndex) {
-            lineWidth += mergedConfig.activeSegmentOutlineWidthDelta;
-        }
-        lineWidth = mergedConfig.renderOutline ? lineWidth : 0;
-        fillOpacity = mergedConfig.renderFill ? fillOpacity : 0;
-        const color = `rgba(${segmentColor[0]}, ${segmentColor[1]}, ${segmentColor[2]}, ${lineOpacity})`;
-        const fillColor = `rgb(${segmentColor[0]}, ${segmentColor[1]}, ${segmentColor[2]})`;
-        const hiddenSegments = (0,internalGetHiddenSegmentIndices/* internalGetHiddenSegmentIndices */.s)(viewportId, {
-            segmentationId,
-            type: enums.SegmentationRepresentations.Contour,
-        });
-        const isVisible = !hiddenSegments.has(segmentIndex);
         return {
             color,
             fillColor,
@@ -6014,7 +6087,7 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
             textbox: {
                 color,
             },
-            visibility: segmentationVisible && isVisible,
+            visibility,
             locked: annotationLocked,
         };
     }
@@ -6022,6 +6095,129 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
 
 
 
+/***/ }),
+
+/***/ 10639:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(81985);
+/* harmony import */ var _base__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(85817);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(99737);
+/* harmony import */ var _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(1300);
+/* harmony import */ var _stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(49906);
+/* harmony import */ var _utilities_segmentation_getSVGStyleForSegment__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(86644);
+
+
+
+
+
+
+const { transformWorldToIndex, transformIndexToWorld } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
+class GrowCutBaseTool extends _base__WEBPACK_IMPORTED_MODULE_1__/* .BaseTool */ .oS {
+    constructor(toolProps, defaultToolProps) {
+        super(toolProps, defaultToolProps);
+    }
+    async preMouseDownCallback(evt) {
+        const eventData = evt.detail;
+        const { element, currentPoints } = eventData;
+        const { world: worldPoint } = currentPoints;
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+        const { viewport, renderingEngine } = enabledElement;
+        const { viewUp } = viewport.getCamera();
+        const { segmentationId, segmentIndex, labelmapVolumeId, referencedVolumeId, } = this.getLabelmapSegmentationData(viewport);
+        if (!this._isOrthogonalView(viewport, referencedVolumeId)) {
+            throw new Error('Oblique view is not supported yet');
+        }
+        this.growCutData = {
+            metadata: {
+                ...viewport.getViewReference({ points: [worldPoint] }),
+                viewUp,
+            },
+            segmentation: {
+                segmentationId,
+                segmentIndex,
+                labelmapVolumeId,
+                referencedVolumeId,
+            },
+            viewportId: viewport.id,
+            renderingEngineId: renderingEngine.id,
+        };
+        evt.preventDefault();
+        return true;
+    }
+    async getGrowCutLabelmap() {
+        throw new Error('Not implemented');
+    }
+    async runGrowCut() {
+        const { segmentation: { segmentationId, segmentIndex, labelmapVolumeId }, } = this.growCutData;
+        const labelmap = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(labelmapVolumeId);
+        const growcutLabelmap = await this.getGrowCutLabelmap();
+        this.applyGrowCutLabelmap(segmentationId, segmentIndex, labelmap, growcutLabelmap);
+    }
+    applyGrowCutLabelmap(segmentationId, segmentIndex, targetLabelmap, sourceLabelmap) {
+        const srcLabelmapData = sourceLabelmap.voxelManager.getCompleteScalarDataArray();
+        const targetLabelmapData = targetLabelmap.voxelManager.getCompleteScalarDataArray();
+        const [srcColumns, srcRows, srcNumSlices] = sourceLabelmap.dimensions;
+        const [tgtColumns, tgtRows] = targetLabelmap.dimensions;
+        const srcPixelsPerSlice = srcColumns * srcRows;
+        const tgtPixelsPerSlice = tgtColumns * tgtRows;
+        for (let srcSlice = 0; srcSlice < srcNumSlices; srcSlice++) {
+            for (let srcRow = 0; srcRow < srcRows; srcRow++) {
+                const srcRowIJK = [0, srcRow, srcSlice];
+                const rowVoxelWorld = transformIndexToWorld(sourceLabelmap.imageData, srcRowIJK);
+                const tgtRowIJK = transformWorldToIndex(targetLabelmap.imageData, rowVoxelWorld);
+                const [tgtColumn, tgtRow, tgtSlice] = tgtRowIJK;
+                const srcOffset = srcRow * srcColumns + srcSlice * srcPixelsPerSlice;
+                const tgtOffset = tgtColumn + tgtRow * tgtColumns + tgtSlice * tgtPixelsPerSlice;
+                for (let column = 0; column < srcColumns; column++) {
+                    targetLabelmapData[tgtOffset + column] =
+                        srcLabelmapData[srcOffset + column] === segmentIndex
+                            ? segmentIndex
+                            : 0;
+                }
+            }
+        }
+        targetLabelmap.voxelManager.setCompleteScalarDataArray(targetLabelmapData);
+        (0,_stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_4__.triggerSegmentationDataModified)(segmentationId);
+    }
+    getSegmentStyle({ segmentationId, viewportId, segmentIndex }) {
+        return (0,_utilities_segmentation_getSVGStyleForSegment__WEBPACK_IMPORTED_MODULE_5__/* .getSVGStyleForSegment */ .u)({
+            segmentationId,
+            segmentIndex,
+            viewportId,
+        });
+    }
+    getLabelmapSegmentationData(viewport) {
+        const { segmentationId } = _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_3__.activeSegmentation.getActiveSegmentation(viewport.id);
+        const segmentIndex = _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_3__.segmentIndex.getActiveSegmentIndex(segmentationId);
+        const { representationData } = _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_3__.state.getSegmentation(segmentationId);
+        const labelmapData = representationData[_enums__WEBPACK_IMPORTED_MODULE_2__.SegmentationRepresentations.Labelmap];
+        const { volumeId: labelmapVolumeId, referencedVolumeId } = labelmapData;
+        return {
+            segmentationId,
+            segmentIndex,
+            labelmapVolumeId,
+            referencedVolumeId,
+        };
+    }
+    _isOrthogonalView(viewport, referencedVolumeId) {
+        const volume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(referencedVolumeId);
+        const volumeImageData = volume.imageData;
+        const camera = viewport.getCamera();
+        const { ijkVecColDir, ijkVecSliceDir } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getVolumeDirectionVectors(volumeImageData, camera);
+        return [ijkVecColDir, ijkVecSliceDir].every((vec) => _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isEqual(Math.abs(vec[0]), 1) ||
+            _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isEqual(Math.abs(vec[1]), 1) ||
+            _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isEqual(Math.abs(vec[2]), 1));
+    }
+}
+GrowCutBaseTool.toolName = 'GrowCutBaseTool';
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (GrowCutBaseTool);
+
+
 /***/ }),
 
 /***/ 67772:
@@ -6284,7 +6480,7 @@ async function addLabelmapToElement(element, labelMapData, segmentationId) {
                 representationUID: `${segmentationId}-${_enums__WEBPACK_IMPORTED_MODULE_4__.SegmentationRepresentations.Labelmap}`,
             },
         ];
-        await (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.addImageSlicesToViewports)(renderingEngine, stackInputs, [viewportId]);
+        (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.addImageSlicesToViewports)(renderingEngine, stackInputs, [viewportId]);
     }
     (0,_stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_3__.triggerSegmentationDataModified)(segmentationId);
 }
@@ -6433,7 +6629,6 @@ function validate(segmentationRepresentationData) {
 function addOrUpdateSurfaceToElement(element, surface, segmentationId) {
     const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
     const { viewport } = enabledElement;
-    const representationUID = (0,_stateManagement_segmentation_helpers_getSegmentationActor__WEBPACK_IMPORTED_MODULE_5__/* .getSurfaceActorUID */ .jU)(viewport.id, segmentationId, surface.segmentIndex);
     const surfaceActorEntry = (0,_stateManagement_segmentation_helpers_getSegmentationActor__WEBPACK_IMPORTED_MODULE_5__/* .getSurfaceActorEntry */ .Th)(viewport.id, segmentationId, surface.segmentIndex);
     const surfaceActor = surfaceActorEntry?.actor;
     if (surfaceActor) {
@@ -6474,6 +6669,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 = (0,_stateManagement_segmentation_helpers_getSegmentationActor__WEBPACK_IMPORTED_MODULE_5__/* .getSurfaceRepresentationUID */ .DU)(segmentationId, surface.segmentIndex);
     viewport.addActor({
         uid: _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.uuidv4(),
         actor: actor,
@@ -6542,60 +6738,310 @@ const distancePointToContour = (viewport, annotation, coords) => {
 
 /***/ }),
 
-/***/ 55887:
+/***/ 23631:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (/* binding */ BrushStrategy)
+/* harmony export */   A: () => (/* binding */ LabelmapBaseTool)
 /* harmony export */ });
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(81985);
-/* harmony import */ var _stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(49906);
-/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(21553);
-/* harmony import */ var _utils_getStrategyData__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(40905);
-/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(99737);
+/* harmony import */ var _base__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(85817);
+/* harmony import */ var _enums_SegmentationRepresentations__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(18682);
+/* harmony import */ var _stateManagement_segmentation_getActiveSegmentation__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(67165);
+/* harmony import */ var _stateManagement_segmentation_segmentLocking__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(26795);
+/* harmony import */ var _stateManagement_segmentation_getSegmentation__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(33283);
+/* harmony import */ var _utilities_annotationHydration__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(64485);
+/* harmony import */ var _stateManagement_segmentation_getCurrentLabelmapImageIdForViewport__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(97577);
+/* harmony import */ var _stateManagement_segmentation_getStackSegmentationImageIdsForViewport__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(71309);
+/* harmony import */ var _stateManagement_segmentation_config_segmentationColor__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(93733);
+/* harmony import */ var _stateManagement_segmentation_getActiveSegmentIndex__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(60740);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(99737);
+/* harmony import */ var _utilities_segmentation_createLabelmapMemo__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(2397);
 
 
 
 
 
-const { VoxelManager } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
-class BrushStrategy {
-    static { this.COMPOSITIONS = _compositions__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A; }
-    static { this.childFunctions = {
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.OnInteractionStart]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.OnInteractionStart, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.OnInteractionEnd]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.OnInteractionEnd, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Fill]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Fill),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.CreateIsInThreshold]: addSingletonMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.CreateIsInThreshold),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.AcceptPreview]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.AcceptPreview, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.RejectPreview]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.RejectPreview, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.INTERNAL_setValue]: addSingletonMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.INTERNAL_setValue),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Preview]: addSingletonMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Preview, false),
-        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.ComputeInnerCircleRadius]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.ComputeInnerCircleRadius),
-        compositions: null,
-    }; }
-    constructor(name, ...initializers) {
-        this._initialize = [];
-        this._fill = [];
-        this._onInteractionStart = [];
-        this.fill = (enabledElement, operationData) => {
-            const initializedData = this.initialize(enabledElement, operationData, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Fill);
-            if (!initializedData) {
+
+
+
+
+
+
+
+
+class LabelmapBaseTool extends _base__WEBPACK_IMPORTED_MODULE_1__/* .BaseTool */ .oS {
+    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) {
+        this.memo ||= _utilities_segmentation_createLabelmapMemo__WEBPACK_IMPORTED_MODULE_12__.createLabelmapMemo(segmentId, segmentationVoxelManager, preview);
+        return this.memo;
+    }
+    createEditData(element) {
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+        const { viewport } = enabledElement;
+        const activeSegmentation = (0,_stateManagement_segmentation_getActiveSegmentation__WEBPACK_IMPORTED_MODULE_3__/* .getActiveSegmentation */ .T)(viewport.id);
+        if (!activeSegmentation) {
+            const event = new CustomEvent(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.Enums.Events.ERROR_EVENT, {
+                detail: {
+                    type: 'Segmentation',
+                    message: 'No active segmentation detected, create a segmentation representation before using the brush tool',
+                },
+                cancelable: true,
+            });
+            _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.eventTarget.dispatchEvent(event);
+            return null;
+        }
+        const { segmentationId } = activeSegmentation;
+        const segmentsLocked = (0,_stateManagement_segmentation_segmentLocking__WEBPACK_IMPORTED_MODULE_4__.getLockedSegmentIndices)(segmentationId);
+        const { representationData } = (0,_stateManagement_segmentation_getSegmentation__WEBPACK_IMPORTED_MODULE_5__/* .getSegmentation */ .T)(segmentationId);
+        if (viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.BaseVolumeViewport) {
+            const { volumeId } = representationData[_enums_SegmentationRepresentations__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A.Labelmap];
+            const actors = viewport.getActors();
+            const isStackViewport = viewport instanceof _utilities_annotationHydration__WEBPACK_IMPORTED_MODULE_6__/* .getClosestImageIdForStackViewport */ .x;
+            if (isStackViewport) {
+                const event = new CustomEvent(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.Enums.Events.ERROR_EVENT, {
+                    detail: {
+                        type: 'Segmentation',
+                        message: 'Cannot perform brush operation on the selected viewport',
+                    },
+                    cancelable: true,
+                });
+                _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.eventTarget.dispatchEvent(event);
+                return null;
+            }
+            const volumes = actors.map((actorEntry) => _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(actorEntry.referencedId));
+            const segmentationVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(volumeId);
+            const referencedVolumeIdToThreshold = volumes.find((volume) => _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isEqual(volume.dimensions, segmentationVolume.dimensions))?.volumeId || volumes[0]?.volumeId;
+            return {
+                volumeId,
+                referencedVolumeId: this.configuration.thresholdVolumeId ?? referencedVolumeIdToThreshold,
+                segmentsLocked,
+            };
+        }
+        else {
+            const segmentationImageId = (0,_stateManagement_segmentation_getCurrentLabelmapImageIdForViewport__WEBPACK_IMPORTED_MODULE_7__/* .getCurrentLabelmapImageIdForViewport */ .v)(viewport.id, segmentationId);
+            if (!segmentationImageId) {
                 return;
             }
-            const { strategySpecificConfiguration = {}, centerIJK } = initializedData;
-            if (_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isEqual(centerIJK, strategySpecificConfiguration.centerIJK)) {
-                return operationData.preview;
+            if (this.configuration.activeStrategy.includes('SPHERE')) {
+                const referencedImageIds = viewport.getImageIds();
+                const isValidVolumeForSphere = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isValidVolume(referencedImageIds);
+                if (!isValidVolumeForSphere) {
+                    throw new Error('Volume is not reconstructable for sphere manipulation');
+                }
+                const volumeId = `${segmentationId}_${viewport.id}`;
+                const volume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(volumeId);
+                if (volume) {
+                    return {
+                        imageId: segmentationImageId,
+                        segmentsLocked,
+                        override: {
+                            voxelManager: volume.voxelManager,
+                            imageData: volume.imageData,
+                        },
+                    };
+                }
+                else {
+                    const labelmapImageIds = (0,_stateManagement_segmentation_getStackSegmentationImageIdsForViewport__WEBPACK_IMPORTED_MODULE_8__/* .getStackSegmentationImageIdsForViewport */ .B)(viewport.id, segmentationId);
+                    if (!labelmapImageIds || labelmapImageIds.length === 1) {
+                        return {
+                            imageId: segmentationImageId,
+                            segmentsLocked,
+                        };
+                    }
+                    const volume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.volumeLoader.createAndCacheVolumeFromImagesSync(volumeId, labelmapImageIds);
+                    return {
+                        imageId: segmentationImageId,
+                        segmentsLocked,
+                        override: {
+                            voxelManager: volume.voxelManager,
+                            imageData: volume.imageData,
+                        },
+                    };
+                }
             }
             else {
-                strategySpecificConfiguration.centerIJK = centerIJK;
+                return {
+                    imageId: segmentationImageId,
+                    segmentsLocked,
+                };
             }
-            this._fill.forEach((func) => func(initializedData));
-            const { segmentationVoxelManager, previewVoxelManager, previewSegmentIndex, } = initializedData;
-            (0,_stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_1__.triggerSegmentationDataModified)(initializedData.segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices());
-            if (!previewSegmentIndex || !previewVoxelManager.modifiedSlices.size) {
-                segmentationVoxelManager.resetModifiedSlices();
+        }
+    }
+    createHoverData(element, centerCanvas) {
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.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 = (0,_stateManagement_segmentation_getActiveSegmentation__WEBPACK_IMPORTED_MODULE_3__/* .getActiveSegmentation */ .T)(viewportId);
+        if (!activeRepresentation) {
+            return;
+        }
+        const { segmentationId } = activeRepresentation;
+        const segmentIndex = (0,_stateManagement_segmentation_getActiveSegmentIndex__WEBPACK_IMPORTED_MODULE_10__/* .getActiveSegmentIndex */ .Q)(segmentationId);
+        if (!segmentIndex) {
+            return;
+        }
+        const segmentColor = (0,_stateManagement_segmentation_config_segmentationColor__WEBPACK_IMPORTED_MODULE_9__.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,
+            createMemo: this.createMemo.bind(this),
+        };
+        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 = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+        this._previewData.preview = this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), _enums__WEBPACK_IMPORTED_MODULE_11__.StrategyCallbacks.AddPreview);
+        this._previewData.isDrag = true;
+        return this._previewData.preview;
+    }
+    rejectPreview(element = this._previewData.element) {
+        if (!element || !this._previewData.preview) {
+            return;
+        }
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), _enums__WEBPACK_IMPORTED_MODULE_11__.StrategyCallbacks.RejectPreview);
+        this._previewData.preview = null;
+        this._previewData.isDrag = false;
+    }
+    acceptPreview(element = this._previewData.element) {
+        if (!element) {
+            return;
+        }
+        this.doneEditMemo();
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
+        this.applyActiveStrategyCallback(enabledElement, this.getOperationData(element), _enums__WEBPACK_IMPORTED_MODULE_11__.StrategyCallbacks.AcceptPreview);
+        this._previewData.isDrag = false;
+        this._previewData.preview = null;
+        this.doneEditMemo();
+    }
+}
+
+
+/***/ }),
+
+/***/ 55887:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ BrushStrategy)
+/* harmony export */ });
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(81985);
+/* harmony import */ var _stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(49906);
+/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(96814);
+/* harmony import */ var _utils_getStrategyData__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(40905);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(99737);
+
+
+
+
+
+const { VoxelManager } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
+class BrushStrategy {
+    static { this.COMPOSITIONS = _compositions__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A; }
+    static { this.childFunctions = {
+        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.OnInteractionStart]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.OnInteractionStart, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
+        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.OnInteractionEnd]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.OnInteractionEnd, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
+        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Fill]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Fill),
+        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
+        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.CreateIsInThreshold]: addSingletonMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.CreateIsInThreshold),
+        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.AcceptPreview]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.AcceptPreview, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
+        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.RejectPreview]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.RejectPreview, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize),
+        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.INTERNAL_setValue]: addSingletonMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.INTERNAL_setValue),
+        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Preview]: addSingletonMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Preview, false),
+        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.ComputeInnerCircleRadius]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.ComputeInnerCircleRadius),
+        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.AddPreview]: addListMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.AddPreview),
+        [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.GetStatistics]: addSingletonMethod(_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.GetStatistics),
+        compositions: null,
+    }; }
+    constructor(name, ...initializers) {
+        this._initialize = [];
+        this._fill = [];
+        this._onInteractionStart = [];
+        this.fill = (enabledElement, operationData) => {
+            const initializedData = this.initialize(enabledElement, operationData, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Fill);
+            if (!initializedData) {
+                return;
+            }
+            const { strategySpecificConfiguration = {}, centerIJK } = initializedData;
+            if (_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isEqual(centerIJK, strategySpecificConfiguration.centerIJK)) {
+                return operationData.preview;
+            }
+            else {
+                strategySpecificConfiguration.centerIJK = centerIJK;
+            }
+            this._fill.forEach((func) => func(initializedData));
+            const { segmentationVoxelManager, previewVoxelManager, previewSegmentIndex, segmentIndex, } = initializedData;
+            const isPreview = previewSegmentIndex && previewVoxelManager.modifiedSlices.size;
+            (0,_stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_1__.triggerSegmentationDataModified)(initializedData.segmentationId, segmentationVoxelManager.getArrayOfModifiedSlices(), isPreview ? previewSegmentIndex : segmentIndex);
+            if (!previewSegmentIndex || !previewVoxelManager.modifiedSlices.size) {
+                segmentationVoxelManager.resetModifiedSlices();
                 return null;
             }
             return initializedData.preview || initializedData;
@@ -6612,6 +7058,13 @@ class BrushStrategy {
             }
             this._onInteractionStart.forEach((func) => func.call(this, initializedData));
         };
+        this.addPreview = (enabledElement, operationData) => {
+            const initializedData = this.initialize(enabledElement, operationData, _enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.AddPreview);
+            if (!initializedData) {
+                return;
+            }
+            return initializedData.preview || initializedData;
+        };
         this.configurationName = name;
         this.compositions = initializers;
         initializers.forEach((initializer) => {
@@ -6644,9 +7097,7 @@ class BrushStrategy {
         const segmentationVoxelManagerToUse = operationData.override?.voxelManager || segmentationVoxelManager;
         const segmentationImageDataToUse = operationData.override?.imageData || segmentationImageData;
         const previewVoxelManager = operationData.preview?.previewVoxelManager ||
-            VoxelManager.createHistoryVoxelManager({
-                sourceVoxelManager: segmentationVoxelManagerToUse,
-            });
+            VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
         const previewEnabled = !!operationData.previewColors;
         const previewSegmentIndex = previewEnabled ? 255 : undefined;
         const initializedData = {
@@ -6690,9 +7141,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);
             };
     };
 }
@@ -6700,7 +7151,7 @@ function addSingletonMethod(name, isInitialized = true) {
 
 /***/ }),
 
-/***/ 21553:
+/***/ 96814:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -6726,20 +7177,33 @@ var StrategyCallbacks = __webpack_require__(84093);
         }
     },
     [StrategyCallbacks/* default */.A.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;
         };
-        imageVoxelManager.forEach(callback, {
+        segmentationVoxelManager.forEach(callback, {
             imageData: segmentationImageData,
             isInObject: operationData.isInObject,
+            boundsIJK: nestedBounds,
         });
         if (!hasSegmentIndex && !hasPreviewIndex) {
             return;
@@ -6770,7 +7234,7 @@ var esm = __webpack_require__(3823);
 
 /* harmony default export */ const dynamicThreshold = ({
     [StrategyCallbacks/* default */.A.Initialize]: (operationData) => {
-        const { operationName, centerIJK, strategySpecificConfiguration, segmentationVoxelManager, imageVoxelManager, segmentIndex, } = operationData;
+        const { operationName, centerIJK, strategySpecificConfiguration, segmentationVoxelManager, imageVoxelManager, segmentIndex, viewport, } = operationData;
         const { THRESHOLD } = strategySpecificConfiguration;
         if (!THRESHOLD?.isDynamic || !centerIJK || !segmentIndex) {
             return;
@@ -6782,6 +7246,7 @@ var esm = __webpack_require__(3823);
         const boundsIJK = segmentationVoxelManager.getBoundsIJK();
         const { threshold: oldThreshold, dynamicRadius = 0 } = THRESHOLD;
         const useDelta = oldThreshold ? 0 : dynamicRadius;
+        const { viewPlaneNormal } = viewport.getCamera();
         const nestedBounds = boundsIJK.map((ijk, idx) => {
             const [min, max] = ijk;
             return [
@@ -6789,8 +7254,22 @@ var esm = __webpack_require__(3823);
                 Math.min(max, centerIJK[idx] + useDelta),
             ];
         });
+        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 threshold = oldThreshold || [Infinity, -Infinity];
-        const callback = ({ value }) => {
+        const useDeltaSqr = useDelta * useDelta;
+        const callback = ({ value, pointIJK }) => {
+            const distance = esm/* vec3.sqrDist */.eR.sqrDist(centerIJK, pointIJK);
+            if (distance > useDeltaSqr) {
+                return;
+            }
             const gray = Array.isArray(value) ? esm/* vec3.len */.eR.len(value) : value;
             threshold[0] = Math.min(gray, threshold[0]);
             threshold[1] = Math.max(gray, threshold[1]);
@@ -6830,7 +7309,7 @@ var esm = __webpack_require__(3823);
             strategySpecificConfiguration[activeStrategy] = {};
         }
         strategySpecificConfiguration[activeStrategy].dynamicRadiusInCanvas =
-            dynamicRadiusInCanvas;
+            3 + dynamicRadiusInCanvas;
     },
 });
 
@@ -6842,134 +7321,207 @@ var esm = __webpack_require__(3823);
     },
 });
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/floodFill.js
-var floodFill = __webpack_require__(84882);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js
+var dist_esm = __webpack_require__(81985);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/triggerSegmentationEvents.js
 var triggerSegmentationEvents = __webpack_require__(49906);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/utils/normalizeViewportPlane.js
+
+const { isEqual } = dist_esm.utilities;
+const acquisitionMapping = {
+    toIJK: (ijkPrime) => ijkPrime,
+    fromIJK: (ijk) => ijk,
+    type: 'acquistion',
+};
+const jkMapping = {
+    toIJK: ([j, k, i]) => [i, j, k],
+    fromIJK: ([i, j, k]) => [j, k, i],
+    type: 'jk',
+};
+const ikMapping = {
+    toIJK: ([i, k, j]) => [i, j, k],
+    fromIJK: ([i, j, k]) => [i, k, j],
+    type: 'ik',
+};
+function normalizeViewportPlane(viewport, boundsIJK) {
+    if (!(viewport instanceof dist_esm.BaseVolumeViewport)) {
+        return { ...acquisitionMapping, boundsIJKPrime: boundsIJK };
+    }
+    const { viewPlaneNormal } = viewport.getCamera();
+    const mapping = (isEqual(Math.abs(viewPlaneNormal[0]), 1) && jkMapping) ||
+        (isEqual(Math.abs(viewPlaneNormal[1]), 1) && ikMapping) ||
+        (isEqual(Math.abs(viewPlaneNormal[2]), 1) && acquisitionMapping);
+    if (!mapping) {
+        return {
+            toIJK: null,
+            boundsIJKPrime: null,
+            fromIJK: null,
+            error: `Only mappings orthogonal to acquisition plane are permitted, but requested ${viewPlaneNormal}`,
+        };
+    }
+    return { ...mapping, boundsIJKPrime: mapping.fromIJK(boundsIJK) };
+}
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/islandRemoval.js
 
 
 
+
+const { RLEVoxelMap } = dist_esm.utilities;
+const MAX_IMAGE_SIZE = 65535;
+var SegmentationEnum;
+(function (SegmentationEnum) {
+    SegmentationEnum[SegmentationEnum["SEGMENT"] = 1] = "SEGMENT";
+    SegmentationEnum[SegmentationEnum["ISLAND"] = 2] = "ISLAND";
+    SegmentationEnum[SegmentationEnum["INTERIOR"] = 3] = "INTERIOR";
+    SegmentationEnum[SegmentationEnum["EXTERIOR"] = 4] = "EXTERIOR";
+    SegmentationEnum[SegmentationEnum["INTERIOR_SMALL"] = -5] = "INTERIOR_SMALL";
+    SegmentationEnum[SegmentationEnum["INTERIOR_TEST"] = -6] = "INTERIOR_TEST";
+})(SegmentationEnum || (SegmentationEnum = {}));
 /* harmony default export */ const islandRemoval = ({
     [StrategyCallbacks/* default */.A.OnInteractionEnd]: (operationData) => {
-        const { previewVoxelManager: previewVoxelManager, segmentationVoxelManager, strategySpecificConfiguration, previewSegmentIndex, segmentIndex, } = operationData;
-        if (!strategySpecificConfiguration.THRESHOLD || segmentIndex === null) {
+        const { strategySpecificConfiguration, previewSegmentIndex, segmentIndex } = operationData;
+        if (!strategySpecificConfiguration.THRESHOLD ||
+            segmentIndex === null ||
+            previewSegmentIndex === undefined) {
             return;
         }
-        const clickedPoints = previewVoxelManager.getPoints();
-        if (!clickedPoints?.length) {
+        const segmentSet = createSegmentSet(operationData);
+        if (!segmentSet) {
             return;
         }
-        if (previewSegmentIndex === undefined) {
+        const externalRemoved = removeExternalIslands(operationData, segmentSet);
+        if (externalRemoved === undefined) {
             return;
         }
-        const boundsIJK = previewVoxelManager
-            .getBoundsIJK()
-            .map((bound, i) => [
-            Math.min(bound[0], ...clickedPoints.map((point) => point[i])),
-            Math.max(bound[1], ...clickedPoints.map((point) => point[i])),
-        ]);
-        if (boundsIJK.find((it) => it[0] < 0 || it[1] > 65535)) {
+        const arrayOfSlices = removeInternalIslands(operationData, segmentSet);
+        if (!arrayOfSlices) {
             return;
         }
-        const floodedSet = new Set();
-        const getter = (i, j, k) => {
-            if (i < boundsIJK[0][0] ||
-                i > boundsIJK[0][1] ||
-                j < boundsIJK[1][0] ||
-                j > boundsIJK[1][1] ||
-                k < boundsIJK[2][0] ||
-                k > boundsIJK[2][1]) {
-                return -1;
-            }
-            const index = segmentationVoxelManager.toIndex([i, j, k]);
-            if (floodedSet.has(index)) {
-                return -2;
-            }
-            const oldVal = segmentationVoxelManager.getAtIndex(index);
-            const isIn = oldVal === previewSegmentIndex || oldVal === segmentIndex ? 1 : 0;
-            if (!isIn) {
-                segmentationVoxelManager.addPoint(index);
-            }
-            return isIn;
-        };
-        let floodedCount = 0;
-        const onFlood = (i, j, k) => {
-            const index = segmentationVoxelManager.toIndex([i, j, k]);
-            if (floodedSet.has(index)) {
-                return;
-            }
-            previewVoxelManager.setAtIJK(i, j, k, previewSegmentIndex);
-            floodedSet.add(index);
-            floodedCount++;
-        };
-        clickedPoints.forEach((clickedPoint) => {
-            if (getter(...clickedPoint) === 1) {
-                (0,floodFill/* default */.A)(getter, clickedPoint, {
-                    onFlood,
-                    diagonals: true,
-                });
-            }
-        });
-        let clearedCount = 0;
-        let previewCount = 0;
-        const callback = ({ index, pointIJK, value: trackValue }) => {
-            const value = segmentationVoxelManager.getAtIndex(index);
-            if (floodedSet.has(index)) {
-                previewCount++;
-                const newValue = trackValue === segmentIndex ? segmentIndex : previewSegmentIndex;
-                previewVoxelManager.setAtIJKPoint(pointIJK, newValue);
-            }
-            else if (value === previewSegmentIndex) {
-                clearedCount++;
-                const newValue = trackValue ?? 0;
-                previewVoxelManager.setAtIJKPoint(pointIJK, newValue);
-            }
-        };
-        previewVoxelManager.forEach(callback, {});
-        if (floodedCount - previewCount !== 0) {
-            console.warn('There were flooded=', floodedCount, 'cleared=', clearedCount, 'preview count=', previewCount, 'not handled', floodedCount - previewCount);
+        (0,triggerSegmentationEvents.triggerSegmentationDataModified)(operationData.segmentationId, arrayOfSlices, previewSegmentIndex);
+    },
+});
+function createSegmentSet(operationData) {
+    const { segmentationVoxelManager, previewSegmentIndex, previewVoxelManager, segmentIndex, viewport, } = operationData;
+    const clickedPoints = previewVoxelManager.getPoints();
+    if (!clickedPoints?.length) {
+        return;
+    }
+    const boundsIJK = previewVoxelManager
+        .getBoundsIJK()
+        .map((bound, i) => [
+        Math.min(bound[0], ...clickedPoints.map((point) => point[i])),
+        Math.max(bound[1], ...clickedPoints.map((point) => point[i])),
+    ]);
+    if (boundsIJK.find((it) => it[0] < 0 || it[1] > MAX_IMAGE_SIZE)) {
+        return;
+    }
+    const { toIJK, fromIJK, boundsIJKPrime, error } = normalizeViewportPlane(viewport, boundsIJK);
+    if (error) {
+        console.warn('Not performing island removal for planes not orthogonal to acquisition plane', error);
+        return;
+    }
+    const [width, height, depth] = fromIJK(segmentationVoxelManager.dimensions);
+    const floodedSet = new RLEVoxelMap(width, height, depth);
+    const getter = (i, j, k) => {
+        const index = segmentationVoxelManager.toIndex(toIJK([i, j, k]));
+        const oldVal = segmentationVoxelManager.getAtIndex(index);
+        if (oldVal === previewSegmentIndex || oldVal === segmentIndex) {
+            return SegmentationEnum.SEGMENT;
         }
-        const islandMap = new Set(segmentationVoxelManager.points || []);
-        floodedSet.clear();
-        for (const index of islandMap.keys()) {
-            if (floodedSet.has(index)) {
+    };
+    floodedSet.fillFrom(getter, boundsIJKPrime);
+    floodedSet.normalizer = { toIJK, fromIJK, boundsIJKPrime };
+    return floodedSet;
+}
+function removeInternalIslands(operationData, floodedSet) {
+    const { height, normalizer } = floodedSet;
+    const { toIJK } = normalizer;
+    const { previewVoxelManager, previewSegmentIndex } = operationData;
+    floodedSet.forEachRow((baseIndex, row) => {
+        let lastRle;
+        for (const rle of [...row]) {
+            if (rle.value !== SegmentationEnum.ISLAND) {
                 continue;
             }
-            let isInternal = true;
-            const internalSet = new Set();
-            const onFloodInternal = (i, j, k) => {
-                const floodIndex = previewVoxelManager.toIndex([i, j, k]);
-                floodedSet.add(floodIndex);
-                if ((boundsIJK[0][0] !== boundsIJK[0][1] &&
-                    (i === boundsIJK[0][0] || i === boundsIJK[0][1])) ||
-                    (boundsIJK[1][0] !== boundsIJK[1][1] &&
-                        (j === boundsIJK[1][0] || j === boundsIJK[1][1])) ||
-                    (boundsIJK[2][0] !== boundsIJK[2][1] &&
-                        (k === boundsIJK[2][0] || k === boundsIJK[2][1]))) {
-                    isInternal = false;
-                }
-                if (isInternal) {
-                    internalSet.add(floodIndex);
-                }
-            };
-            const pointIJK = previewVoxelManager.toIJK(index);
-            if (getter(...pointIJK) !== 0) {
+            if (!lastRle) {
+                lastRle = rle;
                 continue;
             }
-            (0,floodFill/* default */.A)(getter, pointIJK, {
-                onFlood: onFloodInternal,
-                diagonals: false,
-            });
-            if (isInternal) {
-                for (const index of internalSet) {
-                    previewVoxelManager.setAtIndex(index, previewSegmentIndex);
-                }
+            for (let iPrime = lastRle.end; iPrime < rle.start; iPrime++) {
+                floodedSet.set(baseIndex + iPrime, SegmentationEnum.INTERIOR);
             }
+            lastRle = rle;
         }
-        (0,triggerSegmentationEvents.triggerSegmentationDataModified)(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices());
-    },
-});
+    });
+    floodedSet.forEach((baseIndex, rle) => {
+        if (rle.value !== SegmentationEnum.INTERIOR) {
+            return;
+        }
+        const [, jPrime, kPrime] = floodedSet.toIJK(baseIndex);
+        const rowPrev = jPrime > 0 ? floodedSet.getRun(jPrime - 1, kPrime) : null;
+        const rowNext = jPrime + 1 < height ? floodedSet.getRun(jPrime + 1, kPrime) : null;
+        const prevCovers = covers(rle, rowPrev);
+        const nextCovers = covers(rle, rowNext);
+        if (rle.end - rle.start > 2 && (!prevCovers || !nextCovers)) {
+            floodedSet.floodFill(rle.start, jPrime, kPrime, SegmentationEnum.EXTERIOR, { singlePlane: true });
+        }
+    });
+    floodedSet.forEach((baseIndex, rle) => {
+        if (rle.value !== SegmentationEnum.INTERIOR) {
+            return;
+        }
+        for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
+            const clearPoint = toIJK(floodedSet.toIJK(baseIndex + iPrime));
+            previewVoxelManager.setAtIJKPoint(clearPoint, previewSegmentIndex);
+        }
+    });
+    return previewVoxelManager.getArrayOfModifiedSlices();
+}
+function removeExternalIslands(operationData, floodedSet) {
+    const { previewVoxelManager } = operationData;
+    const { toIJK, fromIJK } = floodedSet.normalizer;
+    const clickedPoints = previewVoxelManager.getPoints();
+    let floodedCount = 0;
+    clickedPoints.forEach((clickedPoint) => {
+        const ijkPrime = fromIJK(clickedPoint);
+        const index = floodedSet.toIndex(ijkPrime);
+        const [iPrime, jPrime, kPrime] = ijkPrime;
+        if (floodedSet.get(index) === SegmentationEnum.SEGMENT) {
+            floodedCount += floodedSet.floodFill(iPrime, jPrime, kPrime, SegmentationEnum.ISLAND);
+        }
+    });
+    if (floodedCount === 0) {
+        return;
+    }
+    const callback = (index, rle) => {
+        const [, jPrime, kPrime] = floodedSet.toIJK(index);
+        if (rle.value !== SegmentationEnum.ISLAND) {
+            for (let iPrime = rle.start; iPrime < rle.end; iPrime++) {
+                const clearPoint = toIJK([iPrime, jPrime, kPrime]);
+                previewVoxelManager.setAtIJKPoint(clearPoint, null);
+            }
+        }
+    };
+    floodedSet.forEach(callback, { rowModified: true });
+    return floodedCount;
+}
+function covers(rle, row) {
+    if (!row) {
+        return false;
+    }
+    let { start } = rle;
+    const { end } = rle;
+    for (const rowRle of row) {
+        if (start >= rowRle.start && start < rowRle.end) {
+            start = rowRle.end;
+            if (start >= end) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/events/triggerSegmentationDataModified.js
 var triggerSegmentationDataModified = __webpack_require__(98798);
@@ -7007,8 +7559,9 @@ function lightenColor(r, g, b, a, factor = 0.4) {
         return preview;
     },
     [StrategyCallbacks/* default */.A.Initialize]: (operationData) => {
-        const { segmentIndex, previewSegmentIndex, previewColors, preview } = operationData;
-        if (previewColors === undefined) {
+        const { segmentIndex, previewSegmentIndex, previewColors, preview, segmentationId, segmentationVoxelManager, } = operationData;
+        if (previewColors === undefined || !previewSegmentIndex) {
+            operationData.memo = operationData.createMemo(segmentationId, segmentationVoxelManager);
             return;
         }
         if (preview) {
@@ -7016,7 +7569,7 @@ function lightenColor(r, g, b, a, factor = 0.4) {
                 operationData.segmentationVoxelManager;
             operationData.previewVoxelManager = preview.previewVoxelManager;
         }
-        if (segmentIndex === null || !previewSegmentIndex) {
+        if (segmentIndex === null) {
             return;
         }
         const configColor = previewColors?.[segmentIndex];
@@ -7028,24 +7581,27 @@ function lightenColor(r, g, b, a, factor = 0.4) {
         (0,segmentationColor.setSegmentIndexColor)(operationData.viewport.id, operationData.segmentationId, previewSegmentIndex, previewColor);
     },
     [StrategyCallbacks/* default */.A.AcceptPreview]: (operationData) => {
-        const { segmentationVoxelManager, previewVoxelManager: previewVoxelManager, previewSegmentIndex, preview, } = operationData || {};
+        const { segmentationVoxelManager, previewVoxelManager: previewVoxelManager, previewSegmentIndex, segmentationId, preview, } = operationData || {};
         if (previewSegmentIndex === undefined) {
             return;
         }
         const segmentIndex = preview?.segmentIndex ?? operationData.segmentIndex;
-        const tracking = previewVoxelManager;
-        if (!tracking || tracking.modifiedSlices.size === 0) {
+        if (!previewVoxelManager || previewVoxelManager.modifiedSlices.size === 0) {
             return;
         }
-        const callback = ({ index }) => {
+        const memo = operationData.createMemo(segmentationId, segmentationVoxelManager);
+        operationData.memo = memo;
+        const { voxelManager } = memo;
+        const callback = ({ index, value }) => {
             const oldValue = segmentationVoxelManager.getAtIndex(index);
             if (oldValue === previewSegmentIndex) {
-                segmentationVoxelManager.setAtIndex(index, segmentIndex);
+                segmentationVoxelManager.setAtIndex(index, value);
+                voxelManager.setAtIndex(index, segmentIndex);
             }
         };
-        tracking.forEach(callback, {});
-        (0,triggerSegmentationDataModified/* triggerSegmentationDataModified */.Q)(operationData.segmentationId, tracking.getArrayOfModifiedSlices());
-        tracking.clear();
+        previewVoxelManager.forEach(callback, {});
+        (0,triggerSegmentationDataModified/* triggerSegmentationDataModified */.Q)(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices(), preview.segmentIndex);
+        previewVoxelManager.clear();
     },
     [StrategyCallbacks/* default */.A.RejectPreview]: (operationData) => {
         const { previewVoxelManager: previewVoxelManager, segmentationVoxelManager, } = operationData;
@@ -7056,7 +7612,7 @@ function lightenColor(r, g, b, a, factor = 0.4) {
             segmentationVoxelManager.setAtIndex(index, value);
         };
         previewVoxelManager.forEach(callback);
-        (0,triggerSegmentationDataModified/* triggerSegmentationDataModified */.Q)(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices());
+        (0,triggerSegmentationDataModified/* triggerSegmentationDataModified */.Q)(operationData.segmentationId, previewVoxelManager.getArrayOfModifiedSlices(), 0);
         previewVoxelManager.clear();
     },
 });
@@ -7065,7 +7621,7 @@ function lightenColor(r, g, b, a, factor = 0.4) {
 
 /* harmony default export */ const regionFill = ({
     [StrategyCallbacks/* default */.A.Fill]: (operationData) => {
-        const { segmentsLocked, segmentationImageData, segmentationVoxelManager, previewVoxelManager: previewVoxelManager, brushStrategy, centerIJK, } = operationData;
+        const { segmentsLocked, segmentationImageData, segmentationVoxelManager, previewVoxelManager, brushStrategy, centerIJK, } = operationData;
         const isWithinThreshold = brushStrategy.createIsInThreshold?.(operationData);
         const { setValue } = brushStrategy;
         const callback = isWithinThreshold
@@ -7086,14 +7642,12 @@ function lightenColor(r, g, b, a, factor = 0.4) {
     },
 });
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js
-var dist_esm = __webpack_require__(81985);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/setValue.js
 
-
 /* harmony default export */ const setValue = ({
     [StrategyCallbacks/* default */.A.INTERNAL_setValue]: (operationData, { value, index }) => {
-        const { segmentsLocked, segmentIndex, previewVoxelManager, previewSegmentIndex, segmentationVoxelManager, } = operationData;
+        const { segmentsLocked, segmentIndex, previewSegmentIndex, segmentationVoxelManager, memo, } = operationData;
+        const previewVoxelManager = memo?.voxelManager || operationData.previewVoxelManager;
         const existingValue = segmentationVoxelManager.getAtIndex(index);
         let changed = false;
         if (segmentIndex === null) {
@@ -7143,6 +7697,50 @@ var dist_esm = __webpack_require__(81985);
     },
 });
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/VolumetricCalculator.js
+var VolumetricCalculator = __webpack_require__(68915);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getActiveSegmentIndex.js
+var getActiveSegmentIndex = __webpack_require__(60740);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/utils/getStrategyData.js
+var getStrategyData = __webpack_require__(40905);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/labelmapStatistics.js
+
+
+
+
+/* harmony default export */ const labelmapStatistics = ({
+    [StrategyCallbacks/* default */.A.GetStatistics]: function (enabledElement, operationData, options) {
+        const { viewport } = enabledElement;
+        let { indices } = options;
+        const { segmentationId } = operationData;
+        if (!indices) {
+            indices = [(0,getActiveSegmentIndex/* getActiveSegmentIndex */.Q)(segmentationId)];
+        }
+        else if (!Array.isArray(indices)) {
+            indices = [indices, 255];
+        }
+        const indicesArr = indices;
+        const { segmentationVoxelManager, imageVoxelManager, segmentationImageData, } = (0,getStrategyData/* getStrategyData */.S)({
+            operationData,
+            viewport,
+        });
+        const spacing = segmentationImageData.getSpacing();
+        const { boundsIJK: boundsOrig } = segmentationVoxelManager;
+        if (!boundsOrig) {
+            return VolumetricCalculator/* default */.A.getStatistics({ spacing });
+        }
+        segmentationVoxelManager.forEach((voxel) => {
+            const { value, pointIJK } = voxel;
+            if (indicesArr.indexOf(value) === -1) {
+                return;
+            }
+            const imageValue = imageVoxelManager.getAtIJKPoint(pointIJK);
+            VolumetricCalculator/* default */.A.statsCallback({ value: imageValue });
+        });
+        return VolumetricCalculator/* default */.A.getStatistics({ spacing });
+    },
+});
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/segmentation/strategies/compositions/index.js
 
 
@@ -7152,6 +7750,7 @@ var dist_esm = __webpack_require__(81985);
 
 
 
+
 /* harmony default export */ const compositions = ({
     determineSegmentIndex: determineSegmentIndex,
     dynamicThreshold: dynamicThreshold,
@@ -7161,6 +7760,7 @@ var dist_esm = __webpack_require__(81985);
     regionFill: regionFill,
     setValue: setValue,
     threshold: threshold,
+    labelmapStatistics: labelmapStatistics,
 });
 
 
@@ -7175,7 +7775,7 @@ var dist_esm = __webpack_require__(81985);
 /* harmony export */ });
 /* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(55887);
 /* harmony import */ var _fillCircle__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(56789);
-/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(21553);
+/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(96814);
 
 
 
@@ -7200,7 +7800,7 @@ function eraseRectangle(enabledElement, operationData, inside = true) {
     const eraseOperationData = Object.assign({}, operationData, {
         segmentIndex: 0,
     });
-    (0,_fillRectangle__WEBPACK_IMPORTED_MODULE_0__/* .fillInsideRectangle */ .p)(enabledElement, eraseOperationData);
+    (0,_fillRectangle__WEBPACK_IMPORTED_MODULE_0__/* .fillInsideRectangle */ .pY)(enabledElement, eraseOperationData);
 }
 function eraseInsideRectangle(enabledElement, operationData) {
     eraseRectangle(enabledElement, operationData, true);
@@ -7221,7 +7821,7 @@ function eraseOutsideRectangle(enabledElement, operationData) {
 /* harmony export */ });
 /* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(55887);
 /* harmony import */ var _fillSphere__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(17492);
-/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(21553);
+/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(96814);
 
 
 
@@ -7249,7 +7849,7 @@ const eraseInsideSphere = ERASE_SPHERE_STRATEGY.strategyFunction;
 /* harmony import */ var _utilities_boundingBox__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(72282);
 /* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(55887);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(99737);
-/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(21553);
+/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(96814);
 /* harmony import */ var _utilities_math_sphere__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(62783);
 
 
@@ -7314,8 +7914,8 @@ function createPointInEllipse(worldInfo) {
     const { precalculated } = (0,_utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_2__.precalculatePointInEllipse)(ellipseObj, {});
     return precalculated;
 }
-const CIRCLE_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A('Circle', _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.setValue, initializeCircle, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.preview);
-const CIRCLE_THRESHOLD_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A('CircleThreshold', _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.setValue, initializeCircle, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.dynamicThreshold, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.threshold, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.preview, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.islandRemoval);
+const CIRCLE_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A('Circle', _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.setValue, initializeCircle, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.preview, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.labelmapStatistics);
+const CIRCLE_THRESHOLD_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A('CircleThreshold', _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.setValue, initializeCircle, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.dynamicThreshold, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.threshold, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.preview, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.islandRemoval, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.labelmapStatistics);
 const fillInsideCircle = CIRCLE_STRATEGY.strategyFunction;
 const thresholdInsideCircle = CIRCLE_THRESHOLD_STRATEGY.strategyFunction;
 function fillOutsideCircle() {
@@ -7331,32 +7931,47 @@ function fillOutsideCircle() {
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   p: () => (/* binding */ fillInsideRectangle)
+/* harmony export */   pY: () => (/* binding */ fillInsideRectangle)
 /* harmony export */ });
-/* unused harmony export fillOutsideRectangle */
-/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(81985);
-/* harmony import */ var _utilities_boundingBox__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(72282);
-/* harmony import */ var _stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(49906);
-/* harmony import */ var _utils_getStrategyData__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(40905);
-/* harmony import */ var _utilities_rectangleROITool_isAxisAlignedRectangle__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(26384);
+/* unused harmony exports RECTANGLE_STRATEGY, RECTANGLE_THRESHOLD_STRATEGY, thresholdInsideRectangle */
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3823);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(81985);
+/* harmony import */ var _utilities_boundingBox__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(72282);
+/* harmony import */ var _stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(49906);
+/* harmony import */ var _utils_getStrategyData__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(40905);
+/* harmony import */ var _utilities_rectangleROITool_isAxisAlignedRectangle__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(26384);
+/* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(55887);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(99737);
+/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(96814);
 
 
 
 
 
-const { transformWorldToIndex } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
-function fillRectangle(enabledElement, operationData) {
-    const { points, segmentsLocked, segmentIndex, segmentationId } = operationData;
-    const { viewport } = enabledElement;
-    const strategyData = (0,_utils_getStrategyData__WEBPACK_IMPORTED_MODULE_3__/* .getStrategyData */ .S)({
-        operationData,
-        viewport: enabledElement.viewport,
-    });
-    if (!strategyData) {
-        console.warn('No data found for fillRectangle');
-        return;
-    }
-    const { segmentationImageData, segmentationVoxelManager } = strategyData;
+
+
+
+
+const { transformWorldToIndex } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities;
+const initializeRectangle = {
+    [_enums__WEBPACK_IMPORTED_MODULE_7__.StrategyCallbacks.Initialize]: (operationData) => {
+        const { points, imageVoxelManager, viewport, segmentationImageData, segmentationVoxelManager, } = operationData;
+        if (!points) {
+            return;
+        }
+        const center = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(0, 0, 0);
+        points.forEach((point) => {
+            gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.add */ .eR.add(center, center, point);
+        });
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.scale */ .eR.scale(center, center, 1 / points.length);
+        operationData.centerWorld = center;
+        operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
+        const { boundsIJK, pointInShapeFn } = createPointInRectangle(viewport, points, segmentationImageData);
+        operationData.isInObject = pointInShapeFn;
+        operationData.isInObjectBoundsIJK = boundsIJK;
+    },
+};
+function createPointInRectangle(viewport, points, segmentationImageData) {
     let rectangleCornersIJK = points.map((world) => {
         return transformWorldToIndex(segmentationImageData, world);
     });
@@ -7365,17 +7980,17 @@ function fillRectangle(enabledElement, operationData) {
             return Math.round(coord);
         });
     });
-    const boundsIJK = (0,_utilities_boundingBox__WEBPACK_IMPORTED_MODULE_1__.getBoundingBoxAroundShapeIJK)(rectangleCornersIJK, segmentationImageData.getDimensions());
-    const isStackViewport = viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.StackViewport;
-    const isAligned = isStackViewport || (0,_utilities_rectangleROITool_isAxisAlignedRectangle__WEBPACK_IMPORTED_MODULE_4__/* .isAxisAlignedRectangle */ .l)(rectangleCornersIJK);
+    const boundsIJK = (0,_utilities_boundingBox__WEBPACK_IMPORTED_MODULE_2__.getBoundingBoxAroundShapeIJK)(rectangleCornersIJK, segmentationImageData.getDimensions());
+    const isStackViewport = viewport instanceof _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.StackViewport;
+    const isAligned = isStackViewport || (0,_utilities_rectangleROITool_isAxisAlignedRectangle__WEBPACK_IMPORTED_MODULE_5__/* .isAxisAlignedRectangle */ .l)(rectangleCornersIJK);
     const direction = segmentationImageData.getDirection();
     const spacing = segmentationImageData.getSpacing();
     const { viewPlaneNormal } = viewport.getCamera();
-    const EPS = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.getSpacingInNormalDirection({
+    const EPS = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities.getSpacingInNormalDirection({
         direction,
         spacing,
     }, viewPlaneNormal);
-    const pointsBoundsLPS = (0,_utilities_boundingBox__WEBPACK_IMPORTED_MODULE_1__.getBoundingBoxAroundShapeWorld)(points);
+    const pointsBoundsLPS = (0,_utilities_boundingBox__WEBPACK_IMPORTED_MODULE_2__.getBoundingBoxAroundShapeWorld)(points);
     let [[xMin, xMax], [yMin, yMax], [zMin, zMax]] = pointsBoundsLPS;
     xMin -= EPS;
     xMax += EPS;
@@ -7392,25 +8007,13 @@ function fillRectangle(enabledElement, operationData) {
             const zInside = z >= zMin && z <= zMax;
             return xInside && yInside && zInside;
         };
-    const callback = ({ value, index }) => {
-        if (segmentsLocked.includes(value)) {
-            return;
-        }
-        segmentationVoxelManager.setAtIndex(index, segmentIndex);
-    };
-    segmentationVoxelManager.forEach(callback, {
-        isInObject: pointInShapeFn,
-        boundsIJK,
-        imageData: segmentationImageData,
-    });
-    (0,_stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_2__.triggerSegmentationDataModified)(segmentationId);
-}
-function fillInsideRectangle(enabledElement, operationData) {
-    fillRectangle(enabledElement, operationData);
-}
-function fillOutsideRectangle(enabledElement, operationData) {
-    fillRectangle(enabledElement, operationData);
+    return { boundsIJK, pointInShapeFn };
 }
+const RECTANGLE_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A('Rectangle', _compositions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A.setValue, initializeRectangle, _compositions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A.preview, _compositions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A.labelmapStatistics);
+const RECTANGLE_THRESHOLD_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A('RectangleThreshold', _compositions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A.setValue, initializeRectangle, _compositions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A.dynamicThreshold, _compositions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A.threshold, _compositions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A.preview, _compositions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A.islandRemoval, _compositions__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A.labelmapStatistics);
+const fillInsideRectangle = RECTANGLE_STRATEGY.strategyFunction;
+const thresholdInsideRectangle = RECTANGLE_THRESHOLD_STRATEGY.strategyFunction;
+
 
 
 /***/ }),
@@ -7421,6 +8024,7 @@ function fillOutsideRectangle(enabledElement, operationData) {
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   Jq: () => (/* binding */ fillInsideSphere),
+/* harmony export */   Sw: () => (/* binding */ thresholdInsideSphereIsland),
 /* harmony export */   rd: () => (/* binding */ thresholdInsideSphere),
 /* harmony export */   u8: () => (/* binding */ SPHERE_STRATEGY)
 /* harmony export */ });
@@ -7428,7 +8032,7 @@ function fillOutsideRectangle(enabledElement, operationData) {
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(81985);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3823);
 /* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(55887);
-/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(21553);
+/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(96814);
 /* harmony import */ var _enums_StrategyCallbacks__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(84093);
 /* harmony import */ var _fillCircle__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(56789);
 /* harmony import */ var _utilities_getSphereBoundsInfo__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(4296);
@@ -7453,7 +8057,7 @@ const sphereComposition = {
         gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.scale */ .eR.scale(center, center, 1 / points.length);
         operationData.centerWorld = center;
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
-        const { boundsIJK: newBoundsIJK, topLeftWorld, bottomRightWorld, } = (0,_utilities_getSphereBoundsInfo__WEBPACK_IMPORTED_MODULE_6__/* .getSphereBoundsInfo */ .R)(points.slice(0, 2), segmentationImageData, viewport);
+        const { boundsIJK: newBoundsIJK, topLeftWorld, bottomRightWorld, } = (0,_utilities_getSphereBoundsInfo__WEBPACK_IMPORTED_MODULE_6__/* .getSphereBoundsInfoFromViewport */ .l)(points.slice(0, 2), segmentationImageData, viewport);
         operationData.isInObjectBoundsIJK = newBoundsIJK;
         operationData.isInObject = (0,_fillCircle__WEBPACK_IMPORTED_MODULE_5__/* .createEllipseInPoint */ .mu)({
             topLeftWorld,
@@ -7462,10 +8066,12 @@ const sphereComposition = {
         });
     },
 };
-const SPHERE_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A('Sphere', _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.setValue, sphereComposition, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.preview);
+const SPHERE_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A('Sphere', _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.setValue, sphereComposition, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.preview, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.labelmapStatistics);
 const fillInsideSphere = SPHERE_STRATEGY.strategyFunction;
-const SPHERE_THRESHOLD_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A('SphereThreshold', ...SPHERE_STRATEGY.compositions, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.dynamicThreshold, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.threshold, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.islandRemoval);
+const SPHERE_THRESHOLD_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A('SphereThreshold', ...SPHERE_STRATEGY.compositions, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.dynamicThreshold, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.threshold);
+const SPHERE_THRESHOLD_STRATEGY_ISLAND = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .A('SphereThreshold', ...SPHERE_STRATEGY.compositions, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.dynamicThreshold, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.threshold, _compositions__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.islandRemoval);
 const thresholdInsideSphere = SPHERE_THRESHOLD_STRATEGY.strategyFunction;
+const thresholdInsideSphereIsland = SPHERE_THRESHOLD_STRATEGY_ISLAND.strategyFunction;
 function fillOutsideSphere() {
     throw new Error('fill outside sphere not implemented');
 }
@@ -7482,7 +8088,7 @@ function fillOutsideSphere() {
 /* harmony export */   S: () => (/* binding */ getStrategyData)
 /* harmony export */ });
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(81985);
-/* harmony import */ var _stateManagement_segmentation_segmentationState__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(98870);
+/* harmony import */ var _stateManagement_segmentation_segmentationState__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(83243);
 /* harmony import */ var _stateManagement_segmentation_helpers__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(27108);
 
 
@@ -8053,12 +8659,14 @@ function _stopClip(element, options = { stopDynamicCine: true, viewportId: undef
 }
 function _stopDynamicVolumeCine(element) {
     const { viewport } = (0,dist_esm.getEnabledElement)(element);
-    const volume = _getVolumeFromViewport(viewport);
-    if (volume?.isDynamicVolume()) {
-        const dynamicCineElement = dynamicVolumesPlayingMap.get(volume.volumeId);
-        dynamicVolumesPlayingMap.delete(volume.volumeId);
-        if (dynamicCineElement && dynamicCineElement !== element) {
-            stopClip(dynamicCineElement);
+    if (viewport instanceof dist_esm.VolumeViewport) {
+        const volume = _getVolumeFromViewport(viewport);
+        if (volume?.isDynamicVolume()) {
+            const dynamicCineElement = dynamicVolumesPlayingMap.get(volume.volumeId);
+            dynamicVolumesPlayingMap.delete(volume.volumeId);
+            if (dynamicCineElement && dynamicCineElement !== element) {
+                stopClip(dynamicCineElement);
+            }
         }
     }
 }
@@ -8108,6 +8716,9 @@ function _stopClipWithData(playClipData) {
     }
 }
 function _getVolumeFromViewport(viewport) {
+    if (!(viewport instanceof dist_esm.VolumeViewport)) {
+        return undefined;
+    }
     const volumeIds = viewport.getAllVolumeIds();
     if (!volumeIds?.length) {
         return undefined;
@@ -8713,14 +9324,15 @@ function generateContourSetsFromLabelmap({ segmentations }) {
         console.warn(`No volume found for ${segVolumeId}`);
         return;
     }
-    const numSlices = vol.dimensions[2];
     const voxelManager = vol.voxelManager;
+    const segData = voxelManager.getCompleteScalarDataArray();
+    const numSlices = vol.dimensions[2];
     const pixelsPerSlice = vol.dimensions[0] * vol.dimensions[1];
     for (let z = 0; z < numSlices; z++) {
         for (let y = 0; y < vol.dimensions[1]; y++) {
             const index = y * vol.dimensions[0] + z * pixelsPerSlice;
-            voxelManager.setAtIndex(index, 0);
-            voxelManager.setAtIndex(index + vol.dimensions[0] - 1, 0);
+            segData[index] = 0;
+            segData[index + vol.dimensions[0] - 1] = 0;
         }
     }
     const ContourSets = [];
@@ -8740,13 +9352,13 @@ function generateContourSetsFromLabelmap({ segmentations }) {
         });
         const { containedSegmentIndices } = segment;
         for (let sliceIndex = 0; sliceIndex < numSlices; sliceIndex++) {
-            if (isSliceEmptyForSegment(sliceIndex, voxelManager, pixelsPerSlice, segIndex)) {
+            if (isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex)) {
                 continue;
             }
             const frameStart = sliceIndex * pixelsPerSlice;
             try {
                 for (let i = 0; i < pixelsPerSlice; i++) {
-                    const value = voxelManager.getAtIndex(i + frameStart);
+                    const value = segData[i + frameStart];
                     if (value === segIndex || containedSegmentIndices?.has(value)) {
                         scalars.setValue(i + frameStart, 1);
                     }
@@ -8795,11 +9407,11 @@ function generateContourSetsFromLabelmap({ segmentations }) {
     }
     return ContourSets;
 }
-function isSliceEmptyForSegment(sliceIndex, voxelManager, pixelsPerSlice, segIndex) {
+function isSliceEmptyForSegment(sliceIndex, segData, pixelsPerSlice, segIndex) {
     const startIdx = sliceIndex * pixelsPerSlice;
     const endIdx = startIdx + pixelsPerSlice;
     for (let i = startIdx; i < endIdx; i++) {
-        if (voxelManager.getAtIndex(i) === segIndex) {
+        if (segData[i] === segIndex) {
             return false;
         }
     }
@@ -9657,7 +10269,8 @@ function _handlePTModality(imageId, options) {
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   R: () => (/* binding */ getSphereBoundsInfo)
+/* harmony export */   R: () => (/* binding */ getSphereBoundsInfo),
+/* harmony export */   l: () => (/* binding */ getSphereBoundsInfoFromViewport)
 /* harmony export */ });
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(81985);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3823);
@@ -9666,14 +10279,11 @@ function _handlePTModality(imageId, options) {
 
 
 const { transformWorldToIndex } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
-function getSphereBoundsInfo(circlePoints, imageData, viewport) {
+function _getSphereBoundsInfo(circlePoints, imageData, directionVectors) {
     const [bottom, top] = circlePoints;
     const centerWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.fromValues */ .eR.fromValues((bottom[0] + top[0]) / 2, (bottom[1] + top[1]) / 2, (bottom[2] + top[2]) / 2);
     const radiusWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.distance */ .eR.distance(bottom, top) / 2;
-    if (!viewport) {
-        throw new Error('viewport is required in order to calculate the sphere bounds');
-    }
-    const { boundsIJK, topLeftWorld, bottomRightWorld } = _computeBoundsIJKWithCamera(imageData, viewport, circlePoints, centerWorld, radiusWorld);
+    const { boundsIJK, topLeftWorld, bottomRightWorld } = _computeBoundsIJK(imageData, directionVectors, circlePoints, centerWorld, radiusWorld);
     return {
         boundsIJK,
         centerWorld: centerWorld,
@@ -9682,20 +10292,46 @@ function getSphereBoundsInfo(circlePoints, imageData, viewport) {
         bottomRightWorld: bottomRightWorld,
     };
 }
-function _computeBoundsIJKWithCamera(imageData, viewport, circlePoints, centerWorld, radiusWorld) {
-    const [bottom, top] = circlePoints;
-    const dimensions = imageData.getDimensions();
+function getSphereBoundsInfo(circlePoints, imageData) {
+    const direction = imageData.getDirection();
+    const rowCosine = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.fromValues */ .eR.fromValues(direction[0], direction[1], direction[2]);
+    const columnCosine = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.fromValues */ .eR.fromValues(direction[3], direction[4], direction[5]);
+    const scanAxis = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.fromValues */ .eR.fromValues(direction[6], direction[7], direction[8]);
+    const viewPlaneNormal = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.negate */ .eR.negate(gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .eR.create(), scanAxis);
+    const directionVectors = {
+        row: rowCosine,
+        column: columnCosine,
+        normal: viewPlaneNormal,
+    };
+    return _getSphereBoundsInfo(circlePoints, imageData, directionVectors);
+}
+function getSphereBoundsInfoFromViewport(circlePoints, imageData, viewport) {
+    if (!viewport) {
+        throw new Error('viewport is required in order to calculate the sphere bounds');
+    }
     const camera = viewport.getCamera();
     const viewUp = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.fromValues */ .eR.fromValues(camera.viewUp[0], camera.viewUp[1], camera.viewUp[2]);
     const viewPlaneNormal = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.fromValues */ .eR.fromValues(camera.viewPlaneNormal[0], camera.viewPlaneNormal[1], camera.viewPlaneNormal[2]);
     const viewRight = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .eR.create();
     gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.cross */ .eR.cross(viewRight, viewUp, viewPlaneNormal);
+    const directionVectors = {
+        row: viewRight,
+        normal: viewPlaneNormal,
+        column: gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.negate */ .eR.negate(gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .eR.create(), viewUp),
+    };
+    return _getSphereBoundsInfo(circlePoints, imageData, directionVectors);
+}
+function _computeBoundsIJK(imageData, directionVectors, circlePoints, centerWorld, radiusWorld) {
+    const dimensions = imageData.getDimensions();
+    const { row: rowCosine, column: columnCosine, normal: vecNormal, } = directionVectors;
     const topLeftWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .eR.create();
     const bottomRightWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .eR.create();
-    gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(topLeftWorld, top, viewPlaneNormal, radiusWorld);
-    gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(bottomRightWorld, bottom, viewPlaneNormal, -radiusWorld);
-    gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(topLeftWorld, topLeftWorld, viewRight, -radiusWorld);
-    gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(bottomRightWorld, bottomRightWorld, viewRight, radiusWorld);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(topLeftWorld, centerWorld, vecNormal, radiusWorld);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(bottomRightWorld, centerWorld, vecNormal, -radiusWorld);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(topLeftWorld, topLeftWorld, columnCosine, -radiusWorld);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(bottomRightWorld, bottomRightWorld, columnCosine, radiusWorld);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(topLeftWorld, topLeftWorld, rowCosine, -radiusWorld);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(bottomRightWorld, bottomRightWorld, rowCosine, radiusWorld);
     const topLeftIJK = transformWorldToIndex(imageData, topLeftWorld);
     const bottomRightIJK = transformWorldToIndex(imageData, bottomRightWorld);
     const pointsIJK = circlePoints.map((p) => transformWorldToIndex(imageData, p));
@@ -10408,7 +11044,9 @@ class BasicStatsCalculator extends basic_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) => {
@@ -12424,6 +13062,10 @@ function filterAnnotationsWithinSlice(annotations, camera, spacingInNormalDirect
             continue;
         }
         const dir = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        if (!point) {
+            annotationsWithinSlice.push(annotation);
+            return;
+        }
         gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.sub */ .eR.sub(dir, focalPoint, point);
         const dot = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(dir, viewPlaneNormal);
         if (Math.abs(dot) < halfSpacingInNormalDirection) {
@@ -14191,6 +14833,123 @@ function getSliceData(viewport) {
 }
 
 
+/***/ }),
+
+/***/ 68915:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ VolumetricCalculator)
+/* harmony export */ });
+/* harmony import */ var _math_basic__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(79362);
+
+class VolumetricCalculator extends _math_basic__WEBPACK_IMPORTED_MODULE_0__.BasicStatsCalculator {
+    static getStatistics(options) {
+        const { spacing } = options;
+        const stats = _math_basic__WEBPACK_IMPORTED_MODULE_0__.BasicStatsCalculator.getStatistics();
+        const volumeUnit = spacing ? 'mm\xb3' : 'voxels\xb3';
+        const volumeScale = spacing
+            ? spacing[0] * spacing[1] * spacing[2] * 1000
+            : 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;
+    }
+}
+
+
+/***/ }),
+
+/***/ 2397:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   createLabelmapMemo: () => (/* binding */ createLabelmapMemo),
+/* harmony export */   createPreviewMemo: () => (/* binding */ createPreviewMemo),
+/* harmony export */   createRleMemo: () => (/* binding */ createRleMemo),
+/* harmony export */   restoreMemo: () => (/* binding */ restoreMemo)
+/* harmony export */ });
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(81985);
+/* harmony import */ var _stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(49906);
+
+
+const { VoxelManager, RLEVoxelMap } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
+function createLabelmapMemo(segmentationId, segmentationVoxelManager, preview) {
+    return preview
+        ? createPreviewMemo(segmentationId, preview)
+        : createRleMemo(segmentationId, segmentationVoxelManager);
+}
+function restoreMemo(isUndo) {
+    const { segmentationVoxelManager, undoVoxelManager, redoVoxelManager } = this;
+    const useVoxelManager = isUndo === false ? redoVoxelManager : undoVoxelManager;
+    useVoxelManager.forEach(({ value, pointIJK }) => {
+        segmentationVoxelManager.setAtIJKPoint(pointIJK, value);
+    });
+    const slices = useVoxelManager.getArrayOfModifiedSlices();
+    (0,_stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_1__.triggerSegmentationDataModified)(this.segmentationId, slices);
+}
+function createRleMemo(segmentationId, segmentationVoxelManager) {
+    const voxelManager = VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
+    const state = {
+        segmentationId,
+        restoreMemo,
+        commitMemo,
+        segmentationVoxelManager,
+        voxelManager,
+    };
+    return state;
+}
+function createPreviewMemo(segmentationId, preview) {
+    const { memo: previewMemo, segmentationVoxelManager, previewVoxelManager, } = preview;
+    const state = {
+        segmentationId,
+        restoreMemo,
+        commitMemo,
+        segmentationVoxelManager,
+        voxelManager: previewVoxelManager,
+        memo: previewMemo,
+        preview,
+    };
+    return state;
+}
+function commitMemo() {
+    if (this.redoVoxelManager) {
+        return true;
+    }
+    if (!this.voxelManager.modifiedSlices.size) {
+        return false;
+    }
+    const { segmentationVoxelManager } = this;
+    const undoVoxelManager = VoxelManager.createRLEHistoryVoxelManager(segmentationVoxelManager);
+    RLEVoxelMap.copyMap(undoVoxelManager.map, this.voxelManager.map);
+    for (const key of this.voxelManager.modifiedSlices.keys()) {
+        undoVoxelManager.modifiedSlices.add(key);
+    }
+    this.undoVoxelManager = undoVoxelManager;
+    const redoVoxelManager = VoxelManager.createRLEVolumeVoxelManager({
+        dimensions: this.segmentationVoxelManager.dimensions,
+    });
+    this.redoVoxelManager = redoVoxelManager;
+    undoVoxelManager.forEach(({ index, pointIJK, value }) => {
+        const currentValue = segmentationVoxelManager.getAtIJKPoint(pointIJK);
+        if (currentValue === value) {
+            return;
+        }
+        redoVoxelManager.setAtIndex(index, currentValue);
+    });
+    return true;
+}
+
+
 /***/ }),
 
 /***/ 84882:
@@ -14204,20 +14963,20 @@ function floodFill(getter, seed, options = {}) {
     const onFlood = options.onFlood;
     const onBoundary = options.onBoundary;
     const equals = options.equals;
+    const filter = options.filter;
     const diagonals = options.diagonals || false;
     const startNode = get(seed);
     const permutations = prunedPermutations();
     const stack = [];
     const flooded = [];
     const visits = new Set();
-    const bounds = new Map();
+    const bounds = options.bounds;
     stack.push({ currentArgs: seed });
     while (stack.length > 0) {
         flood(stack.pop());
     }
     return {
         flooded,
-        boundaries: boundaries(),
     };
     function flood(job) {
         const getArgs = job.currentArgs;
@@ -14257,7 +15016,7 @@ function floodFill(getter, seed, options = {}) {
     function markAsBoundary(prevArgs) {
         const [x, y, z = 0] = prevArgs;
         const iKey = x + 32768 + 65536 * (y + 32768 + 65536 * (z + 32768));
-        bounds.set(iKey, prevArgs);
+        bounds?.set(iKey, prevArgs);
         if (onBoundary) {
             onBoundary(...prevArgs);
         }
@@ -14269,6 +15028,12 @@ function floodFill(getter, seed, options = {}) {
             for (let j = 0; j < getArgs.length; j += 1) {
                 nextArgs[j] += perm[j];
             }
+            if (filter?.(nextArgs) === false) {
+                continue;
+            }
+            if (visited(nextArgs)) {
+                continue;
+            }
             stack.push({
                 currentArgs: nextArgs,
                 previousArgs: getArgs,
@@ -14298,14 +15063,6 @@ function floodFill(getter, seed, options = {}) {
         }
         return perms;
     }
-    function boundaries() {
-        const array = Array.from(bounds.values());
-        array.reverse();
-        return array;
-    }
-}
-function defaultEquals(a, b) {
-    return a === b;
 }
 function countNonZeroes(array) {
     let count = 0;
@@ -14356,7 +15113,93 @@ function getBrushToolInstances(toolGroupId, toolName) {
 
 /***/ }),
 
-/***/ 67470:
+/***/ 86644:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   u: () => (/* binding */ getSVGStyleForSegment)
+/* harmony export */ });
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(99737);
+/* harmony import */ var _stateManagement_segmentation_config_segmentationColor__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(93733);
+/* harmony import */ var _stateManagement_segmentation_getActiveSegmentation__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(67165);
+/* harmony import */ var _stateManagement_segmentation_getActiveSegmentIndex__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(60740);
+/* harmony import */ var _stateManagement_segmentation_getSegmentationRepresentationVisibility__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(33658);
+/* harmony import */ var _stateManagement_segmentation_helpers_internalGetHiddenSegmentIndices__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(47098);
+/* harmony import */ var _stateManagement_segmentation_SegmentationStyle__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(92686);
+
+
+
+
+
+
+
+function getSVGStyleForSegment({ segmentationId, segmentIndex, viewportId, autoGenerated = false, }) {
+    const segmentColor = (0,_stateManagement_segmentation_config_segmentationColor__WEBPACK_IMPORTED_MODULE_1__.getSegmentIndexColor)(viewportId, segmentationId, segmentIndex);
+    const segmentationVisible = (0,_stateManagement_segmentation_getSegmentationRepresentationVisibility__WEBPACK_IMPORTED_MODULE_4__/* .getSegmentationRepresentationVisibility */ .I)(viewportId, {
+        segmentationId,
+        type: _enums__WEBPACK_IMPORTED_MODULE_0__.SegmentationRepresentations.Contour,
+    });
+    const activeSegmentation = (0,_stateManagement_segmentation_getActiveSegmentation__WEBPACK_IMPORTED_MODULE_2__/* .getActiveSegmentation */ .T)(viewportId);
+    const isActive = activeSegmentation?.segmentationId === segmentationId;
+    const style = _stateManagement_segmentation_SegmentationStyle__WEBPACK_IMPORTED_MODULE_6__/* .segmentationStyle */ .Y.getStyle({
+        viewportId,
+        segmentationId,
+        type: _enums__WEBPACK_IMPORTED_MODULE_0__.SegmentationRepresentations.Contour,
+        segmentIndex,
+    });
+    const mergedConfig = style;
+    let lineWidth = 1;
+    let lineDash = undefined;
+    let lineOpacity = 1;
+    let fillOpacity = 0;
+    if (autoGenerated) {
+        lineWidth = mergedConfig.outlineWidthAutoGenerated ?? lineWidth;
+        lineDash = mergedConfig.outlineDashAutoGenerated ?? lineDash;
+        lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
+        fillOpacity = mergedConfig.fillAlphaAutoGenerated ?? fillOpacity;
+    }
+    else if (isActive) {
+        lineWidth = mergedConfig.outlineWidth ?? lineWidth;
+        lineDash = mergedConfig.outlineDash ?? lineDash;
+        lineOpacity = mergedConfig.outlineOpacity ?? lineOpacity;
+        fillOpacity = mergedConfig.fillAlpha ?? fillOpacity;
+    }
+    else {
+        lineWidth = mergedConfig.outlineWidthInactive ?? lineWidth;
+        lineDash = mergedConfig.outlineDashInactive ?? lineDash;
+        lineOpacity = mergedConfig.outlineOpacityInactive ?? lineOpacity;
+        fillOpacity = mergedConfig.fillAlphaInactive ?? fillOpacity;
+    }
+    if ((0,_stateManagement_segmentation_getActiveSegmentIndex__WEBPACK_IMPORTED_MODULE_3__/* .getActiveSegmentIndex */ .Q)(segmentationId) === segmentIndex) {
+        lineWidth += mergedConfig.activeSegmentOutlineWidthDelta;
+    }
+    lineWidth = mergedConfig.renderOutline ? lineWidth : 0;
+    fillOpacity = mergedConfig.renderFill ? fillOpacity : 0;
+    const color = `rgba(${segmentColor[0]}, ${segmentColor[1]}, ${segmentColor[2]}, ${lineOpacity})`;
+    const fillColor = `rgb(${segmentColor[0]}, ${segmentColor[1]}, ${segmentColor[2]})`;
+    const hiddenSegments = (0,_stateManagement_segmentation_helpers_internalGetHiddenSegmentIndices__WEBPACK_IMPORTED_MODULE_5__/* .internalGetHiddenSegmentIndices */ .s)(viewportId, {
+        segmentationId,
+        type: _enums__WEBPACK_IMPORTED_MODULE_0__.SegmentationRepresentations.Contour,
+    });
+    const isVisible = !hiddenSegments.has(segmentIndex);
+    return {
+        color,
+        fillColor,
+        lineWidth,
+        fillOpacity,
+        lineDash,
+        textbox: {
+            color,
+        },
+        visibility: segmentationVisible && isVisible,
+    };
+}
+
+
+/***/ }),
+
+/***/ 26971:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -14365,6 +15208,8 @@ __webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
+  LabelmapMemo: () => (/* reexport */ createLabelmapMemo),
+  VolumetricCalculator: () => (/* reexport */ VolumetricCalculator/* default */.A),
   contourAndFindLargestBidirectional: () => (/* reexport */ contourAndFindLargestBidirectional),
   createBidirectionalToolData: () => (/* reexport */ createBidirectionalToolData),
   createLabelmapVolumeForViewport: () => (/* reexport */ createLabelmapVolumeForViewport),
@@ -14377,6 +15222,7 @@ __webpack_require__.d(__webpack_exports__, {
   getSegmentIndexAtLabelmapBorder: () => (/* reexport */ getSegmentIndexAtLabelmapBorder),
   getSegmentIndexAtWorldPoint: () => (/* reexport */ getSegmentIndexAtWorldPoint),
   getUniqueSegmentIndices: () => (/* reexport */ getUniqueSegmentIndices/* getUniqueSegmentIndices */.O),
+  growCut: () => (/* reexport */ growCut_namespaceObject),
   invalidateBrushCursor: () => (/* reexport */ invalidateBrushCursor/* invalidateBrushCursor */.E),
   rectangleROIThresholdVolumeByRange: () => (/* reexport */ segmentation_rectangleROIThresholdVolumeByRange),
   segmentContourAction: () => (/* reexport */ segmentContourAction),
@@ -14388,6 +15234,16 @@ __webpack_require__.d(__webpack_exports__, {
   triggerSegmentationRenderBySegmentationId: () => (/* reexport */ SegmentationRenderingEngine/* triggerSegmentationRenderBySegmentationId */.fy)
 });
 
+// NAMESPACE OBJECT: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/index.js
+var growCut_namespaceObject = {};
+__webpack_require__.r(growCut_namespaceObject);
+__webpack_require__.d(growCut_namespaceObject, {
+  run: () => (runGrowCut),
+  runGrowCutForBoundingBox: () => (runGrowCutForBoundingBox),
+  runGrowCutForSphere: () => (runGrowCutForSphere),
+  runOneClickGrowCut: () => (runOneClickGrowCut)
+});
+
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/triggerSegmentationEvents.js
 var triggerSegmentationEvents = __webpack_require__(49906);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/utilities.js
@@ -14579,7 +15435,7 @@ async function createLabelmapVolumeForViewport(input) {
     }
     else {
         const volumeId = viewport.getVolumeId();
-        await esm.volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId, {
+        esm.volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId, {
             volumeId: segmentationId,
         });
     }
@@ -14686,6 +15542,8 @@ function getBrushThresholdForToolGroup(toolGroupId) {
         .threshold;
 }
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/VolumetricCalculator.js
+var VolumetricCalculator = __webpack_require__(68915);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/thresholdSegmentationByRange.js
 
 
@@ -15071,8 +15929,8 @@ var invalidateBrushCursor = __webpack_require__(35706);
 var getUniqueSegmentIndices = __webpack_require__(25758);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/index.js + 2 modules
 var enums = __webpack_require__(99737);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/segmentationState.js + 2 modules
-var segmentationState = __webpack_require__(98870);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/segmentationState.js + 1 modules
+var segmentationState = __webpack_require__(83243);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/index.js
 var stateManagement = __webpack_require__(6802);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/polyline/index.js
@@ -15250,6 +16108,851 @@ function getHoveredContourSegmentationAnnotation(segmentationId) {
     return undefined;
 }
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/growCutShader.js
+const shader = `
+const MAX_STRENGTH = 65535f;
+
+// Workgroup soze - X*Y*Z must be multiple of 32 for better performance
+// otherwise warps are sub allocated and some threads will not process anything
+override workGroupSizeX = 1u;
+override workGroupSizeY = 1u;
+override workGroupSizeZ = 1u;
+
+// Compare the current voxel to neighbors using a 9x9x9 window
+override windowSize = 9i;
+
+struct Params {
+  size: vec3u,
+  iteration: u32,
+}
+
+@group(0) @binding(0) var<uniform> params: Params;
+@group(0) @binding(1) var<storage> volumePixelData: array<f32>;
+@group(0) @binding(2) var<storage, read_write> labelmap: array<u32>;
+@group(0) @binding(3) var<storage, read_write> strengthData: array<f32>;
+@group(0) @binding(4) var<storage> prevLabelmap: array<u32>;
+@group(0) @binding(5) var<storage> prevStrengthData: array<f32>;
+@group(0) @binding(6) var<storage, read_write> updatedVoxelsCounter: array<atomic<u32>>;
+
+fn getPixelIndex(ijkPos: vec3u) -> u32 {
+  let numPixelsPerSlice = params.size.x * params.size.y;
+  return ijkPos.x + ijkPos.y * params.size.x + ijkPos.z * numPixelsPerSlice;
+}
+
+@compute @workgroup_size(workGroupSizeX, workGroupSizeY, workGroupSizeZ)
+fn main(
+  @builtin(global_invocation_id) globalId: vec3u,
+) {
+  // Make sure it will not get out of bounds for volume with sizes that
+  // are not multiple of workGroupSize
+  if (
+    globalId.x >= params.size.x ||
+    globalId.y >= params.size.y ||
+    globalId.z >= params.size.z
+  ) {
+    return;
+  }
+
+  let currentCoord = vec3i(globalId);
+  let currentPixelIndex = getPixelIndex(globalId);
+
+  let numPixels = arrayLength(&volumePixelData);
+  let currentPixelValue = volumePixelData[currentPixelIndex];
+
+  if (params.iteration == 0) {
+    // All non-zero initial labels are given maximum strength
+    strengthData[currentPixelIndex] = select(MAX_STRENGTH, 0., labelmap[currentPixelIndex] == 0);
+    return;
+  }
+
+  // It should at least copy the values from previous state
+  var newLabel = prevLabelmap[currentPixelIndex];
+  var newStrength = prevStrengthData[currentPixelIndex];
+
+  let window = i32(ceil(f32(windowSize - 1) * .5));
+  let minWindow = -1i * window;
+  let maxWindow = 1i * window;
+
+  for (var k = minWindow; k <= maxWindow; k++) {
+    for (var j = minWindow; j <= maxWindow; j++) {
+      for (var i = minWindow; i <= maxWindow; i++) {
+        // Skip current voxel
+        if (i == 0 && j == 0 && k == 0) {
+          continue;
+        }
+
+        let neighborCoord = currentCoord + vec3i(i, j, k);
+
+        //  Boundary conditions. Do not grow outside of the volume
+        if (
+          neighborCoord.x < 0i || neighborCoord.x >= i32(params.size.x) ||
+          neighborCoord.y < 0i || neighborCoord.y >= i32(params.size.y) ||
+          neighborCoord.z < 0i || neighborCoord.z >= i32(params.size.z)
+        ) {
+          continue;
+        }
+
+        let neighborIndex = getPixelIndex(vec3u(neighborCoord));
+        let neighborPixelValue = volumePixelData[neighborIndex];
+        let prevNeighborStrength = prevStrengthData[neighborIndex];
+        let strengthCost = abs(neighborPixelValue - currentPixelValue);
+        let takeoverStrength = prevNeighborStrength - strengthCost;
+
+        if (takeoverStrength > newStrength) {
+          newLabel = prevLabelmap[neighborIndex];
+          newStrength = takeoverStrength;
+        }
+      }
+    }
+  }
+
+  if (labelmap[currentPixelIndex] != newLabel) {
+    atomicAdd(&updatedVoxelsCounter[params.iteration], 1u);
+  }
+
+  labelmap[currentPixelIndex] = newLabel;
+  strengthData[currentPixelIndex] = newStrength;
+}
+`;
+/* harmony default export */ const growCutShader = (shader);
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/runGrowCut.js
+
+
+const GB = 1024 * 1024 * 1024;
+const WEBGPU_MEMORY_LIMIT = 1.99 * GB;
+const DEFAULT_GROWCUT_OPTIONS = {
+    windowSize: 3,
+    maxProcessingTime: 30000,
+    inspection: {
+        numCyclesInterval: 5,
+        numCyclesBelowThreshold: 3,
+        threshold: 1e-4,
+    },
+};
+async function runGrowCut(referenceVolumeId, labelmapVolumeId, options = DEFAULT_GROWCUT_OPTIONS) {
+    const workGroupSize = [8, 8, 4];
+    const { windowSize, maxProcessingTime } = Object.assign({}, DEFAULT_GROWCUT_OPTIONS, options);
+    const inspection = Object.assign({}, DEFAULT_GROWCUT_OPTIONS.inspection, options.inspection);
+    const volume = esm.cache.getVolume(referenceVolumeId);
+    const labelmap = esm.cache.getVolume(labelmapVolumeId);
+    const [columns, rows, numSlices] = volume.dimensions;
+    if (labelmap.dimensions[0] !== columns ||
+        labelmap.dimensions[1] !== rows ||
+        labelmap.dimensions[2] !== numSlices) {
+        throw new Error('Volume and labelmap must have the same size');
+    }
+    const numIterations = Math.floor(Math.sqrt(rows ** 2 + columns ** 2 + numSlices ** 2) / 2);
+    const labelmapData = labelmap.voxelManager.getCompleteScalarDataArray();
+    let volumePixelData = volume.voxelManager.getCompleteScalarDataArray();
+    if (!(volumePixelData instanceof Float32Array)) {
+        volumePixelData = new Float32Array(volumePixelData);
+    }
+    const requiredLimits = {
+        maxStorageBufferBindingSize: WEBGPU_MEMORY_LIMIT,
+        maxBufferSize: WEBGPU_MEMORY_LIMIT,
+    };
+    const adapter = await navigator.gpu?.requestAdapter();
+    const device = await adapter.requestDevice({ requiredLimits });
+    const BUFFER_SIZE = volumePixelData.byteLength;
+    const UPDATED_VOXELS_COUNTER_BUFFER_SIZE = numIterations * Uint32Array.BYTES_PER_ELEMENT;
+    const shaderModule = device.createShaderModule({
+        code: growCutShader,
+    });
+    const numIterationIndex = 3;
+    const paramsArrayValues = new Uint32Array([
+        columns,
+        rows,
+        numSlices,
+        0,
+    ]);
+    const gpuParamsBuffer = device.createBuffer({
+        size: paramsArrayValues.byteLength,
+        usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+    });
+    const gpuVolumePixelDataBuffer = device.createBuffer({
+        size: BUFFER_SIZE,
+        usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+    });
+    device.queue.writeBuffer(gpuVolumePixelDataBuffer, 0, volumePixelData);
+    const gpuLabelmapBuffers = [0, 1].map(() => device.createBuffer({
+        size: BUFFER_SIZE,
+        usage: GPUBufferUsage.STORAGE |
+            GPUBufferUsage.COPY_SRC |
+            GPUBufferUsage.COPY_DST,
+    }));
+    device.queue.writeBuffer(gpuLabelmapBuffers[0], 0, new Uint32Array(labelmapData));
+    const gpuStrengthBuffers = [0, 1].map(() => {
+        const strengthBuffer = device.createBuffer({
+            size: BUFFER_SIZE,
+            usage: GPUBufferUsage.STORAGE |
+                GPUBufferUsage.COPY_SRC |
+                GPUBufferUsage.COPY_DST,
+        });
+        return strengthBuffer;
+    });
+    const gpuCounterBuffer = device.createBuffer({
+        size: UPDATED_VOXELS_COUNTER_BUFFER_SIZE,
+        usage: GPUBufferUsage.STORAGE |
+            GPUBufferUsage.COPY_SRC |
+            GPUBufferUsage.COPY_DST,
+    });
+    const bindGroupLayout = device.createBindGroupLayout({
+        entries: [
+            {
+                binding: 0,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'uniform',
+                },
+            },
+            {
+                binding: 1,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'read-only-storage',
+                },
+            },
+            {
+                binding: 2,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'storage',
+                },
+            },
+            {
+                binding: 3,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'storage',
+                },
+            },
+            {
+                binding: 4,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'read-only-storage',
+                },
+            },
+            {
+                binding: 5,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'read-only-storage',
+                },
+            },
+            {
+                binding: 6,
+                visibility: GPUShaderStage.COMPUTE,
+                buffer: {
+                    type: 'storage',
+                },
+            },
+        ],
+    });
+    const bindGroups = [0, 1].map((i) => {
+        const outputLabelmapBuffer = gpuLabelmapBuffers[i];
+        const outputStrengthBuffer = gpuStrengthBuffers[i];
+        const previouLabelmapBuffer = gpuLabelmapBuffers[(i + 1) % 2];
+        const previousStrengthBuffer = gpuStrengthBuffers[(i + 1) % 2];
+        return device.createBindGroup({
+            layout: bindGroupLayout,
+            entries: [
+                {
+                    binding: 0,
+                    resource: {
+                        buffer: gpuParamsBuffer,
+                    },
+                },
+                {
+                    binding: 1,
+                    resource: {
+                        buffer: gpuVolumePixelDataBuffer,
+                    },
+                },
+                {
+                    binding: 2,
+                    resource: {
+                        buffer: outputLabelmapBuffer,
+                    },
+                },
+                {
+                    binding: 3,
+                    resource: {
+                        buffer: outputStrengthBuffer,
+                    },
+                },
+                {
+                    binding: 4,
+                    resource: {
+                        buffer: previouLabelmapBuffer,
+                    },
+                },
+                {
+                    binding: 5,
+                    resource: {
+                        buffer: previousStrengthBuffer,
+                    },
+                },
+                {
+                    binding: 6,
+                    resource: {
+                        buffer: gpuCounterBuffer,
+                    },
+                },
+            ],
+        });
+    });
+    const pipeline = device.createComputePipeline({
+        layout: device.createPipelineLayout({
+            bindGroupLayouts: [bindGroupLayout],
+        }),
+        compute: {
+            module: shaderModule,
+            entryPoint: 'main',
+            constants: {
+                workGroupSizeX: workGroupSize[0],
+                workGroupSizeY: workGroupSize[1],
+                workGroupSizeZ: workGroupSize[2],
+                windowSize,
+            },
+        },
+    });
+    const numWorkGroups = [
+        Math.ceil(columns / workGroupSize[0]),
+        Math.ceil(rows / workGroupSize[1]),
+        Math.ceil(numSlices / workGroupSize[2]),
+    ];
+    const gpuUpdatedVoxelsCounterStagingBuffer = device.createBuffer({
+        size: UPDATED_VOXELS_COUNTER_BUFFER_SIZE,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+    });
+    const labelmapStagingBufferTemp = device.createBuffer({
+        size: BUFFER_SIZE,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+    });
+    const limitProcessingTime = maxProcessingTime
+        ? performance.now() + maxProcessingTime
+        : 0;
+    let currentInspectionNumCyclesInterval = inspection.numCyclesInterval;
+    let belowThresholdCounter = 0;
+    for (let i = 0; i < numIterations; i++) {
+        paramsArrayValues[numIterationIndex] = i;
+        device.queue.writeBuffer(gpuParamsBuffer, 0, paramsArrayValues);
+        const commandEncoder = device.createCommandEncoder();
+        const passEncoder = commandEncoder.beginComputePass();
+        passEncoder.setPipeline(pipeline);
+        passEncoder.setBindGroup(0, bindGroups[i % 2]);
+        passEncoder.dispatchWorkgroups(numWorkGroups[0], numWorkGroups[1], numWorkGroups[2]);
+        passEncoder.end();
+        commandEncoder.copyBufferToBuffer(gpuCounterBuffer, i * Uint32Array.BYTES_PER_ELEMENT, gpuUpdatedVoxelsCounterStagingBuffer, i * Uint32Array.BYTES_PER_ELEMENT, Uint32Array.BYTES_PER_ELEMENT);
+        device.queue.submit([commandEncoder.finish()]);
+        const inspect = i > 0 && !(i % currentInspectionNumCyclesInterval);
+        if (inspect) {
+            await gpuUpdatedVoxelsCounterStagingBuffer.mapAsync(GPUMapMode.READ, 0, UPDATED_VOXELS_COUNTER_BUFFER_SIZE);
+            const updatedVoxelsCounterResultBuffer = gpuUpdatedVoxelsCounterStagingBuffer.getMappedRange(0, UPDATED_VOXELS_COUNTER_BUFFER_SIZE);
+            const updatedVoxelsCounterBufferData = new Uint32Array(updatedVoxelsCounterResultBuffer.slice(0));
+            const updatedVoxelsRatio = updatedVoxelsCounterBufferData[i] / volumePixelData.length;
+            gpuUpdatedVoxelsCounterStagingBuffer.unmap();
+            if (i >= 1 && updatedVoxelsRatio < inspection.threshold) {
+                currentInspectionNumCyclesInterval = 1;
+                belowThresholdCounter++;
+                if (belowThresholdCounter === inspection.numCyclesBelowThreshold) {
+                    break;
+                }
+            }
+            else {
+                currentInspectionNumCyclesInterval = inspection.numCyclesInterval;
+            }
+        }
+        if (limitProcessingTime && performance.now() > limitProcessingTime) {
+            console.warn(`Exceeded processing time limit (${maxProcessingTime})ms`);
+            break;
+        }
+    }
+    const commandEncoder = device.createCommandEncoder();
+    const outputLabelmapBufferIndex = (numIterations + 1) % 2;
+    const labelmapStagingBuffer = device.createBuffer({
+        size: BUFFER_SIZE,
+        usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+    });
+    commandEncoder.copyBufferToBuffer(gpuLabelmapBuffers[outputLabelmapBufferIndex], 0, labelmapStagingBuffer, 0, BUFFER_SIZE);
+    device.queue.submit([commandEncoder.finish()]);
+    await labelmapStagingBuffer.mapAsync(GPUMapMode.READ, 0, BUFFER_SIZE);
+    const labelmapResultBuffer = labelmapStagingBuffer.getMappedRange(0, BUFFER_SIZE);
+    const labelmapResult = new Uint32Array(labelmapResultBuffer);
+    labelmapData.set(labelmapResult);
+    labelmapStagingBuffer.unmap();
+    labelmap.voxelManager.setCompleteScalarDataArray(labelmapData);
+}
+
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/getSphereBoundsInfo.js
+var getSphereBoundsInfo = __webpack_require__(4296);
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/runGrowCutForSphere.js
+
+
+
+
+const { transformWorldToIndex } = esm.utilities;
+const POSITIVE_SEED_VALUE = 254;
+const NEGATIVE_SEED_VALUE = 255;
+const POSITIVE_SEED_VARIANCE = 0.1;
+const NEGATIVE_SEED_VARIANCE = 0.8;
+function _getGrowCutSphereBoundsInfo(referencedVolume, sphereBoundsInfo) {
+    const { topLeftWorld, bottomRightWorld } = sphereBoundsInfo;
+    const topLeftIJK = transformWorldToIndex(referencedVolume.imageData, topLeftWorld);
+    const bottomRightIJK = transformWorldToIndex(referencedVolume.imageData, bottomRightWorld);
+    return {
+        ...sphereBoundsInfo,
+        topLeftIJK,
+        bottomRightIJK,
+    };
+}
+function _getSphereBoundsInfo(referencedVolume, sphereInfo) {
+    const direction = referencedVolume.imageData.getDirection();
+    const vecColumn = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(direction[3], direction[4], direction[5]);
+    const { center: sphereCenterPoint, radius: sphereRadius } = sphereInfo;
+    const refVolImageData = referencedVolume.imageData;
+    const topCirclePoint = gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(gl_matrix_esm/* vec3.create */.eR.create(), sphereCenterPoint, vecColumn, -sphereRadius);
+    const bottomCirclePoint = gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(gl_matrix_esm/* vec3.create */.eR.create(), sphereCenterPoint, vecColumn, sphereRadius);
+    const sphereBoundsInfo = (0,getSphereBoundsInfo/* getSphereBoundsInfo */.R)([bottomCirclePoint, topCirclePoint], refVolImageData);
+    return _getGrowCutSphereBoundsInfo(referencedVolume, sphereBoundsInfo);
+}
+function _createSubVolumeFromSphere(referencedVolume, sphereInfo, viewport) {
+    const refVolImageData = referencedVolume.imageData;
+    const camera = viewport.getCamera();
+    const { ijkVecRowDir, ijkVecColDir } = esm.utilities.getVolumeDirectionVectors(refVolImageData, camera);
+    const obliqueView = [ijkVecRowDir, ijkVecColDir].some((vec) => !esm.utilities.isEqual(Math.abs(vec[0]), 1) &&
+        !esm.utilities.isEqual(Math.abs(vec[1]), 1) &&
+        !esm.utilities.isEqual(Math.abs(vec[2]), 1));
+    if (obliqueView) {
+        console.warn('Oblique view is not supported!');
+        return;
+    }
+    const { boundsIJK: sphereBoundsIJK } = _getSphereBoundsInfo(referencedVolume, sphereInfo);
+    const subVolumeBoundsIJK = {
+        minX: sphereBoundsIJK[0][0],
+        maxX: sphereBoundsIJK[0][1] + 1,
+        minY: sphereBoundsIJK[1][0],
+        maxY: sphereBoundsIJK[1][1] + 1,
+        minZ: sphereBoundsIJK[2][0],
+        maxZ: sphereBoundsIJK[2][1] + 1,
+    };
+    return esm.utilities.createSubVolume(referencedVolume.volumeId, subVolumeBoundsIJK, {
+        targetBuffer: {
+            type: 'Float32Array',
+        },
+    });
+}
+function _setPositiveSeedValues(referencedVolume, labelmap, sphereInfo, options) {
+    const refVolumePixelData = referencedVolume.voxelManager.getCompleteScalarDataArray();
+    const worldStartPos = sphereInfo.center;
+    const [width, height, numSlices] = referencedVolume.dimensions;
+    const numPixelsPerSlice = width * height;
+    const ijkStartPosition = transformWorldToIndex(referencedVolume.imageData, worldStartPos);
+    const referencePixelValue = refVolumePixelData[ijkStartPosition[2] * numPixelsPerSlice +
+        ijkStartPosition[1] * width +
+        ijkStartPosition[0]];
+    const positiveSeedValue = options.positiveSeedValue ?? POSITIVE_SEED_VALUE;
+    const positiveSeedVariance = options.positiveSeedVariance ?? POSITIVE_SEED_VARIANCE;
+    const positiveSeedVarianceValue = Math.abs(referencePixelValue * positiveSeedVariance);
+    const minPositivePixelValue = referencePixelValue - positiveSeedVarianceValue;
+    const maxPositivePixelValue = referencePixelValue + positiveSeedVarianceValue;
+    const neighborsCoordDelta = [
+        [-1, 0, 0],
+        [1, 0, 0],
+        [0, -1, 0],
+        [0, 1, 0],
+        [0, 0, -1],
+        [0, 0, 1],
+    ];
+    const startVoxelIndex = ijkStartPosition[2] * numPixelsPerSlice +
+        ijkStartPosition[1] * width +
+        ijkStartPosition[0];
+    labelmap.voxelManager.setAtIndex(startVoxelIndex, positiveSeedValue);
+    const queue = [ijkStartPosition];
+    while (queue.length) {
+        const ijkVoxel = queue.shift();
+        const [x, y, z] = ijkVoxel;
+        for (let i = 0, len = neighborsCoordDelta.length; i < len; i++) {
+            const neighborCoordDelta = neighborsCoordDelta[i];
+            const nx = x + neighborCoordDelta[0];
+            const ny = y + neighborCoordDelta[1];
+            const nz = z + neighborCoordDelta[2];
+            if (nx < 0 ||
+                nx >= width ||
+                ny < 0 ||
+                ny >= height ||
+                nz < 0 ||
+                nz >= numSlices) {
+                continue;
+            }
+            const neighborVoxelIndex = nz * numPixelsPerSlice + ny * width + nx;
+            const neighborPixelValue = refVolumePixelData[neighborVoxelIndex];
+            const neighborLabelmapValue = labelmap.voxelManager.getAtIndex(neighborVoxelIndex);
+            if (neighborLabelmapValue === positiveSeedValue ||
+                neighborPixelValue < minPositivePixelValue ||
+                neighborPixelValue > maxPositivePixelValue) {
+                continue;
+            }
+            labelmap.voxelManager.setAtIndex(neighborVoxelIndex, positiveSeedValue);
+            queue.push([nx, ny, nz]);
+        }
+    }
+}
+function _setNegativeSeedValues(subVolume, labelmap, sphereInfo, viewport, options) {
+    const subVolPixelData = subVolume.voxelManager.getCompleteScalarDataArray();
+    const [columns, rows, numSlices] = labelmap.dimensions;
+    const numPixelsPerSlice = columns * rows;
+    const { worldVecRowDir, worldVecSliceDir } = esm.utilities.getVolumeDirectionVectors(labelmap.imageData, viewport.getCamera());
+    const ijkSphereCenter = transformWorldToIndex(subVolume.imageData, sphereInfo.center);
+    const referencePixelValue = subVolPixelData[ijkSphereCenter[2] * columns * rows +
+        ijkSphereCenter[1] * columns +
+        ijkSphereCenter[0]];
+    const negativeSeedVariance = options.negativeSeedVariance ?? NEGATIVE_SEED_VARIANCE;
+    const negativeSeedValue = options?.negativeSeedValue ?? NEGATIVE_SEED_VALUE;
+    const negativeSeedVarianceValue = Math.abs(referencePixelValue * negativeSeedVariance);
+    const minNegativePixelValue = referencePixelValue - negativeSeedVarianceValue;
+    const maxNegativePixelValue = referencePixelValue + negativeSeedVarianceValue;
+    const numCirclePoints = 360;
+    const rotationAngle = (2 * Math.PI) / numCirclePoints;
+    const worldQuat = gl_matrix_esm/* quat.setAxisAngle */.Yu.setAxisAngle(gl_matrix_esm/* quat.create */.Yu.create(), worldVecSliceDir, rotationAngle);
+    const vecRotation = gl_matrix_esm/* vec3.clone */.eR.clone(worldVecRowDir);
+    for (let i = 0; i < numCirclePoints; i++) {
+        const worldCircleBorderPoint = gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(gl_matrix_esm/* vec3.create */.eR.create(), sphereInfo.center, vecRotation, sphereInfo.radius);
+        const ijkCircleBorderPoint = transformWorldToIndex(labelmap.imageData, worldCircleBorderPoint);
+        const [x, y, z] = ijkCircleBorderPoint;
+        gl_matrix_esm/* vec3.transformQuat */.eR.transformQuat(vecRotation, vecRotation, worldQuat);
+        if (x < 0 ||
+            x >= columns ||
+            y < 0 ||
+            y >= rows ||
+            z < 0 ||
+            z >= numSlices) {
+            continue;
+        }
+        const offset = x + y * columns + z * numPixelsPerSlice;
+        const pixelValue = subVolPixelData[offset];
+        if (pixelValue < minNegativePixelValue ||
+            pixelValue > maxNegativePixelValue) {
+            labelmap.voxelManager.setAtIndex(offset, negativeSeedValue);
+        }
+    }
+}
+async function _createAndCacheSegmentationSubVolumeForSphere(subVolume, sphereInfo, viewport, options) {
+    const labelmap = await esm.volumeLoader.createAndCacheDerivedLabelmapVolume(subVolume.volumeId);
+    _setPositiveSeedValues(subVolume, labelmap, sphereInfo, options);
+    _setNegativeSeedValues(subVolume, labelmap, sphereInfo, viewport, options);
+    return labelmap;
+}
+async function runGrowCutForSphere(referencedVolumeId, sphereInfo, viewport, options) {
+    const referencedVolume = esm.cache.getVolume(referencedVolumeId);
+    const subVolume = _createSubVolumeFromSphere(referencedVolume, sphereInfo, viewport);
+    const labelmap = await _createAndCacheSegmentationSubVolumeForSphere(subVolume, sphereInfo, viewport, options);
+    await runGrowCut(subVolume.volumeId, labelmap.volumeId);
+    return labelmap;
+}
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/runGrowCutForBoundingBox.js
+
+
+const runGrowCutForBoundingBox_POSITIVE_SEED_VALUE = 254;
+const runGrowCutForBoundingBox_NEGATIVE_SEED_VALUE = 255;
+const NEGATIVE_PIXEL_RANGE = [-Infinity, -995];
+const POSITIVE_PIXEL_RANGE = [0, 1900];
+function runGrowCutForBoundingBox_setNegativeSeedValues(subVolume, labelmap, options) {
+    const { negativeSeedValue = runGrowCutForBoundingBox_NEGATIVE_SEED_VALUE, negativePixelRange = NEGATIVE_PIXEL_RANGE, } = options;
+    const subVolPixelData = subVolume.voxelManager.getCompleteScalarDataArray();
+    const [width, height, numSlices] = labelmap.dimensions;
+    const middleSliceIndex = Math.floor(numSlices / 2);
+    const visited = new Array(width * height).fill(false);
+    const sliceOffset = middleSliceIndex * width * height;
+    const bfs = (startX, startY) => {
+        const queue = [[startX, startY]];
+        while (queue.length) {
+            const [x, y] = queue.shift();
+            const slicePixelIndex = y * width + x;
+            if (x < 0 ||
+                x >= width ||
+                y < 0 ||
+                y >= height ||
+                visited[slicePixelIndex]) {
+                continue;
+            }
+            visited[slicePixelIndex] = true;
+            const volumeVoxelIndex = sliceOffset + slicePixelIndex;
+            const volumeVoxelValue = subVolPixelData[volumeVoxelIndex];
+            if (volumeVoxelValue < negativePixelRange[0] ||
+                volumeVoxelValue > negativePixelRange[1]) {
+                continue;
+            }
+            labelmap.voxelManager.setAtIndex(volumeVoxelIndex, negativeSeedValue);
+            queue.push([x - 1, y]);
+            queue.push([x + 1, y]);
+            queue.push([x, y - 1]);
+            queue.push([x, y + 1]);
+        }
+    };
+    const scanLine = (startX, limitX, incX, y) => {
+        for (let x = startX; x !== limitX; x += incX) {
+            const slicePixelIndex = y * width + x;
+            const volumeVoxelIndex = sliceOffset + slicePixelIndex;
+            const volumeVoxelValue = subVolPixelData[volumeVoxelIndex];
+            if (volumeVoxelValue < negativePixelRange[0] ||
+                volumeVoxelValue > negativePixelRange[1]) {
+                break;
+            }
+            if (!visited[slicePixelIndex]) {
+                bfs(x, y);
+            }
+        }
+    };
+    for (let y = 0; y < height; y++) {
+        scanLine(0, width - 1, 1, y);
+        scanLine(width - 1, 0, -1, y);
+    }
+}
+function runGrowCutForBoundingBox_setPositiveSeedValues(subVolume, labelmap, options) {
+    const { positiveSeedValue = runGrowCutForBoundingBox_POSITIVE_SEED_VALUE, positivePixelRange = POSITIVE_PIXEL_RANGE, } = options;
+    const subVolPixelData = subVolume.voxelManager.getCompleteScalarDataArray();
+    const labelmapData = labelmap.voxelManager.getCompleteScalarDataArray();
+    const [width, height, numSlices] = labelmap.dimensions;
+    const middleSliceIndex = Math.floor(numSlices / 2);
+    const startSliceIndex = Math.max(middleSliceIndex - 3, 0);
+    const stopSliceIndex = Math.max(startSliceIndex + 5, numSlices);
+    const pixelsPerSlice = width * height;
+    for (let z = startSliceIndex; z < stopSliceIndex; z++) {
+        const zOffset = z * pixelsPerSlice;
+        for (let y = 0; y < height; y++) {
+            const yOffset = y * width;
+            for (let x = 0; x < width; x++) {
+                const index = zOffset + yOffset + x;
+                const pixelValue = subVolPixelData[index];
+                const isPositiveValue = pixelValue >= positivePixelRange[0] &&
+                    pixelValue <= positivePixelRange[1];
+                if (isPositiveValue) {
+                    labelmap.voxelManager.setAtIndex(index, positiveSeedValue);
+                }
+            }
+        }
+    }
+}
+async function _createAndCacheSegmentationSubVolumeForBoundingBox(subVolume, options) {
+    const labelmap = esm.volumeLoader.createAndCacheDerivedLabelmapVolume(subVolume.volumeId);
+    runGrowCutForBoundingBox_setPositiveSeedValues(subVolume, labelmap, options);
+    runGrowCutForBoundingBox_setNegativeSeedValues(subVolume, labelmap, options);
+    return labelmap;
+}
+async function runGrowCutForBoundingBox(referencedVolumeId, boundingBoxInfo, options) {
+    const { boundingBox } = boundingBoxInfo;
+    const { ijkTopLeft, ijkBottomRight } = boundingBox;
+    const subVolumeBoundsIJK = {
+        minX: ijkTopLeft[0],
+        maxX: ijkBottomRight[0],
+        minY: ijkTopLeft[1],
+        maxY: ijkBottomRight[1],
+        minZ: ijkTopLeft[2],
+        maxZ: ijkBottomRight[2],
+    };
+    const subVolume = esm.utilities.createSubVolume(referencedVolumeId, subVolumeBoundsIJK, {
+        targetBuffer: {
+            type: 'Float32Array',
+        },
+    });
+    const labelmap = await _createAndCacheSegmentationSubVolumeForBoundingBox(subVolume, options);
+    await runGrowCut(subVolume.volumeId, labelmap.volumeId);
+    return labelmap;
+}
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/runOneClickGrowCut.js
+
+
+
+const { transformWorldToIndex: runOneClickGrowCut_transformWorldToIndex, transformIndexToWorld } = esm.utilities;
+const runOneClickGrowCut_POSITIVE_SEED_VALUE = 254;
+const runOneClickGrowCut_NEGATIVE_SEED_VALUE = 255;
+const runOneClickGrowCut_POSITIVE_SEED_VARIANCE = 0.1;
+const runOneClickGrowCut_NEGATIVE_SEED_VARIANCE = 0.8;
+const SUBVOLUME_PADDING_PERCENTAGE = 0.2;
+const SUBVOLUME_MIN_PADDING = 5;
+function _createSubVolume(referencedVolume, positiveRegionData, options) {
+    const { dimensions } = referencedVolume;
+    const positiveRegionSize = gl_matrix_esm/* vec3.sub */.eR.sub(gl_matrix_esm/* vec3.create */.eR.create(), positiveRegionData.boundingBox.bottomRight, positiveRegionData.boundingBox.topLeft);
+    let subVolumePaddingPercentage = options?.subVolumePaddingPercentage ?? SUBVOLUME_PADDING_PERCENTAGE;
+    let subVolumeMinPadding = options?.subVolumeMinPadding ?? SUBVOLUME_MIN_PADDING;
+    if (typeof subVolumePaddingPercentage === 'number') {
+        subVolumePaddingPercentage = [
+            subVolumePaddingPercentage,
+            subVolumePaddingPercentage,
+            subVolumePaddingPercentage,
+        ];
+    }
+    if (typeof subVolumeMinPadding === 'number') {
+        subVolumeMinPadding = [
+            subVolumeMinPadding,
+            subVolumeMinPadding,
+            subVolumeMinPadding,
+        ];
+    }
+    const padding = gl_matrix_esm/* vec3.mul */.eR.mul(gl_matrix_esm/* vec3.create */.eR.create(), positiveRegionSize, subVolumePaddingPercentage);
+    gl_matrix_esm/* vec3.round */.eR.round(padding, padding);
+    gl_matrix_esm/* vec3.max */.eR.max(padding, padding, subVolumeMinPadding);
+    const subVolumeSize = gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(gl_matrix_esm/* vec3.create */.eR.create(), positiveRegionSize, padding, 2);
+    const ijkTopLeft = gl_matrix_esm/* vec3.sub */.eR.sub(gl_matrix_esm/* vec3.create */.eR.create(), positiveRegionData.boundingBox.topLeft, padding);
+    const ijkBottomRight = gl_matrix_esm/* vec3.add */.eR.add(gl_matrix_esm/* vec3.create */.eR.create(), ijkTopLeft, subVolumeSize);
+    gl_matrix_esm/* vec3.max */.eR.max(ijkTopLeft, ijkTopLeft, [0, 0, 0]);
+    gl_matrix_esm/* vec3.min */.eR.min(ijkTopLeft, ijkTopLeft, dimensions);
+    gl_matrix_esm/* vec3.max */.eR.max(ijkBottomRight, ijkBottomRight, [0, 0, 0]);
+    gl_matrix_esm/* vec3.min */.eR.min(ijkBottomRight, ijkBottomRight, dimensions);
+    const subVolumeBoundsIJK = {
+        minX: ijkTopLeft[0],
+        maxX: ijkBottomRight[0],
+        minY: ijkTopLeft[1],
+        maxY: ijkBottomRight[1],
+        minZ: ijkTopLeft[2],
+        maxZ: ijkBottomRight[2],
+    };
+    return esm.utilities.createSubVolume(referencedVolume.volumeId, subVolumeBoundsIJK, {
+        targetBuffer: {
+            type: 'Float32Array',
+        },
+    });
+}
+function _getPositiveRegionData(referencedVolume, worldPosition, options) {
+    const [width, height, numSlices] = referencedVolume.dimensions;
+    const subVolPixelData = referencedVolume.voxelManager.getCompleteScalarDataArray();
+    const numPixelsPerSlice = width * height;
+    const ijkStartPosition = runOneClickGrowCut_transformWorldToIndex(referencedVolume.imageData, worldPosition);
+    const referencePixelValue = subVolPixelData[ijkStartPosition[2] * numPixelsPerSlice +
+        ijkStartPosition[1] * width +
+        ijkStartPosition[0]];
+    const positiveSeedVariance = options.positiveSeedVariance ?? runOneClickGrowCut_POSITIVE_SEED_VARIANCE;
+    const positiveSeedVarianceValue = Math.abs(referencePixelValue * positiveSeedVariance);
+    const minPositivePixelValue = referencePixelValue - positiveSeedVarianceValue;
+    const maxPositivePixelValue = referencePixelValue + positiveSeedVarianceValue;
+    const neighborsCoordDelta = [
+        [-1, 0, 0],
+        [1, 0, 0],
+        [0, -1, 0],
+        [0, 1, 0],
+        [0, 0, -1],
+        [0, 0, 1],
+    ];
+    let minX = Infinity;
+    let minY = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let maxZ = -Infinity;
+    const startVoxelIndex = ijkStartPosition[2] * numPixelsPerSlice +
+        ijkStartPosition[1] * width +
+        ijkStartPosition[0];
+    const voxelIndexesSet = new Set([startVoxelIndex]);
+    const worldVoxelSet = new Set([worldPosition]);
+    const queue = [ijkStartPosition];
+    while (queue.length) {
+        const ijkVoxel = queue.shift();
+        const [x, y, z] = ijkVoxel;
+        minX = ijkVoxel[0] < minX ? ijkVoxel[0] : minX;
+        minY = ijkVoxel[1] < minY ? ijkVoxel[1] : minY;
+        minZ = ijkVoxel[2] < minZ ? ijkVoxel[2] : minZ;
+        maxX = ijkVoxel[0] > maxX ? ijkVoxel[0] : maxX;
+        maxY = ijkVoxel[1] > maxY ? ijkVoxel[1] : maxY;
+        maxZ = ijkVoxel[2] > maxZ ? ijkVoxel[2] : maxZ;
+        for (let i = 0, len = neighborsCoordDelta.length; i < len; i++) {
+            const neighborCoordDelta = neighborsCoordDelta[i];
+            const nx = x + neighborCoordDelta[0];
+            const ny = y + neighborCoordDelta[1];
+            const nz = z + neighborCoordDelta[2];
+            if (nx < 0 ||
+                nx >= width ||
+                ny < 0 ||
+                ny >= height ||
+                nz < 0 ||
+                nz >= numSlices) {
+                continue;
+            }
+            const neighborVoxelIndex = nz * numPixelsPerSlice + ny * width + nx;
+            const neighborPixelValue = subVolPixelData[neighborVoxelIndex];
+            if (voxelIndexesSet.has(neighborVoxelIndex) ||
+                neighborPixelValue < minPositivePixelValue ||
+                neighborPixelValue > maxPositivePixelValue) {
+                continue;
+            }
+            const ijkVoxel = [nx, ny, nz];
+            const worldVoxel = transformIndexToWorld(referencedVolume.imageData, ijkVoxel);
+            voxelIndexesSet.add(neighborVoxelIndex);
+            worldVoxelSet.add(worldVoxel);
+            queue.push(ijkVoxel);
+        }
+    }
+    return {
+        worldVoxels: Array.from(worldVoxelSet),
+        boundingBox: {
+            topLeft: [minX, minY, minZ],
+            bottomRight: [maxX, maxY, maxZ],
+        },
+    };
+}
+function runOneClickGrowCut_setPositiveSeedValues(labelmap, positiveRegionData, options) {
+    const { dimensions } = labelmap;
+    const [width, height] = dimensions;
+    const numPixelsPerSlice = width * height;
+    const positiveSeedValue = options.positiveSeedValue ?? runOneClickGrowCut_POSITIVE_SEED_VALUE;
+    const { worldVoxels } = positiveRegionData;
+    for (let i = 0, len = worldVoxels.length; i < len; i++) {
+        const worldVoxel = worldVoxels[i];
+        const ijkVoxel = runOneClickGrowCut_transformWorldToIndex(labelmap.imageData, worldVoxel);
+        const voxelIndex = ijkVoxel[2] * numPixelsPerSlice + ijkVoxel[1] * width + ijkVoxel[0];
+        labelmap.voxelManager.setAtIndex(voxelIndex, positiveSeedValue);
+    }
+}
+function runOneClickGrowCut_setNegativeSeedValues(subVolume, labelmap, worldPosition, options) {
+    const [width, height] = subVolume.dimensions;
+    const subVolPixelData = subVolume.voxelManager.getCompleteScalarDataArray();
+    const labelmapData = labelmap.voxelManager.getCompleteScalarDataArray();
+    const ijkPosition = runOneClickGrowCut_transformWorldToIndex(subVolume.imageData, worldPosition);
+    const referencePixelValue = subVolPixelData[ijkPosition[2] * width * height + ijkPosition[1] * width + ijkPosition[0]];
+    const negativeSeedVariance = options.negativeSeedVariance ?? runOneClickGrowCut_NEGATIVE_SEED_VARIANCE;
+    const negativeSeedValue = options.negativeSeedValue ?? runOneClickGrowCut_NEGATIVE_SEED_VALUE;
+    const negativeSeedVarianceValue = Math.abs(referencePixelValue * negativeSeedVariance);
+    const minNegativePixelValue = referencePixelValue - negativeSeedVarianceValue;
+    const maxNegativePixelValue = referencePixelValue + negativeSeedVarianceValue;
+    for (let i = 0, len = subVolPixelData.length; i < len; i++) {
+        const pixelValue = subVolPixelData[i];
+        if (!labelmapData[i] &&
+            (pixelValue < minNegativePixelValue || pixelValue > maxNegativePixelValue)) {
+            labelmap.voxelManager.setAtIndex(i, negativeSeedValue);
+        }
+    }
+}
+async function _createAndCacheSegmentation(subVolume, positiveRegionData, worldPosition, options) {
+    const labelmap = esm.volumeLoader.createAndCacheDerivedLabelmapVolume(subVolume.volumeId);
+    runOneClickGrowCut_setPositiveSeedValues(labelmap, positiveRegionData, options);
+    runOneClickGrowCut_setNegativeSeedValues(subVolume, labelmap, worldPosition, options);
+    return labelmap;
+}
+async function runOneClickGrowCut(referencedVolumeId, worldPosition, viewport, options) {
+    const referencedVolume = esm.cache.getVolume(referencedVolumeId);
+    const positiveRegionData = _getPositiveRegionData(referencedVolume, worldPosition, options);
+    const subVolume = _createSubVolume(referencedVolume, positiveRegionData, options);
+    const labelmap = await _createAndCacheSegmentation(subVolume, positiveRegionData, worldPosition, options);
+    await runGrowCut(subVolume.volumeId, labelmap.volumeId);
+    return labelmap;
+}
+
+
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/growCut/index.js
+
+
+
+
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/createLabelmapMemo.js
+var createLabelmapMemo = __webpack_require__(2397);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/index.js
 
 
@@ -15268,6 +16971,9 @@ function getHoveredContourSegmentationAnnotation(segmentationId) {
 
 
 
+
+
+