@ohif/app 3.10.0-beta.13 → 3.10.0-beta.15

package/dist/{9909.bundle.a87c9d96eefff9b0961b.js → 3022.bundle.51a7056ea0e39b06e095.js}

@@ -1,4 +1,4 @@
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[9909],{
+(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);
 }
 
 
@@ -2157,23 +2193,6 @@ function getNextColorLUTIndex() {
 }
 
 
-/***/ }),
-
-/***/ 33283:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   T: () => (/* binding */ getSegmentation)
-/* harmony export */ });
-/* harmony import */ var _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(59475);
-
-function getSegmentation(segmentationId) {
-    const segmentationStateManager = _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_0__/* .defaultSegmentationStateManager */ ._6;
-    return segmentationStateManager.getSegmentation(segmentationId);
-}
-
-
 /***/ }),
 
 /***/ 21:
@@ -3067,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();
@@ -3179,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 });
         }
     }
@@ -3390,6 +3410,7 @@ function activateClosedContourEdit(evt, annotation, viewportIdsToRender) {
         editCanvasPoints: [canvasPos],
         startCrossingIndex: undefined,
         editIndex: 0,
+        annotation,
     };
     this.commonData = {
         annotation,
@@ -3424,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();
@@ -3481,6 +3503,7 @@ function finishEditAndStartNewEdit(evt) {
         startCrossingIndex: undefined,
         editIndex: 0,
         snapIndex: undefined,
+        annotation,
     };
     (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)(viewportIdsToRender);
 }
@@ -3566,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)
@@ -3669,6 +3693,7 @@ function activateDraw(evt, annotation, viewportIdsToRender) {
         canvasPoints: [canvasPos],
         polylineIndex: 0,
         contourHoleProcessingEnabled,
+        newAnnotation: true,
     };
     this.commonData = {
         annotation,
@@ -3703,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();
@@ -3745,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 });
@@ -4175,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 = {
@@ -4216,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));
@@ -4270,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);
 }
@@ -4420,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)
@@ -5484,6 +5516,12 @@ 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);
+
+
+
 
 
 
@@ -5491,6 +5529,8 @@ 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 = {
@@ -5663,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);
@@ -5684,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
@@ -5754,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);
@@ -5861,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
 
 
@@ -5894,10 +5975,6 @@ var internalGetHiddenSegmentIndices = __webpack_require__(47098);
 
 
 
-
-
-
-
 class ContourSegmentationBaseTool extends ContourBaseTool {
     constructor(toolProps, defaultToolProps) {
         super(toolProps, defaultToolProps);
@@ -5995,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,
@@ -6052,7 +6087,7 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
             textbox: {
                 color,
             },
-            visibility: segmentationVisible && isVisible,
+            visibility,
             locked: annotationLocked,
         };
     }
@@ -6060,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:
@@ -6322,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);
 }
@@ -6580,58 +6738,306 @@ 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__(96814);
-/* 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),
-        [_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) {
+
+
+
+
+
+
+
+
+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, segmentIndex, } = initializedData;
+        }
+    }
+    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) {
@@ -6652,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) => {
@@ -6764,13 +7177,25 @@ 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;
@@ -6778,6 +7203,7 @@ var StrategyCallbacks = __webpack_require__(84093);
         segmentationVoxelManager.forEach(callback, {
             imageData: segmentationImageData,
             isInObject: operationData.isInObject,
+            boundsIJK: nestedBounds,
         });
         if (!hasSegmentIndex && !hasPreviewIndex) {
             return;
@@ -6949,6 +7375,8 @@ var SegmentationEnum;
     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) => {
@@ -7131,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) {
@@ -7140,9 +7569,7 @@ function lightenColor(r, g, b, a, factor = 0.4) {
                 operationData.segmentationVoxelManager;
             operationData.previewVoxelManager = preview.previewVoxelManager;
         }
-        if (segmentIndex === undefined ||
-            segmentIndex === null ||
-            !previewSegmentIndex) {
+        if (segmentIndex === null) {
             return;
         }
         const configColor = previewColors?.[segmentIndex];
@@ -7154,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(), preview.segmentIndex);
-        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;
@@ -7216,7 +7646,8 @@ function lightenColor(r, g, b, a, factor = 0.4) {
 
 /* 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) {
@@ -7294,6 +7725,10 @@ var getStrategyData = __webpack_require__(40905);
             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) {
@@ -7365,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);
@@ -7496,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);
     });
@@ -7530,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;
@@ -7557,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;
+
 
 
 /***/ }),
@@ -7619,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,
@@ -7630,7 +8068,7 @@ 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, _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;
@@ -7650,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);
 
 
@@ -9831,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);
@@ -9840,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,
@@ -9856,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));
@@ -12600,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) {
@@ -14399,6 +14865,91 @@ class VolumetricCalculator extends _math_basic__WEBPACK_IMPORTED_MODULE_0__.Basi
 }
 
 
+/***/ }),
+
+/***/ 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:
@@ -14562,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";
@@ -14571,6 +15208,7 @@ __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),
@@ -14584,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),
@@ -14595,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
@@ -14786,7 +15435,7 @@ async function createLabelmapVolumeForViewport(input) {
     }
     else {
         const volumeId = viewport.getVolumeId();
-        await esm.volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId, {
+        esm.volumeLoader.createAndCacheDerivedLabelmapVolume(volumeId, {
             volumeId: segmentationId,
         });
     }
@@ -15280,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
@@ -15459,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
 
 
@@ -15479,6 +16973,8 @@ function getHoveredContourSegmentationAnnotation(segmentationId) {
 
 
 
+
+