@ohif/app 3.11.0-beta.99 → 3.12.0-beta.0

package/dist/{2011.bundle.c44c0094525a51b528f4.js → 2011.bundle.12539f6bbbfc20a372e9.js}

@@ -386,6 +386,8 @@ class SegmentLabelTool extends _base__WEBPACK_IMPORTED_MODULE_2__/* .BaseTool */
         configuration: {
             hoverTimeout: 100,
             searchRadius: 6,
+            color: null,
+            background: null,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -450,7 +452,8 @@ class SegmentLabelTool extends _base__WEBPACK_IMPORTED_MODULE_2__/* .BaseTool */
             viewport,
         });
         const segment = activeSegmentation.segments[hoveredSegmentIndex];
-        const color = _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_1__.config.color.getSegmentIndexColor(viewport.id, segmentationId, hoveredSegmentIndex);
+        const color = this.configuration.color ??
+            _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_1__.config.color.getSegmentIndexColor(viewport.id, segmentationId, hoveredSegmentIndex);
         const label = segment?.label;
         const canvasCoordinates = viewport.worldToCanvas(worldPoint);
         this._editData = {
@@ -483,6 +486,7 @@ class SegmentLabelTool extends _base__WEBPACK_IMPORTED_MODULE_2__/* .BaseTool */
         ];
         const boundingBox = (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_8__.drawTextBox)(svgDrawingHelper, 'segmentSelectLabelAnnotation', 'segmentSelectLabelTextBox', [hoveredSegmentLabel ?? '(unnamed segment)'], textBoxPosition, {
             color: `rgba(${color[0]}, ${color[1]}, ${color[2]}, ${color[3]})`,
+            background: this.configuration.background ?? undefined,
         });
         const left = canvasCoordinates[0];
         const top = canvasCoordinates[1];
@@ -2658,6 +2662,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   UltrasoundDirectionalTool: () => (/* reexport safe */ _tools__WEBPACK_IMPORTED_MODULE_13__.oi),
 /* harmony export */   UltrasoundPleuraBLineTool: () => (/* reexport safe */ _tools__WEBPACK_IMPORTED_MODULE_13__.T8),
 /* harmony export */   VideoRedactionTool: () => (/* reexport safe */ _tools_annotation_VideoRedactionTool__WEBPACK_IMPORTED_MODULE_14__.A),
+/* harmony export */   VolumeCroppingControlTool: () => (/* reexport safe */ _tools__WEBPACK_IMPORTED_MODULE_13__.Eb),
+/* harmony export */   VolumeCroppingTool: () => (/* reexport safe */ _tools__WEBPACK_IMPORTED_MODULE_13__.NF),
 /* harmony export */   VolumeRotateTool: () => (/* reexport safe */ _tools__WEBPACK_IMPORTED_MODULE_13__.Oh),
 /* harmony export */   WholeBodySegmentTool: () => (/* reexport safe */ _tools__WEBPACK_IMPORTED_MODULE_13__.Tc),
 /* harmony export */   WindowLevelRegionTool: () => (/* reexport safe */ _tools__WEBPACK_IMPORTED_MODULE_13__.TG),
@@ -3027,7 +3033,7 @@ class Colorbar extends _widgets_Widget__WEBPACK_IMPORTED_MODULE_7__/* ["default"
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   r: () => (/* binding */ version)
 /* harmony export */ });
-const version = '3.30.3';
+const version = '3.32.5';
 
 
 /***/ }),
@@ -6029,15 +6035,9 @@ function slabThicknessSyncCallback(_synchronizerInstance, sourceViewport, target
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3823);
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15327);
 /* 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__(11990);
-
-
-
+/* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(55887);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(99737);
+/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(11990);
 
 
 
@@ -6046,8 +6046,8 @@ function slabThicknessSyncCallback(_synchronizerInstance, sourceViewport, target
 
 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;
+    [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize]: (operationData) => {
+        const { points, viewport, segmentationImageData, } = operationData;
         if (!points) {
             return;
         }
@@ -6073,8 +6073,18 @@ function createPointInRectangle(viewport, points, segmentationImageData) {
         });
     });
     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 [p0, p1, p2, p3] = points;
+    const axisU = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    const axisV = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(axisU, p1, p0);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(axisV, p3, p0);
+    const uLen = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.length */ .eR.length(axisU);
+    const vLen = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.length */ .eR.length(axisV);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(axisU, axisU);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(axisV, axisV);
+    const normal = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .eR.cross(normal, axisU, axisV);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(normal, normal);
     const direction = segmentationImageData.getDirection();
     const spacing = segmentationImageData.getSpacing();
     const { viewPlaneNormal } = viewport.getCamera();
@@ -6082,27 +6092,22 @@ function createPointInRectangle(viewport, points, segmentationImageData) {
         direction,
         spacing,
     }, viewPlaneNormal);
-    const pointsBoundsLPS = (0,_utilities_boundingBox__WEBPACK_IMPORTED_MODULE_2__.getBoundingBoxAroundShapeWorld)(points);
-    let [[xMin, xMax], [yMin, yMax], [zMin, zMax]] = pointsBoundsLPS;
-    xMin -= EPS;
-    xMax += EPS;
-    yMin -= EPS;
-    yMax += EPS;
-    zMin -= EPS;
-    zMax += EPS;
-    const pointInShapeFn = isAligned
-        ? () => true
-        : (pointLPS) => {
-            const [x, y, z] = pointLPS;
-            const xInside = x >= xMin && x <= xMax;
-            const yInside = y >= yMin && y <= yMax;
-            const zInside = z >= zMin && z <= zMax;
-            return xInside && yInside && zInside;
-        };
+    const pointInShapeFn = (pointLPS) => {
+        const v = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(v, pointLPS, p0);
+        const u = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(v, axisU);
+        const vproj = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(v, axisV);
+        const d = Math.abs(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(v, normal));
+        return (u >= -EPS &&
+            u <= uLen + EPS &&
+            vproj >= -EPS &&
+            vproj <= vLen + EPS &&
+            d <= EPS);
+    };
     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 RECTANGLE_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A('Rectangle', _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.setValue, initializeRectangle, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.preview, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.labelmapStatistics);
+const RECTANGLE_THRESHOLD_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A('RectangleThreshold', _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.setValue, initializeRectangle, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.dynamicThreshold, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.threshold, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.preview, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.islandRemoval, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.labelmapStatistics);
 const fillInsideRectangle = RECTANGLE_STRATEGY.strategyFunction;
 const thresholdInsideRectangle = RECTANGLE_THRESHOLD_STRATEGY.strategyFunction;
 
@@ -6890,7 +6895,7 @@ class VideoRedactionTool extends _base__WEBPACK_IMPORTED_MODULE_2__/* .Annotatio
         data.handles.activeHandleIndex = null;
         (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_11__/* ["default"] */ .A)(viewportUIDsToRender);
         this.editData = null;
-        return annotation.metadata.annotationUID;
+        return annotation.annotationUID;
     }
     _getImageVolumeFromTargetUID(targetUID, renderingEngine) {
         let imageVolume, viewport;
@@ -7855,7 +7860,6 @@ const OPERATION = {
     ROTATE: 2,
     SLAB: 3,
 };
-const EPSILON = 1e-3;
 class CrosshairsTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .AnnotationTool */ .EC {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse'],
@@ -8875,7 +8879,7 @@ class CrosshairsTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .AnnotationToo
                         ];
                         const viewportDraggableRotatable = this._getReferenceLineDraggableRotatable(otherViewport.id);
                         if (!viewportDraggableRotatable) {
-                            const { rotationPoints } = this.editData.annotation.data.handles;
+                            const { rotationPoints } = (this.editData.annotation.data).handles;
                             const otherViewportRotationPoints = rotationPoints.filter((point) => point[1].uid === otherViewport.id);
                             if (otherViewportRotationPoints.length === 2) {
                                 const point1 = viewport.canvasToWorld(otherViewportRotationPoints[0][3]);
@@ -14855,6 +14859,41 @@ function _drawTextBackground(group, color) {
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (drawTextBox);
 
 
+/***/ }),
+
+/***/ 26384:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   l: () => (/* binding */ isAxisAlignedRectangle)
+/* harmony export */ });
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3823);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15327);
+
+
+const { isEqual } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities;
+const iAxis = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(1, 0, 0);
+const jAxis = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(0, 1, 0);
+const kAxis = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.fromValues */ .eR.fromValues(0, 0, 1);
+const axisList = [iAxis, jAxis, kAxis];
+function isAxisAlignedRectangle(rectangleCornersIJK) {
+    const rectangleVec1 = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), rectangleCornersIJK[0], rectangleCornersIJK[1]);
+    const rectangleVec2 = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create(), rectangleCornersIJK[0], rectangleCornersIJK[2]);
+    const anglesVec1 = calculateAnglesWithAxes(rectangleVec1, axisList);
+    const anglesVec2 = calculateAnglesWithAxes(rectangleVec2, axisList);
+    const isAligned = [...anglesVec1, ...anglesVec2].every((angle) => isEqual(angle, 0) ||
+        isEqual(angle, 90) ||
+        isEqual(angle, 180) ||
+        isEqual(angle, 270));
+    return isAligned;
+}
+function calculateAnglesWithAxes(vec, axes) {
+    return axes.map((axis) => (gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.angle */ .eR.angle(vec, axis) * 180) / Math.PI);
+}
+
+
+
 /***/ }),
 
 /***/ 26795:
@@ -16879,7 +16918,7 @@ function createPresentationViewSynchronizer(synchronizerName, options) {
 /* harmony import */ var _utilities_getPixelValueUnits__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(40634);
 /* harmony import */ var _utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(18990);
 /* harmony import */ var _utilities_math_circle__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(77081);
-/* harmony import */ var _utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(11683);
+/* harmony import */ var _utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(87009);
 /* harmony import */ var _utilities_math_basic__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(73262);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(3823);
 
@@ -17925,7 +17964,7 @@ class SegmentationIntersectionTool extends _base_AnnotationDisplayTool__WEBPACK_
             }
             const annotation = annotations[0];
             const { annotationUID } = annotation;
-            const actorsWorldPointsMap = annotation.data.actorsWorldPointsMap;
+            const actorsWorldPointsMap = (annotation).data.actorsWorldPointsMap;
             calculateSurfaceSegmentationIntersectionsForViewport(actorsWorldPointsMap, viewport);
             const actorEntries = viewport.getActors();
             const cacheId = getCacheId(viewport);
@@ -18843,6 +18882,1240 @@ const createStackImageSynchronizer = _synchronizers_createImageSliceSynchronizer
 
 
 
+/***/ }),
+
+/***/ 35300:
+/***/ ((__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 gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3823);
+/* harmony import */ var _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(84607);
+/* harmony import */ var _base__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(85817);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(15327);
+/* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(77609);
+/* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(82056);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(74347);
+/* harmony import */ var _store_state__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(85204);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(99737);
+/* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(60810);
+/* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(7001);
+/* harmony import */ var _utilities_math_vec2_liangBarksyClip__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(35381);
+/* harmony import */ var _utilities_math_line__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(93258);
+/* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(2076);
+/* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(58640);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const { RENDERING_DEFAULTS } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.CONSTANTS;
+function defaultReferenceLineColor() {
+    return 'rgb(0, 200, 0)';
+}
+function defaultReferenceLineControllable() {
+    return true;
+}
+const OPERATION = {
+    DRAG: 1,
+    ROTATE: 2,
+    SLAB: 3,
+};
+class VolumeCroppingControlTool extends _base__WEBPACK_IMPORTED_MODULE_2__/* .AnnotationTool */ .EC {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse'],
+        configuration: {
+            viewportIndicators: false,
+            viewportIndicatorsConfig: {
+                radius: 5,
+                x: null,
+                y: null,
+            },
+            extendReferenceLines: true,
+            initialCropFactor: 0.2,
+            mobile: {
+                enabled: false,
+                opacity: 0.8,
+            },
+            lineColors: {
+                AXIAL: [1.0, 0.0, 0.0],
+                CORONAL: [0.0, 1.0, 0.0],
+                SAGITTAL: [1.0, 1.0, 0.0],
+                UNKNOWN: [0.0, 0.0, 1.0],
+            },
+            lineWidth: 1.5,
+            lineWidthActive: 2.5,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this._virtualAnnotations = [];
+        this.sphereStates = [];
+        this.draggingSphereIndex = null;
+        this.toolCenter = [0, 0, 0];
+        this.toolCenterMin = [0, 0, 0];
+        this.toolCenterMax = [0, 0, 0];
+        this.initializeViewport = ({ renderingEngineId, viewportId, }) => {
+            if (!renderingEngineId || !viewportId) {
+                console.warn('VolumeCroppingControlTool: Missing renderingEngineId or viewportId');
+                return;
+            }
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getEnabledElementByIds)(viewportId, renderingEngineId);
+            if (!enabledElement) {
+                return;
+            }
+            const { viewport } = enabledElement;
+            this._updateToolCentersFromViewport(viewport);
+            const { element } = viewport;
+            const { position, focalPoint, viewPlaneNormal } = viewport.getCamera();
+            let annotations = this._getAnnotations(enabledElement);
+            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            if (annotations?.length) {
+                (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.removeAnnotation)(annotations[0].annotationUID);
+            }
+            const orientation = this._getOrientationFromNormal(viewport.getCamera().viewPlaneNormal);
+            const annotation = {
+                highlighted: false,
+                metadata: {
+                    cameraPosition: [...position],
+                    cameraFocalPoint: [...focalPoint],
+                    toolName: this.getToolName(),
+                },
+                data: {
+                    handles: {
+                        toolCenter: this.toolCenter,
+                        toolCenterMin: this.toolCenterMin,
+                        toolCenterMax: this.toolCenterMax,
+                    },
+                    activeOperation: null,
+                    activeViewportIds: [],
+                    viewportId,
+                    referenceLines: [],
+                    orientation,
+                },
+            };
+            (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.addAnnotation)(annotation, element);
+            return {
+                normal: viewPlaneNormal,
+                point: viewport.canvasToWorld([100, 100]),
+            };
+        };
+        this._getViewportsInfo = () => {
+            const viewports = (0,_store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_4__.getToolGroup)(this.toolGroupId).viewportsInfo;
+            return viewports;
+        };
+        this.resetCroppingSpheres = () => {
+            const viewportsInfo = this._getViewportsInfo();
+            for (const viewportInfo of viewportsInfo) {
+                const { viewportId, renderingEngineId } = viewportInfo;
+                const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getEnabledElementByIds)(viewportId, renderingEngineId);
+                const viewport = enabledElement.viewport;
+                const resetPan = true;
+                const resetZoom = true;
+                const resetToCenter = true;
+                const resetRotation = true;
+                const suppressEvents = true;
+                viewport.resetCamera({
+                    resetPan,
+                    resetZoom,
+                    resetToCenter,
+                    resetRotation,
+                    suppressEvents,
+                });
+                viewport.resetSlabThickness();
+                const { element } = viewport;
+                let annotations = this._getAnnotations(enabledElement);
+                annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+                if (annotations.length) {
+                    (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.removeAnnotation)(annotations[0].annotationUID);
+                }
+                viewport.render();
+            }
+            this._computeToolCenter(viewportsInfo);
+        };
+        this.computeToolCenter = () => {
+            const viewportsInfo = this._getViewportsInfo();
+        };
+        this._computeToolCenter = (viewportsInfo) => {
+            if (!viewportsInfo || !viewportsInfo[0]) {
+                console.warn('  _computeToolCenter : No valid viewportsInfo for computeToolCenter.');
+                return;
+            }
+            const orientationIds = ['AXIAL', 'CORONAL', 'SAGITTAL'];
+            const presentOrientations = viewportsInfo
+                .map((vp) => {
+                if (vp.renderingEngineId) {
+                    const renderingEngine = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getRenderingEngine)(vp.renderingEngineId);
+                    const viewport = renderingEngine.getViewport(vp.viewportId);
+                    if (viewport && viewport.getCamera) {
+                        const orientation = this._getOrientationFromNormal(viewport.getCamera().viewPlaneNormal);
+                        if (orientation) {
+                            return orientation;
+                        }
+                    }
+                }
+                return null;
+            })
+                .filter(Boolean);
+            const missingOrientation = orientationIds.find((id) => !presentOrientations.includes(id));
+            const presentNormals = [];
+            const presentCenters = [];
+            const presentViewportInfos = viewportsInfo.filter((vp) => {
+                let orientation = null;
+                if (vp.renderingEngineId) {
+                    const renderingEngine = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getRenderingEngine)(vp.renderingEngineId);
+                    const viewport = renderingEngine.getViewport(vp.viewportId);
+                    if (viewport && viewport.getCamera) {
+                        orientation = this._getOrientationFromNormal(viewport.getCamera().viewPlaneNormal);
+                    }
+                }
+                return orientation && orientationIds.includes(orientation);
+            });
+            presentViewportInfos.forEach((vpInfo) => {
+                const { normal, point } = this.initializeViewport(vpInfo);
+                presentNormals.push(normal);
+                presentCenters.push(point);
+            });
+            if (presentViewportInfos.length === 2 && missingOrientation) {
+                const virtualNormal = [0, 0, 0];
+                gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .eR.cross(virtualNormal, presentNormals[0], presentNormals[1]);
+                gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(virtualNormal, virtualNormal);
+                const virtualCenter = [
+                    (presentCenters[0][0] + presentCenters[1][0]) / 2,
+                    (presentCenters[0][1] + presentCenters[1][1]) / 2,
+                    (presentCenters[0][2] + presentCenters[1][2]) / 2,
+                ];
+                const orientation = null;
+                const virtualAnnotation = {
+                    highlighted: false,
+                    metadata: {
+                        cameraPosition: [...virtualCenter],
+                        cameraFocalPoint: [...virtualCenter],
+                        toolName: this.getToolName(),
+                    },
+                    data: {
+                        handles: {
+                            activeOperation: null,
+                            toolCenter: this.toolCenter,
+                            toolCenterMin: this.toolCenterMin,
+                            toolCenterMax: this.toolCenterMax,
+                        },
+                        activeViewportIds: [],
+                        viewportId: missingOrientation,
+                        referenceLines: [],
+                        orientation,
+                    },
+                    isVirtual: true,
+                    virtualNormal,
+                };
+                this._virtualAnnotations = [virtualAnnotation];
+            }
+            else if (presentViewportInfos.length === 1) {
+                let presentOrientation = null;
+                const vpInfo = presentViewportInfos[0];
+                if (vpInfo.renderingEngineId) {
+                    const renderingEngine = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getRenderingEngine)(vpInfo.renderingEngineId);
+                    const viewport = renderingEngine.getViewport(vpInfo.viewportId);
+                    if (viewport && viewport.getCamera) {
+                        presentOrientation = this._getOrientationFromNormal(viewport.getCamera().viewPlaneNormal);
+                    }
+                }
+                const presentCenter = presentCenters[0];
+                const canonicalNormals = {
+                    AXIAL: [0, 0, 1],
+                    CORONAL: [0, 1, 0],
+                    SAGITTAL: [1, 0, 0],
+                };
+                const missingIds = orientationIds.filter((id) => id !== presentOrientation);
+                const virtualAnnotations = missingIds.map((orientation) => {
+                    const normal = canonicalNormals[orientation];
+                    const virtualAnnotation = {
+                        highlighted: false,
+                        metadata: {
+                            cameraPosition: [...presentCenter],
+                            cameraFocalPoint: [...presentCenter],
+                            toolName: this.getToolName(),
+                        },
+                        data: {
+                            handles: {
+                                activeOperation: null,
+                                toolCenter: this.toolCenter,
+                                toolCenterMin: this.toolCenterMin,
+                                toolCenterMax: this.toolCenterMax,
+                            },
+                            activeViewportIds: [],
+                            viewportId: orientation,
+                            referenceLines: [],
+                            orientation,
+                        },
+                        isVirtual: true,
+                        virtualNormal: normal,
+                    };
+                    return virtualAnnotation;
+                });
+                this._virtualAnnotations = virtualAnnotations;
+            }
+            if (viewportsInfo && viewportsInfo.length) {
+                (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_14__/* ["default"] */ .A)(viewportsInfo.map(({ viewportId }) => viewportId));
+            }
+        };
+        this.cancel = () => {
+            console.log('Not implemented yet');
+        };
+        this.isPointNearTool = (element, annotation, canvasCoords, proximity) => {
+            if (this._pointNearTool(element, annotation, canvasCoords, 6)) {
+                return true;
+            }
+            return false;
+        };
+        this.toolSelectedCallback = (evt, annotation, interactionType) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            annotation.highlighted = true;
+            this._activateModify(element);
+            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_10__.hideElementCursor)(element);
+            evt.preventDefault();
+        };
+        this.onResetCamera = (evt) => {
+            this.resetCroppingSpheres();
+        };
+        this.mouseMoveCallback = (evt, filteredToolAnnotations) => {
+            if (!filteredToolAnnotations) {
+                return;
+            }
+            const { element, currentPoints } = evt.detail;
+            const canvasCoords = currentPoints.canvas;
+            let imageNeedsUpdate = false;
+            for (let i = 0; i < filteredToolAnnotations.length; i++) {
+                const annotation = filteredToolAnnotations[i];
+                if ((0,_stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_13__.isAnnotationLocked)(annotation.annotationUID)) {
+                    continue;
+                }
+                const { data, highlighted } = annotation;
+                if (!data.handles) {
+                    continue;
+                }
+                const previousActiveOperation = data.handles.activeOperation;
+                const previousActiveViewportIds = data.activeViewportIds && data.activeViewportIds.length > 0
+                    ? [...data.activeViewportIds]
+                    : [];
+                data.activeViewportIds = [];
+                let near = false;
+                near = this._pointNearTool(element, annotation, canvasCoords, 6);
+                const nearToolAndNotMarkedActive = near && !highlighted;
+                const notNearToolAndMarkedActive = !near && highlighted;
+                if (nearToolAndNotMarkedActive || notNearToolAndMarkedActive) {
+                    annotation.highlighted = !highlighted;
+                    imageNeedsUpdate = true;
+                }
+            }
+            return imageNeedsUpdate;
+        };
+        this.filterInteractableAnnotationsForElement = (element, annotations) => {
+            if (!annotations || !annotations.length) {
+                return [];
+            }
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getEnabledElement)(element);
+            let orientation = null;
+            if (enabledElement.viewport && enabledElement.viewport.getCamera) {
+                orientation = this._getOrientationFromNormal(enabledElement.viewport.getCamera().viewPlaneNormal);
+            }
+            const filtered = annotations.filter((annotation) => {
+                if (annotation.isVirtual) {
+                    return true;
+                }
+                if (annotation.data.orientation &&
+                    orientation &&
+                    annotation.data.orientation === orientation) {
+                    return true;
+                }
+                return false;
+            });
+            return filtered;
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            function lineIntersection2D(p1, p2, q1, q2) {
+                const s1_x = p2[0] - p1[0];
+                const s1_y = p2[1] - p1[1];
+                const s2_x = q2[0] - q1[0];
+                const s2_y = q2[1] - q1[1];
+                const denom = -s2_x * s1_y + s1_x * s2_y;
+                if (Math.abs(denom) < 1e-8) {
+                    return null;
+                }
+                const s = (-s1_y * (p1[0] - q1[0]) + s1_x * (p1[1] - q1[1])) / denom;
+                const t = (s2_x * (p1[1] - q1[1]) - s2_y * (p1[0] - q1[0])) / denom;
+                if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
+                    return [p1[0] + t * s1_x, p1[1] + t * s1_y];
+                }
+                return null;
+            }
+            const viewportsInfo = this._getViewportsInfo();
+            if (!viewportsInfo || viewportsInfo.length === 0) {
+                return false;
+            }
+            let renderStatus = false;
+            const { viewport, renderingEngine } = enabledElement;
+            const { element } = viewport;
+            let annotations = this._getAnnotations(enabledElement);
+            if (this._virtualAnnotations && this._virtualAnnotations.length) {
+                annotations = annotations.concat(this._virtualAnnotations);
+            }
+            const camera = viewport.getCamera();
+            const filteredToolAnnotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            const viewportAnnotation = filteredToolAnnotations[0];
+            if (!viewportAnnotation || !viewportAnnotation.data) {
+                return renderStatus;
+            }
+            const annotationUID = viewportAnnotation.annotationUID;
+            const { clientWidth, clientHeight } = viewport.canvas;
+            const canvasDiagonalLength = Math.sqrt(clientWidth * clientWidth + clientHeight * clientHeight);
+            const data = viewportAnnotation.data;
+            const otherViewportAnnotations = annotations;
+            const volumeCroppingCenterCanvasMin = viewport.worldToCanvas(this.toolCenterMin);
+            const volumeCroppingCenterCanvasMax = viewport.worldToCanvas(this.toolCenterMax);
+            const referenceLines = [];
+            const canvasBox = [0, 0, clientWidth, clientHeight];
+            otherViewportAnnotations.forEach((annotation) => {
+                const data = annotation.data;
+                const isVirtual = 'isVirtual' in annotation &&
+                    annotation.isVirtual === true;
+                data.handles.toolCenter = this.toolCenter;
+                let otherViewport, otherCamera, clientWidth, clientHeight, otherCanvasDiagonalLength, otherCanvasCenter, otherViewportCenterWorld;
+                if (isVirtual) {
+                    const realViewports = viewportsInfo.filter((vp) => vp.viewportId !== data.viewportId);
+                    if (realViewports.length === 2) {
+                        const vp1 = renderingEngine.getViewport(realViewports[0].viewportId);
+                        const vp2 = renderingEngine.getViewport(realViewports[1].viewportId);
+                        const normal1 = vp1.getCamera().viewPlaneNormal;
+                        const normal2 = vp2.getCamera().viewPlaneNormal;
+                        const virtualNormal = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+                        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .eR.cross(virtualNormal, normal1, normal2);
+                        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(virtualNormal, virtualNormal);
+                        otherCamera = {
+                            viewPlaneNormal: virtualNormal,
+                            position: data.handles.toolCenter,
+                            focalPoint: data.handles.toolCenter,
+                            viewUp: [0, 1, 0],
+                        };
+                        clientWidth = viewport.canvas.clientWidth;
+                        clientHeight = viewport.canvas.clientHeight;
+                        otherCanvasDiagonalLength = Math.sqrt(clientWidth * clientWidth + clientHeight * clientHeight);
+                        otherCanvasCenter = [clientWidth * 0.5, clientHeight * 0.5];
+                        otherViewportCenterWorld = data.handles.toolCenter;
+                        otherViewport = {
+                            id: data.viewportId,
+                            canvas: viewport.canvas,
+                            canvasToWorld: () => data.handles.toolCenter,
+                        };
+                    }
+                    else {
+                        const virtualNormal = annotation
+                            .virtualNormal ?? [0, 0, 1];
+                        otherCamera = {
+                            viewPlaneNormal: virtualNormal,
+                            position: data.handles.toolCenter,
+                            focalPoint: data.handles.toolCenter,
+                            viewUp: [0, 1, 0],
+                        };
+                        clientWidth = viewport.canvas.clientWidth;
+                        clientHeight = viewport.canvas.clientHeight;
+                        otherCanvasDiagonalLength = Math.sqrt(clientWidth * clientWidth + clientHeight * clientHeight);
+                        otherCanvasCenter = [clientWidth * 0.5, clientHeight * 0.5];
+                        otherViewportCenterWorld = data.handles.toolCenter;
+                        otherViewport = {
+                            id: data.viewportId,
+                            canvas: viewport.canvas,
+                            canvasToWorld: () => data.handles.toolCenter,
+                        };
+                    }
+                }
+                else {
+                    otherViewport = renderingEngine.getViewport(data.viewportId);
+                    otherCamera = otherViewport.getCamera();
+                    clientWidth = otherViewport.canvas.clientWidth;
+                    clientHeight = otherViewport.canvas.clientHeight;
+                    otherCanvasDiagonalLength = Math.sqrt(clientWidth * clientWidth + clientHeight * clientHeight);
+                    otherCanvasCenter = [clientWidth * 0.5, clientHeight * 0.5];
+                    otherViewportCenterWorld =
+                        otherViewport.canvasToWorld(otherCanvasCenter);
+                }
+                const otherViewportControllable = this._getReferenceLineControllable(otherViewport.id);
+                const direction = [0, 0, 0];
+                _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_1__/* ["default"].cross */ .Ay.cross(camera.viewPlaneNormal, otherCamera.viewPlaneNormal, direction);
+                _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_1__/* ["default"].normalize */ .Ay.normalize(direction);
+                _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_1__/* ["default"].multiplyScalar */ .Ay.multiplyScalar(direction, otherCanvasDiagonalLength);
+                const pointWorld0 = [0, 0, 0];
+                _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_1__/* ["default"].add */ .Ay.add(otherViewportCenterWorld, direction, pointWorld0);
+                const pointWorld1 = [0, 0, 0];
+                _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_1__/* ["default"].subtract */ .Ay.subtract(otherViewportCenterWorld, direction, pointWorld1);
+                const pointCanvas0 = viewport.worldToCanvas(pointWorld0);
+                const otherViewportCenterCanvas = viewport.worldToCanvas([
+                    otherViewportCenterWorld[0] ?? 0,
+                    otherViewportCenterWorld[1] ?? 0,
+                    otherViewportCenterWorld[2] ?? 0,
+                ]);
+                const canvasUnitVectorFromCenter = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create();
+                gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.subtract */ .Zc.subtract(canvasUnitVectorFromCenter, pointCanvas0, otherViewportCenterCanvas);
+                gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.normalize */ .Zc.normalize(canvasUnitVectorFromCenter, canvasUnitVectorFromCenter);
+                const canvasVectorFromCenterLong = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create();
+                gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.scale */ .Zc.scale(canvasVectorFromCenterLong, canvasUnitVectorFromCenter, canvasDiagonalLength * 100);
+                const refLinesCenterMin = otherViewportControllable
+                    ? gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.clone */ .Zc.clone(volumeCroppingCenterCanvasMin)
+                    : gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.clone */ .Zc.clone(otherViewportCenterCanvas);
+                const refLinePointMinOne = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create();
+                const refLinePointMinTwo = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create();
+                gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.add */ .Zc.add(refLinePointMinOne, refLinesCenterMin, canvasVectorFromCenterLong);
+                gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.subtract */ .Zc.subtract(refLinePointMinTwo, refLinesCenterMin, canvasVectorFromCenterLong);
+                (0,_utilities_math_vec2_liangBarksyClip__WEBPACK_IMPORTED_MODULE_11__/* ["default"] */ .A)(refLinePointMinOne, refLinePointMinTwo, canvasBox);
+                referenceLines.push([
+                    otherViewport,
+                    refLinePointMinOne,
+                    refLinePointMinTwo,
+                    'min',
+                ]);
+                const refLinesCenterMax = otherViewportControllable
+                    ? gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.clone */ .Zc.clone(volumeCroppingCenterCanvasMax)
+                    : gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.clone */ .Zc.clone(otherViewportCenterCanvas);
+                const refLinePointMaxOne = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create();
+                const refLinePointMaxTwo = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.create */ .Zc.create();
+                gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.add */ .Zc.add(refLinePointMaxOne, refLinesCenterMax, canvasVectorFromCenterLong);
+                gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.subtract */ .Zc.subtract(refLinePointMaxTwo, refLinesCenterMax, canvasVectorFromCenterLong);
+                (0,_utilities_math_vec2_liangBarksyClip__WEBPACK_IMPORTED_MODULE_11__/* ["default"] */ .A)(refLinePointMaxOne, refLinePointMaxTwo, canvasBox);
+                referenceLines.push([
+                    otherViewport,
+                    refLinePointMaxOne,
+                    refLinePointMaxTwo,
+                    'max',
+                ]);
+            });
+            data.referenceLines = referenceLines;
+            const viewportColor = this._getReferenceLineColor(viewport.id);
+            const color = viewportColor !== undefined ? viewportColor : 'rgb(200, 200, 200)';
+            referenceLines.forEach((line, lineIndex) => {
+                const intersections = [];
+                for (let j = 0; j < referenceLines.length; ++j) {
+                    if (j === lineIndex) {
+                        continue;
+                    }
+                    const otherLine = referenceLines[j];
+                    const intersection = lineIntersection2D(line[1], line[2], otherLine[1], otherLine[2]);
+                    if (intersection) {
+                        intersections.push({
+                            with: otherLine[3],
+                            point: intersection,
+                        });
+                    }
+                }
+                const otherViewport = line[0];
+                let orientation = null;
+                if (otherViewport && otherViewport.id) {
+                    const annotationForViewport = annotations.find((a) => a.data.viewportId === otherViewport.id);
+                    if (annotationForViewport && annotationForViewport.data.orientation) {
+                        orientation = String(annotationForViewport.data.orientation).toUpperCase();
+                    }
+                    else {
+                        const idUpper = otherViewport.id.toUpperCase();
+                        if (idUpper.includes('AXIAL')) {
+                            orientation = 'AXIAL';
+                        }
+                        else if (idUpper.includes('CORONAL')) {
+                            orientation = 'CORONAL';
+                        }
+                        else if (idUpper.includes('SAGITTAL')) {
+                            orientation = 'SAGITTAL';
+                        }
+                    }
+                }
+                const lineColors = this.configuration.lineColors || {};
+                const colorArr = lineColors[orientation] ||
+                    lineColors.unknown || [1.0, 0.0, 0.0];
+                const color = Array.isArray(colorArr)
+                    ? `rgb(${colorArr.map((v) => Math.round(v * 255)).join(',')})`
+                    : colorArr;
+                const viewportControllable = this._getReferenceLineControllable(otherViewport.id);
+                const selectedViewportId = data.activeViewportIds.find((id) => id === otherViewport.id);
+                let lineWidth = this.configuration.lineWidth ?? 1.5;
+                const lineActive = data.handles.activeOperation !== null &&
+                    data.handles.activeOperation === OPERATION.DRAG &&
+                    selectedViewportId;
+                if (lineActive) {
+                    lineWidth = this.configuration.activeLineWidth ?? 2.5;
+                }
+                const lineUID = `${lineIndex}`;
+                if (viewportControllable) {
+                    if (intersections.length === 2) {
+                        (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_6__.drawLine)(svgDrawingHelper, annotationUID, lineUID, intersections[0].point, intersections[1].point, {
+                            color,
+                            lineWidth,
+                        });
+                    }
+                    if (this.configuration.extendReferenceLines &&
+                        intersections.length === 2) {
+                        if (this.configuration.extendReferenceLines &&
+                            intersections.length === 2) {
+                            const sortedIntersections = intersections
+                                .map((intersection) => ({
+                                ...intersection,
+                                distance: gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec2.distance */ .Zc.distance(line[1], intersection.point),
+                            }))
+                                .sort((a, b) => a.distance - b.distance);
+                            (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_6__.drawLine)(svgDrawingHelper, annotationUID, lineUID + '_dashed_before', line[1], sortedIntersections[0].point, { color, lineWidth, lineDash: [4, 4] });
+                            (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_6__.drawLine)(svgDrawingHelper, annotationUID, lineUID + '_dashed_after', sortedIntersections[1].point, line[2], { color, lineWidth, lineDash: [4, 4] });
+                        }
+                    }
+                }
+            });
+            renderStatus = true;
+            if (this.configuration.viewportIndicators) {
+                const { viewportIndicatorsConfig } = this.configuration;
+                const xOffset = viewportIndicatorsConfig?.xOffset || 0.95;
+                const yOffset = viewportIndicatorsConfig?.yOffset || 0.05;
+                const referenceColorCoordinates = [
+                    clientWidth * xOffset,
+                    clientHeight * yOffset,
+                ];
+                const circleRadius = viewportIndicatorsConfig?.circleRadius || canvasDiagonalLength * 0.01;
+                const circleUID = '0';
+                (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_6__.drawCircle)(svgDrawingHelper, annotationUID, circleUID, referenceColorCoordinates, circleRadius, { color, fill: color });
+            }
+            return renderStatus;
+        };
+        this._getAnnotations = (enabledElement) => {
+            const { viewport } = enabledElement;
+            const annotations = (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.getAnnotations)(this.getToolName(), viewport.element) || [];
+            const viewportIds = this._getViewportsInfo().map(({ viewportId }) => viewportId);
+            const toolGroupAnnotations = annotations.filter((annotation) => {
+                const { data } = annotation;
+                return viewportIds.includes(data.viewportId);
+            });
+            return toolGroupAnnotations;
+        };
+        this._onSphereMoved = (evt) => {
+            if (evt.detail.originalClippingPlanes) {
+                this._syncWithVolumeCroppingTool(evt.detail.originalClippingPlanes);
+            }
+            else {
+                if (evt.detail.seriesInstanceUID !== this.seriesInstanceUID) {
+                    return;
+                }
+                const { draggingSphereIndex, toolCenter } = evt.detail;
+                const newMin = [...this.toolCenterMin];
+                const newMax = [...this.toolCenterMax];
+                if (draggingSphereIndex >= 0 && draggingSphereIndex <= 5) {
+                    const axis = Math.floor(draggingSphereIndex / 2);
+                    const isMin = draggingSphereIndex % 2 === 0;
+                    (isMin ? newMin : newMax)[axis] = toolCenter[axis];
+                    this.setToolCenter(newMin, 'min');
+                    this.setToolCenter(newMax, 'max');
+                    return;
+                }
+                if (draggingSphereIndex >= 6 && draggingSphereIndex <= 13) {
+                    const idx = draggingSphereIndex;
+                    if (idx < 10) {
+                        newMin[0] = toolCenter[0];
+                    }
+                    else {
+                        newMax[0] = toolCenter[0];
+                    }
+                    if ([6, 7, 10, 11].includes(idx)) {
+                        newMin[1] = toolCenter[1];
+                    }
+                    else {
+                        newMax[1] = toolCenter[1];
+                    }
+                    if (idx % 2 === 0) {
+                        newMin[2] = toolCenter[2];
+                    }
+                    else {
+                        newMax[2] = toolCenter[2];
+                    }
+                    this.setToolCenter(newMin, 'min');
+                    this.setToolCenter(newMax, 'max');
+                }
+            }
+        };
+        this._onNewVolume = () => {
+            const viewportsInfo = this._getViewportsInfo();
+            if (viewportsInfo && viewportsInfo.length > 0) {
+                const { viewportId, renderingEngineId } = viewportsInfo[0];
+                const renderingEngine = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getRenderingEngine)(renderingEngineId);
+                const viewport = renderingEngine.getViewport(viewportId);
+                const volumeActors = viewport.getActors();
+                if (volumeActors.length > 0) {
+                    const imageData = volumeActors[0].actor.getMapper().getInputData();
+                    if (imageData) {
+                        this.seriesInstanceUID = imageData.seriesInstanceUID;
+                        this._updateToolCentersFromViewport(viewport);
+                        const annotations = (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.getAnnotations)(this.getToolName(), viewportId) || [];
+                        annotations.forEach((annotation) => {
+                            if (annotation.data && annotation.data.handles) {
+                                annotation.data.handles.toolCenter = [...this.toolCenter];
+                            }
+                        });
+                    }
+                }
+            }
+            this._computeToolCenter(viewportsInfo);
+            (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.eventTarget, _enums__WEBPACK_IMPORTED_MODULE_8__.Events.VOLUMECROPPINGCONTROL_TOOL_CHANGED, {
+                toolGroupId: this.toolGroupId,
+                viewportsInfo: viewportsInfo,
+                seriesInstanceUID: this.seriesInstanceUID,
+            });
+        };
+        this._getAnnotationsForViewportsWithDifferentCameras = (enabledElement, annotations) => {
+            const { viewportId, renderingEngine, viewport } = enabledElement;
+            const otherViewportAnnotations = annotations.filter((annotation) => annotation.data.viewportId !== viewportId);
+            if (!otherViewportAnnotations || !otherViewportAnnotations.length) {
+                return [];
+            }
+            const camera = viewport.getCamera();
+            const { viewPlaneNormal, position } = camera;
+            const viewportsWithDifferentCameras = otherViewportAnnotations.filter((annotation) => {
+                const { viewportId } = annotation.data;
+                const targetViewport = renderingEngine.getViewport(viewportId);
+                const cameraOfTarget = targetViewport.getCamera();
+                return !(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.utilities.isEqual(cameraOfTarget.viewPlaneNormal, viewPlaneNormal, 1e-2) && _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.utilities.isEqual(cameraOfTarget.position, position, 1));
+            });
+            return viewportsWithDifferentCameras;
+        };
+        this._filterViewportWithSameOrientation = (enabledElement, referenceAnnotation, annotations) => {
+            const { renderingEngine } = enabledElement;
+            const { data } = referenceAnnotation;
+            const viewport = renderingEngine.getViewport(data.viewportId);
+            const linkedViewportAnnotations = annotations.filter((annotation) => {
+                const { data } = annotation;
+                const otherViewport = renderingEngine.getViewport(data.viewportId);
+                const otherViewportControllable = this._getReferenceLineControllable(otherViewport.id);
+                return otherViewportControllable === true;
+            });
+            if (!linkedViewportAnnotations || !linkedViewportAnnotations.length) {
+                return [];
+            }
+            const camera = viewport.getCamera();
+            const viewPlaneNormal = camera.viewPlaneNormal;
+            _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_1__/* ["default"].normalize */ .Ay.normalize(viewPlaneNormal);
+            const otherViewportsAnnotationsWithSameCameraDirection = linkedViewportAnnotations.filter((annotation) => {
+                const { viewportId } = annotation.data;
+                const otherViewport = renderingEngine.getViewport(viewportId);
+                const otherCamera = otherViewport.getCamera();
+                const otherViewPlaneNormal = otherCamera.viewPlaneNormal;
+                _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_1__/* ["default"].normalize */ .Ay.normalize(otherViewPlaneNormal);
+                return (_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.utilities.isEqual(viewPlaneNormal, otherViewPlaneNormal, 1e-2) &&
+                    _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.utilities.isEqual(camera.viewUp, otherCamera.viewUp, 1e-2));
+            });
+            return otherViewportsAnnotationsWithSameCameraDirection;
+        };
+        this._activateModify = (element) => {
+            _store_state__WEBPACK_IMPORTED_MODULE_7__/* .state */ .wk.isInteractingWithTool = !this.configuration.mobile?.enabled;
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_8__.Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_8__.Events.MOUSE_DRAG, this._dragCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_8__.Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_8__.Events.TOUCH_END, this._endCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_8__.Events.TOUCH_DRAG, this._dragCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_8__.Events.TOUCH_TAP, this._endCallback);
+        };
+        this._deactivateModify = (element) => {
+            _store_state__WEBPACK_IMPORTED_MODULE_7__/* .state */ .wk.isInteractingWithTool = false;
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_8__.Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_8__.Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_8__.Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_8__.Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_8__.Events.TOUCH_DRAG, this._dragCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_8__.Events.TOUCH_TAP, this._endCallback);
+        };
+        this._endCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            this.editData.annotation.data.handles.activeOperation = null;
+            this.editData.annotation.data.activeViewportIds = [];
+            this._deactivateModify(element);
+            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_10__.resetElementCursor)(element);
+            this.editData = null;
+            const requireSameOrientation = false;
+            const viewportIdsToRender = (0,_utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_9__.getViewportIdsWithToolToRender)(element, this.getToolName(), requireSameOrientation);
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_14__/* ["default"] */ .A)(viewportIdsToRender);
+        };
+        this._dragCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const delta = eventDetail.deltaPoints.world;
+            if (Math.abs(delta[0]) < 1e-3 &&
+                Math.abs(delta[1]) < 1e-3 &&
+                Math.abs(delta[2]) < 1e-3) {
+                return;
+            }
+            const { element } = eventDetail;
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getEnabledElement)(element);
+            const { viewport } = enabledElement;
+            if (viewport.type === _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.Enums.ViewportType.VOLUME_3D) {
+                return;
+            }
+            const annotations = this._getAnnotations(enabledElement);
+            const filteredToolAnnotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            const viewportAnnotation = filteredToolAnnotations[0];
+            if (!viewportAnnotation) {
+                return;
+            }
+            const { handles } = viewportAnnotation.data;
+            if (handles.activeOperation === OPERATION.DRAG) {
+                if (handles.activeType === 'min') {
+                    this.toolCenterMin[0] += delta[0];
+                    this.toolCenterMin[1] += delta[1];
+                    this.toolCenterMin[2] += delta[2];
+                }
+                else if (handles.activeType === 'max') {
+                    this.toolCenterMax[0] += delta[0];
+                    this.toolCenterMax[1] += delta[1];
+                    this.toolCenterMax[2] += delta[2];
+                }
+                else {
+                    this.toolCenter[0] += delta[0];
+                    this.toolCenter[1] += delta[1];
+                    this.toolCenter[2] += delta[2];
+                }
+                const viewportsInfo = this._getViewportsInfo();
+                (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_14__/* ["default"] */ .A)(viewportsInfo.map(({ viewportId }) => viewportId));
+                (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.eventTarget, _enums__WEBPACK_IMPORTED_MODULE_8__.Events.VOLUMECROPPINGCONTROL_TOOL_CHANGED, {
+                    toolGroupId: this.toolGroupId,
+                    toolCenter: this.toolCenter,
+                    toolCenterMin: this.toolCenterMin,
+                    toolCenterMax: this.toolCenterMax,
+                    handleType: handles.activeType,
+                    viewportOrientation: [],
+                    seriesInstanceUID: this.seriesInstanceUID,
+                });
+            }
+        };
+        this._getReferenceLineColor =
+            toolProps.configuration?.getReferenceLineColor ||
+                defaultReferenceLineColor;
+        this._getReferenceLineControllable =
+            toolProps.configuration?.getReferenceLineControllable ||
+                defaultReferenceLineControllable;
+        const viewportsInfo = (0,_store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_4__.getToolGroup)(this.toolGroupId)?.viewportsInfo;
+        _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.eventTarget.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_8__.Events.VOLUMECROPPING_TOOL_CHANGED, this._onSphereMoved);
+        if (viewportsInfo && viewportsInfo.length > 0) {
+            const { viewportId, renderingEngineId } = viewportsInfo[0];
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getEnabledElementByIds)(viewportId, renderingEngineId);
+            const renderingEngine = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getRenderingEngine)(renderingEngineId);
+            const viewport = renderingEngine.getViewport(viewportId);
+            const volumeActors = viewport.getActors();
+            if (!volumeActors || !volumeActors.length) {
+                console.warn(`VolumeCroppingControlTool: No volume actors found in viewport ${viewportId}.`);
+                return;
+            }
+            const imageData = volumeActors[0].actor.getMapper().getInputData();
+            if (imageData) {
+                const dimensions = imageData.getDimensions();
+                const spacing = imageData.getSpacing();
+                const origin = imageData.getOrigin();
+                this.seriesInstanceUID = imageData.seriesInstanceUID || 'unknown';
+                const cropFactor = this.configuration.initialCropFactor ?? 0.2;
+                this.toolCenter = [
+                    origin[0] + cropFactor * (dimensions[0] - 1) * spacing[0],
+                    origin[1] + cropFactor * (dimensions[1] - 1) * spacing[1],
+                    origin[2] + cropFactor * (dimensions[2] - 1) * spacing[2],
+                ];
+                const maxCropFactor = 1 - cropFactor;
+                this.toolCenterMin = [
+                    origin[0] + cropFactor * (dimensions[0] - 1) * spacing[0],
+                    origin[1] + cropFactor * (dimensions[1] - 1) * spacing[1],
+                    origin[2] + cropFactor * (dimensions[2] - 1) * spacing[2],
+                ];
+                this.toolCenterMax = [
+                    origin[0] + maxCropFactor * (dimensions[0] - 1) * spacing[0],
+                    origin[1] + maxCropFactor * (dimensions[1] - 1) * spacing[1],
+                    origin[2] + maxCropFactor * (dimensions[2] - 1) * spacing[2],
+                ];
+            }
+        }
+    }
+    _updateToolCentersFromViewport(viewport) {
+        const volumeActors = viewport.getActors();
+        if (!volumeActors || !volumeActors.length) {
+            return;
+        }
+        const imageData = volumeActors[0].actor.getMapper().getInputData();
+        if (!imageData) {
+            return;
+        }
+        this.seriesInstanceUID = imageData.seriesInstanceUID || 'unknown';
+        const dimensions = imageData.getDimensions();
+        const spacing = imageData.getSpacing();
+        const origin = imageData.getOrigin();
+        const cropFactor = this.configuration.initialCropFactor ?? 0.2;
+        const cropStart = cropFactor / 2;
+        const cropEnd = 1 - cropFactor / 2;
+        this.toolCenter = [
+            origin[0] +
+                ((cropStart + cropEnd) / 2) * (dimensions[0] - 1) * spacing[0],
+            origin[1] +
+                ((cropStart + cropEnd) / 2) * (dimensions[1] - 1) * spacing[1],
+            origin[2] +
+                ((cropStart + cropEnd) / 2) * (dimensions[2] - 1) * spacing[2],
+        ];
+        this.toolCenterMin = [
+            origin[0] + cropStart * (dimensions[0] - 1) * spacing[0],
+            origin[1] + cropStart * (dimensions[1] - 1) * spacing[1],
+            origin[2] + cropStart * (dimensions[2] - 1) * spacing[2],
+        ];
+        this.toolCenterMax = [
+            origin[0] + cropEnd * (dimensions[0] - 1) * spacing[0],
+            origin[1] + cropEnd * (dimensions[1] - 1) * spacing[1],
+            origin[2] + cropEnd * (dimensions[2] - 1) * spacing[2],
+        ];
+    }
+    onSetToolInactive() {
+        console.debug(`VolumeCroppingControlTool: onSetToolInactive called for tool ${this.getToolName()}`);
+    }
+    onSetToolActive() {
+        const viewportsInfo = this._getViewportsInfo();
+        let anyAnnotationExists = false;
+        for (const vpInfo of viewportsInfo) {
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getEnabledElementByIds)(vpInfo.viewportId, vpInfo.renderingEngineId);
+            const annotations = this._getAnnotations(enabledElement);
+            if (annotations && annotations.length > 0) {
+                anyAnnotationExists = true;
+                break;
+            }
+        }
+        if (!anyAnnotationExists) {
+            this._unsubscribeToViewportNewVolumeSet(viewportsInfo);
+            this._subscribeToViewportNewVolumeSet(viewportsInfo);
+            this._computeToolCenter(viewportsInfo);
+            (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.eventTarget, _enums__WEBPACK_IMPORTED_MODULE_8__.Events.VOLUMECROPPINGCONTROL_TOOL_CHANGED, {
+                toolGroupId: this.toolGroupId,
+                viewportsInfo: viewportsInfo,
+                seriesInstanceUID: this.seriesInstanceUID,
+            });
+        }
+        else {
+            for (const vpInfo of viewportsInfo) {
+                const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getEnabledElementByIds)(vpInfo.viewportId, vpInfo.renderingEngineId);
+                if (!enabledElement) {
+                    continue;
+                }
+                const annotations = this._getAnnotations(enabledElement);
+                if (annotations && annotations.length > 0) {
+                    annotations.forEach((annotation) => {
+                        (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.removeAnnotation)(annotation.annotationUID);
+                    });
+                }
+                enabledElement.viewport.render();
+            }
+        }
+    }
+    onSetToolEnabled() {
+        console.debug(`VolumeCroppingControlTool: onSetToolEnabled called for tool ${this.getToolName()}`);
+        const viewportsInfo = this._getViewportsInfo();
+    }
+    onSetToolDisabled() {
+        console.debug(`VolumeCroppingControlTool: onSetToolDisabled called for tool ${this.getToolName()}`);
+        const viewportsInfo = this._getViewportsInfo();
+        this._unsubscribeToViewportNewVolumeSet(viewportsInfo);
+        viewportsInfo.forEach(({ renderingEngineId, viewportId }) => {
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getEnabledElementByIds)(viewportId, renderingEngineId);
+            if (!enabledElement) {
+                return;
+            }
+            const annotations = this._getAnnotations(enabledElement);
+            if (annotations?.length) {
+                annotations.forEach((annotation) => {
+                    (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_5__.removeAnnotation)(annotation.annotationUID);
+                });
+            }
+        });
+    }
+    _getOrientationFromNormal(normal) {
+        if (!normal) {
+            return null;
+        }
+        const canonical = {
+            AXIAL: [0, 0, 1],
+            CORONAL: [0, 1, 0],
+            SAGITTAL: [1, 0, 0],
+        };
+        const tol = 1e-2;
+        for (const [key, value] of Object.entries(canonical)) {
+            if (Math.abs(normal[0] - value[0]) < tol &&
+                Math.abs(normal[1] - value[1]) < tol &&
+                Math.abs(normal[2] - value[2]) < tol) {
+                return key;
+            }
+            if (Math.abs(normal[0] + value[0]) < tol &&
+                Math.abs(normal[1] + value[1]) < tol &&
+                Math.abs(normal[2] + value[2]) < tol) {
+                return key;
+            }
+        }
+        return null;
+    }
+    _syncWithVolumeCroppingTool(originalClippingPlanes) {
+        const planes = originalClippingPlanes;
+        if (planes.length >= 6) {
+            this.toolCenterMin = [
+                planes[0].origin[0],
+                planes[2].origin[1],
+                planes[4].origin[2],
+            ];
+            this.toolCenterMax = [
+                planes[1].origin[0],
+                planes[3].origin[1],
+                planes[5].origin[2],
+            ];
+            this.toolCenter = [
+                (this.toolCenterMin[0] + this.toolCenterMax[0]) / 2,
+                (this.toolCenterMin[1] + this.toolCenterMax[1]) / 2,
+                (this.toolCenterMin[2] + this.toolCenterMax[2]) / 2,
+            ];
+            const viewportsInfo = this._getViewportsInfo();
+            viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+                const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getEnabledElementByIds)(viewportId, renderingEngineId);
+                if (enabledElement) {
+                    const annotations = this._getAnnotations(enabledElement);
+                    annotations.forEach((annotation) => {
+                        if (annotation.data &&
+                            annotation.data.handles &&
+                            annotation.data.orientation) {
+                            const orientation = annotation.data.orientation;
+                            if (orientation === 'AXIAL') {
+                                annotation.data.handles.toolCenterMin = [
+                                    planes[0].origin[0],
+                                    planes[2].origin[1],
+                                    annotation.data.handles.toolCenterMin[2],
+                                ];
+                                annotation.data.handles.toolCenterMax = [
+                                    planes[1].origin[0],
+                                    planes[3].origin[1],
+                                    annotation.data.handles.toolCenterMax[2],
+                                ];
+                            }
+                            else if (orientation === 'CORONAL') {
+                                annotation.data.handles.toolCenterMin = [
+                                    planes[0].origin[0],
+                                    annotation.data.handles.toolCenterMin[1],
+                                    planes[4].origin[2],
+                                ];
+                                annotation.data.handles.toolCenterMax = [
+                                    planes[1].origin[0],
+                                    annotation.data.handles.toolCenterMax[1],
+                                    planes[5].origin[2],
+                                ];
+                            }
+                            else if (orientation === 'SAGITTAL') {
+                                annotation.data.handles.toolCenterMin = [
+                                    annotation.data.handles.toolCenterMin[0],
+                                    planes[2].origin[1],
+                                    planes[4].origin[2],
+                                ];
+                                annotation.data.handles.toolCenterMax = [
+                                    annotation.data.handles.toolCenterMax[0],
+                                    planes[3].origin[1],
+                                    planes[5].origin[2],
+                                ];
+                            }
+                            annotation.data.handles.toolCenter = [
+                                (annotation.data.handles.toolCenterMin[0] +
+                                    annotation.data.handles.toolCenterMax[0]) /
+                                    2,
+                                (annotation.data.handles.toolCenterMin[1] +
+                                    annotation.data.handles.toolCenterMax[1]) /
+                                    2,
+                                (annotation.data.handles.toolCenterMin[2] +
+                                    annotation.data.handles.toolCenterMax[2]) /
+                                    2,
+                            ];
+                        }
+                    });
+                }
+            });
+            if (this._virtualAnnotations && this._virtualAnnotations.length > 0) {
+                this._virtualAnnotations.forEach((annotation) => {
+                    if (annotation.data &&
+                        annotation.data.handles &&
+                        annotation.data.orientation) {
+                        const orientation = annotation.data.orientation.toUpperCase();
+                        if (orientation === 'AXIAL') {
+                            annotation.data.handles.toolCenterMin = [
+                                planes[0].origin[0],
+                                planes[2].origin[1],
+                                annotation.data.handles.toolCenterMin[2],
+                            ];
+                            annotation.data.handles.toolCenterMax = [
+                                planes[1].origin[0],
+                                planes[3].origin[1],
+                                annotation.data.handles.toolCenterMax[2],
+                            ];
+                        }
+                        else if (orientation === 'CORONAL') {
+                            annotation.data.handles.toolCenterMin = [
+                                planes[0].origin[0],
+                                annotation.data.handles.toolCenterMin[1],
+                                planes[4].origin[2],
+                            ];
+                            annotation.data.handles.toolCenterMax = [
+                                planes[1].origin[0],
+                                annotation.data.handles.toolCenterMax[1],
+                                planes[5].origin[2],
+                            ];
+                        }
+                        else if (orientation === 'SAGITTAL') {
+                            annotation.data.handles.toolCenterMin = [
+                                annotation.data.handles.toolCenterMin[0],
+                                planes[2].origin[1],
+                                planes[4].origin[2],
+                            ];
+                            annotation.data.handles.toolCenterMax = [
+                                annotation.data.handles.toolCenterMax[0],
+                                planes[3].origin[1],
+                                planes[5].origin[2],
+                            ];
+                        }
+                        annotation.data.handles.toolCenter = [
+                            (annotation.data.handles.toolCenterMin[0] +
+                                annotation.data.handles.toolCenterMax[0]) /
+                                2,
+                            (annotation.data.handles.toolCenterMin[1] +
+                                annotation.data.handles.toolCenterMax[1]) /
+                                2,
+                            (annotation.data.handles.toolCenterMin[2] +
+                                annotation.data.handles.toolCenterMax[2]) /
+                                2,
+                        ];
+                    }
+                });
+            }
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_14__/* ["default"] */ .A)(viewportsInfo.map(({ viewportId }) => viewportId));
+        }
+    }
+    setToolCenter(toolCenter, handleType) {
+        if (handleType === 'min') {
+            this.toolCenterMin = [...toolCenter];
+        }
+        else if (handleType === 'max') {
+            this.toolCenterMax = [...toolCenter];
+        }
+        const viewportsInfo = this._getViewportsInfo();
+        (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_14__/* ["default"] */ .A)(viewportsInfo.map(({ viewportId }) => viewportId));
+    }
+    addNewAnnotation(evt) {
+        const eventDetail = evt.detail;
+        const { element } = eventDetail;
+        const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getEnabledElement)(element);
+        const { viewport } = enabledElement;
+        const annotations = this._getAnnotations(enabledElement);
+        const filteredAnnotations = this.filterInteractableAnnotationsForElement(viewport.element, annotations);
+        if (!filteredAnnotations ||
+            filteredAnnotations.length === 0 ||
+            !filteredAnnotations[0]) {
+            return null;
+        }
+        const { data } = filteredAnnotations[0];
+        const viewportIdArray = [];
+        const referenceLines = data.referenceLines || [];
+        for (let i = 0; i < referenceLines.length; ++i) {
+            const otherViewport = referenceLines[i][0];
+            const viewportControllable = this._getReferenceLineControllable(otherViewport.id);
+            if (!viewportControllable) {
+                continue;
+            }
+            viewportIdArray.push(otherViewport.id);
+            i++;
+        }
+        data.activeViewportIds = [...viewportIdArray];
+        data.handles.activeOperation = OPERATION.DRAG;
+        evt.preventDefault();
+        (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_10__.hideElementCursor)(element);
+        this._activateModify(element);
+        return filteredAnnotations[0];
+    }
+    handleSelectedCallback(evt, annotation, handle, interactionType) {
+        this.toolSelectedCallback(evt, annotation, interactionType);
+    }
+    _unsubscribeToViewportNewVolumeSet(viewportsInfo) {
+        viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+            const { viewport } = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getEnabledElementByIds)(viewportId, renderingEngineId);
+            const { element } = viewport;
+            element.removeEventListener(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, this._onNewVolume);
+        });
+    }
+    _subscribeToViewportNewVolumeSet(viewports) {
+        viewports.forEach(({ viewportId, renderingEngineId }) => {
+            const { viewport } = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.getEnabledElementByIds)(viewportId, renderingEngineId);
+            const { element } = viewport;
+            element.addEventListener(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_3__.Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, this._onNewVolume);
+        });
+    }
+    _applyDeltaShiftToSelectedViewportCameras(renderingEngine, viewportsAnnotationsToUpdate, delta) {
+        viewportsAnnotationsToUpdate.forEach((annotation) => {
+            this._applyDeltaShiftToViewportCamera(renderingEngine, annotation, delta);
+        });
+    }
+    _applyDeltaShiftToViewportCamera(renderingEngine, annotation, delta) {
+        const { data } = annotation;
+        const viewport = renderingEngine.getViewport(data.viewportId);
+        const camera = viewport.getCamera();
+        const normal = camera.viewPlaneNormal;
+        const dotProd = _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_1__/* ["default"].dot */ .Ay.dot(delta, normal);
+        const projectedDelta = [...normal];
+        _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_1__/* ["default"].multiplyScalar */ .Ay.multiplyScalar(projectedDelta, dotProd);
+        if (Math.abs(projectedDelta[0]) > 1e-3 ||
+            Math.abs(projectedDelta[1]) > 1e-3 ||
+            Math.abs(projectedDelta[2]) > 1e-3) {
+            const newFocalPoint = [0, 0, 0];
+            const newPosition = [0, 0, 0];
+            _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_1__/* ["default"].add */ .Ay.add(camera.focalPoint, projectedDelta, newFocalPoint);
+            _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_1__/* ["default"].add */ .Ay.add(camera.position, projectedDelta, newPosition);
+            viewport.setCamera({
+                focalPoint: newFocalPoint,
+                position: newPosition,
+            });
+            viewport.render();
+        }
+    }
+    _pointNearTool(element, annotation, canvasCoords, proximity) {
+        const { data } = annotation;
+        const referenceLines = data.referenceLines;
+        const viewportIdArray = [];
+        if (referenceLines) {
+            for (let i = 0; i < referenceLines.length; ++i) {
+                const otherViewport = referenceLines[i][0];
+                const start1 = referenceLines[i][1];
+                const end1 = referenceLines[i][2];
+                const type = referenceLines[i][3];
+                const distance1 = _utilities_math_line__WEBPACK_IMPORTED_MODULE_12__.distanceToPoint(start1, end1, [
+                    canvasCoords[0],
+                    canvasCoords[1],
+                ]);
+                if (distance1 <= proximity) {
+                    viewportIdArray.push(otherViewport.id);
+                    data.handles.activeOperation = 1;
+                    data.handles.activeType = type;
+                }
+            }
+        }
+        data.activeViewportIds = [...viewportIdArray];
+        this.editData = {
+            annotation,
+        };
+        return data.handles.activeOperation === 1 ? true : false;
+    }
+}
+VolumeCroppingControlTool.toolName = 'VolumeCroppingControl';
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (VolumeCroppingControlTool);
+
+
 /***/ }),
 
 /***/ 35706:
@@ -21334,6 +22607,131 @@ function _handlePTModality(imageId, options) {
 
 
 
+/***/ }),
+
+/***/ 40905:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   S: () => (/* binding */ getStrategyData)
+/* harmony export */ });
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
+/* harmony import */ var _stateManagement_segmentation_segmentationState__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(98870);
+/* harmony import */ var _stateManagement_segmentation_helpers__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(91963);
+/* harmony import */ var _utilities_segmentation_getReferenceVolumeForSegmentationVolume__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(12853);
+
+
+
+
+function getStrategyDataForVolumeViewport({ operationData }) {
+    const { volumeId } = operationData;
+    if (!volumeId) {
+        const event = new CustomEvent(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.Enums.Events.ERROR_EVENT, {
+            detail: {
+                type: 'Segmentation',
+                message: 'No volume id found for the segmentation',
+            },
+            cancelable: true,
+        });
+        _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.eventTarget.dispatchEvent(event);
+        return null;
+    }
+    const segmentationVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolume(volumeId);
+    const imageVolume = (0,_utilities_segmentation_getReferenceVolumeForSegmentationVolume__WEBPACK_IMPORTED_MODULE_3__/* .getReferenceVolumeForSegmentationVolume */ .b)(volumeId);
+    if (!segmentationVolume || !imageVolume) {
+        return null;
+    }
+    const { imageData: segmentationImageData } = segmentationVolume;
+    const { voxelManager: segmentationVoxelManager } = segmentationVolume;
+    const { voxelManager: imageVoxelManager, imageData } = imageVolume;
+    return {
+        segmentationImageData,
+        segmentationVoxelManager,
+        segmentationScalarData: null,
+        imageScalarData: null,
+        imageVoxelManager,
+        imageData,
+    };
+}
+function getStrategyDataForStackViewport({ operationData, viewport, strategy, }) {
+    const { segmentationId } = operationData;
+    let segmentationImageData;
+    let segmentationVoxelManager;
+    let segmentationScalarData;
+    let imageScalarData;
+    let imageVoxelManager;
+    let imageData;
+    if (strategy.ensureSegmentationVolumeFor3DManipulation) {
+        strategy.ensureSegmentationVolumeFor3DManipulation({
+            operationData,
+            viewport,
+        });
+        segmentationVoxelManager = operationData.segmentationVoxelManager;
+        segmentationImageData = operationData.segmentationImageData;
+        segmentationScalarData = null;
+    }
+    else {
+        const labelmapImageId = (0,_stateManagement_segmentation_segmentationState__WEBPACK_IMPORTED_MODULE_1__.getCurrentLabelmapImageIdForViewport)(viewport.id, segmentationId);
+        if (!labelmapImageId) {
+            return null;
+        }
+        const actorEntry = (0,_stateManagement_segmentation_helpers__WEBPACK_IMPORTED_MODULE_2__/* .getLabelmapActorEntry */ .wV)(viewport.id, segmentationId);
+        if (!actorEntry) {
+            return null;
+        }
+        const currentSegImage = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getImage(labelmapImageId);
+        segmentationImageData = actorEntry.actor.getMapper().getInputData();
+        segmentationVoxelManager = currentSegImage.voxelManager;
+        const currentSegmentationImageId = operationData.imageId;
+        const segmentationImage = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getImage(currentSegmentationImageId);
+        if (!segmentationImage) {
+            return null;
+        }
+        segmentationScalarData = segmentationImage.getPixelData?.();
+    }
+    if (strategy.ensureImageVolumeFor3DManipulation) {
+        strategy.ensureImageVolumeFor3DManipulation({
+            operationData,
+            viewport,
+        });
+        imageVoxelManager = operationData.imageVoxelManager;
+        imageScalarData = operationData.imageScalarData;
+        imageData = operationData.imageData;
+    }
+    else {
+        const currentImageId = viewport.getCurrentImageId();
+        if (!currentImageId) {
+            return null;
+        }
+        const image = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getImage(currentImageId);
+        imageData = image ? null : viewport.getImageData();
+        imageScalarData = image?.getPixelData() || imageData.getScalarData();
+        imageVoxelManager = image?.voxelManager;
+    }
+    return {
+        segmentationImageData,
+        segmentationScalarData,
+        imageScalarData,
+        segmentationVoxelManager,
+        imageVoxelManager,
+        imageData,
+    };
+}
+function getStrategyData({ operationData, viewport, strategy, }) {
+    if (!operationData) {
+        return null;
+    }
+    if (('volumeId' in operationData && operationData.volumeId != null) ||
+        ('referencedVolumeId' in operationData &&
+            operationData.referencedVolumeId != null)) {
+        return getStrategyDataForVolumeViewport({ operationData });
+    }
+    return getStrategyDataForStackViewport({ operationData, viewport, strategy });
+}
+
+
+
 /***/ }),
 
 /***/ 41293:
@@ -24257,128 +25655,134 @@ function updateViewportsForAnnotations(viewport, annotations) {
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A5: () => (/* reexport safe */ _PlanarRotateTool__WEBPACK_IMPORTED_MODULE_6__.A),
+/* harmony export */   A5: () => (/* reexport safe */ _PlanarRotateTool__WEBPACK_IMPORTED_MODULE_8__.A),
 /* harmony export */   CH: () => (/* reexport safe */ _PanTool__WEBPACK_IMPORTED_MODULE_1__.A),
-/* harmony export */   Du: () => (/* reexport safe */ _WindowLevelTool__WEBPACK_IMPORTED_MODULE_3__.A),
-/* harmony export */   E0: () => (/* reexport safe */ _annotation_RectangleROITool__WEBPACK_IMPORTED_MODULE_25__.A),
+/* harmony export */   Du: () => (/* reexport safe */ _WindowLevelTool__WEBPACK_IMPORTED_MODULE_5__.A),
+/* harmony export */   E0: () => (/* reexport safe */ _annotation_RectangleROITool__WEBPACK_IMPORTED_MODULE_27__.A),
 /* harmony export */   EC: () => (/* reexport safe */ _base__WEBPACK_IMPORTED_MODULE_0__.EC),
-/* harmony export */   EV: () => (/* reexport safe */ _annotation_CobbAngleTool__WEBPACK_IMPORTED_MODULE_37__.A),
-/* harmony export */   FE: () => (/* reexport safe */ _ScaleOverlayTool__WEBPACK_IMPORTED_MODULE_16__.A),
-/* harmony export */   Fz: () => (/* reexport safe */ _segmentation_SegmentBidirectionalTool__WEBPACK_IMPORTED_MODULE_56__.A),
-/* harmony export */   G2: () => (/* reexport safe */ _segmentation_CircleScissorsTool__WEBPACK_IMPORTED_MODULE_47__.A),
-/* harmony export */   IX: () => (/* reexport safe */ _segmentation_SegmentSelectTool__WEBPACK_IMPORTED_MODULE_55__.A),
-/* harmony export */   Ix: () => (/* reexport safe */ _annotation_LivewireContourSegmentationTool__WEBPACK_IMPORTED_MODULE_34__.A),
-/* harmony export */   J2: () => (/* reexport safe */ _annotation_SplineROITool__WEBPACK_IMPORTED_MODULE_29__.A),
-/* harmony export */   LK: () => (/* reexport safe */ _segmentation_LabelmapEditWithContour__WEBPACK_IMPORTED_MODULE_59__.A),
-/* harmony export */   LW: () => (/* reexport safe */ _annotation_LengthTool__WEBPACK_IMPORTED_MODULE_21__.A),
-/* harmony export */   M$: () => (/* reexport safe */ _AdvancedMagnifyTool__WEBPACK_IMPORTED_MODULE_11__.A),
-/* harmony export */   Mu: () => (/* reexport safe */ _annotation_BidirectionalTool__WEBPACK_IMPORTED_MODULE_19__.A),
-/* harmony export */   N: () => (/* reexport safe */ _SculptorTool__WEBPACK_IMPORTED_MODULE_17__.A),
-/* harmony export */   N7: () => (/* reexport safe */ _annotation_ProbeTool__WEBPACK_IMPORTED_MODULE_23__.A),
-/* harmony export */   Nk: () => (/* reexport safe */ _OverlayGridTool__WEBPACK_IMPORTED_MODULE_13__.A),
-/* harmony export */   Np: () => (/* reexport safe */ _annotation_KeyImageTool__WEBPACK_IMPORTED_MODULE_40__.A),
-/* harmony export */   OQ: () => (/* reexport safe */ _ZoomTool__WEBPACK_IMPORTED_MODULE_7__.A),
-/* harmony export */   Oh: () => (/* reexport safe */ _VolumeRotateTool__WEBPACK_IMPORTED_MODULE_18__.A),
+/* harmony export */   EV: () => (/* reexport safe */ _annotation_CobbAngleTool__WEBPACK_IMPORTED_MODULE_39__.A),
+/* harmony export */   Eb: () => (/* reexport safe */ _VolumeCroppingControlTool__WEBPACK_IMPORTED_MODULE_4__.A),
+/* harmony export */   FE: () => (/* reexport safe */ _ScaleOverlayTool__WEBPACK_IMPORTED_MODULE_18__.A),
+/* harmony export */   Fz: () => (/* reexport safe */ _segmentation_SegmentBidirectionalTool__WEBPACK_IMPORTED_MODULE_58__.A),
+/* harmony export */   G2: () => (/* reexport safe */ _segmentation_CircleScissorsTool__WEBPACK_IMPORTED_MODULE_49__.A),
+/* harmony export */   IX: () => (/* reexport safe */ _segmentation_SegmentSelectTool__WEBPACK_IMPORTED_MODULE_57__.A),
+/* harmony export */   Ix: () => (/* reexport safe */ _annotation_LivewireContourSegmentationTool__WEBPACK_IMPORTED_MODULE_36__.A),
+/* harmony export */   J2: () => (/* reexport safe */ _annotation_SplineROITool__WEBPACK_IMPORTED_MODULE_31__.A),
+/* harmony export */   LK: () => (/* reexport safe */ _segmentation_LabelmapEditWithContour__WEBPACK_IMPORTED_MODULE_61__.A),
+/* harmony export */   LW: () => (/* reexport safe */ _annotation_LengthTool__WEBPACK_IMPORTED_MODULE_23__.A),
+/* harmony export */   M$: () => (/* reexport safe */ _AdvancedMagnifyTool__WEBPACK_IMPORTED_MODULE_13__.A),
+/* harmony export */   Mu: () => (/* reexport safe */ _annotation_BidirectionalTool__WEBPACK_IMPORTED_MODULE_21__.A),
+/* harmony export */   N: () => (/* reexport safe */ _SculptorTool__WEBPACK_IMPORTED_MODULE_19__.A),
+/* harmony export */   N7: () => (/* reexport safe */ _annotation_ProbeTool__WEBPACK_IMPORTED_MODULE_25__.A),
+/* harmony export */   NF: () => (/* reexport safe */ _VolumeCroppingTool__WEBPACK_IMPORTED_MODULE_3__.A),
+/* harmony export */   Nk: () => (/* reexport safe */ _OverlayGridTool__WEBPACK_IMPORTED_MODULE_15__.A),
+/* harmony export */   Np: () => (/* reexport safe */ _annotation_KeyImageTool__WEBPACK_IMPORTED_MODULE_42__.A),
+/* harmony export */   OQ: () => (/* reexport safe */ _ZoomTool__WEBPACK_IMPORTED_MODULE_9__.A),
+/* harmony export */   Oh: () => (/* reexport safe */ _VolumeRotateTool__WEBPACK_IMPORTED_MODULE_20__.A),
 /* harmony export */   So: () => (/* reexport safe */ _TrackballRotateTool__WEBPACK_IMPORTED_MODULE_2__.A),
-/* harmony export */   T8: () => (/* reexport safe */ _annotation_UltrasoundPleuraBLineTool_UltrasoundPleuraBLineTool__WEBPACK_IMPORTED_MODULE_39__.A),
-/* harmony export */   TG: () => (/* reexport safe */ _WindowLevelRegionTool__WEBPACK_IMPORTED_MODULE_4__.A),
-/* harmony export */   TR: () => (/* reexport safe */ _segmentation_RectangleROIThresholdTool__WEBPACK_IMPORTED_MODULE_49__.A),
-/* harmony export */   Tc: () => (/* reexport safe */ _annotation_WholeBodySegmentTool__WEBPACK_IMPORTED_MODULE_44__.A),
-/* harmony export */   Uj: () => (/* reexport safe */ _segmentation_PaintFillTool__WEBPACK_IMPORTED_MODULE_53__.A),
-/* harmony export */   Vl: () => (/* reexport safe */ _annotation_CircleROITool__WEBPACK_IMPORTED_MODULE_27__.A),
-/* harmony export */   X8: () => (/* reexport safe */ _ReferenceLinesTool__WEBPACK_IMPORTED_MODULE_12__.A),
-/* harmony export */   Xr: () => (/* reexport safe */ _OrientationMarkerTool__WEBPACK_IMPORTED_MODULE_54__.A),
-/* harmony export */   Ys: () => (/* reexport safe */ _annotation_LivewireContourTool__WEBPACK_IMPORTED_MODULE_33__.A),
-/* harmony export */   ae: () => (/* reexport safe */ _StackScrollTool__WEBPACK_IMPORTED_MODULE_5__.A),
-/* harmony export */   ao: () => (/* reexport safe */ _annotation_ArrowAnnotateTool__WEBPACK_IMPORTED_MODULE_35__.A),
-/* harmony export */   cN: () => (/* reexport safe */ _SegmentationIntersectionTool__WEBPACK_IMPORTED_MODULE_14__.A),
-/* harmony export */   dB: () => (/* reexport safe */ _AnnotationEraserTool__WEBPACK_IMPORTED_MODULE_41__.A),
-/* harmony export */   eh: () => (/* reexport safe */ _MagnifyTool__WEBPACK_IMPORTED_MODULE_10__.A),
-/* harmony export */   ep: () => (/* reexport safe */ _CrosshairsTool__WEBPACK_IMPORTED_MODULE_9__.A),
-/* harmony export */   ex: () => (/* reexport safe */ _annotation_PlanarFreehandROITool__WEBPACK_IMPORTED_MODULE_31__.A),
-/* harmony export */   hz: () => (/* reexport safe */ _annotation_LabelTool__WEBPACK_IMPORTED_MODULE_20__.A),
-/* harmony export */   il: () => (/* reexport safe */ _segmentation_LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_45__.A),
-/* harmony export */   j$: () => (/* reexport safe */ _annotation_DragProbeTool__WEBPACK_IMPORTED_MODULE_24__.A),
-/* harmony export */   ls: () => (/* reexport safe */ _segmentation_BrushTool__WEBPACK_IMPORTED_MODULE_52__.A),
-/* harmony export */   m8: () => (/* reexport safe */ _annotation_HeightTool__WEBPACK_IMPORTED_MODULE_22__.A),
-/* harmony export */   mX: () => (/* reexport safe */ _segmentation_RectangleROIStartEndThresholdTool__WEBPACK_IMPORTED_MODULE_50__.A),
-/* harmony export */   nJ: () => (/* reexport safe */ _annotation_ETDRSGridTool__WEBPACK_IMPORTED_MODULE_28__.A),
+/* harmony export */   T8: () => (/* reexport safe */ _annotation_UltrasoundPleuraBLineTool_UltrasoundPleuraBLineTool__WEBPACK_IMPORTED_MODULE_41__.A),
+/* harmony export */   TG: () => (/* reexport safe */ _WindowLevelRegionTool__WEBPACK_IMPORTED_MODULE_6__.A),
+/* harmony export */   TR: () => (/* reexport safe */ _segmentation_RectangleROIThresholdTool__WEBPACK_IMPORTED_MODULE_51__.A),
+/* harmony export */   Tc: () => (/* reexport safe */ _annotation_WholeBodySegmentTool__WEBPACK_IMPORTED_MODULE_46__.A),
+/* harmony export */   Uj: () => (/* reexport safe */ _segmentation_PaintFillTool__WEBPACK_IMPORTED_MODULE_55__.A),
+/* harmony export */   Vl: () => (/* reexport safe */ _annotation_CircleROITool__WEBPACK_IMPORTED_MODULE_29__.A),
+/* harmony export */   X8: () => (/* reexport safe */ _ReferenceLinesTool__WEBPACK_IMPORTED_MODULE_14__.A),
+/* harmony export */   Xr: () => (/* reexport safe */ _OrientationMarkerTool__WEBPACK_IMPORTED_MODULE_56__.A),
+/* harmony export */   Ys: () => (/* reexport safe */ _annotation_LivewireContourTool__WEBPACK_IMPORTED_MODULE_35__.A),
+/* harmony export */   ae: () => (/* reexport safe */ _StackScrollTool__WEBPACK_IMPORTED_MODULE_7__.A),
+/* harmony export */   ao: () => (/* reexport safe */ _annotation_ArrowAnnotateTool__WEBPACK_IMPORTED_MODULE_37__.A),
+/* harmony export */   cN: () => (/* reexport safe */ _SegmentationIntersectionTool__WEBPACK_IMPORTED_MODULE_16__.A),
+/* harmony export */   dB: () => (/* reexport safe */ _AnnotationEraserTool__WEBPACK_IMPORTED_MODULE_43__.A),
+/* harmony export */   eh: () => (/* reexport safe */ _MagnifyTool__WEBPACK_IMPORTED_MODULE_12__.A),
+/* harmony export */   ep: () => (/* reexport safe */ _CrosshairsTool__WEBPACK_IMPORTED_MODULE_11__.A),
+/* harmony export */   ex: () => (/* reexport safe */ _annotation_PlanarFreehandROITool__WEBPACK_IMPORTED_MODULE_33__.A),
+/* harmony export */   hz: () => (/* reexport safe */ _annotation_LabelTool__WEBPACK_IMPORTED_MODULE_22__.A),
+/* harmony export */   il: () => (/* reexport safe */ _segmentation_LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_47__.A),
+/* harmony export */   j$: () => (/* reexport safe */ _annotation_DragProbeTool__WEBPACK_IMPORTED_MODULE_26__.A),
+/* harmony export */   ls: () => (/* reexport safe */ _segmentation_BrushTool__WEBPACK_IMPORTED_MODULE_54__.A),
+/* harmony export */   m8: () => (/* reexport safe */ _annotation_HeightTool__WEBPACK_IMPORTED_MODULE_24__.A),
+/* harmony export */   mX: () => (/* reexport safe */ _segmentation_RectangleROIStartEndThresholdTool__WEBPACK_IMPORTED_MODULE_52__.A),
+/* harmony export */   nJ: () => (/* reexport safe */ _annotation_ETDRSGridTool__WEBPACK_IMPORTED_MODULE_30__.A),
 /* harmony export */   oS: () => (/* reexport safe */ _base__WEBPACK_IMPORTED_MODULE_0__.oS),
-/* harmony export */   oi: () => (/* reexport safe */ _annotation_UltrasoundDirectionalTool__WEBPACK_IMPORTED_MODULE_38__.A),
-/* harmony export */   pq: () => (/* reexport safe */ _segmentation_CircleROIStartEndThresholdTool__WEBPACK_IMPORTED_MODULE_51__.A),
-/* harmony export */   qD: () => (/* reexport safe */ _annotation_EllipticalROITool__WEBPACK_IMPORTED_MODULE_26__.A),
-/* harmony export */   qT: () => (/* reexport safe */ _annotation_SplineContourSegmentationTool__WEBPACK_IMPORTED_MODULE_30__.A),
-/* harmony export */   qi: () => (/* reexport safe */ _annotation_PlanarFreehandContourSegmentationTool__WEBPACK_IMPORTED_MODULE_32__.A),
-/* harmony export */   sR: () => (/* reexport safe */ _annotation_RegionSegmentPlusTool__WEBPACK_IMPORTED_MODULE_43__.A),
-/* harmony export */   td: () => (/* reexport safe */ _segmentation_RectangleScissorsTool__WEBPACK_IMPORTED_MODULE_46__.A),
-/* harmony export */   u9: () => (/* reexport safe */ _segmentation_SegmentLabelTool__WEBPACK_IMPORTED_MODULE_58__.A),
-/* harmony export */   uJ: () => (/* reexport safe */ _MIPJumpToClickTool__WEBPACK_IMPORTED_MODULE_8__.A),
-/* harmony export */   wR: () => (/* reexport safe */ _annotation_RegionSegmentTool__WEBPACK_IMPORTED_MODULE_42__.A),
+/* harmony export */   oi: () => (/* reexport safe */ _annotation_UltrasoundDirectionalTool__WEBPACK_IMPORTED_MODULE_40__.A),
+/* harmony export */   pq: () => (/* reexport safe */ _segmentation_CircleROIStartEndThresholdTool__WEBPACK_IMPORTED_MODULE_53__.A),
+/* harmony export */   qD: () => (/* reexport safe */ _annotation_EllipticalROITool__WEBPACK_IMPORTED_MODULE_28__.A),
+/* harmony export */   qT: () => (/* reexport safe */ _annotation_SplineContourSegmentationTool__WEBPACK_IMPORTED_MODULE_32__.A),
+/* harmony export */   qi: () => (/* reexport safe */ _annotation_PlanarFreehandContourSegmentationTool__WEBPACK_IMPORTED_MODULE_34__.A),
+/* harmony export */   sR: () => (/* reexport safe */ _annotation_RegionSegmentPlusTool__WEBPACK_IMPORTED_MODULE_45__.A),
+/* harmony export */   td: () => (/* reexport safe */ _segmentation_RectangleScissorsTool__WEBPACK_IMPORTED_MODULE_48__.A),
+/* harmony export */   u9: () => (/* reexport safe */ _segmentation_SegmentLabelTool__WEBPACK_IMPORTED_MODULE_60__.A),
+/* harmony export */   uJ: () => (/* reexport safe */ _MIPJumpToClickTool__WEBPACK_IMPORTED_MODULE_10__.A),
+/* harmony export */   wR: () => (/* reexport safe */ _annotation_RegionSegmentTool__WEBPACK_IMPORTED_MODULE_44__.A),
 /* harmony export */   wh: () => (/* reexport safe */ _base__WEBPACK_IMPORTED_MODULE_0__.wh),
-/* harmony export */   xI: () => (/* reexport safe */ _ReferenceCursors__WEBPACK_IMPORTED_MODULE_15__.A),
-/* harmony export */   yT: () => (/* reexport safe */ _annotation_AngleTool__WEBPACK_IMPORTED_MODULE_36__.A),
-/* harmony export */   zH: () => (/* reexport safe */ _segmentation_SphereScissorsTool__WEBPACK_IMPORTED_MODULE_48__.A)
+/* harmony export */   xI: () => (/* reexport safe */ _ReferenceCursors__WEBPACK_IMPORTED_MODULE_17__.A),
+/* harmony export */   yT: () => (/* reexport safe */ _annotation_AngleTool__WEBPACK_IMPORTED_MODULE_38__.A),
+/* harmony export */   zH: () => (/* reexport safe */ _segmentation_SphereScissorsTool__WEBPACK_IMPORTED_MODULE_50__.A)
 /* harmony export */ });
 /* harmony import */ var _base__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(85817);
 /* harmony import */ var _PanTool__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(38782);
 /* harmony import */ var _TrackballRotateTool__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(26884);
-/* harmony import */ var _WindowLevelTool__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(43159);
-/* harmony import */ var _WindowLevelRegionTool__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(17819);
-/* harmony import */ var _StackScrollTool__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(89460);
-/* harmony import */ var _PlanarRotateTool__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(82058);
-/* harmony import */ var _ZoomTool__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(26938);
-/* harmony import */ var _MIPJumpToClickTool__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(66944);
-/* harmony import */ var _CrosshairsTool__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(14840);
-/* harmony import */ var _MagnifyTool__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(72674);
-/* harmony import */ var _AdvancedMagnifyTool__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(45152);
-/* harmony import */ var _ReferenceLinesTool__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(36797);
-/* harmony import */ var _OverlayGridTool__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(43185);
-/* harmony import */ var _SegmentationIntersectionTool__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(32302);
-/* harmony import */ var _ReferenceCursors__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(85735);
-/* harmony import */ var _ScaleOverlayTool__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(26039);
-/* harmony import */ var _SculptorTool__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(3751);
-/* harmony import */ var _VolumeRotateTool__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(30588);
-/* harmony import */ var _annotation_BidirectionalTool__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(25072);
-/* harmony import */ var _annotation_LabelTool__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(37117);
-/* harmony import */ var _annotation_LengthTool__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(14335);
-/* harmony import */ var _annotation_HeightTool__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(59320);
-/* harmony import */ var _annotation_ProbeTool__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(61873);
-/* harmony import */ var _annotation_DragProbeTool__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(40487);
-/* harmony import */ var _annotation_RectangleROITool__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(4010);
-/* harmony import */ var _annotation_EllipticalROITool__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(78684);
-/* harmony import */ var _annotation_CircleROITool__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(31137);
-/* harmony import */ var _annotation_ETDRSGridTool__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(8467);
-/* harmony import */ var _annotation_SplineROITool__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(3066);
-/* harmony import */ var _annotation_SplineContourSegmentationTool__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(60580);
-/* harmony import */ var _annotation_PlanarFreehandROITool__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(28220);
-/* harmony import */ var _annotation_PlanarFreehandContourSegmentationTool__WEBPACK_IMPORTED_MODULE_32__ = __webpack_require__(37590);
-/* harmony import */ var _annotation_LivewireContourTool__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__(9136);
-/* harmony import */ var _annotation_LivewireContourSegmentationTool__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__(76358);
-/* harmony import */ var _annotation_ArrowAnnotateTool__WEBPACK_IMPORTED_MODULE_35__ = __webpack_require__(24146);
-/* harmony import */ var _annotation_AngleTool__WEBPACK_IMPORTED_MODULE_36__ = __webpack_require__(9608);
-/* harmony import */ var _annotation_CobbAngleTool__WEBPACK_IMPORTED_MODULE_37__ = __webpack_require__(99718);
-/* harmony import */ var _annotation_UltrasoundDirectionalTool__WEBPACK_IMPORTED_MODULE_38__ = __webpack_require__(94504);
-/* harmony import */ var _annotation_UltrasoundPleuraBLineTool_UltrasoundPleuraBLineTool__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__(20214);
-/* harmony import */ var _annotation_KeyImageTool__WEBPACK_IMPORTED_MODULE_40__ = __webpack_require__(33327);
-/* harmony import */ var _AnnotationEraserTool__WEBPACK_IMPORTED_MODULE_41__ = __webpack_require__(68760);
-/* harmony import */ var _annotation_RegionSegmentTool__WEBPACK_IMPORTED_MODULE_42__ = __webpack_require__(9626);
-/* harmony import */ var _annotation_RegionSegmentPlusTool__WEBPACK_IMPORTED_MODULE_43__ = __webpack_require__(7750);
-/* harmony import */ var _annotation_WholeBodySegmentTool__WEBPACK_IMPORTED_MODULE_44__ = __webpack_require__(31787);
-/* harmony import */ var _segmentation_LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_45__ = __webpack_require__(23631);
-/* harmony import */ var _segmentation_RectangleScissorsTool__WEBPACK_IMPORTED_MODULE_46__ = __webpack_require__(56526);
-/* harmony import */ var _segmentation_CircleScissorsTool__WEBPACK_IMPORTED_MODULE_47__ = __webpack_require__(66917);
-/* harmony import */ var _segmentation_SphereScissorsTool__WEBPACK_IMPORTED_MODULE_48__ = __webpack_require__(10804);
-/* harmony import */ var _segmentation_RectangleROIThresholdTool__WEBPACK_IMPORTED_MODULE_49__ = __webpack_require__(40336);
-/* harmony import */ var _segmentation_RectangleROIStartEndThresholdTool__WEBPACK_IMPORTED_MODULE_50__ = __webpack_require__(67847);
-/* harmony import */ var _segmentation_CircleROIStartEndThresholdTool__WEBPACK_IMPORTED_MODULE_51__ = __webpack_require__(65284);
-/* harmony import */ var _segmentation_BrushTool__WEBPACK_IMPORTED_MODULE_52__ = __webpack_require__(48736);
-/* harmony import */ var _segmentation_PaintFillTool__WEBPACK_IMPORTED_MODULE_53__ = __webpack_require__(61777);
-/* harmony import */ var _OrientationMarkerTool__WEBPACK_IMPORTED_MODULE_54__ = __webpack_require__(36913);
-/* harmony import */ var _segmentation_SegmentSelectTool__WEBPACK_IMPORTED_MODULE_55__ = __webpack_require__(12905);
-/* harmony import */ var _segmentation_SegmentBidirectionalTool__WEBPACK_IMPORTED_MODULE_56__ = __webpack_require__(38502);
-/* harmony import */ var _segmentation_strategies__WEBPACK_IMPORTED_MODULE_57__ = __webpack_require__(99522);
-/* harmony import */ var _segmentation_SegmentLabelTool__WEBPACK_IMPORTED_MODULE_58__ = __webpack_require__(987);
-/* harmony import */ var _segmentation_LabelmapEditWithContour__WEBPACK_IMPORTED_MODULE_59__ = __webpack_require__(89584);
+/* harmony import */ var _VolumeCroppingTool__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(82461);
+/* harmony import */ var _VolumeCroppingControlTool__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(35300);
+/* harmony import */ var _WindowLevelTool__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(43159);
+/* harmony import */ var _WindowLevelRegionTool__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(17819);
+/* harmony import */ var _StackScrollTool__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(89460);
+/* harmony import */ var _PlanarRotateTool__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(82058);
+/* harmony import */ var _ZoomTool__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(26938);
+/* harmony import */ var _MIPJumpToClickTool__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(66944);
+/* harmony import */ var _CrosshairsTool__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(14840);
+/* harmony import */ var _MagnifyTool__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(72674);
+/* harmony import */ var _AdvancedMagnifyTool__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(45152);
+/* harmony import */ var _ReferenceLinesTool__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(36797);
+/* harmony import */ var _OverlayGridTool__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(43185);
+/* harmony import */ var _SegmentationIntersectionTool__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(32302);
+/* harmony import */ var _ReferenceCursors__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(85735);
+/* harmony import */ var _ScaleOverlayTool__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(26039);
+/* harmony import */ var _SculptorTool__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(3751);
+/* harmony import */ var _VolumeRotateTool__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(30588);
+/* harmony import */ var _annotation_BidirectionalTool__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(25072);
+/* harmony import */ var _annotation_LabelTool__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(37117);
+/* harmony import */ var _annotation_LengthTool__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(14335);
+/* harmony import */ var _annotation_HeightTool__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(59320);
+/* harmony import */ var _annotation_ProbeTool__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(61873);
+/* harmony import */ var _annotation_DragProbeTool__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(40487);
+/* harmony import */ var _annotation_RectangleROITool__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(4010);
+/* harmony import */ var _annotation_EllipticalROITool__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(78684);
+/* harmony import */ var _annotation_CircleROITool__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(31137);
+/* harmony import */ var _annotation_ETDRSGridTool__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(8467);
+/* harmony import */ var _annotation_SplineROITool__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(3066);
+/* harmony import */ var _annotation_SplineContourSegmentationTool__WEBPACK_IMPORTED_MODULE_32__ = __webpack_require__(60580);
+/* harmony import */ var _annotation_PlanarFreehandROITool__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__(28220);
+/* harmony import */ var _annotation_PlanarFreehandContourSegmentationTool__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__(37590);
+/* harmony import */ var _annotation_LivewireContourTool__WEBPACK_IMPORTED_MODULE_35__ = __webpack_require__(9136);
+/* harmony import */ var _annotation_LivewireContourSegmentationTool__WEBPACK_IMPORTED_MODULE_36__ = __webpack_require__(76358);
+/* harmony import */ var _annotation_ArrowAnnotateTool__WEBPACK_IMPORTED_MODULE_37__ = __webpack_require__(24146);
+/* harmony import */ var _annotation_AngleTool__WEBPACK_IMPORTED_MODULE_38__ = __webpack_require__(9608);
+/* harmony import */ var _annotation_CobbAngleTool__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__(99718);
+/* harmony import */ var _annotation_UltrasoundDirectionalTool__WEBPACK_IMPORTED_MODULE_40__ = __webpack_require__(94504);
+/* harmony import */ var _annotation_UltrasoundPleuraBLineTool_UltrasoundPleuraBLineTool__WEBPACK_IMPORTED_MODULE_41__ = __webpack_require__(20214);
+/* harmony import */ var _annotation_KeyImageTool__WEBPACK_IMPORTED_MODULE_42__ = __webpack_require__(33327);
+/* harmony import */ var _AnnotationEraserTool__WEBPACK_IMPORTED_MODULE_43__ = __webpack_require__(68760);
+/* harmony import */ var _annotation_RegionSegmentTool__WEBPACK_IMPORTED_MODULE_44__ = __webpack_require__(9626);
+/* harmony import */ var _annotation_RegionSegmentPlusTool__WEBPACK_IMPORTED_MODULE_45__ = __webpack_require__(7750);
+/* harmony import */ var _annotation_WholeBodySegmentTool__WEBPACK_IMPORTED_MODULE_46__ = __webpack_require__(31787);
+/* harmony import */ var _segmentation_LabelmapBaseTool__WEBPACK_IMPORTED_MODULE_47__ = __webpack_require__(23631);
+/* harmony import */ var _segmentation_RectangleScissorsTool__WEBPACK_IMPORTED_MODULE_48__ = __webpack_require__(56526);
+/* harmony import */ var _segmentation_CircleScissorsTool__WEBPACK_IMPORTED_MODULE_49__ = __webpack_require__(66917);
+/* harmony import */ var _segmentation_SphereScissorsTool__WEBPACK_IMPORTED_MODULE_50__ = __webpack_require__(10804);
+/* harmony import */ var _segmentation_RectangleROIThresholdTool__WEBPACK_IMPORTED_MODULE_51__ = __webpack_require__(40336);
+/* harmony import */ var _segmentation_RectangleROIStartEndThresholdTool__WEBPACK_IMPORTED_MODULE_52__ = __webpack_require__(67847);
+/* harmony import */ var _segmentation_CircleROIStartEndThresholdTool__WEBPACK_IMPORTED_MODULE_53__ = __webpack_require__(65284);
+/* harmony import */ var _segmentation_BrushTool__WEBPACK_IMPORTED_MODULE_54__ = __webpack_require__(48736);
+/* harmony import */ var _segmentation_PaintFillTool__WEBPACK_IMPORTED_MODULE_55__ = __webpack_require__(61777);
+/* harmony import */ var _OrientationMarkerTool__WEBPACK_IMPORTED_MODULE_56__ = __webpack_require__(36913);
+/* harmony import */ var _segmentation_SegmentSelectTool__WEBPACK_IMPORTED_MODULE_57__ = __webpack_require__(12905);
+/* harmony import */ var _segmentation_SegmentBidirectionalTool__WEBPACK_IMPORTED_MODULE_58__ = __webpack_require__(38502);
+/* harmony import */ var _segmentation_strategies__WEBPACK_IMPORTED_MODULE_59__ = __webpack_require__(99522);
+/* harmony import */ var _segmentation_SegmentLabelTool__WEBPACK_IMPORTED_MODULE_60__ = __webpack_require__(987);
+/* harmony import */ var _segmentation_LabelmapEditWithContour__WEBPACK_IMPORTED_MODULE_61__ = __webpack_require__(89584);
+
+
 
 
 
@@ -25911,6 +27315,8 @@ function getContourHolesDataWorld(annotation) {
 /* harmony import */ var _triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(49906);
 /* harmony import */ var _addColorLUT__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(4714);
 /* harmony import */ var _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(59475);
+/* harmony import */ var _segmentIndex__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(70930);
+
 
 
 
@@ -25924,6 +27330,16 @@ function internalAddSegmentationRepresentation(viewportId, representationInput)
         ...config,
     };
     _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_5__/* .defaultSegmentationStateManager */ ._6.addSegmentationRepresentation(viewportId, segmentationId, representationInput.type, renderingConfig);
+    if (!(0,_segmentIndex__WEBPACK_IMPORTED_MODULE_6__.getActiveSegmentIndex)(segmentationId)) {
+        const segmentation = _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_5__/* .defaultSegmentationStateManager */ ._6.getSegmentation(segmentationId);
+        if (segmentation) {
+            const segmentKeys = Object.keys(segmentation.segments);
+            if (segmentKeys.length > 0) {
+                const firstSegmentIndex = segmentKeys.map((k) => Number(k)).sort()[0];
+                (0,_segmentIndex__WEBPACK_IMPORTED_MODULE_6__.setActiveSegmentIndex)(segmentationId, firstSegmentIndex);
+            }
+        }
+    }
     if (representationInput.type === _enums__WEBPACK_IMPORTED_MODULE_2__.SegmentationRepresentations.Contour) {
         (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_1__/* .triggerAnnotationRenderForViewportIds */ .t)([viewportId]);
     }
@@ -26826,6 +28242,7 @@ function presentationViewSyncCallback(_synchronizerInstance, sourceViewport, tar
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   C$: () => (/* binding */ getEllipseCornersFromCanvasCoordinates),
 /* harmony export */   N5: () => (/* binding */ fillOutsideCircle),
 /* harmony export */   kr: () => (/* binding */ fillInsideCircle),
 /* harmony export */   mu: () => (/* binding */ createPointInEllipse),
@@ -26835,13 +28252,11 @@ function presentationViewSyncCallback(_synchronizerInstance, sourceViewport, tar
 /* unused harmony export CIRCLE_THRESHOLD_STRATEGY */
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(3823);
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(15327);
-/* harmony import */ var _utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(11683);
-/* harmony import */ var _utilities_boundingBox__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(72282);
-/* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(55887);
-/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(99737);
-/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(11990);
-/* harmony import */ var _utilities_math_sphere__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(62783);
-
+/* harmony import */ var _utilities_boundingBox__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(72282);
+/* harmony import */ var _BrushStrategy__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(55887);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(99737);
+/* harmony import */ var _compositions__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(11990);
+/* harmony import */ var _utilities_math_sphere__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(62783);
 
 
 
@@ -26850,62 +28265,86 @@ function presentationViewSyncCallback(_synchronizerInstance, sourceViewport, tar
 
 
 const { transformWorldToIndex, isEqual } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities;
+function getEllipseCornersFromCanvasCoordinates(canvasCoordinates) {
+    const [bottom, top, left, right] = canvasCoordinates;
+    const topLeft = [left[0], top[1]];
+    const bottomRight = [right[0], bottom[1]];
+    const bottomLeft = [left[0], bottom[1]];
+    const topRight = [right[0], top[1]];
+    return [topLeft, bottomRight, bottomLeft, topRight];
+}
 const initializeCircle = {
-    [_enums__WEBPACK_IMPORTED_MODULE_5__.StrategyCallbacks.Initialize]: (operationData) => {
+    [_enums__WEBPACK_IMPORTED_MODULE_4__.StrategyCallbacks.Initialize]: (operationData) => {
         const { points, viewport, segmentationImageData, } = 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);
+        const center = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        if (points.length >= 2) {
+            gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.add */ .eR.add(center, points[0], points[1]);
+            gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.scale */ .eR.scale(center, center, 0.5);
+        }
+        else {
+            gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.copy */ .eR.copy(center, points[0]);
+        }
         operationData.centerWorld = center;
         operationData.centerIJK = transformWorldToIndex(segmentationImageData, center);
         const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-        const [topLeftCanvas, bottomRightCanvas] = (0,_utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_2__.getCanvasEllipseCorners)(canvasCoordinates);
-        const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
-        const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);
+        const corners = getEllipseCornersFromCanvasCoordinates(canvasCoordinates);
+        const cornersInWorld = corners.map((corner) => viewport.canvasToWorld(corner));
         const circleCornersIJK = points.map((world) => {
             return transformWorldToIndex(segmentationImageData, world);
         });
-        const boundsIJK = (0,_utilities_boundingBox__WEBPACK_IMPORTED_MODULE_3__.getBoundingBoxAroundShapeIJK)(circleCornersIJK, segmentationImageData.getDimensions());
-        operationData.isInObject = createPointInEllipse({
-            topLeftWorld,
-            bottomRightWorld,
-            center,
-        });
+        const boundsIJK = (0,_utilities_boundingBox__WEBPACK_IMPORTED_MODULE_2__.getBoundingBoxAroundShapeIJK)(circleCornersIJK, segmentationImageData.getDimensions());
+        operationData.isInObject = createPointInEllipse(cornersInWorld);
         operationData.isInObjectBoundsIJK = boundsIJK;
     },
 };
-function createPointInEllipse(worldInfo) {
-    const { topLeftWorld, bottomRightWorld, center } = worldInfo;
-    const xRadius = Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2;
-    const yRadius = Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2;
-    const zRadius = Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2;
-    const radius = Math.max(xRadius, yRadius, zRadius);
-    if (isEqual(xRadius, radius) &&
-        isEqual(yRadius, radius) &&
-        isEqual(zRadius, radius)) {
+function createPointInEllipse(cornersInWorld = []) {
+    if (!cornersInWorld || cornersInWorld.length !== 4) {
+        throw new Error('createPointInEllipse: cornersInWorld must have 4 points');
+    }
+    const [topLeft, bottomRight, bottomLeft, topRight] = cornersInWorld;
+    const center = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.add */ .eR.add(center, topLeft, bottomRight);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.scale */ .eR.scale(center, center, 0.5);
+    const majorAxisVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(majorAxisVec, topRight, topLeft);
+    const xRadius = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.length */ .eR.length(majorAxisVec) / 2;
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(majorAxisVec, majorAxisVec);
+    const minorAxisVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(minorAxisVec, bottomLeft, topLeft);
+    const yRadius = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.length */ .eR.length(minorAxisVec) / 2;
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(minorAxisVec, minorAxisVec);
+    const normal = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.cross */ .eR.cross(normal, majorAxisVec, minorAxisVec);
+    gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.normalize */ .eR.normalize(normal, normal);
+    if (isEqual(xRadius, yRadius)) {
+        const radius = xRadius;
         const sphereObj = {
             center,
             radius,
             radius2: radius * radius,
         };
-        return (pointLPS) => (0,_utilities_math_sphere__WEBPACK_IMPORTED_MODULE_7__/* .pointInSphere */ .d)(sphereObj, pointLPS);
-    }
-    const ellipseObj = {
-        center: center,
-        xRadius,
-        yRadius,
-        zRadius,
+        return (pointLPS) => (0,_utilities_math_sphere__WEBPACK_IMPORTED_MODULE_6__/* .pointInSphere */ .d)(sphereObj, pointLPS);
+    }
+    return (pointLPS) => {
+        const pointVec = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(pointVec, pointLPS, center);
+        const distToPlane = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(pointVec, normal);
+        const proj = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.scaleAndAdd */ .eR.scaleAndAdd(proj, pointVec, normal, -distToPlane);
+        const fromTopLeft = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        const centerToTopLeft = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.create */ .eR.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(centerToTopLeft, center, topLeft);
+        gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.subtract */ .eR.subtract(fromTopLeft, proj, centerToTopLeft);
+        const x = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(fromTopLeft, majorAxisVec);
+        const y = gl_matrix__WEBPACK_IMPORTED_MODULE_0__/* .vec3.dot */ .eR.dot(fromTopLeft, minorAxisVec);
+        return (x * x) / (xRadius * xRadius) + (y * y) / (yRadius * yRadius) <= 1;
     };
-    const { precalculated } = (0,_utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_2__.precalculatePointInEllipse)(ellipseObj, {});
-    return precalculated;
 }
-const CIRCLE_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A('Circle', _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.setValue, initializeCircle, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.preview, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.labelmapStatistics);
-const CIRCLE_THRESHOLD_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .A('CircleThreshold', _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.setValue, initializeCircle, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.dynamicThreshold, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.threshold, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.preview, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.islandRemoval, _compositions__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A.labelmapStatistics);
+const CIRCLE_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A('Circle', _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.setValue, initializeCircle, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.preview, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.labelmapStatistics);
+const CIRCLE_THRESHOLD_STRATEGY = new _BrushStrategy__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A('CircleThreshold', _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.regionFill, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.setValue, initializeCircle, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.determineSegmentIndex, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.dynamicThreshold, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.threshold, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.preview, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.islandRemoval, _compositions__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.labelmapStatistics);
 const fillInsideCircle = CIRCLE_STRATEGY.strategyFunction;
 const thresholdInsideCircle = CIRCLE_THRESHOLD_STRATEGY.strategyFunction;
 function fillOutsideCircle() {
@@ -29316,6 +30755,7 @@ class ProbeTool extends _base__WEBPACK_IMPORTED_MODULE_2__/* .AnnotationTool */
                     Modality: modality,
                     modalityUnit,
                 };
+                annotation.invalidated = true;
             }
             else {
                 this.isHandleOutsideImage = true;
@@ -30142,7 +31582,7 @@ function cleanupPolylines(polylines) {
 /* harmony import */ var _utilities_math_circle__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(77081);
 /* harmony import */ var _utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(4096);
 /* harmony import */ var _utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(18990);
-/* harmony import */ var _utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(11683);
+/* harmony import */ var _utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(87009);
 /* harmony import */ var _utilities_math_basic__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(73262);
 /* harmony import */ var _utilities_planar__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(13165);
 /* harmony import */ var _utilities_getPixelValueUnits__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(40634);
@@ -35129,7 +36569,7 @@ function updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(60810);
 /* harmony import */ var _utilities_drawing__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(473);
 /* harmony import */ var _utilities_planar_getWorldWidthAndHeightFromTwoPoints__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(62514);
-/* harmony import */ var _utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(11683);
+/* harmony import */ var _utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(87009);
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(7001);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(58640);
 /* harmony import */ var _utilities_getPixelValueUnits__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(40634);
@@ -36812,6 +38252,1095 @@ PlanarRotateTool.toolName = 'PlanarRotate';
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (PlanarRotateTool);
 
 
+/***/ }),
+
+/***/ 82461:
+/***/ ((__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 _kitware_vtk_js_Common_DataModel_PolyData__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(87275);
+/* harmony import */ var _kitware_vtk_js_Common_Core_Points__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(74966);
+/* harmony import */ var _kitware_vtk_js_Common_Core_CellArray__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(35056);
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(3823);
+/* harmony import */ var _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(84607);
+/* harmony import */ var _kitware_vtk_js_Rendering_Core_Actor__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(7019);
+/* harmony import */ var _kitware_vtk_js_Filters_Sources_SphereSource__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(1060);
+/* harmony import */ var _kitware_vtk_js_Rendering_Core_Mapper__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(82409);
+/* harmony import */ var _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(75127);
+/* harmony import */ var _base__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(85817);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(15327);
+/* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(77609);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(99737);
+
+
+
+
+
+
+
+
+
+
+
+
+
+const PLANEINDEX = {
+    XMIN: 0,
+    XMAX: 1,
+    YMIN: 2,
+    YMAX: 3,
+    ZMIN: 4,
+    ZMAX: 5,
+};
+const SPHEREINDEX = {
+    XMIN: 0,
+    XMAX: 1,
+    YMIN: 2,
+    YMAX: 3,
+    ZMIN: 4,
+    ZMAX: 5,
+    XMIN_YMIN_ZMIN: 6,
+    XMIN_YMIN_ZMAX: 7,
+    XMIN_YMAX_ZMIN: 8,
+    XMIN_YMAX_ZMAX: 9,
+    XMAX_YMIN_ZMIN: 10,
+    XMAX_YMIN_ZMAX: 11,
+    XMAX_YMAX_ZMIN: 12,
+    XMAX_YMAX_ZMAX: 13,
+};
+class VolumeCroppingTool extends _base__WEBPACK_IMPORTED_MODULE_9__/* .BaseTool */ .oS {
+    constructor(toolProps = {}, defaultToolProps = {
+        configuration: {
+            showCornerSpheres: true,
+            showHandles: true,
+            showClippingPlanes: true,
+            mobile: {
+                enabled: false,
+                opacity: 0.8,
+            },
+            initialCropFactor: 0.08,
+            sphereColors: {
+                SAGITTAL: [1.0, 1.0, 0.0],
+                CORONAL: [0.0, 1.0, 0.0],
+                AXIAL: [1.0, 0.0, 0.0],
+                CORNERS: [0.0, 0.0, 1.0],
+            },
+            sphereRadius: 8,
+            grabSpherePixelDistance: 20,
+            rotateIncrementDegrees: 2,
+            rotateSampleDistanceFactor: 2,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this._resizeObservers = new Map();
+        this._hasResolutionChanged = false;
+        this.originalClippingPlanes = [];
+        this.draggingSphereIndex = null;
+        this.toolCenter = [0, 0, 0];
+        this.cornerDragOffset = null;
+        this.faceDragOffset = null;
+        this.sphereStates = [];
+        this.edgeLines = {};
+        this.onSetToolConfiguration = () => {
+            console.debug('Setting tool settoolconfiguration : volumeCropping');
+        };
+        this.onSetToolEnabled = () => {
+            console.debug('Setting tool enabled: volumeCropping');
+        };
+        this.onCameraModified = (evt) => {
+            const { element } = evt.currentTarget
+                ? { element: evt.currentTarget }
+                : evt.detail;
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.getEnabledElement)(element);
+            this._updateClippingPlanes(enabledElement.viewport);
+            enabledElement.viewport.render();
+        };
+        this.preMouseDownCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.getEnabledElement)(element);
+            const { viewport } = enabledElement;
+            const actorEntry = viewport.getDefaultActor();
+            const actor = actorEntry.actor;
+            const mapper = actor.getMapper();
+            const mouseCanvas = [
+                evt.detail.currentPoints.canvas[0],
+                evt.detail.currentPoints.canvas[1],
+            ];
+            this.draggingSphereIndex = null;
+            this.cornerDragOffset = null;
+            this.faceDragOffset = null;
+            for (let i = 0; i < this.sphereStates.length; ++i) {
+                const sphereCanvas = viewport.worldToCanvas(this.sphereStates[i].point);
+                const dist = Math.sqrt(Math.pow(mouseCanvas[0] - sphereCanvas[0], 2) +
+                    Math.pow(mouseCanvas[1] - sphereCanvas[1], 2));
+                if (dist < this.configuration.grabSpherePixelDistance) {
+                    this.draggingSphereIndex = i;
+                    element.style.cursor = 'grabbing';
+                    const sphereState = this.sphereStates[i];
+                    const mouseWorld = viewport.canvasToWorld(mouseCanvas);
+                    if (sphereState.isCorner) {
+                        this.cornerDragOffset = [
+                            sphereState.point[0] - mouseWorld[0],
+                            sphereState.point[1] - mouseWorld[1],
+                            sphereState.point[2] - mouseWorld[2],
+                        ];
+                        this.faceDragOffset = null;
+                    }
+                    else {
+                        const axisIdx = { x: 0, y: 1, z: 2 }[sphereState.axis];
+                        this.faceDragOffset =
+                            sphereState.point[axisIdx] - mouseWorld[axisIdx];
+                        this.cornerDragOffset = null;
+                    }
+                    return true;
+                }
+            }
+            const hasSampleDistance = 'getSampleDistance' in mapper || 'getCurrentSampleDistance' in mapper;
+            if (!hasSampleDistance) {
+                return true;
+            }
+            const originalSampleDistance = mapper.getSampleDistance();
+            if (!this._hasResolutionChanged) {
+                const { rotateSampleDistanceFactor } = this.configuration;
+                mapper.setSampleDistance(originalSampleDistance * rotateSampleDistanceFactor);
+                this._hasResolutionChanged = true;
+                if (this.cleanUp !== null) {
+                    document.removeEventListener('mouseup', this.cleanUp);
+                }
+                this.cleanUp = () => {
+                    mapper.setSampleDistance(originalSampleDistance);
+                    evt.target.style.cursor = '';
+                    if (this.draggingSphereIndex !== null) {
+                        const sphereState = this.sphereStates[this.draggingSphereIndex];
+                        const [viewport3D] = this._getViewportsInfo();
+                        const renderingEngine = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.getRenderingEngine)(viewport3D.renderingEngineId);
+                        const viewport = renderingEngine.getViewport(viewport3D.viewportId);
+                        if (sphereState.isCorner) {
+                            this._updateCornerSpheres();
+                            this._updateFaceSpheresFromCorners();
+                            this._updateClippingPlanesFromFaceSpheres(viewport);
+                        }
+                    }
+                    this.draggingSphereIndex = null;
+                    this.cornerDragOffset = null;
+                    this.faceDragOffset = null;
+                    viewport.render();
+                    this._hasResolutionChanged = false;
+                };
+                document.addEventListener('mouseup', this.cleanUp, { once: true });
+            }
+            return true;
+        };
+        this._onMouseMoveSphere = (evt) => {
+            if (this.draggingSphereIndex === null) {
+                return false;
+            }
+            const sphereState = this.sphereStates[this.draggingSphereIndex];
+            if (!sphereState) {
+                return false;
+            }
+            const { viewport, world } = this._getViewportAndWorldCoords(evt);
+            if (!viewport || !world) {
+                return false;
+            }
+            if (sphereState.isCorner) {
+                const newCorner = this._calculateNewCornerPosition(world);
+                this._updateSpherePosition(sphereState, newCorner);
+                const axisFlags = this._parseCornerKey(sphereState.uid);
+                this._updateRelatedCorners(sphereState, newCorner, axisFlags);
+                this._updateFaceSpheresFromCorners();
+                this._updateCornerSpheres();
+            }
+            else {
+                const axisIdx = { x: 0, y: 1, z: 2 }[sphereState.axis];
+                let newValue = world[axisIdx];
+                if (this.faceDragOffset !== null) {
+                    newValue += this.faceDragOffset;
+                }
+                sphereState.point[axisIdx] = newValue;
+                sphereState.sphereSource.setCenter(...sphereState.point);
+                sphereState.sphereSource.modified();
+                this._updateCornerSpheresFromFaces();
+                this._updateFaceSpheresFromCorners();
+                this._updateCornerSpheres();
+            }
+            this._updateClippingPlanesFromFaceSpheres(viewport);
+            viewport.render();
+            this._triggerToolChangedEvent(sphereState);
+            return true;
+        };
+        this._onControlToolChange = (evt) => {
+            const viewport = this._getViewport();
+            if (!evt.detail.toolCenter) {
+                (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.eventTarget, _enums__WEBPACK_IMPORTED_MODULE_12__.Events.VOLUMECROPPING_TOOL_CHANGED, {
+                    originalClippingPlanes: this.originalClippingPlanes,
+                    viewportId: viewport.id,
+                    renderingEngineId: viewport.renderingEngineId,
+                    seriesInstanceUID: this.seriesInstanceUID,
+                });
+            }
+            else {
+                if (evt.detail.seriesInstanceUID !== this.seriesInstanceUID) {
+                    return;
+                }
+                const isMin = evt.detail.handleType === 'min';
+                const toolCenter = isMin
+                    ? evt.detail.toolCenterMin
+                    : evt.detail.toolCenterMax;
+                const normals = isMin
+                    ? [
+                        [1, 0, 0],
+                        [0, 1, 0],
+                        [0, 0, 1],
+                    ]
+                    : [
+                        [-1, 0, 0],
+                        [0, -1, 0],
+                        [0, 0, -1],
+                    ];
+                const planeIndices = isMin
+                    ? [PLANEINDEX.XMIN, PLANEINDEX.YMIN, PLANEINDEX.ZMIN]
+                    : [PLANEINDEX.XMAX, PLANEINDEX.YMAX, PLANEINDEX.ZMAX];
+                const sphereIndices = isMin
+                    ? [SPHEREINDEX.XMIN, SPHEREINDEX.YMIN, SPHEREINDEX.ZMIN]
+                    : [SPHEREINDEX.XMAX, SPHEREINDEX.YMAX, SPHEREINDEX.ZMAX];
+                const axes = ['x', 'y', 'z'];
+                const orientationAxes = [
+                    _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.Enums.OrientationAxis.SAGITTAL,
+                    _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.Enums.OrientationAxis.CORONAL,
+                    _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.Enums.OrientationAxis.AXIAL,
+                ];
+                for (let i = 0; i < 3; ++i) {
+                    const origin = [0, 0, 0];
+                    origin[i] = toolCenter[i];
+                    const plane = _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_8__/* ["default"].newInstance */ .Ay.newInstance({
+                        origin,
+                        normal: normals[i],
+                    });
+                    this.originalClippingPlanes[planeIndices[i]].origin = plane.getOrigin();
+                    this.sphereStates[sphereIndices[i]].point[i] = plane.getOrigin()[i];
+                    this.sphereStates[sphereIndices[i]].sphereSource.setCenter(...this.sphereStates[sphereIndices[i]].point);
+                    this.sphereStates[sphereIndices[i]].sphereSource.modified();
+                    const otherSphere = this.sphereStates.find((s, idx) => s.axis === axes[i] && idx !== sphereIndices[i]);
+                    const newCenter = (otherSphere.point[i] + plane.getOrigin()[i]) / 2;
+                    this.sphereStates.forEach((state) => {
+                        if (!state.isCorner &&
+                            state.axis !== axes[i] &&
+                            !evt.detail.viewportOrientation.includes(orientationAxes[i])) {
+                            state.point[i] = newCenter;
+                            state.sphereSource.setCenter(state.point);
+                            state.sphereActor.getProperty().setColor(state.color);
+                            state.sphereSource.modified();
+                        }
+                    });
+                    const volumeActor = viewport.getDefaultActor()?.actor;
+                    if (volumeActor) {
+                        const mapper = volumeActor.getMapper();
+                        const clippingPlanes = mapper.getClippingPlanes();
+                        if (clippingPlanes) {
+                            clippingPlanes[planeIndices[i]].setOrigin(plane.getOrigin());
+                        }
+                    }
+                }
+                this._updateCornerSpheres();
+                viewport.render();
+            }
+        };
+        this._getViewportsInfo = () => {
+            const viewports = (0,_store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_11__.getToolGroup)(this.toolGroupId).viewportsInfo;
+            return viewports;
+        };
+        this._initialize3DViewports = (viewportsInfo) => {
+            if (!viewportsInfo || !viewportsInfo.length || !viewportsInfo[0]) {
+                console.warn('VolumeCroppingTool: No viewportsInfo available for initialization of volumecroppingtool.');
+                return;
+            }
+            const viewport = this._getViewport();
+            const volumeActors = viewport.getActors();
+            if (!volumeActors || volumeActors.length === 0) {
+                console.warn('VolumeCroppingTool: No volume actors found in the viewport.');
+                return;
+            }
+            const imageData = volumeActors[0].actor.getMapper().getInputData();
+            if (!imageData) {
+                console.warn('VolumeCroppingTool: No image data found for volume actor.');
+                return;
+            }
+            this.seriesInstanceUID = imageData.seriesInstanceUID || 'unknown';
+            const worldBounds = imageData.getBounds();
+            const cropFactor = this.configuration.initialCropFactor || 0.1;
+            const xRange = worldBounds[1] - worldBounds[0];
+            const yRange = worldBounds[3] - worldBounds[2];
+            const zRange = worldBounds[5] - worldBounds[4];
+            const xMin = worldBounds[0] + cropFactor * xRange;
+            const xMax = worldBounds[1] - cropFactor * xRange;
+            const yMin = worldBounds[2] + cropFactor * yRange;
+            const yMax = worldBounds[3] - cropFactor * yRange;
+            const zMin = worldBounds[4] + cropFactor * zRange;
+            const zMax = worldBounds[5] - cropFactor * zRange;
+            const planes = [];
+            const planeXmin = _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_8__/* ["default"].newInstance */ .Ay.newInstance({
+                origin: [xMin, 0, 0],
+                normal: [1, 0, 0],
+            });
+            const planeXmax = _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_8__/* ["default"].newInstance */ .Ay.newInstance({
+                origin: [xMax, 0, 0],
+                normal: [-1, 0, 0],
+            });
+            const planeYmin = _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_8__/* ["default"].newInstance */ .Ay.newInstance({
+                origin: [0, yMin, 0],
+                normal: [0, 1, 0],
+            });
+            const planeYmax = _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_8__/* ["default"].newInstance */ .Ay.newInstance({
+                origin: [0, yMax, 0],
+                normal: [0, -1, 0],
+            });
+            const planeZmin = _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_8__/* ["default"].newInstance */ .Ay.newInstance({
+                origin: [0, 0, zMin],
+                normal: [0, 0, 1],
+            });
+            const planeZmax = _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_8__/* ["default"].newInstance */ .Ay.newInstance({
+                origin: [0, 0, zMax],
+                normal: [0, 0, -1],
+            });
+            const mapper = viewport
+                .getDefaultActor()
+                .actor.getMapper();
+            planes.push(planeXmin);
+            planes.push(planeXmax);
+            planes.push(planeYmin);
+            planes.push(planeYmax);
+            planes.push(planeZmin);
+            planes.push(planeZmax);
+            const originalPlanes = planes.map((plane) => ({
+                origin: [...plane.getOrigin()],
+                normal: [...plane.getNormal()],
+            }));
+            this.originalClippingPlanes = originalPlanes;
+            const sphereXminPoint = [xMin, (yMax + yMin) / 2, (zMax + zMin) / 2];
+            const sphereXmaxPoint = [xMax, (yMax + yMin) / 2, (zMax + zMin) / 2];
+            const sphereYminPoint = [(xMax + xMin) / 2, yMin, (zMax + zMin) / 2];
+            const sphereYmaxPoint = [(xMax + xMin) / 2, yMax, (zMax + zMin) / 2];
+            const sphereZminPoint = [(xMax + xMin) / 2, (yMax + yMin) / 2, zMin];
+            const sphereZmaxPoint = [(xMax + xMin) / 2, (yMax + yMin) / 2, zMax];
+            const adaptiveRadius = this._calculateAdaptiveSphereRadius(Math.sqrt(xRange * xRange + yRange * yRange + zRange * zRange));
+            this._addSphere(viewport, sphereXminPoint, 'x', 'min', null, adaptiveRadius);
+            this._addSphere(viewport, sphereXmaxPoint, 'x', 'max', null, adaptiveRadius);
+            this._addSphere(viewport, sphereYminPoint, 'y', 'min', null, adaptiveRadius);
+            this._addSphere(viewport, sphereYmaxPoint, 'y', 'max', null, adaptiveRadius);
+            this._addSphere(viewport, sphereZminPoint, 'z', 'min', null, adaptiveRadius);
+            this._addSphere(viewport, sphereZmaxPoint, 'z', 'max', null, adaptiveRadius);
+            const corners = [
+                [xMin, yMin, zMin],
+                [xMin, yMin, zMax],
+                [xMin, yMax, zMin],
+                [xMin, yMax, zMax],
+                [xMax, yMin, zMin],
+                [xMax, yMin, zMax],
+                [xMax, yMax, zMin],
+                [xMax, yMax, zMax],
+            ];
+            const cornerKeys = [
+                'XMIN_YMIN_ZMIN',
+                'XMIN_YMIN_ZMAX',
+                'XMIN_YMAX_ZMIN',
+                'XMIN_YMAX_ZMAX',
+                'XMAX_YMIN_ZMIN',
+                'XMAX_YMIN_ZMAX',
+                'XMAX_YMAX_ZMIN',
+                'XMAX_YMAX_ZMAX',
+            ];
+            for (let i = 0; i < corners.length; i++) {
+                this._addSphere(viewport, corners[i], 'corner', null, cornerKeys[i], adaptiveRadius);
+            }
+            const edgeCornerPairs = [
+                ['XMIN_YMIN_ZMIN', 'XMAX_YMIN_ZMIN'],
+                ['XMIN_YMIN_ZMAX', 'XMAX_YMIN_ZMAX'],
+                ['XMIN_YMAX_ZMIN', 'XMAX_YMAX_ZMIN'],
+                ['XMIN_YMAX_ZMAX', 'XMAX_YMAX_ZMAX'],
+                ['XMIN_YMIN_ZMIN', 'XMIN_YMAX_ZMIN'],
+                ['XMIN_YMIN_ZMAX', 'XMIN_YMAX_ZMAX'],
+                ['XMAX_YMIN_ZMIN', 'XMAX_YMAX_ZMIN'],
+                ['XMAX_YMIN_ZMAX', 'XMAX_YMAX_ZMAX'],
+                ['XMIN_YMIN_ZMIN', 'XMIN_YMIN_ZMAX'],
+                ['XMIN_YMAX_ZMIN', 'XMIN_YMAX_ZMAX'],
+                ['XMAX_YMIN_ZMIN', 'XMAX_YMIN_ZMAX'],
+                ['XMAX_YMAX_ZMIN', 'XMAX_YMAX_ZMAX'],
+            ];
+            edgeCornerPairs.forEach(([key1, key2], i) => {
+                const state1 = this.sphereStates.find((s) => s.uid === `corner_${key1}`);
+                const state2 = this.sphereStates.find((s) => s.uid === `corner_${key2}`);
+                if (state1 && state2) {
+                    const uid = `edge_${key1}_${key2}`;
+                    const { actor, source } = this._addLine3DBetweenPoints(viewport, state1.point, state2.point, [0.7, 0.7, 0.7], uid);
+                    this.edgeLines[uid] = { actor, source, key1, key2 };
+                }
+            });
+            mapper.addClippingPlane(planeXmin);
+            mapper.addClippingPlane(planeXmax);
+            mapper.addClippingPlane(planeYmin);
+            mapper.addClippingPlane(planeYmax);
+            mapper.addClippingPlane(planeZmin);
+            mapper.addClippingPlane(planeZmax);
+            _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.eventTarget.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_12__.Events.VOLUMECROPPINGCONTROL_TOOL_CHANGED, (evt) => {
+                this._onControlToolChange(evt);
+            });
+            viewport.render();
+        };
+        this._getViewportAndWorldCoords = (evt) => {
+            const viewport = this._getViewport();
+            const x = evt.detail.currentPoints.canvas[0];
+            const y = evt.detail.currentPoints.canvas[1];
+            const world = viewport.canvasToWorld([x, y]);
+            return { viewport, world };
+        };
+        this._getViewport = () => {
+            const [viewport3D] = this._getViewportsInfo();
+            const renderingEngine = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.getRenderingEngine)(viewport3D.renderingEngineId);
+            return renderingEngine.getViewport(viewport3D.viewportId);
+        };
+        this._handleCornerSphereMovement = (sphereState, world, viewport) => {
+            const newCorner = this._calculateNewCornerPosition(world);
+            this._updateSpherePosition(sphereState, newCorner);
+            const axisFlags = this._parseCornerKey(sphereState.uid);
+            this._updateRelatedCorners(sphereState, newCorner, axisFlags);
+            this._updateAfterCornerMovement(viewport);
+        };
+        this._handleFaceSphereMovement = (sphereState, world, viewport) => {
+            const axisIdx = { x: 0, y: 1, z: 2 }[sphereState.axis];
+            let newValue = world[axisIdx];
+            if (this.faceDragOffset !== null) {
+                newValue += this.faceDragOffset;
+            }
+            sphereState.point[axisIdx] = newValue;
+            sphereState.sphereSource.setCenter(...sphereState.point);
+            sphereState.sphereSource.modified();
+            this._updateAfterFaceMovement(viewport);
+        };
+        this._calculateNewCornerPosition = (world) => {
+            let newCorner = [world[0], world[1], world[2]];
+            if (this.cornerDragOffset) {
+                newCorner = [
+                    world[0] + this.cornerDragOffset[0],
+                    world[1] + this.cornerDragOffset[1],
+                    world[2] + this.cornerDragOffset[2],
+                ];
+            }
+            return newCorner;
+        };
+        this._parseCornerKey = (uid) => {
+            const cornerKey = uid.replace('corner_', '');
+            return {
+                isXMin: cornerKey.includes('XMIN'),
+                isXMax: cornerKey.includes('XMAX'),
+                isYMin: cornerKey.includes('YMIN'),
+                isYMax: cornerKey.includes('YMAX'),
+                isZMin: cornerKey.includes('ZMIN'),
+                isZMax: cornerKey.includes('ZMAX'),
+            };
+        };
+        this._updateSpherePosition = (sphereState, newPosition) => {
+            sphereState.point = newPosition;
+            sphereState.sphereSource.setCenter(...newPosition);
+            sphereState.sphereSource.modified();
+        };
+        this._updateRelatedCorners = (draggedSphere, newCorner, axisFlags) => {
+            this.sphereStates.forEach((state) => {
+                if (!state.isCorner || state === draggedSphere) {
+                    return;
+                }
+                const key = state.uid.replace('corner_', '');
+                const shouldUpdate = this._shouldUpdateCorner(key, axisFlags);
+                if (shouldUpdate) {
+                    this._updateCornerCoordinates(state, newCorner, key, axisFlags);
+                }
+            });
+        };
+        this._shouldUpdateCorner = (cornerKey, axisFlags) => {
+            return ((axisFlags.isXMin && cornerKey.includes('XMIN')) ||
+                (axisFlags.isXMax && cornerKey.includes('XMAX')) ||
+                (axisFlags.isYMin && cornerKey.includes('YMIN')) ||
+                (axisFlags.isYMax && cornerKey.includes('YMAX')) ||
+                (axisFlags.isZMin && cornerKey.includes('ZMIN')) ||
+                (axisFlags.isZMax && cornerKey.includes('ZMAX')));
+        };
+        this._updateCornerCoordinates = (state, newCorner, cornerKey, axisFlags) => {
+            if ((axisFlags.isXMin && cornerKey.includes('XMIN')) ||
+                (axisFlags.isXMax && cornerKey.includes('XMAX'))) {
+                state.point[0] = newCorner[0];
+            }
+            if ((axisFlags.isYMin && cornerKey.includes('YMIN')) ||
+                (axisFlags.isYMax && cornerKey.includes('YMAX'))) {
+                state.point[1] = newCorner[1];
+            }
+            if ((axisFlags.isZMin && cornerKey.includes('ZMIN')) ||
+                (axisFlags.isZMax && cornerKey.includes('ZMAX'))) {
+                state.point[2] = newCorner[2];
+            }
+            state.sphereSource.setCenter(...state.point);
+            state.sphereSource.modified();
+        };
+        this._updateAfterCornerMovement = (viewport) => {
+            this._updateFaceSpheresFromCorners();
+            this._updateCornerSpheres();
+            this._updateClippingPlanesFromFaceSpheres(viewport);
+        };
+        this._updateAfterFaceMovement = (viewport) => {
+            this._updateCornerSpheresFromFaces();
+            this._updateClippingPlanesFromFaceSpheres(viewport);
+        };
+        this._triggerToolChangedEvent = (sphereState) => {
+            (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.eventTarget, _enums__WEBPACK_IMPORTED_MODULE_12__.Events.VOLUMECROPPING_TOOL_CHANGED, {
+                toolCenter: sphereState.point,
+                axis: sphereState.isCorner ? 'corner' : sphereState.axis,
+                draggingSphereIndex: this.draggingSphereIndex,
+                seriesInstanceUID: this.seriesInstanceUID,
+            });
+        };
+        this._onNewVolume = () => {
+            const viewportsInfo = this._getViewportsInfo();
+            this.originalClippingPlanes = [];
+            this.sphereStates = [];
+            this.edgeLines = {};
+            this._initialize3DViewports(viewportsInfo);
+        };
+        this._rotateCamera = (viewport, centerWorld, axis, angle) => {
+            const vtkCamera = viewport.getVtkActiveCamera();
+            const viewUp = vtkCamera.getViewUp();
+            const focalPoint = vtkCamera.getFocalPoint();
+            const position = vtkCamera.getPosition();
+            const newPosition = [0, 0, 0];
+            const newFocalPoint = [0, 0, 0];
+            const newViewUp = [0, 0, 0];
+            const transform = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .mat4.identity */ .pB.identity(new Float32Array(16));
+            gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .mat4.translate */ .pB.translate(transform, transform, centerWorld);
+            gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .mat4.rotate */ .pB.rotate(transform, transform, angle, axis);
+            gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .mat4.translate */ .pB.translate(transform, transform, [
+                -centerWorld[0],
+                -centerWorld[1],
+                -centerWorld[2],
+            ]);
+            gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.transformMat4 */ .eR.transformMat4(newPosition, position, transform);
+            gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.transformMat4 */ .eR.transformMat4(newFocalPoint, focalPoint, transform);
+            gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .mat4.identity */ .pB.identity(transform);
+            gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .mat4.rotate */ .pB.rotate(transform, transform, angle, axis);
+            gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.transformMat4 */ .eR.transformMat4(newViewUp, viewUp, transform);
+            viewport.setCamera({
+                position: newPosition,
+                viewUp: newViewUp,
+                focalPoint: newFocalPoint,
+            });
+        };
+        this.touchDragCallback = this._dragCallback.bind(this);
+        this.mouseDragCallback = this._dragCallback.bind(this);
+    }
+    onSetToolActive() {
+        if (this.sphereStates && this.sphereStates.length > 0) {
+            if (this.configuration.showHandles) {
+                this.setHandlesVisible(false);
+                this.setClippingPlanesVisible(false);
+            }
+            else {
+                this.setHandlesVisible(true);
+                this.setClippingPlanesVisible(true);
+            }
+        }
+        else {
+            const viewportsInfo = this._getViewportsInfo();
+            const subscribeToElementResize = () => {
+                viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+                    if (!this._resizeObservers.has(viewportId)) {
+                        const { viewport } = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.getEnabledElementByIds)(viewportId, renderingEngineId) || { viewport: null };
+                        if (!viewport) {
+                            return;
+                        }
+                        const { element } = viewport;
+                        const resizeObserver = new ResizeObserver(() => {
+                            const element = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.getEnabledElementByIds)(viewportId, renderingEngineId);
+                            if (!element) {
+                                return;
+                            }
+                            const { viewport } = element;
+                            const viewPresentation = viewport.getViewPresentation();
+                            viewport.resetCamera();
+                            viewport.setViewPresentation(viewPresentation);
+                            viewport.render();
+                        });
+                        resizeObserver.observe(element);
+                        this._resizeObservers.set(viewportId, resizeObserver);
+                    }
+                });
+            };
+            subscribeToElementResize();
+            this._viewportAddedListener = (evt) => {
+                if (evt.detail.toolGroupId === this.toolGroupId) {
+                    subscribeToElementResize();
+                }
+            };
+            _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.eventTarget.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_12__.Events.TOOLGROUP_VIEWPORT_ADDED, this._viewportAddedListener);
+            this._unsubscribeToViewportNewVolumeSet(viewportsInfo);
+            this._subscribeToViewportNewVolumeSet(viewportsInfo);
+            this._initialize3DViewports(viewportsInfo);
+            if (this.sphereStates && this.sphereStates.length > 0) {
+                this.setHandlesVisible(true);
+            }
+            else {
+                this.originalClippingPlanes = [];
+                this._initialize3DViewports(viewportsInfo);
+            }
+        }
+    }
+    onSetToolDisabled() {
+        this._resizeObservers.forEach((resizeObserver, viewportId) => {
+            resizeObserver.disconnect();
+            this._resizeObservers.delete(viewportId);
+        });
+        if (this._viewportAddedListener) {
+            _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.eventTarget.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_12__.Events.TOOLGROUP_VIEWPORT_ADDED, this._viewportAddedListener);
+            this._viewportAddedListener = null;
+        }
+        const viewportsInfo = this._getViewportsInfo();
+        this._unsubscribeToViewportNewVolumeSet(viewportsInfo);
+    }
+    setHandlesVisible(visible) {
+        this.configuration.showHandles = visible;
+        if (visible) {
+            this.sphereStates[SPHEREINDEX.XMIN].point[0] =
+                this.originalClippingPlanes[PLANEINDEX.XMIN].origin[0];
+            this.sphereStates[SPHEREINDEX.XMAX].point[0] =
+                this.originalClippingPlanes[PLANEINDEX.XMAX].origin[0];
+            this.sphereStates[SPHEREINDEX.YMIN].point[1] =
+                this.originalClippingPlanes[PLANEINDEX.YMIN].origin[1];
+            this.sphereStates[SPHEREINDEX.YMAX].point[1] =
+                this.originalClippingPlanes[PLANEINDEX.YMAX].origin[1];
+            this.sphereStates[SPHEREINDEX.ZMIN].point[2] =
+                this.originalClippingPlanes[PLANEINDEX.ZMIN].origin[2];
+            this.sphereStates[SPHEREINDEX.ZMAX].point[2] =
+                this.originalClippingPlanes[PLANEINDEX.ZMAX].origin[2];
+            [
+                SPHEREINDEX.XMIN,
+                SPHEREINDEX.XMAX,
+                SPHEREINDEX.YMIN,
+                SPHEREINDEX.YMAX,
+                SPHEREINDEX.ZMIN,
+                SPHEREINDEX.ZMAX,
+            ].forEach((idx) => {
+                const s = this.sphereStates[idx];
+                s.sphereSource.setCenter(...s.point);
+                s.sphereSource.modified();
+            });
+            this._updateCornerSpheres();
+        }
+        this._updateHandlesVisibility();
+        const viewportsInfo = this._getViewportsInfo();
+        const [viewport3D] = viewportsInfo;
+        const renderingEngine = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.getRenderingEngine)(viewport3D.renderingEngineId);
+        const viewport = renderingEngine.getViewport(viewport3D.viewportId);
+        viewport.render();
+    }
+    getHandlesVisible() {
+        return this.configuration.showHandles;
+    }
+    getClippingPlanesVisible() {
+        return this.configuration.showClippingPlanes;
+    }
+    setClippingPlanesVisible(visible) {
+        this.configuration.showClippingPlanes = visible;
+        const viewport = this._getViewport();
+        this._updateClippingPlanes(viewport);
+        viewport.render();
+    }
+    _dragCallback(evt) {
+        const { element, currentPoints, lastPoints } = evt.detail;
+        if (this.draggingSphereIndex !== null) {
+            this._onMouseMoveSphere(evt);
+        }
+        else {
+            const currentPointsCanvas = currentPoints.canvas;
+            const lastPointsCanvas = lastPoints.canvas;
+            const { rotateIncrementDegrees } = this.configuration;
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.getEnabledElement)(element);
+            const { viewport } = enabledElement;
+            const camera = viewport.getCamera();
+            const width = element.clientWidth;
+            const height = element.clientHeight;
+            const normalizedPosition = [
+                currentPointsCanvas[0] / width,
+                currentPointsCanvas[1] / height,
+            ];
+            const normalizedPreviousPosition = [
+                lastPointsCanvas[0] / width,
+                lastPointsCanvas[1] / height,
+            ];
+            const center = [width * 0.5, height * 0.5];
+            const centerWorld = viewport.canvasToWorld(center);
+            const normalizedCenter = [0.5, 0.5];
+            const radsq = (1.0 + Math.abs(normalizedCenter[0])) ** 2.0;
+            const op = [normalizedPreviousPosition[0], 0, 0];
+            const oe = [normalizedPosition[0], 0, 0];
+            const opsq = op[0] ** 2;
+            const oesq = oe[0] ** 2;
+            const lop = opsq > radsq ? 0 : Math.sqrt(radsq - opsq);
+            const loe = oesq > radsq ? 0 : Math.sqrt(radsq - oesq);
+            const nop = [op[0], 0, lop];
+            _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_4__/* ["default"].normalize */ .Ay.normalize(nop);
+            const noe = [oe[0], 0, loe];
+            _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_4__/* ["default"].normalize */ .Ay.normalize(noe);
+            const dot = _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_4__/* ["default"].dot */ .Ay.dot(nop, noe);
+            if (Math.abs(dot) > 0.0001) {
+                const angleX = -2 *
+                    Math.acos(_kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_4__/* ["default"].clampValue */ .Ay.clampValue(dot, -1.0, 1.0)) *
+                    Math.sign(normalizedPosition[0] - normalizedPreviousPosition[0]) *
+                    rotateIncrementDegrees;
+                const upVec = camera.viewUp;
+                const atV = camera.viewPlaneNormal;
+                const rightV = [0, 0, 0];
+                const forwardV = [0, 0, 0];
+                _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_4__/* ["default"].cross */ .Ay.cross(upVec, atV, rightV);
+                _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_4__/* ["default"].normalize */ .Ay.normalize(rightV);
+                _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_4__/* ["default"].cross */ .Ay.cross(atV, rightV, forwardV);
+                _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_4__/* ["default"].normalize */ .Ay.normalize(forwardV);
+                _kitware_vtk_js_Common_Core_Math__WEBPACK_IMPORTED_MODULE_4__/* ["default"].normalize */ .Ay.normalize(upVec);
+                this._rotateCamera(viewport, centerWorld, forwardV, angleX);
+                const angleY = (normalizedPreviousPosition[1] - normalizedPosition[1]) *
+                    rotateIncrementDegrees;
+                this._rotateCamera(viewport, centerWorld, rightV, angleY);
+            }
+            viewport.render();
+        }
+    }
+    _updateClippingPlanes(viewport) {
+        const actorEntry = viewport.getDefaultActor();
+        if (!actorEntry || !actorEntry.actor) {
+            if (!viewport._missingActorWarned) {
+                console.warn('VolumeCroppingTool._updateClippingPlanes: No default actor found in viewport.');
+                viewport._missingActorWarned = true;
+            }
+            return;
+        }
+        const actor = actorEntry.actor;
+        const mapper = actor.getMapper();
+        const matrix = actor.getMatrix();
+        if (!this.configuration.showClippingPlanes) {
+            mapper.removeAllClippingPlanes();
+            return;
+        }
+        const rot = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .mat3.create */ .w0.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .mat3.fromMat4 */ .w0.fromMat4(rot, matrix);
+        const normalMatrix = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .mat3.create */ .w0.create();
+        gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .mat3.invert */ .w0.invert(normalMatrix, rot);
+        gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .mat3.transpose */ .w0.transpose(normalMatrix, normalMatrix);
+        const originalPlanes = this.originalClippingPlanes;
+        if (!originalPlanes || !originalPlanes.length) {
+            return;
+        }
+        mapper.removeAllClippingPlanes();
+        const transformedOrigins = [];
+        const transformedNormals = [];
+        for (let i = 0; i < originalPlanes.length; ++i) {
+            const plane = originalPlanes[i];
+            const oVec = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.create */ .eR.create();
+            gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.transformMat4 */ .eR.transformMat4(oVec, new Float32Array(plane.origin), matrix);
+            const o = [oVec[0], oVec[1], oVec[2]];
+            const nVec = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.create */ .eR.create();
+            gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.transformMat3 */ .eR.transformMat3(nVec, new Float32Array(plane.normal), normalMatrix);
+            gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.normalize */ .eR.normalize(nVec, nVec);
+            const n = [nVec[0], nVec[1], nVec[2]];
+            transformedOrigins.push(o);
+            transformedNormals.push(n);
+        }
+        for (let i = 0; i < transformedOrigins.length; ++i) {
+            const planeInstance = _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_8__/* ["default"].newInstance */ .Ay.newInstance({
+                origin: transformedOrigins[i],
+                normal: transformedNormals[i],
+            });
+            mapper.addClippingPlane(planeInstance);
+        }
+    }
+    _updateHandlesVisibility() {
+        this.sphereStates.forEach((state) => {
+            if (state.sphereActor) {
+                state.sphereActor.setVisibility(this.configuration.showHandles);
+            }
+        });
+        Object.values(this.edgeLines).forEach(({ actor }) => {
+            if (actor) {
+                actor.setVisibility(this.configuration.showHandles);
+            }
+        });
+    }
+    _addLine3DBetweenPoints(viewport, point1, point2, color = [0.7, 0.7, 0.7], uid = '') {
+        if (point1[0] === point2[0] &&
+            point1[1] === point2[1] &&
+            point1[2] === point2[2]) {
+            return { actor: null, source: null };
+        }
+        const points = _kitware_vtk_js_Common_Core_Points__WEBPACK_IMPORTED_MODULE_1__/* ["default"].newInstance */ .Ay.newInstance();
+        points.setNumberOfPoints(2);
+        points.setPoint(0, point1[0], point1[1], point1[2]);
+        points.setPoint(1, point2[0], point2[1], point2[2]);
+        const lines = _kitware_vtk_js_Common_Core_CellArray__WEBPACK_IMPORTED_MODULE_2__/* ["default"].newInstance */ .Ay.newInstance({ values: [2, 0, 1] });
+        const polyData = _kitware_vtk_js_Common_DataModel_PolyData__WEBPACK_IMPORTED_MODULE_0__/* ["default"].newInstance */ .Ay.newInstance();
+        polyData.setPoints(points);
+        polyData.setLines(lines);
+        const mapper = _kitware_vtk_js_Rendering_Core_Mapper__WEBPACK_IMPORTED_MODULE_7__/* ["default"].newInstance */ .Ay.newInstance();
+        mapper.setInputData(polyData);
+        const actor = _kitware_vtk_js_Rendering_Core_Actor__WEBPACK_IMPORTED_MODULE_5__/* ["default"].newInstance */ .Ay.newInstance();
+        actor.setMapper(mapper);
+        actor.getProperty().setColor(...color);
+        actor.getProperty().setLineWidth(0.5);
+        actor.getProperty().setOpacity(1.0);
+        actor.getProperty().setInterpolationToFlat();
+        actor.getProperty().setAmbient(1.0);
+        actor.getProperty().setDiffuse(0.0);
+        actor.getProperty().setSpecular(0.0);
+        actor.setVisibility(this.configuration.showHandles);
+        viewport.addActor({ actor, uid });
+        return { actor, source: polyData };
+    }
+    _addSphere(viewport, point, axis, position, cornerKey = null, adaptiveRadius) {
+        const uid = cornerKey ? `corner_${cornerKey}` : `${axis}_${position}`;
+        const sphereState = this.sphereStates.find((s) => s.uid === uid);
+        if (sphereState) {
+            return;
+        }
+        const sphereSource = _kitware_vtk_js_Filters_Sources_SphereSource__WEBPACK_IMPORTED_MODULE_6__/* ["default"].newInstance */ .Ay.newInstance();
+        sphereSource.setCenter(point);
+        sphereSource.setRadius(adaptiveRadius);
+        const sphereMapper = _kitware_vtk_js_Rendering_Core_Mapper__WEBPACK_IMPORTED_MODULE_7__/* ["default"].newInstance */ .Ay.newInstance();
+        sphereMapper.setInputConnection(sphereSource.getOutputPort());
+        const sphereActor = _kitware_vtk_js_Rendering_Core_Actor__WEBPACK_IMPORTED_MODULE_5__/* ["default"].newInstance */ .Ay.newInstance();
+        sphereActor.setMapper(sphereMapper);
+        let color = [0.0, 1.0, 0.0];
+        const sphereColors = this.configuration.sphereColors || {};
+        if (cornerKey) {
+            color = sphereColors.CORNERS || [0.0, 0.0, 1.0];
+        }
+        else if (axis === 'z') {
+            color = sphereColors.AXIAL || [1.0, 0.0, 0.0];
+        }
+        else if (axis === 'x') {
+            color = sphereColors.SAGITTAL || [1.0, 1.0, 0.0];
+        }
+        else if (axis === 'y') {
+            color = sphereColors.CORONAL || [0.0, 1.0, 0.0];
+        }
+        const idx = this.sphereStates.findIndex((s) => s.uid === uid);
+        if (idx === -1) {
+            this.sphereStates.push({
+                point: point.slice(),
+                axis,
+                uid,
+                sphereSource,
+                sphereActor,
+                isCorner: !!cornerKey,
+                color,
+            });
+        }
+        else {
+            this.sphereStates[idx].point = point.slice();
+            this.sphereStates[idx].sphereSource = sphereSource;
+        }
+        const existingActors = viewport.getActors();
+        const existing = existingActors.find((a) => a.uid === uid);
+        if (existing) {
+            return;
+        }
+        sphereActor.getProperty().setColor(color);
+        sphereActor.setVisibility(this.configuration.showHandles);
+        viewport.addActor({ actor: sphereActor, uid: uid });
+    }
+    _calculateAdaptiveSphereRadius(diagonal) {
+        const baseRadius = this.configuration.sphereRadius !== undefined
+            ? this.configuration.sphereRadius
+            : 8;
+        const scaleFactor = this.configuration.sphereRadiusScale || 0.01;
+        const adaptiveRadius = diagonal * scaleFactor;
+        const minRadius = this.configuration.minSphereRadius || 2;
+        const maxRadius = this.configuration.maxSphereRadius || 50;
+        return Math.max(minRadius, Math.min(maxRadius, adaptiveRadius));
+    }
+    _updateClippingPlanesFromFaceSpheres(viewport) {
+        const mapper = viewport.getDefaultActor().actor.getMapper();
+        this.originalClippingPlanes[0].origin = [
+            ...this.sphereStates[SPHEREINDEX.XMIN].point,
+        ];
+        this.originalClippingPlanes[1].origin = [
+            ...this.sphereStates[SPHEREINDEX.XMAX].point,
+        ];
+        this.originalClippingPlanes[2].origin = [
+            ...this.sphereStates[SPHEREINDEX.YMIN].point,
+        ];
+        this.originalClippingPlanes[3].origin = [
+            ...this.sphereStates[SPHEREINDEX.YMAX].point,
+        ];
+        this.originalClippingPlanes[4].origin = [
+            ...this.sphereStates[SPHEREINDEX.ZMIN].point,
+        ];
+        this.originalClippingPlanes[5].origin = [
+            ...this.sphereStates[SPHEREINDEX.ZMAX].point,
+        ];
+        mapper.removeAllClippingPlanes();
+        for (let i = 0; i < 6; ++i) {
+            const origin = this.originalClippingPlanes[i].origin;
+            const normal = this.originalClippingPlanes[i].normal;
+            const plane = _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_8__/* ["default"].newInstance */ .Ay.newInstance({
+                origin,
+                normal,
+            });
+            mapper.addClippingPlane(plane);
+        }
+    }
+    _updateCornerSpheresFromFaces() {
+        const xMin = this.sphereStates[SPHEREINDEX.XMIN].point[0];
+        const xMax = this.sphereStates[SPHEREINDEX.XMAX].point[0];
+        const yMin = this.sphereStates[SPHEREINDEX.YMIN].point[1];
+        const yMax = this.sphereStates[SPHEREINDEX.YMAX].point[1];
+        const zMin = this.sphereStates[SPHEREINDEX.ZMIN].point[2];
+        const zMax = this.sphereStates[SPHEREINDEX.ZMAX].point[2];
+        const corners = [
+            { key: 'XMIN_YMIN_ZMIN', pos: [xMin, yMin, zMin] },
+            { key: 'XMIN_YMIN_ZMAX', pos: [xMin, yMin, zMax] },
+            { key: 'XMIN_YMAX_ZMIN', pos: [xMin, yMax, zMin] },
+            { key: 'XMIN_YMAX_ZMAX', pos: [xMin, yMax, zMax] },
+            { key: 'XMAX_YMIN_ZMIN', pos: [xMax, yMin, zMin] },
+            { key: 'XMAX_YMIN_ZMAX', pos: [xMax, yMin, zMax] },
+            { key: 'XMAX_YMAX_ZMIN', pos: [xMax, yMax, zMin] },
+            { key: 'XMAX_YMAX_ZMAX', pos: [xMax, yMax, zMax] },
+        ];
+        for (const corner of corners) {
+            const state = this.sphereStates.find((s) => s.uid === `corner_${corner.key}`);
+            if (state) {
+                state.point[0] = corner.pos[0];
+                state.point[1] = corner.pos[1];
+                state.point[2] = corner.pos[2];
+                state.sphereSource.setCenter(...state.point);
+                state.sphereSource.modified();
+            }
+        }
+    }
+    _updateFaceSpheresFromCorners() {
+        const corners = [
+            this.sphereStates[SPHEREINDEX.XMIN_YMIN_ZMIN].point,
+            this.sphereStates[SPHEREINDEX.XMIN_YMIN_ZMAX].point,
+            this.sphereStates[SPHEREINDEX.XMIN_YMAX_ZMIN].point,
+            this.sphereStates[SPHEREINDEX.XMIN_YMAX_ZMAX].point,
+            this.sphereStates[SPHEREINDEX.XMAX_YMIN_ZMIN].point,
+            this.sphereStates[SPHEREINDEX.XMAX_YMIN_ZMAX].point,
+            this.sphereStates[SPHEREINDEX.XMAX_YMAX_ZMIN].point,
+            this.sphereStates[SPHEREINDEX.XMAX_YMAX_ZMAX].point,
+        ];
+        const xs = corners.map((p) => p[0]);
+        const ys = corners.map((p) => p[1]);
+        const zs = corners.map((p) => p[2]);
+        const xMin = Math.min(...xs), xMax = Math.max(...xs);
+        const yMin = Math.min(...ys), yMax = Math.max(...ys);
+        const zMin = Math.min(...zs), zMax = Math.max(...zs);
+        this.sphereStates[SPHEREINDEX.XMIN].point = [
+            xMin,
+            (yMin + yMax) / 2,
+            (zMin + zMax) / 2,
+        ];
+        this.sphereStates[SPHEREINDEX.XMAX].point = [
+            xMax,
+            (yMin + yMax) / 2,
+            (zMin + zMax) / 2,
+        ];
+        this.sphereStates[SPHEREINDEX.YMIN].point = [
+            (xMin + xMax) / 2,
+            yMin,
+            (zMin + zMax) / 2,
+        ];
+        this.sphereStates[SPHEREINDEX.YMAX].point = [
+            (xMin + xMax) / 2,
+            yMax,
+            (zMin + zMax) / 2,
+        ];
+        this.sphereStates[SPHEREINDEX.ZMIN].point = [
+            (xMin + xMax) / 2,
+            (yMin + yMax) / 2,
+            zMin,
+        ];
+        this.sphereStates[SPHEREINDEX.ZMAX].point = [
+            (xMin + xMax) / 2,
+            (yMin + yMax) / 2,
+            zMax,
+        ];
+        [
+            SPHEREINDEX.XMIN,
+            SPHEREINDEX.XMAX,
+            SPHEREINDEX.YMIN,
+            SPHEREINDEX.YMAX,
+            SPHEREINDEX.ZMIN,
+            SPHEREINDEX.ZMAX,
+        ].forEach((idx) => {
+            const s = this.sphereStates[idx];
+            s.sphereSource.setCenter(...s.point);
+            s.sphereSource.modified();
+        });
+    }
+    _updateCornerSpheres() {
+        const xMin = this.sphereStates[SPHEREINDEX.XMIN].point[0];
+        const xMax = this.sphereStates[SPHEREINDEX.XMAX].point[0];
+        const yMin = this.sphereStates[SPHEREINDEX.YMIN].point[1];
+        const yMax = this.sphereStates[SPHEREINDEX.YMAX].point[1];
+        const zMin = this.sphereStates[SPHEREINDEX.ZMIN].point[2];
+        const zMax = this.sphereStates[SPHEREINDEX.ZMAX].point[2];
+        const corners = [
+            { key: 'XMIN_YMIN_ZMIN', pos: [xMin, yMin, zMin] },
+            { key: 'XMIN_YMIN_ZMAX', pos: [xMin, yMin, zMax] },
+            { key: 'XMIN_YMAX_ZMIN', pos: [xMin, yMax, zMin] },
+            { key: 'XMIN_YMAX_ZMAX', pos: [xMin, yMax, zMax] },
+            { key: 'XMAX_YMIN_ZMIN', pos: [xMax, yMin, zMin] },
+            { key: 'XMAX_YMIN_ZMAX', pos: [xMax, yMin, zMax] },
+            { key: 'XMAX_YMAX_ZMIN', pos: [xMax, yMax, zMin] },
+            { key: 'XMAX_YMAX_ZMAX', pos: [xMax, yMax, zMax] },
+        ];
+        for (const corner of corners) {
+            const state = this.sphereStates.find((s) => s.uid === `corner_${corner.key}`);
+            if (state) {
+                state.point[0] = corner.pos[0];
+                state.point[1] = corner.pos[1];
+                state.point[2] = corner.pos[2];
+                state.sphereSource.setCenter(...state.point);
+                state.sphereSource.modified();
+            }
+        }
+        Object.values(this.edgeLines).forEach(({ source, key1, key2 }) => {
+            const state1 = this.sphereStates.find((s) => s.uid === `corner_${key1}`);
+            const state2 = this.sphereStates.find((s) => s.uid === `corner_${key2}`);
+            if (state1 && state2) {
+                const points = source.getPoints();
+                points.setPoint(0, state1.point[0], state1.point[1], state1.point[2]);
+                points.setPoint(1, state2.point[0], state2.point[1], state2.point[2]);
+                points.modified();
+                source.modified();
+            }
+        });
+    }
+    _unsubscribeToViewportNewVolumeSet(viewportsInfo) {
+        viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+            const { viewport } = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.getEnabledElementByIds)(viewportId, renderingEngineId);
+            const { element } = viewport;
+            element.removeEventListener(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, this._onNewVolume);
+        });
+    }
+    _subscribeToViewportNewVolumeSet(viewports) {
+        viewports.forEach(({ viewportId, renderingEngineId }) => {
+            const { viewport } = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.getEnabledElementByIds)(viewportId, renderingEngineId);
+            const { element } = viewport;
+            element.addEventListener(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_10__.Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, this._onNewVolume);
+        });
+    }
+}
+VolumeCroppingTool.toolName = 'VolumeCropping';
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (VolumeCroppingTool);
+
+
 /***/ }),
 
 /***/ 83052:
@@ -41085,7 +43614,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _aabb__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(88638);
 /* harmony import */ var _basic__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(73262);
 /* harmony import */ var _circle__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(77081);
-/* harmony import */ var _ellipse__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(11683);
+/* harmony import */ var _ellipse__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(87009);
 /* harmony import */ var _line__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(93258);
 /* harmony import */ var _point__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(82216);
 /* harmony import */ var _polyline__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(92984);