@ohif/app 3.13.0-beta.35 → 3.13.0-beta.39

package/dist/{6280.bundle.081861b7e685b28616c8.js → 9039.bundle.fd54c15934103ff3fd3b.js}

@@ -1,4 +1,4 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[2075,6280],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[2075,9039],{
 
 /***/ 5057
 (__unused_webpack_module, __webpack_exports__, __webpack_require__) {
@@ -348,6 +348,7 @@ __webpack_require__.d(__webpack_exports__, {
   addImageSlicesToViewports: () => (/* reexport */ helpers/* addImageSlicesToViewports */.ge),
   addVolumesToViewports: () => (/* reexport */ helpers/* addVolumesToViewports */.x),
   cache: () => (/* reexport */ cache_cache/* default */.Ay),
+  convertColorArrayToRgbString: () => (/* reexport */ convertColorArrayToRgbString/* convertColorArrayToRgbString */.J),
   convertMapperToNotSharedMapper: () => (/* reexport */ createVolumeMapper/* convertMapperToNotSharedMapper */.h),
   eventTarget: () => (/* reexport */ eventTarget/* default */.A),
   getConfiguration: () => (/* reexport */ init/* getConfiguration */.D0),
@@ -626,6 +627,8 @@ var decimatedVolumeLoader = __webpack_require__(18481);
 var utilities = __webpack_require__(85343);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/triggerEvent.js
 var triggerEvent = __webpack_require__(69372);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/convertColorArrayToRgbString.js
+var convertColorArrayToRgbString = __webpack_require__(57652);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/cornerstoneStreamingImageVolumeLoader.js
 var cornerstoneStreamingImageVolumeLoader = __webpack_require__(55500);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/cornerstoneStreamingDynamicImageVolumeLoader.js
@@ -675,6 +678,7 @@ var helpers = __webpack_require__(40661);
 
 
 
+
 
 
 /***/ },
@@ -3231,6 +3235,7 @@ __webpack_require__.d(__webpack_exports__, {
   clip: () => (/* reexport */ utilities_clip),
   color: () => (/* reexport */ color_namespaceObject),
   colormap: () => (/* reexport */ colormap),
+  convertColorArrayToRgbString: () => (/* reexport */ convertColorArrayToRgbString/* convertColorArrayToRgbString */.J),
   convertStackToVolumeViewport: () => (/* reexport */ convertStackToVolumeViewport),
   convertToGrayscale: () => (/* reexport */ convertToGrayscale),
   convertVolumeToStackViewport: () => (/* reexport */ convertVolumeToStackViewport),
@@ -4660,6 +4665,8 @@ function convertToGrayscale(scalarData, width, height) {
     }
 }
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/convertColorArrayToRgbString.js
+var convertColorArrayToRgbString = __webpack_require__(57652);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/RenderingEngine/index.js + 3 modules
 var RenderingEngine = __webpack_require__(90340);
 ;// ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/getViewportImageIds.js
@@ -5573,6 +5580,7 @@ var updatePlaneRestriction = __webpack_require__(41365);
 
 
 
+
 
 
 const getViewportModality = (viewport, volumeId) => _getViewportModality(viewport, volumeId, cache/* default */.Ay.getVolume);
@@ -6347,7 +6355,7 @@ function toLowHighRange(windowWidth, windowCenter, voiLUTFunction = _enums_VOILU
 
 /***/ },
 
-/***/ 4921
+/***/ 94836
 (__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) {
 
 "use strict";
@@ -7298,7 +7306,7 @@ var COLOR_LUT = __webpack_require__(93952);
 
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/version.js
-const version = '4.18.2';
+const version = '4.19.0';
 
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/synchronizers/callbacks/cameraSyncCallback.js
 /* unused harmony import specifier */ var cameraSyncCallback_getRenderingEngine;
@@ -8251,6 +8259,65 @@ function _createCinePlayContext(viewport, playClipOptions) {
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/boundingBox/index.js
 var boundingBox = __webpack_require__(72282);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 7 modules
+var PolyData = __webpack_require__(27480);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/Points.js
+var Points = __webpack_require__(74973);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/CellArray.js
+var CellArray = __webpack_require__(32461);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Actor.js
+var Actor = __webpack_require__(44404);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Mapper.js + 1 modules
+var Mapper = __webpack_require__(81418);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/draw3D/addLine3DBetweenPoints.js
+
+
+
+
+
+function addLine3DBetweenPoints(viewport, point1, point2, color = [0.7, 0.7, 0.7], uid = '', showHandles = true) {
+    if (point1[0] === point2[0] &&
+        point1[1] === point2[1] &&
+        point1[2] === point2[2]) {
+        return { actor: null, source: null };
+    }
+    const points = Points/* 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 = CellArray/* default.newInstance */.Ay.newInstance({ values: [2, 0, 1] });
+    const polyData = PolyData/* default.newInstance */.Ay.newInstance();
+    polyData.setPoints(points);
+    polyData.setLines(lines);
+    const mapper = Mapper/* default.newInstance */.Ay.newInstance();
+    mapper.setInputData(polyData);
+    const actor = Actor/* 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(showHandles);
+    viewport.addActor({ actor, uid });
+    return { actor, source: polyData };
+}
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/draw3D/calculateAdaptiveSphereRadius.js
+function calculateAdaptiveSphereRadius(diagonal, config) {
+    const scaleFactor = config.sphereRadiusScale || 0.01;
+    const adaptiveRadius = diagonal * scaleFactor;
+    const minRadius = config.minSphereRadius || 2;
+    const maxRadius = config.maxSphereRadius || 50;
+    return Math.max(minRadius, Math.min(maxRadius, adaptiveRadius));
+}
+
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/draw3D/index.js
+
+
+
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/planarFreehandROITool/smoothAnnotation.js
 var smoothAnnotation = __webpack_require__(61587);
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/planarFreehandROITool/index.js
@@ -10265,6 +10332,7 @@ function calculateFanGeometry(imageId) {
 
 
 
+
 
 
 const roundNumber = esm.utilities.roundNumber;
@@ -11266,20 +11334,12 @@ class TrackballRotateTool extends base/* BaseTool */.oS {
 TrackballRotateTool.toolName = 'TrackballRotate';
 /* harmony default export */ const tools_TrackballRotateTool = ((/* unused pure expression or super */ null && (TrackballRotateTool)));
 
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js + 11 modules
-var PolyData = __webpack_require__(12548);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/Points.js
-var Points = __webpack_require__(74973);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/CellArray.js
-var CellArray = __webpack_require__(32461);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Actor.js
-var Actor = __webpack_require__(44404);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Filters/Sources/SphereSource.js
 var SphereSource = __webpack_require__(73435);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/Mapper.js + 1 modules
-var Mapper = __webpack_require__(81418);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Plane.js + 1 modules
-var Plane = __webpack_require__(43884);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/DataModel/Plane.js
+var Plane = __webpack_require__(49794);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/volumeCropping/index.js + 8 modules
+var volumeCropping = __webpack_require__(88380);
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/VolumeCroppingTool.js
 
 
@@ -11294,30 +11354,6 @@ var Plane = __webpack_require__(43884);
 
 
 
-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/* BaseTool */.oS {
     constructor(toolProps = {}, defaultToolProps = {
         configuration: {
@@ -11339,6 +11375,7 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
             grabSpherePixelDistance: 20,
             rotateIncrementDegrees: 2,
             rotateSampleDistanceFactor: 2,
+            rotateClippingPlanesIncrementDegrees: 5,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -11346,16 +11383,15 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
         this._hasResolutionChanged = false;
         this.originalClippingPlanes = [];
         this.draggingSphereIndex = null;
-        this.toolCenter = [0, 0, 0];
+        this.rotatePlanesOnDrag = false;
         this.cornerDragOffset = null;
         this.faceDragOffset = null;
+        this.volumeDirectionVectors = 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
@@ -11398,9 +11434,16 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
                         this.faceDragOffset = null;
                     }
                     else {
-                        const axisIdx = { x: 0, y: 1, z: 2 }[sphereState.axis];
+                        const directionVector = this._getDirectionVectorForAxis(sphereState.axis);
+                        const delta = [
+                            sphereState.point[0] - mouseWorld[0],
+                            sphereState.point[1] - mouseWorld[1],
+                            sphereState.point[2] - mouseWorld[2],
+                        ];
                         this.faceDragOffset =
-                            sphereState.point[axisIdx] - mouseWorld[axisIdx];
+                            delta[0] * directionVector[0] +
+                                delta[1] * directionVector[1] +
+                                delta[2] * directionVector[2];
                         this.cornerDragOffset = null;
                     }
                     return true;
@@ -11455,118 +11498,143 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
                 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();
+                const newCorner = this.cornerDragOffset
+                    ? gl_matrix_esm/* vec3.add */.eR.add([0, 0, 0], world, this.cornerDragOffset)
+                    : world;
+                const oldCorner = sphereState.point;
+                const axisFlags = (0,volumeCropping.parseCornerKey)(sphereState.uid);
+                const { xDir, yDir, zDir } = this._getDirectionVectors();
+                if (!xDir || !yDir || !zDir)
+                    return false;
+                const delta = [
+                    newCorner[0] - oldCorner[0],
+                    newCorner[1] - oldCorner[1],
+                    newCorner[2] - oldCorner[2],
+                ];
+                const deltaX = delta[0] * xDir[0] + delta[1] * xDir[1] + delta[2] * xDir[2];
+                const deltaY = delta[0] * yDir[0] + delta[1] * yDir[1] + delta[2] * yDir[2];
+                const deltaZ = delta[0] * zDir[0] + delta[1] * zDir[1] + delta[2] * zDir[2];
+                if (axisFlags.isXMin) {
+                    const faceXMin = this.sphereStates[volumeCropping.SPHEREINDEX.XMIN];
+                    const newPoint = [
+                        faceXMin.point[0] + deltaX * xDir[0],
+                        faceXMin.point[1] + deltaX * xDir[1],
+                        faceXMin.point[2] + deltaX * xDir[2],
+                    ];
+                    this._updateSpherePosition(volumeCropping.SPHEREINDEX.XMIN, newPoint);
+                }
+                else if (axisFlags.isXMax) {
+                    const faceXMax = this.sphereStates[volumeCropping.SPHEREINDEX.XMAX];
+                    const newPoint = [
+                        faceXMax.point[0] + deltaX * xDir[0],
+                        faceXMax.point[1] + deltaX * xDir[1],
+                        faceXMax.point[2] + deltaX * xDir[2],
+                    ];
+                    this._updateSpherePosition(volumeCropping.SPHEREINDEX.XMAX, newPoint);
+                }
+                if (axisFlags.isYMin) {
+                    const faceYMin = this.sphereStates[volumeCropping.SPHEREINDEX.YMIN];
+                    const newPoint = [
+                        faceYMin.point[0] + deltaY * yDir[0],
+                        faceYMin.point[1] + deltaY * yDir[1],
+                        faceYMin.point[2] + deltaY * yDir[2],
+                    ];
+                    this._updateSpherePosition(volumeCropping.SPHEREINDEX.YMIN, newPoint);
+                }
+                else if (axisFlags.isYMax) {
+                    const faceYMax = this.sphereStates[volumeCropping.SPHEREINDEX.YMAX];
+                    const newPoint = [
+                        faceYMax.point[0] + deltaY * yDir[0],
+                        faceYMax.point[1] + deltaY * yDir[1],
+                        faceYMax.point[2] + deltaY * yDir[2],
+                    ];
+                    this._updateSpherePosition(volumeCropping.SPHEREINDEX.YMAX, newPoint);
+                }
+                if (axisFlags.isZMin) {
+                    const faceZMin = this.sphereStates[volumeCropping.SPHEREINDEX.ZMIN];
+                    const newPoint = [
+                        faceZMin.point[0] + deltaZ * zDir[0],
+                        faceZMin.point[1] + deltaZ * zDir[1],
+                        faceZMin.point[2] + deltaZ * zDir[2],
+                    ];
+                    this._updateSpherePosition(volumeCropping.SPHEREINDEX.ZMIN, newPoint);
+                }
+                else if (axisFlags.isZMax) {
+                    const faceZMax = this.sphereStates[volumeCropping.SPHEREINDEX.ZMAX];
+                    const newPoint = [
+                        faceZMax.point[0] + deltaZ * zDir[0],
+                        faceZMax.point[1] + deltaZ * zDir[1],
+                        faceZMax.point[2] + deltaZ * zDir[2],
+                    ];
+                    this._updateSpherePosition(volumeCropping.SPHEREINDEX.ZMAX, newPoint);
+                }
                 this._updateCornerSpheres();
+                this._updateFaceSpheresFromCorners();
             }
             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();
+                const directionVector = this._getDirectionVectorForAxis(sphereState.axis);
+                const delta = [
+                    world[0] - sphereState.point[0],
+                    world[1] - sphereState.point[1],
+                    world[2] - sphereState.point[2],
+                ];
+                const distanceAlongAxis = delta[0] * directionVector[0] +
+                    delta[1] * directionVector[1] +
+                    delta[2] * directionVector[2];
+                const adjustedDistance = this.faceDragOffset !== null
+                    ? distanceAlongAxis + this.faceDragOffset
+                    : distanceAlongAxis;
+                const newPoint = [
+                    sphereState.point[0] + adjustedDistance * directionVector[0],
+                    sphereState.point[1] + adjustedDistance * directionVector[1],
+                    sphereState.point[2] + adjustedDistance * directionVector[2],
+                ];
+                this._updateSpherePosition(this.draggingSphereIndex, newPoint);
                 this._updateCornerSpheresFromFaces();
                 this._updateFaceSpheresFromCorners();
                 this._updateCornerSpheres();
             }
             this._updateClippingPlanesFromFaceSpheres(viewport);
             viewport.render();
-            this._triggerToolChangedEvent(sphereState);
+            this._notifyClippingPlanesChanged();
             return true;
         };
         this._onControlToolChange = (evt) => {
             const viewport = this._getViewport();
-            if (!evt.detail.toolCenter) {
-                (0,esm.triggerEvent)(esm.eventTarget, enums.Events.VOLUMECROPPING_TOOL_CHANGED, {
-                    originalClippingPlanes: this.originalClippingPlanes,
-                    viewportId: viewport.id,
-                    renderingEngineId: viewport.renderingEngineId,
-                    seriesInstanceUID: this.seriesInstanceUID,
-                });
+            if (evt.detail.seriesInstanceUID !== this.seriesInstanceUID) {
+                return;
             }
-            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 = [
-                    esm.Enums.OrientationAxis.SAGITTAL,
-                    esm.Enums.OrientationAxis.CORONAL,
-                    esm.Enums.OrientationAxis.AXIAL,
-                ];
-                for (let i = 0; i < 3; ++i) {
-                    const origin = [0, 0, 0];
-                    origin[i] = toolCenter[i];
-                    const plane = Plane/* 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());
-                        }
-                    }
-                }
+            if (evt.detail.clippingPlanes &&
+                evt.detail.clippingPlanes.length >= volumeCropping.NUM_CLIPPING_PLANES) {
+                this.originalClippingPlanes = (0,volumeCropping.copyClippingPlanes)(evt.detail.clippingPlanes);
+                this._updateFaceSpheresFromClippingPlanes();
+                this._updateCornerSpheresFromFaces();
+                this._updateFaceSpheresFromCorners();
                 this._updateCornerSpheres();
+                const mapper = this._getVolumeMapper(viewport);
+                if (mapper) {
+                    this._applyClippingPlanesToMapper(mapper);
+                }
                 viewport.render();
+                this._notifyClippingPlanesChanged(viewport);
+            }
+            else {
+                this._notifyClippingPlanesChanged(viewport);
             }
         };
         this._getViewportsInfo = () => {
-            const viewports = (0,ToolGroupManager.getToolGroup)(this.toolGroupId).viewportsInfo;
-            return viewports;
+            const toolGroup = (0,ToolGroupManager.getToolGroup)(this.toolGroupId);
+            return toolGroup?.viewportsInfo || [];
         };
         this._initialize3DViewports = (viewportsInfo) => {
-            if (!viewportsInfo || !viewportsInfo.length || !viewportsInfo[0]) {
+            if (!viewportsInfo?.length || !viewportsInfo[0]) {
                 console.warn('VolumeCroppingTool: No viewportsInfo available for initialization of volumecroppingtool.');
                 return;
             }
             const viewport = this._getViewport();
+            if (!viewport) {
+                return;
+            }
             const volumeActors = viewport.getActors();
             if (!volumeActors || volumeActors.length === 0) {
                 console.warn('VolumeCroppingTool: No volume actors found in the viewport.');
@@ -11578,78 +11646,85 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
                 return;
             }
             this.seriesInstanceUID = imageData.seriesInstanceUID || 'unknown';
-            const worldBounds = imageData.getBounds();
+            this.volumeDirectionVectors = (0,volumeCropping.extractVolumeDirectionVectors)(imageData);
+            const { xDir, yDir, zDir } = this.volumeDirectionVectors;
+            const dimensions = imageData.getDimensions();
             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 = Plane/* default.newInstance */.Ay.newInstance({
-                origin: [xMin, 0, 0],
-                normal: [1, 0, 0],
+            const xMin = cropFactor * dimensions[0];
+            const xMax = (1 - cropFactor) * dimensions[0];
+            const yMin = cropFactor * dimensions[1];
+            const yMax = (1 - cropFactor) * dimensions[1];
+            const zMin = cropFactor * dimensions[2];
+            const zMax = (1 - cropFactor) * dimensions[2];
+            const xCenter = (xMin + xMax) / 2;
+            const yCenter = (yMin + yMax) / 2;
+            const zCenter = (zMin + zMax) / 2;
+            const faceXMin = imageData.indexToWorld([xMin, yCenter, zCenter]);
+            const faceXMax = imageData.indexToWorld([xMax, yCenter, zCenter]);
+            const faceYMin = imageData.indexToWorld([xCenter, yMin, zCenter]);
+            const faceYMax = imageData.indexToWorld([xCenter, yMax, zCenter]);
+            const faceZMin = imageData.indexToWorld([xCenter, yCenter, zMin]);
+            const faceZMax = imageData.indexToWorld([xCenter, yCenter, zMax]);
+            const planeXMin = Plane/* default.newInstance */.Ay.newInstance({
+                origin: faceXMin,
+                normal: xDir,
             });
-            const planeXmax = Plane/* default.newInstance */.Ay.newInstance({
-                origin: [xMax, 0, 0],
-                normal: [-1, 0, 0],
+            const planeXMax = Plane/* default.newInstance */.Ay.newInstance({
+                origin: faceXMax,
+                normal: [-xDir[0], -xDir[1], -xDir[2]],
             });
-            const planeYmin = Plane/* default.newInstance */.Ay.newInstance({
-                origin: [0, yMin, 0],
-                normal: [0, 1, 0],
+            const planeYMin = Plane/* default.newInstance */.Ay.newInstance({
+                origin: faceYMin,
+                normal: yDir,
             });
-            const planeYmax = Plane/* default.newInstance */.Ay.newInstance({
-                origin: [0, yMax, 0],
-                normal: [0, -1, 0],
+            const planeYMax = Plane/* default.newInstance */.Ay.newInstance({
+                origin: faceYMax,
+                normal: [-yDir[0], -yDir[1], -yDir[2]],
             });
-            const planeZmin = Plane/* default.newInstance */.Ay.newInstance({
-                origin: [0, 0, zMin],
-                normal: [0, 0, 1],
+            const planeZMin = Plane/* default.newInstance */.Ay.newInstance({
+                origin: faceZMin,
+                normal: zDir,
             });
-            const planeZmax = Plane/* default.newInstance */.Ay.newInstance({
-                origin: [0, 0, zMax],
-                normal: [0, 0, -1],
+            const planeZMax = Plane/* default.newInstance */.Ay.newInstance({
+                origin: faceZMax,
+                normal: [-zDir[0], -zDir[1], -zDir[2]],
             });
-            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 planes = [
+                planeXMin,
+                planeXMax,
+                planeYMin,
+                planeYMax,
+                planeZMin,
+                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 diag0 = imageData.indexToWorld([0, 0, 0]);
+            const diag1 = imageData.indexToWorld([
+                dimensions[0],
+                dimensions[1],
+                dimensions[2],
+            ]);
+            const diagonal = gl_matrix_esm/* vec3.distance */.eR.distance(diag0, diag1);
+            const adaptiveRadius = calculateAdaptiveSphereRadius(diagonal, this.configuration);
+            this._addSphere(viewport, faceXMin, 'x', 'min', null, adaptiveRadius);
+            this._addSphere(viewport, faceXMax, 'x', 'max', null, adaptiveRadius);
+            this._addSphere(viewport, faceYMin, 'y', 'min', null, adaptiveRadius);
+            this._addSphere(viewport, faceYMax, 'y', 'max', null, adaptiveRadius);
+            this._addSphere(viewport, faceZMin, 'z', 'min', null, adaptiveRadius);
+            this._addSphere(viewport, faceZMax, '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],
+                imageData.indexToWorld([xMin, yMin, zMin]),
+                imageData.indexToWorld([xMin, yMin, zMax]),
+                imageData.indexToWorld([xMin, yMax, zMin]),
+                imageData.indexToWorld([xMin, yMax, zMax]),
+                imageData.indexToWorld([xMax, yMin, zMin]),
+                imageData.indexToWorld([xMax, yMin, zMax]),
+                imageData.indexToWorld([xMax, yMax, zMin]),
+                imageData.indexToWorld([xMax, yMax, zMax]),
             ];
             const cornerKeys = [
                 'XMIN_YMIN_ZMIN',
@@ -11678,21 +11753,24 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
                 ['XMAX_YMIN_ZMIN', 'XMAX_YMIN_ZMAX'],
                 ['XMAX_YMAX_ZMIN', 'XMAX_YMAX_ZMAX'],
             ];
-            edgeCornerPairs.forEach(([key1, key2], i) => {
+            edgeCornerPairs.forEach(([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 uid = `edge_${key1}_${key2}`;
-                    const { actor, source } = this._addLine3DBetweenPoints(viewport, state1.point, state2.point, [0.7, 0.7, 0.7], uid);
+                    const { actor, source } = addLine3DBetweenPoints(viewport, state1.point, state2.point, [0.7, 0.7, 0.7], uid, this.configuration.showHandles);
                     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);
+            const mapper = viewport
+                .getDefaultActor()
+                .actor.getMapper();
+            mapper.addClippingPlane(planeXMin);
+            mapper.addClippingPlane(planeXMax);
+            mapper.addClippingPlane(planeYMin);
+            mapper.addClippingPlane(planeYMax);
+            mapper.addClippingPlane(planeZMin);
+            mapper.addClippingPlane(planeZMax);
             esm.eventTarget.addEventListener(enums.Events.VOLUMECROPPINGCONTROL_TOOL_CHANGED, (evt) => {
                 this._onControlToolChange(evt);
             });
@@ -11706,107 +11784,14 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
             return { viewport, world };
         };
         this._getViewport = () => {
-            const [viewport3D] = this._getViewportsInfo();
-            const renderingEngine = (0,esm.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];
+            const viewportsInfo = this._getViewportsInfo();
+            if (!viewportsInfo || viewportsInfo.length === 0) {
+                return null;
             }
-            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,esm.triggerEvent)(esm.eventTarget, enums.Events.VOLUMECROPPING_TOOL_CHANGED, {
-                toolCenter: sphereState.point,
-                axis: sphereState.isCorner ? 'corner' : sphereState.axis,
-                draggingSphereIndex: this.draggingSphereIndex,
-                seriesInstanceUID: this.seriesInstanceUID,
-            });
+            const [viewport3D] = viewportsInfo;
+            const renderingEngine = (0,esm.getRenderingEngine)(viewport3D.renderingEngineId);
+            const viewport = renderingEngine?.getViewport(viewport3D.viewportId);
+            return viewport || null;
         };
         this._onNewVolume = () => {
             const viewportsInfo = this._getViewportsInfo();
@@ -11815,6 +11800,207 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
             this.edgeLines = {};
             this._initialize3DViewports(viewportsInfo);
         };
+        this._rotateClippingPlanes = (evt) => {
+            const { element, currentPoints, lastPoints } = evt.detail;
+            const currentPointsCanvas = currentPoints.canvas;
+            const lastPointsCanvas = lastPoints.canvas;
+            const rotateIncrementDegrees = this.configuration.rotateClippingPlanesIncrementDegrees ??
+                this.configuration.rotateIncrementDegrees ??
+                5;
+            const enabledElement = (0,esm.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 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];
+            Core_Math/* default.normalize */.Ay.normalize(nop);
+            const noe = [oe[0], 0, loe];
+            Core_Math/* default.normalize */.Ay.normalize(noe);
+            const dot = Core_Math/* default.dot */.Ay.dot(nop, noe);
+            if (Math.abs(dot) > 0.0001) {
+                const angleX = 20 *
+                    Math.acos(Core_Math/* 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];
+                Core_Math/* default.cross */.Ay.cross(upVec, atV, rightV);
+                Core_Math/* default.normalize */.Ay.normalize(rightV);
+                Core_Math/* default.cross */.Ay.cross(atV, rightV, forwardV);
+                Core_Math/* default.normalize */.Ay.normalize(forwardV);
+                const angleY = 20 *
+                    (normalizedPosition[1] - normalizedPreviousPosition[1]) *
+                    rotateIncrementDegrees;
+                let rotationCenter;
+                if (this.sphereStates.length >= volumeCropping.NUM_CLIPPING_PLANES) {
+                    const faces = [
+                        this.sphereStates[volumeCropping.SPHEREINDEX.XMIN],
+                        this.sphereStates[volumeCropping.SPHEREINDEX.XMAX],
+                        this.sphereStates[volumeCropping.SPHEREINDEX.YMIN],
+                        this.sphereStates[volumeCropping.SPHEREINDEX.YMAX],
+                        this.sphereStates[volumeCropping.SPHEREINDEX.ZMIN],
+                        this.sphereStates[volumeCropping.SPHEREINDEX.ZMAX],
+                    ];
+                    rotationCenter = [
+                        (faces[0].point[0] +
+                            faces[1].point[0] +
+                            faces[2].point[0] +
+                            faces[3].point[0] +
+                            faces[4].point[0] +
+                            faces[5].point[0]) /
+                            volumeCropping.NUM_CLIPPING_PLANES,
+                        (faces[0].point[1] +
+                            faces[1].point[1] +
+                            faces[2].point[1] +
+                            faces[3].point[1] +
+                            faces[4].point[1] +
+                            faces[5].point[1]) /
+                            volumeCropping.NUM_CLIPPING_PLANES,
+                        (faces[0].point[2] +
+                            faces[1].point[2] +
+                            faces[2].point[2] +
+                            faces[3].point[2] +
+                            faces[4].point[2] +
+                            faces[5].point[2]) /
+                            volumeCropping.NUM_CLIPPING_PLANES,
+                    ];
+                }
+                else {
+                    rotationCenter = [0, 0, 0];
+                }
+                const transformX = gl_matrix_esm/* mat4.identity */.pB.identity(new Float32Array(16));
+                gl_matrix_esm/* mat4.translate */.pB.translate(transformX, transformX, rotationCenter);
+                gl_matrix_esm/* mat4.rotate */.pB.rotate(transformX, transformX, (angleX * Math.PI) / 180, forwardV);
+                gl_matrix_esm/* mat4.translate */.pB.translate(transformX, transformX, [
+                    -rotationCenter[0],
+                    -rotationCenter[1],
+                    -rotationCenter[2],
+                ]);
+                const transformY = gl_matrix_esm/* mat4.identity */.pB.identity(new Float32Array(16));
+                gl_matrix_esm/* mat4.translate */.pB.translate(transformY, transformY, rotationCenter);
+                gl_matrix_esm/* mat4.rotate */.pB.rotate(transformY, transformY, (angleY * Math.PI) / 180, rightV);
+                gl_matrix_esm/* mat4.translate */.pB.translate(transformY, transformY, [
+                    -rotationCenter[0],
+                    -rotationCenter[1],
+                    -rotationCenter[2],
+                ]);
+                const transform = gl_matrix_esm/* mat4.create */.pB.create();
+                gl_matrix_esm/* mat4.multiply */.pB.multiply(transform, transformY, transformX);
+                const normalTransformX4 = gl_matrix_esm/* mat4.identity */.pB.identity(new Float32Array(16));
+                gl_matrix_esm/* mat4.rotate */.pB.rotate(normalTransformX4, normalTransformX4, (angleX * Math.PI) / 180, forwardV);
+                const normalTransformX = gl_matrix_esm/* mat3.create */.w0.create();
+                gl_matrix_esm/* mat3.fromMat4 */.w0.fromMat4(normalTransformX, normalTransformX4);
+                const normalTransformY4 = gl_matrix_esm/* mat4.identity */.pB.identity(new Float32Array(16));
+                gl_matrix_esm/* mat4.rotate */.pB.rotate(normalTransformY4, normalTransformY4, (angleY * Math.PI) / 180, rightV);
+                const normalTransformY = gl_matrix_esm/* mat3.create */.w0.create();
+                gl_matrix_esm/* mat3.fromMat4 */.w0.fromMat4(normalTransformY, normalTransformY4);
+                const normalTransform = gl_matrix_esm/* mat3.create */.w0.create();
+                gl_matrix_esm/* mat3.multiply */.w0.multiply(normalTransform, normalTransformY, normalTransformX);
+                for (let i = 0; i < this.originalClippingPlanes.length; ++i) {
+                    const plane = this.originalClippingPlanes[i];
+                    const originVec = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(plane.origin[0], plane.origin[1], plane.origin[2]);
+                    gl_matrix_esm/* vec3.transformMat4 */.eR.transformMat4(originVec, originVec, transform);
+                    plane.origin = [originVec[0], originVec[1], originVec[2]];
+                    const normalVec = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(plane.normal[0], plane.normal[1], plane.normal[2]);
+                    gl_matrix_esm/* vec3.transformMat3 */.eR.transformMat3(normalVec, normalVec, normalTransform);
+                    gl_matrix_esm/* vec3.normalize */.eR.normalize(normalVec, normalVec);
+                    plane.normal = [normalVec[0], normalVec[1], normalVec[2]];
+                }
+                if (this.sphereStates.length >= volumeCropping.NUM_CLIPPING_PLANES) {
+                    this.sphereStates[volumeCropping.SPHEREINDEX.XMIN].point = [
+                        ...this.originalClippingPlanes[volumeCropping.PLANEINDEX.XMIN].origin,
+                    ];
+                    this.sphereStates[volumeCropping.SPHEREINDEX.XMAX].point = [
+                        ...this.originalClippingPlanes[volumeCropping.PLANEINDEX.XMAX].origin,
+                    ];
+                    this.sphereStates[volumeCropping.SPHEREINDEX.YMIN].point = [
+                        ...this.originalClippingPlanes[volumeCropping.PLANEINDEX.YMIN].origin,
+                    ];
+                    this.sphereStates[volumeCropping.SPHEREINDEX.YMAX].point = [
+                        ...this.originalClippingPlanes[volumeCropping.PLANEINDEX.YMAX].origin,
+                    ];
+                    this.sphereStates[volumeCropping.SPHEREINDEX.ZMIN].point = [
+                        ...this.originalClippingPlanes[volumeCropping.PLANEINDEX.ZMIN].origin,
+                    ];
+                    this.sphereStates[volumeCropping.SPHEREINDEX.ZMAX].point = [
+                        ...this.originalClippingPlanes[volumeCropping.PLANEINDEX.ZMAX].origin,
+                    ];
+                    [
+                        volumeCropping.SPHEREINDEX.XMIN,
+                        volumeCropping.SPHEREINDEX.XMAX,
+                        volumeCropping.SPHEREINDEX.YMIN,
+                        volumeCropping.SPHEREINDEX.YMAX,
+                        volumeCropping.SPHEREINDEX.ZMIN,
+                        volumeCropping.SPHEREINDEX.ZMAX,
+                    ].forEach((idx) => {
+                        const s = this.sphereStates[idx];
+                        s.sphereSource.setCenter(...s.point);
+                        s.sphereSource.modified();
+                    });
+                    const cornerIndices = [
+                        volumeCropping.SPHEREINDEX.XMIN_YMIN_ZMIN,
+                        volumeCropping.SPHEREINDEX.XMIN_YMIN_ZMAX,
+                        volumeCropping.SPHEREINDEX.XMIN_YMAX_ZMIN,
+                        volumeCropping.SPHEREINDEX.XMIN_YMAX_ZMAX,
+                        volumeCropping.SPHEREINDEX.XMAX_YMIN_ZMIN,
+                        volumeCropping.SPHEREINDEX.XMAX_YMIN_ZMAX,
+                        volumeCropping.SPHEREINDEX.XMAX_YMAX_ZMIN,
+                        volumeCropping.SPHEREINDEX.XMAX_YMAX_ZMAX,
+                    ];
+                    cornerIndices.forEach((idx) => {
+                        const cornerState = this.sphereStates[idx];
+                        if (cornerState) {
+                            const cornerVec = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(cornerState.point[0], cornerState.point[1], cornerState.point[2]);
+                            gl_matrix_esm/* vec3.transformMat4 */.eR.transformMat4(cornerVec, cornerVec, transform);
+                            cornerState.point = [
+                                cornerVec[0],
+                                cornerVec[1],
+                                cornerVec[2],
+                            ];
+                            cornerState.sphereSource.setCenter(...cornerState.point);
+                            cornerState.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();
+                        }
+                    });
+                }
+                this._updateClippingPlanes(viewport);
+                viewport.render();
+                (0,esm.triggerEvent)(esm.eventTarget, enums.Events.VOLUMECROPPING_TOOL_CHANGED, {
+                    originalClippingPlanes: this.originalClippingPlanes,
+                    viewportId: viewport.id,
+                    renderingEngineId: viewport.renderingEngineId,
+                    seriesInstanceUID: this.seriesInstanceUID,
+                });
+            }
+        };
         this._rotateCamera = (viewport, centerWorld, axis, angle) => {
             const vtkCamera = viewport.getVtkActiveCamera();
             const viewUp = vtkCamera.getViewUp();
@@ -11846,59 +12032,55 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
         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,esm.getEnabledElementByIds)(viewportId, renderingEngineId) || { viewport: null };
-                        if (!viewport) {
+        const viewportsInfo = this._getViewportsInfo();
+        const subscribeToElementResize = () => {
+            viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+                if (!this._resizeObservers.has(viewportId)) {
+                    const { viewport } = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId) || { viewport: null };
+                    if (!viewport) {
+                        return;
+                    }
+                    const { element } = viewport;
+                    const resizeObserver = new ResizeObserver(() => {
+                        const element = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
+                        if (!element) {
                             return;
                         }
-                        const { element } = viewport;
-                        const resizeObserver = new ResizeObserver(() => {
-                            const element = (0,esm.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();
+                        const { viewport } = element;
+                        const viewPresentation = viewport.getViewPresentation();
+                        viewport.resetCamera();
+                        viewport.setViewPresentation(viewPresentation);
+                        viewport.render();
+                    });
+                    resizeObserver.observe(element);
+                    this._resizeObservers.set(viewportId, resizeObserver);
                 }
-            };
-            esm.eventTarget.addEventListener(enums.Events.TOOLGROUP_VIEWPORT_ADDED, this._viewportAddedListener);
-            this._unsubscribeToViewportNewVolumeSet(viewportsInfo);
-            this._subscribeToViewportNewVolumeSet(viewportsInfo);
+            });
+        };
+        subscribeToElementResize();
+        this._viewportAddedListener = (evt) => {
+            if (evt.detail.toolGroupId === this.toolGroupId) {
+                subscribeToElementResize();
+            }
+        };
+        esm.eventTarget.addEventListener(enums.Events.TOOLGROUP_VIEWPORT_ADDED, this._viewportAddedListener);
+        this._unsubscribeToViewportNewVolumeSet(viewportsInfo);
+        this._subscribeToViewportNewVolumeSet(viewportsInfo);
+        if (this.sphereStates && this.sphereStates.length === 0) {
+            this.originalClippingPlanes = [];
             this._initialize3DViewports(viewportsInfo);
+        }
+        this.configuration.showClippingPlanes = false;
+        this.configuration.showHandles = false;
+        const viewport = this._getViewport();
+        if (viewport &&
+            this.originalClippingPlanes &&
+            this.originalClippingPlanes.length > 0) {
+            this._updateClippingPlanes(viewport);
             if (this.sphereStates && this.sphereStates.length > 0) {
-                this.setHandlesVisible(true);
-            }
-            else {
-                this.originalClippingPlanes = [];
-                this._initialize3DViewports(viewportsInfo);
+                this._updateHandlesVisibility();
             }
+            viewport.render();
         }
     }
     onSetToolDisabled() {
@@ -11916,30 +12098,7 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
     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._updateFaceSpheresFromClippingPlanes();
             this._updateCornerSpheres();
         }
         this._updateHandlesVisibility();
@@ -11959,14 +12118,38 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
         this.configuration.showClippingPlanes = visible;
         const viewport = this._getViewport();
         this._updateClippingPlanes(viewport);
+        if (this.sphereStates && this.sphereStates.length > 0) {
+            this.configuration.showHandles = visible;
+            this._updateHandlesVisibility();
+        }
+        if (visible &&
+            viewport &&
+            this.originalClippingPlanes?.length >= volumeCropping.NUM_CLIPPING_PLANES) {
+            this._notifyClippingPlanesChanged(viewport);
+        }
         viewport.render();
     }
+    getRotatePlanesOnDrag() {
+        return this.rotatePlanesOnDrag;
+    }
+    setRotatePlanesOnDrag(enable) {
+        this.rotatePlanesOnDrag = enable;
+        const viewport = this._getViewport();
+        if (viewport) {
+            viewport.render();
+        }
+    }
     _dragCallback(evt) {
         const { element, currentPoints, lastPoints } = evt.detail;
         if (this.draggingSphereIndex !== null) {
             this._onMouseMoveSphere(evt);
         }
         else {
+            const shiftKey = evt.detail.event?.shiftKey ?? false;
+            if (this.rotatePlanesOnDrag === true || shiftKey) {
+                this._rotateClippingPlanes(evt);
+                return;
+            }
             const currentPointsCanvas = currentPoints.canvas;
             const lastPointsCanvas = lastPoints.canvas;
             const { rotateIncrementDegrees } = this.configuration;
@@ -12022,13 +12205,6 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
     }
     _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();
@@ -12080,35 +12256,6 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
             }
         });
     }
-    _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 = Points/* 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 = CellArray/* default.newInstance */.Ay.newInstance({ values: [2, 0, 1] });
-        const polyData = PolyData/* default.newInstance */.Ay.newInstance();
-        polyData.setPoints(points);
-        polyData.setLines(lines);
-        const mapper = Mapper/* default.newInstance */.Ay.newInstance();
-        mapper.setInputData(polyData);
-        const actor = Actor/* 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);
@@ -12137,9 +12284,10 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
             color = sphereColors.CORONAL || [0.0, 1.0, 0.0];
         }
         const idx = this.sphereStates.findIndex((s) => s.uid === uid);
+        const pointCopy = [point[0], point[1], point[2]];
         if (idx === -1) {
             this.sphereStates.push({
-                point: point.slice(),
+                point: pointCopy,
                 axis,
                 uid,
                 sphereSource,
@@ -12149,185 +12297,248 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
             });
         }
         else {
-            this.sphereStates[idx].point = point.slice();
+            this.sphereStates[idx].point = pointCopy;
             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));
+    _getDirectionVectorForAxis(axis) {
+        if (this.originalClippingPlanes &&
+            this.originalClippingPlanes.length >= volumeCropping.NUM_CLIPPING_PLANES) {
+            switch (axis) {
+                case 'x':
+                    return this.originalClippingPlanes[volumeCropping.PLANEINDEX.XMIN]
+                        .normal;
+                case 'y':
+                    return this.originalClippingPlanes[volumeCropping.PLANEINDEX.YMIN]
+                        .normal;
+                case 'z':
+                    return this.originalClippingPlanes[volumeCropping.PLANEINDEX.ZMIN]
+                        .normal;
+                default:
+                    return [1, 0, 0];
+            }
+        }
+        if (!this.volumeDirectionVectors) {
+            if (axis === 'x')
+                return [1, 0, 0];
+            if (axis === 'y')
+                return [0, 1, 0];
+            if (axis === 'z')
+                return [0, 0, 1];
+            return [1, 0, 0];
+        }
+        switch (axis) {
+            case 'x':
+                return this.volumeDirectionVectors.xDir;
+            case 'y':
+                return this.volumeDirectionVectors.yDir;
+            case 'z':
+                return this.volumeDirectionVectors.zDir;
+            default:
+                return [1, 0, 0];
+        }
+    }
+    _getVolumeActor(viewport) {
+        const vp = viewport || this._getViewport();
+        return vp?.getDefaultActor()?.actor;
+    }
+    _getVolumeMapper(viewport) {
+        const actor = this._getVolumeActor(viewport);
+        return actor?.getMapper();
+    }
+    _applyClippingPlanesToMapper(mapper) {
+        mapper.removeAllClippingPlanes();
+        for (let i = 0; i < volumeCropping.NUM_CLIPPING_PLANES; ++i) {
+            const plane = Plane/* default.newInstance */.Ay.newInstance({
+                origin: this.originalClippingPlanes[i].origin,
+                normal: this.originalClippingPlanes[i].normal,
+            });
+            mapper.addClippingPlane(plane);
+        }
     }
     _updateClippingPlanesFromFaceSpheres(viewport) {
         const mapper = viewport.getDefaultActor().actor.getMapper();
-        this.originalClippingPlanes[0].origin = [
-            ...this.sphereStates[SPHEREINDEX.XMIN].point,
+        this.originalClippingPlanes[volumeCropping.PLANEINDEX.XMIN].origin = [
+            ...this.sphereStates[volumeCropping.SPHEREINDEX.XMIN].point,
         ];
-        this.originalClippingPlanes[1].origin = [
-            ...this.sphereStates[SPHEREINDEX.XMAX].point,
+        this.originalClippingPlanes[volumeCropping.PLANEINDEX.XMAX].origin = [
+            ...this.sphereStates[volumeCropping.SPHEREINDEX.XMAX].point,
         ];
-        this.originalClippingPlanes[2].origin = [
-            ...this.sphereStates[SPHEREINDEX.YMIN].point,
+        this.originalClippingPlanes[volumeCropping.PLANEINDEX.YMIN].origin = [
+            ...this.sphereStates[volumeCropping.SPHEREINDEX.YMIN].point,
         ];
-        this.originalClippingPlanes[3].origin = [
-            ...this.sphereStates[SPHEREINDEX.YMAX].point,
+        this.originalClippingPlanes[volumeCropping.PLANEINDEX.YMAX].origin = [
+            ...this.sphereStates[volumeCropping.SPHEREINDEX.YMAX].point,
         ];
-        this.originalClippingPlanes[4].origin = [
-            ...this.sphereStates[SPHEREINDEX.ZMIN].point,
+        this.originalClippingPlanes[volumeCropping.PLANEINDEX.ZMIN].origin = [
+            ...this.sphereStates[volumeCropping.SPHEREINDEX.ZMIN].point,
         ];
-        this.originalClippingPlanes[5].origin = [
-            ...this.sphereStates[SPHEREINDEX.ZMAX].point,
+        this.originalClippingPlanes[volumeCropping.PLANEINDEX.ZMAX].origin = [
+            ...this.sphereStates[volumeCropping.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 = Plane/* default.newInstance */.Ay.newInstance({
-                origin,
-                normal,
-            });
-            mapper.addClippingPlane(plane);
-        }
+        this._applyClippingPlanesToMapper(mapper);
     }
     _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 { xDir, yDir, zDir } = this._getDirectionVectors();
+        if (!xDir || !yDir || !zDir)
+            return;
+        const faceXMin = this.sphereStates[volumeCropping.SPHEREINDEX.XMIN].point;
+        const faceXMax = this.sphereStates[volumeCropping.SPHEREINDEX.XMAX].point;
+        const faceYMin = this.sphereStates[volumeCropping.SPHEREINDEX.YMIN].point;
+        const faceYMax = this.sphereStates[volumeCropping.SPHEREINDEX.YMAX].point;
+        const faceZMin = this.sphereStates[volumeCropping.SPHEREINDEX.ZMIN].point;
+        const faceZMax = this.sphereStates[volumeCropping.SPHEREINDEX.ZMAX].point;
         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] },
+            {
+                key: 'XMIN_YMIN_ZMIN',
+                pos: this._calculateCornerFromFaces(faceXMin, faceYMin, faceZMin, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMIN_YMIN_ZMAX',
+                pos: this._calculateCornerFromFaces(faceXMin, faceYMin, faceZMax, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMIN_YMAX_ZMIN',
+                pos: this._calculateCornerFromFaces(faceXMin, faceYMax, faceZMin, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMIN_YMAX_ZMAX',
+                pos: this._calculateCornerFromFaces(faceXMin, faceYMax, faceZMax, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMAX_YMIN_ZMIN',
+                pos: this._calculateCornerFromFaces(faceXMax, faceYMin, faceZMin, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMAX_YMIN_ZMAX',
+                pos: this._calculateCornerFromFaces(faceXMax, faceYMin, faceZMax, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMAX_YMAX_ZMIN',
+                pos: this._calculateCornerFromFaces(faceXMax, faceYMax, faceZMin, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMAX_YMAX_ZMAX',
+                pos: this._calculateCornerFromFaces(faceXMax, faceYMax, faceZMax, xDir, yDir, zDir),
+            },
         ];
         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();
+            const stateIndex = this.sphereStates.findIndex((s) => s.uid === `corner_${corner.key}`);
+            if (stateIndex !== -1) {
+                this._updateSpherePosition(stateIndex, corner.pos);
             }
         }
     }
     _updateFaceSpheresFromCorners() {
+        if (!this.volumeDirectionVectors)
+            return;
         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,
+            this.sphereStates[volumeCropping.SPHEREINDEX.XMIN_YMIN_ZMIN].point,
+            this.sphereStates[volumeCropping.SPHEREINDEX.XMIN_YMIN_ZMAX].point,
+            this.sphereStates[volumeCropping.SPHEREINDEX.XMIN_YMAX_ZMIN].point,
+            this.sphereStates[volumeCropping.SPHEREINDEX.XMIN_YMAX_ZMAX].point,
+            this.sphereStates[volumeCropping.SPHEREINDEX.XMAX_YMIN_ZMIN].point,
+            this.sphereStates[volumeCropping.SPHEREINDEX.XMAX_YMIN_ZMAX].point,
+            this.sphereStates[volumeCropping.SPHEREINDEX.XMAX_YMAX_ZMIN].point,
+            this.sphereStates[volumeCropping.SPHEREINDEX.XMAX_YMAX_ZMAX].point,
         ];
-        [
-            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();
-        });
+        const faceXMin = this._averagePoints([
+            corners[0],
+            corners[1],
+            corners[2],
+            corners[3],
+        ]);
+        const faceXMax = this._averagePoints([
+            corners[4],
+            corners[5],
+            corners[6],
+            corners[7],
+        ]);
+        const faceYMin = this._averagePoints([
+            corners[0],
+            corners[1],
+            corners[4],
+            corners[5],
+        ]);
+        const faceYMax = this._averagePoints([
+            corners[2],
+            corners[3],
+            corners[6],
+            corners[7],
+        ]);
+        const faceZMin = this._averagePoints([
+            corners[0],
+            corners[2],
+            corners[4],
+            corners[6],
+        ]);
+        const faceZMax = this._averagePoints([
+            corners[1],
+            corners[3],
+            corners[5],
+            corners[7],
+        ]);
+        this._updateSpherePosition(volumeCropping.SPHEREINDEX.XMIN, faceXMin);
+        this._updateSpherePosition(volumeCropping.SPHEREINDEX.XMAX, faceXMax);
+        this._updateSpherePosition(volumeCropping.SPHEREINDEX.YMIN, faceYMin);
+        this._updateSpherePosition(volumeCropping.SPHEREINDEX.YMAX, faceYMax);
+        this._updateSpherePosition(volumeCropping.SPHEREINDEX.ZMIN, faceZMin);
+        this._updateSpherePosition(volumeCropping.SPHEREINDEX.ZMAX, faceZMax);
     }
     _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 { xDir, yDir, zDir } = this._getDirectionVectors();
+        if (!xDir || !yDir || !zDir)
+            return;
+        const faceXMin = this.sphereStates[volumeCropping.SPHEREINDEX.XMIN].point;
+        const faceXMax = this.sphereStates[volumeCropping.SPHEREINDEX.XMAX].point;
+        const faceYMin = this.sphereStates[volumeCropping.SPHEREINDEX.YMIN].point;
+        const faceYMax = this.sphereStates[volumeCropping.SPHEREINDEX.YMAX].point;
+        const faceZMin = this.sphereStates[volumeCropping.SPHEREINDEX.ZMIN].point;
+        const faceZMax = this.sphereStates[volumeCropping.SPHEREINDEX.ZMAX].point;
         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] },
+            {
+                key: 'XMIN_YMIN_ZMIN',
+                pos: this._calculateCornerFromProjection(faceXMin, faceYMin, faceZMin, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMIN_YMIN_ZMAX',
+                pos: this._calculateCornerFromProjection(faceXMin, faceYMin, faceZMax, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMIN_YMAX_ZMIN',
+                pos: this._calculateCornerFromProjection(faceXMin, faceYMax, faceZMin, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMIN_YMAX_ZMAX',
+                pos: this._calculateCornerFromProjection(faceXMin, faceYMax, faceZMax, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMAX_YMIN_ZMIN',
+                pos: this._calculateCornerFromProjection(faceXMax, faceYMin, faceZMin, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMAX_YMIN_ZMAX',
+                pos: this._calculateCornerFromProjection(faceXMax, faceYMin, faceZMax, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMAX_YMAX_ZMIN',
+                pos: this._calculateCornerFromProjection(faceXMax, faceYMax, faceZMin, xDir, yDir, zDir),
+            },
+            {
+                key: 'XMAX_YMAX_ZMAX',
+                pos: this._calculateCornerFromProjection(faceXMax, faceYMax, faceZMax, xDir, yDir, zDir),
+            },
         ];
         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();
+            const stateIndex = this.sphereStates.findIndex((s) => s.uid === `corner_${corner.key}`);
+            if (stateIndex !== -1) {
+                this._updateSpherePosition(stateIndex, corner.pos);
             }
         }
-        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();
-            }
-        });
+        this._updateEdgeLines();
     }
     _unsubscribeToViewportNewVolumeSet(viewportsInfo) {
         viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
@@ -12343,14 +12554,111 @@ class VolumeCroppingTool extends base/* BaseTool */.oS {
             element.addEventListener(esm.Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, this._onNewVolume);
         });
     }
+    _getDirectionVectors() {
+        const hasPlanes = this.originalClippingPlanes?.length >= volumeCropping.NUM_CLIPPING_PLANES;
+        return {
+            xDir: hasPlanes
+                ? this.originalClippingPlanes[volumeCropping.PLANEINDEX.XMIN].normal
+                : this.volumeDirectionVectors?.xDir || [1, 0, 0],
+            yDir: hasPlanes
+                ? this.originalClippingPlanes[volumeCropping.PLANEINDEX.YMIN].normal
+                : this.volumeDirectionVectors?.yDir || [0, 1, 0],
+            zDir: hasPlanes
+                ? this.originalClippingPlanes[volumeCropping.PLANEINDEX.ZMIN].normal
+                : this.volumeDirectionVectors?.zDir || [0, 0, 1],
+        };
+    }
+    _updateSpherePosition(sphereIndex, newPoint) {
+        const state = this.sphereStates[sphereIndex];
+        if (state) {
+            state.point = newPoint;
+            state.sphereSource.setCenter(...newPoint);
+            state.sphereSource.modified();
+        }
+    }
+    _updateFaceSpheresFromClippingPlanes() {
+        const faceMappings = [
+            { sphereIdx: volumeCropping.SPHEREINDEX.XMIN, planeIdx: volumeCropping.PLANEINDEX.XMIN },
+            { sphereIdx: volumeCropping.SPHEREINDEX.XMAX, planeIdx: volumeCropping.PLANEINDEX.XMAX },
+            { sphereIdx: volumeCropping.SPHEREINDEX.YMIN, planeIdx: volumeCropping.PLANEINDEX.YMIN },
+            { sphereIdx: volumeCropping.SPHEREINDEX.YMAX, planeIdx: volumeCropping.PLANEINDEX.YMAX },
+            { sphereIdx: volumeCropping.SPHEREINDEX.ZMIN, planeIdx: volumeCropping.PLANEINDEX.ZMIN },
+            { sphereIdx: volumeCropping.SPHEREINDEX.ZMAX, planeIdx: volumeCropping.PLANEINDEX.ZMAX },
+        ];
+        faceMappings.forEach(({ sphereIdx, planeIdx }) => {
+            const newPoint = [
+                ...this.originalClippingPlanes[planeIdx].origin,
+            ];
+            this._updateSpherePosition(sphereIdx, newPoint);
+        });
+    }
+    _averagePoints(points) {
+        const sum = points.reduce((acc, p) => [acc[0] + p[0], acc[1] + p[1], acc[2] + p[2]], [0, 0, 0]);
+        return [
+            sum[0] / points.length,
+            sum[1] / points.length,
+            sum[2] / points.length,
+        ];
+    }
+    _notifyClippingPlanesChanged(viewport) {
+        const eventData = {
+            originalClippingPlanes: this.originalClippingPlanes,
+            seriesInstanceUID: this.seriesInstanceUID,
+        };
+        if (viewport) {
+            eventData.viewportId = viewport.id;
+            eventData.renderingEngineId = viewport.renderingEngineId;
+        }
+        (0,esm.triggerEvent)(esm.eventTarget, enums.Events.VOLUMECROPPING_TOOL_CHANGED, eventData);
+    }
+    _calculateCornerFromFaces(faceX, faceY, faceZ, xDir, yDir, zDir) {
+        const deltaXY = [
+            faceY[0] - faceX[0],
+            faceY[1] - faceX[1],
+            faceY[2] - faceX[2],
+        ];
+        const distY = deltaXY[0] * yDir[0] + deltaXY[1] * yDir[1] + deltaXY[2] * yDir[2];
+        const deltaXZ = [
+            faceZ[0] - faceX[0],
+            faceZ[1] - faceX[1],
+            faceZ[2] - faceX[2],
+        ];
+        const distZ = deltaXZ[0] * zDir[0] + deltaXZ[1] * zDir[1] + deltaXZ[2] * zDir[2];
+        return [
+            faceX[0] + distY * yDir[0] + distZ * zDir[0],
+            faceX[1] + distY * yDir[1] + distZ * zDir[1],
+            faceX[2] + distY * yDir[2] + distZ * zDir[2],
+        ];
+    }
+    _calculateCornerFromProjection(faceX, faceY, faceZ, xDir, yDir, zDir) {
+        const dX = faceX[0] * xDir[0] + faceX[1] * xDir[1] + faceX[2] * xDir[2];
+        const dY = faceY[0] * yDir[0] + faceY[1] * yDir[1] + faceY[2] * yDir[2];
+        const dZ = faceZ[0] * zDir[0] + faceZ[1] * zDir[1] + faceZ[2] * zDir[2];
+        return [
+            dX * xDir[0] + dY * yDir[0] + dZ * zDir[0],
+            dX * xDir[1] + dY * yDir[1] + dZ * zDir[1],
+            dX * xDir[2] + dY * yDir[2] + dZ * zDir[2],
+        ];
+    }
+    _updateEdgeLines() {
+        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();
+            }
+        });
+    }
 }
 VolumeCroppingTool.toolName = 'VolumeCropping';
 /* harmony default export */ const tools_VolumeCroppingTool = ((/* unused pure expression or super */ null && (VolumeCroppingTool)));
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/cursors/elementCursor.js
 var elementCursor = __webpack_require__(7001);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/vec2/liangBarksyClip.js
-var liangBarksyClip = __webpack_require__(35381);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/annotationLocking.js
 var annotationLocking = __webpack_require__(2076);
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/VolumeCroppingControlTool.js
@@ -12369,13 +12677,6 @@ var annotationLocking = __webpack_require__(2076);
 
 
 
-const { RENDERING_DEFAULTS } = esm.CONSTANTS;
-function defaultReferenceLineColor() {
-    return 'rgb(0, 200, 0)';
-}
-function defaultReferenceLineControllable() {
-    return true;
-}
 const OPERATION = {
     DRAG: 1,
     ROTATE: 2,
@@ -12408,12 +12709,7 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
         },
     }) {
         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.clippingPlanes = [];
         this.initializeViewport = ({ renderingEngineId, viewportId, }) => {
             if (!renderingEngineId || !viewportId) {
                 console.warn('VolumeCroppingControlTool: Missing renderingEngineId or viewportId');
@@ -12424,15 +12720,21 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
                 return;
             }
             const { viewport } = enabledElement;
-            this._updateToolCentersFromViewport(viewport);
+            const volumeActors = viewport.getActors();
+            if (volumeActors && volumeActors.length > 0) {
+                const imageData = volumeActors[0].actor.getMapper().getInputData();
+                if (imageData) {
+                    this.seriesInstanceUID = imageData.seriesInstanceUID || 'unknown';
+                }
+            }
             const { element } = viewport;
-            const { position, focalPoint, viewPlaneNormal } = viewport.getCamera();
+            const { position, focalPoint } = viewport.getCamera();
             let annotations = this._getAnnotations(enabledElement);
             annotations = this.filterInteractableAnnotationsForElement(element, annotations);
             if (annotations?.length) {
                 (0,annotationState.removeAnnotation)(annotations[0].annotationUID);
             }
-            const orientation = this._getOrientationFromNormal(viewport.getCamera().viewPlaneNormal);
+            const orientation = (0,volumeCropping.getOrientationFromNormal)(viewport.getCamera().viewPlaneNormal);
             const annotation = {
                 highlighted: false,
                 metadata: {
@@ -12442,11 +12744,11 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
                 },
                 data: {
                     handles: {
-                        toolCenter: this.toolCenter,
-                        toolCenterMin: this.toolCenterMin,
-                        toolCenterMax: this.toolCenterMax,
+                        activeOperation: null,
+                        clippingPlanes: this.clippingPlanes.length > 0
+                            ? (0,volumeCropping.copyClippingPlanes)(this.clippingPlanes)
+                            : [],
                     },
-                    activeOperation: null,
                     activeViewportIds: [],
                     viewportId,
                     referenceLines: [],
@@ -12454,10 +12756,6 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
                 },
             };
             (0,annotationState.addAnnotation)(annotation, element);
-            return {
-                normal: viewPlaneNormal,
-                point: viewport.canvasToWorld([100, 100]),
-            };
         };
         this._getViewportsInfo = () => {
             const viewports = (0,ToolGroupManager.getToolGroup)(this.toolGroupId).viewportsInfo;
@@ -12490,139 +12788,22 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
                 }
                 viewport.render();
             }
-            this._computeToolCenter(viewportsInfo);
+            this._initializeViewports(viewportsInfo);
         };
-        this.computeToolCenter = () => {
-            const viewportsInfo = this._getViewportsInfo();
-        };
-        this._computeToolCenter = (viewportsInfo) => {
-            if (!viewportsInfo || !viewportsInfo[0]) {
-                console.warn('  _computeToolCenter : No valid viewportsInfo for computeToolCenter.');
+        this._initializeViewports = (viewportsInfo) => {
+            if (!viewportsInfo?.length || !viewportsInfo[0]) {
+                console.warn('VolumeCroppingControlTool: No valid viewportsInfo for initialization.');
                 return;
             }
-            const orientationIds = ['AXIAL', 'CORONAL', 'SAGITTAL'];
-            const presentOrientations = viewportsInfo
-                .map((vp) => {
-                if (vp.renderingEngineId) {
-                    const renderingEngine = (0,esm.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,esm.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);
+            viewportsInfo.forEach((vpInfo) => {
+                this.initializeViewport(vpInfo);
             });
-            if (presentViewportInfos.length === 2 && missingOrientation) {
-                const virtualNormal = [0, 0, 0];
-                gl_matrix_esm/* vec3.cross */.eR.cross(virtualNormal, presentNormals[0], presentNormals[1]);
-                gl_matrix_esm/* 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,esm.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,triggerAnnotationRenderForViewportIds/* default */.A)(viewportsInfo.map(({ viewportId }) => viewportId));
-            }
+            (0,triggerAnnotationRenderForViewportIds/* 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)) {
+            if (this._pointNearTool(element, annotation, canvasCoords, volumeCropping.POINT_PROXIMITY_THRESHOLD_PIXELS)) {
                 return true;
             }
             return false;
@@ -12654,13 +12835,8 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
                 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 near = this._pointNearTool(element, annotation, canvasCoords, volumeCropping.POINT_PROXIMITY_THRESHOLD_PIXELS);
                 const nearToolAndNotMarkedActive = near && !highlighted;
                 const notNearToolAndMarkedActive = !near && highlighted;
                 if (nearToolAndNotMarkedActive || notNearToolAndMarkedActive) {
@@ -12677,12 +12853,9 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
             const enabledElement = (0,esm.getEnabledElement)(element);
             let orientation = null;
             if (enabledElement.viewport && enabledElement.viewport.getCamera) {
-                orientation = this._getOrientationFromNormal(enabledElement.viewport.getCamera().viewPlaneNormal);
+                orientation = (0,volumeCropping.getOrientationFromNormal)(enabledElement.viewport.getCamera().viewPlaneNormal);
             }
             const filtered = annotations.filter((annotation) => {
-                if (annotation.isVirtual) {
-                    return true;
-                }
                 if (annotation.data.orientation &&
                     orientation &&
                     annotation.data.orientation === orientation) {
@@ -12699,7 +12872,7 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
                 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) {
+                if (Math.abs(denom) < volumeCropping.LINE_INTERSECTION_TOLERANCE) {
                     return null;
                 }
                 const s = (-s1_y * (p1[0] - q1[0]) + s1_x * (p1[1] - q1[1])) / denom;
@@ -12716,10 +12889,7 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
             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 annotations = this._getAnnotations(enabledElement);
             const camera = viewport.getCamera();
             const filteredToolAnnotations = this.filterInteractableAnnotationsForElement(element, annotations);
             const viewportAnnotation = filteredToolAnnotations[0];
@@ -12730,135 +12900,65 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
             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_esm/* vec3.create */.eR.create();
-                        gl_matrix_esm/* vec3.cross */.eR.cross(virtualNormal, normal1, normal2);
-                        gl_matrix_esm/* 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,
-                        };
-                    }
+            let clippingPlanes = viewportAnnotation.data.handles.clippingPlanes;
+            if (!clippingPlanes || clippingPlanes.length < volumeCropping.NUM_CLIPPING_PLANES) {
+                if (this.clippingPlanes &&
+                    this.clippingPlanes.length >= volumeCropping.NUM_CLIPPING_PLANES) {
+                    clippingPlanes = this.clippingPlanes;
+                    data.handles.clippingPlanes = (0,volumeCropping.copyClippingPlanes)(this.clippingPlanes);
                 }
                 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);
+                    return false;
+                }
+            }
+            const { viewPlaneNormal, focalPoint } = camera;
+            const referenceLines = [];
+            const planeTypes = [
+                'min',
+                'max',
+                'min',
+                'max',
+                'min',
+                'max',
+            ];
+            for (let planeIndex = 0; planeIndex < volumeCropping.NUM_CLIPPING_PLANES; planeIndex++) {
+                const clippingPlane = clippingPlanes[planeIndex];
+                const intersection = (0,volumeCropping.computePlanePlaneIntersection)(clippingPlane, viewPlaneNormal, focalPoint);
+                if (!intersection) {
+                    continue;
+                }
+                const lineBounds = (0,volumeCropping.findLineBoundsIntersection)(intersection.point, intersection.direction, viewport);
+                if (!lineBounds) {
+                    continue;
                 }
-                const otherViewportControllable = this._getReferenceLineControllable(otherViewport.id);
-                const direction = [0, 0, 0];
-                Core_Math/* default.cross */.Ay.cross(camera.viewPlaneNormal, otherCamera.viewPlaneNormal, direction);
-                Core_Math/* default.normalize */.Ay.normalize(direction);
-                Core_Math/* default.multiplyScalar */.Ay.multiplyScalar(direction, otherCanvasDiagonalLength);
-                const pointWorld0 = [0, 0, 0];
-                Core_Math/* default.add */.Ay.add(otherViewportCenterWorld, direction, pointWorld0);
-                const pointWorld1 = [0, 0, 0];
-                Core_Math/* 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_esm/* vec2.create */.Zc.create();
-                gl_matrix_esm/* vec2.subtract */.Zc.subtract(canvasUnitVectorFromCenter, pointCanvas0, otherViewportCenterCanvas);
-                gl_matrix_esm/* vec2.normalize */.Zc.normalize(canvasUnitVectorFromCenter, canvasUnitVectorFromCenter);
-                const canvasVectorFromCenterLong = gl_matrix_esm/* vec2.create */.Zc.create();
-                gl_matrix_esm/* vec2.scale */.Zc.scale(canvasVectorFromCenterLong, canvasUnitVectorFromCenter, canvasDiagonalLength * 100);
-                const refLinesCenterMin = otherViewportControllable
-                    ? gl_matrix_esm/* vec2.clone */.Zc.clone(volumeCroppingCenterCanvasMin)
-                    : gl_matrix_esm/* vec2.clone */.Zc.clone(otherViewportCenterCanvas);
-                const refLinePointMinOne = gl_matrix_esm/* vec2.create */.Zc.create();
-                const refLinePointMinTwo = gl_matrix_esm/* vec2.create */.Zc.create();
-                gl_matrix_esm/* vec2.add */.Zc.add(refLinePointMinOne, refLinesCenterMin, canvasVectorFromCenterLong);
-                gl_matrix_esm/* vec2.subtract */.Zc.subtract(refLinePointMinTwo, refLinesCenterMin, canvasVectorFromCenterLong);
-                (0,liangBarksyClip/* default */.A)(refLinePointMinOne, refLinePointMinTwo, canvasBox);
-                referenceLines.push([
-                    otherViewport,
-                    refLinePointMinOne,
-                    refLinePointMinTwo,
-                    'min',
-                ]);
-                const refLinesCenterMax = otherViewportControllable
-                    ? gl_matrix_esm/* vec2.clone */.Zc.clone(volumeCroppingCenterCanvasMax)
-                    : gl_matrix_esm/* vec2.clone */.Zc.clone(otherViewportCenterCanvas);
-                const refLinePointMaxOne = gl_matrix_esm/* vec2.create */.Zc.create();
-                const refLinePointMaxTwo = gl_matrix_esm/* vec2.create */.Zc.create();
-                gl_matrix_esm/* vec2.add */.Zc.add(refLinePointMaxOne, refLinesCenterMax, canvasVectorFromCenterLong);
-                gl_matrix_esm/* vec2.subtract */.Zc.subtract(refLinePointMaxTwo, refLinesCenterMax, canvasVectorFromCenterLong);
-                (0,liangBarksyClip/* default */.A)(refLinePointMaxOne, refLinePointMaxTwo, canvasBox);
                 referenceLines.push([
-                    otherViewport,
-                    refLinePointMaxOne,
-                    refLinePointMaxTwo,
-                    'max',
+                    {
+                        id: viewport.id,
+                        canvas: viewport.canvas,
+                    },
+                    lineBounds.start,
+                    lineBounds.end,
+                    planeTypes[planeIndex],
+                    planeIndex,
                 ]);
-            });
+            }
             data.referenceLines = referenceLines;
             const viewportColor = this._getReferenceLineColor(viewport.id);
-            const color = viewportColor !== undefined ? viewportColor : 'rgb(200, 200, 200)';
+            const defaultColor = viewportColor !== undefined ? viewportColor : 'rgb(200, 200, 200)';
             referenceLines.forEach((line, lineIndex) => {
+                const [otherViewport, startPoint, endPoint, type, planeIndex] = line;
+                if (planeIndex === undefined ||
+                    planeIndex < 0 ||
+                    planeIndex >= volumeCropping.NUM_CLIPPING_PLANES) {
+                    return;
+                }
                 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]);
+                    const intersection = lineIntersection2D(startPoint, endPoint, otherLine[1], otherLine[2]);
                     if (intersection) {
                         intersections.push({
                             with: otherLine[3],
@@ -12866,32 +12966,12 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
                         });
                     }
                 }
-                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 colorKey = (0,volumeCropping.getColorKeyForPlaneIndex)(planeIndex);
                 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 colorArr = colorKey
+                    ? lineColors[colorKey] || lineColors.UNKNOWN || [1.0, 0.0, 0.0]
+                    : [1.0, 0.0, 0.0];
+                const color = (0,esm.convertColorArrayToRgbString)(colorArr);
                 const viewportControllable = this._getReferenceLineControllable(otherViewport.id);
                 const selectedViewportId = data.activeViewportIds.find((id) => id === otherViewport.id);
                 let lineWidth = this.configuration.lineWidth ?? 1.5;
@@ -12901,28 +12981,29 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
                 if (lineActive) {
                     lineWidth = this.configuration.activeLineWidth ?? 2.5;
                 }
-                const lineUID = `${lineIndex}`;
-                if (viewportControllable) {
-                    if (intersections.length === 2) {
-                        (0,drawingSvg.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_esm/* vec2.distance */.Zc.distance(line[1], intersection.point),
-                            }))
-                                .sort((a, b) => a.distance - b.distance);
-                            (0,drawingSvg.drawLine)(svgDrawingHelper, annotationUID, lineUID + '_dashed_before', line[1], sortedIntersections[0].point, { color, lineWidth, lineDash: [4, 4] });
-                            (0,drawingSvg.drawLine)(svgDrawingHelper, annotationUID, lineUID + '_dashed_after', sortedIntersections[1].point, line[2], { color, lineWidth, lineDash: [4, 4] });
-                        }
-                    }
+                const lineUID = `plane_${planeIndex}`;
+                if (intersections.length === 2) {
+                    (0,drawingSvg.drawLine)(svgDrawingHelper, annotationUID, lineUID, intersections[0].point, intersections[1].point, {
+                        color,
+                        lineWidth,
+                    });
+                }
+                else {
+                    (0,drawingSvg.drawLine)(svgDrawingHelper, annotationUID, lineUID, startPoint, endPoint, {
+                        color,
+                        lineWidth,
+                    });
+                }
+                if (this.configuration.extendReferenceLines &&
+                    intersections.length === 2) {
+                    const sortedIntersections = intersections
+                        .map((intersection) => ({
+                        ...intersection,
+                        distance: gl_matrix_esm/* vec2.distance */.Zc.distance(startPoint, intersection.point),
+                    }))
+                        .sort((a, b) => a.distance - b.distance);
+                    (0,drawingSvg.drawLine)(svgDrawingHelper, annotationUID, lineUID + '_dashed_before', startPoint, sortedIntersections[0].point, { color, lineWidth, lineDash: [4, 4] });
+                    (0,drawingSvg.drawLine)(svgDrawingHelper, annotationUID, lineUID + '_dashed_after', sortedIntersections[1].point, endPoint, { color, lineWidth, lineDash: [4, 4] });
                 }
             });
             renderStatus = true;
@@ -12936,7 +13017,7 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
                 ];
                 const circleRadius = viewportIndicatorsConfig?.circleRadius || canvasDiagonalLength * 0.01;
                 const circleUID = '0';
-                (0,drawingSvg.drawCircle)(svgDrawingHelper, annotationUID, circleUID, referenceColorCoordinates, circleRadius, { color, fill: color });
+                (0,drawingSvg.drawCircle)(svgDrawingHelper, annotationUID, circleUID, referenceColorCoordinates, circleRadius, { color: defaultColor, fill: defaultColor });
             }
             return renderStatus;
         };
@@ -12958,40 +13039,7 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
                 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');
-                }
+                return;
             }
         };
         this._onNewVolume = () => {
@@ -12999,72 +13047,28 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
             if (viewportsInfo && viewportsInfo.length > 0) {
                 const { viewportId, renderingEngineId } = viewportsInfo[0];
                 const renderingEngine = (0,esm.getRenderingEngine)(renderingEngineId);
+                if (!renderingEngine) {
+                    return;
+                }
                 const viewport = renderingEngine.getViewport(viewportId);
+                if (!viewport) {
+                    return;
+                }
                 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,annotationState.getAnnotations)(this.getToolName(), viewportId) || [];
-                        annotations.forEach((annotation) => {
-                            if (annotation.data && annotation.data.handles) {
-                                annotation.data.handles.toolCenter = [...this.toolCenter];
-                            }
-                        });
                     }
                 }
             }
-            this._computeToolCenter(viewportsInfo);
+            this._initializeViewports(viewportsInfo);
             (0,esm.triggerEvent)(esm.eventTarget, enums.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 !(esm.utilities.isEqual(cameraOfTarget.viewPlaneNormal, viewPlaneNormal, 1e-2) && esm.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;
-            Core_Math/* 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;
-                Core_Math/* default.normalize */.Ay.normalize(otherViewPlaneNormal);
-                return (esm.utilities.isEqual(viewPlaneNormal, otherViewPlaneNormal, 1e-2) &&
-                    esm.utilities.isEqual(camera.viewUp, otherCamera.viewUp, 1e-2));
-            });
-            return otherViewportsAnnotationsWithSameCameraDirection;
-        };
         this._activateModify = (element) => {
             state/* state */.wk.isInteractingWithTool = !this.configuration.mobile?.enabled;
             element.addEventListener(enums.Events.MOUSE_UP, this._endCallback);
@@ -13116,48 +13120,71 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
                 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];
+            const clippingPlanes = handles.clippingPlanes;
+            if (handles.activeOperation === OPERATION.DRAG &&
+                clippingPlanes &&
+                clippingPlanes.length >= volumeCropping.NUM_CLIPPING_PLANES) {
+                if (handles.activePlaneIndex !== undefined &&
+                    handles.activePlaneIndex >= 0 &&
+                    handles.activePlaneIndex < volumeCropping.NUM_CLIPPING_PLANES) {
+                    const planeIndex = handles.activePlaneIndex;
+                    const plane = clippingPlanes[planeIndex];
+                    const normal = plane.normal;
+                    const dotProd = Core_Math/* default.dot */.Ay.dot(delta, normal);
+                    const moveDistance = dotProd;
+                    plane.origin[0] += normal[0] * moveDistance;
+                    plane.origin[1] += normal[1] * moveDistance;
+                    plane.origin[2] += normal[2] * moveDistance;
                 }
-                else if (handles.activeType === 'max') {
-                    this.toolCenterMax[0] += delta[0];
-                    this.toolCenterMax[1] += delta[1];
-                    this.toolCenterMax[2] += delta[2];
+                else if (handles.activeType === 'min') {
+                    clippingPlanes[0].origin[0] += delta[0];
+                    clippingPlanes[2].origin[1] += delta[1];
+                    clippingPlanes[4].origin[2] += delta[2];
                 }
-                else {
-                    this.toolCenter[0] += delta[0];
-                    this.toolCenter[1] += delta[1];
-                    this.toolCenter[2] += delta[2];
+                else if (handles.activeType === 'max') {
+                    clippingPlanes[1].origin[0] += delta[0];
+                    clippingPlanes[3].origin[1] += delta[1];
+                    clippingPlanes[5].origin[2] += delta[2];
                 }
+                this.clippingPlanes = (0,volumeCropping.copyClippingPlanes)(clippingPlanes);
                 const viewportsInfo = this._getViewportsInfo();
+                viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+                    const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
+                    if (enabledElement) {
+                        const annotations = this._getAnnotations(enabledElement);
+                        annotations.forEach((annotation) => {
+                            if (annotation.data?.handles) {
+                                annotation.data.handles.clippingPlanes = (0,volumeCropping.copyClippingPlanes)(this.clippingPlanes);
+                            }
+                        });
+                    }
+                });
                 (0,triggerAnnotationRenderForViewportIds/* default */.A)(viewportsInfo.map(({ viewportId }) => viewportId));
                 (0,esm.triggerEvent)(esm.eventTarget, enums.Events.VOLUMECROPPINGCONTROL_TOOL_CHANGED, {
                     toolGroupId: this.toolGroupId,
-                    toolCenter: this.toolCenter,
-                    toolCenterMin: this.toolCenterMin,
-                    toolCenterMax: this.toolCenterMax,
+                    clippingPlanes: this.clippingPlanes,
                     handleType: handles.activeType,
-                    viewportOrientation: [],
                     seriesInstanceUID: this.seriesInstanceUID,
                 });
             }
         };
         this._getReferenceLineColor =
             toolProps.configuration?.getReferenceLineColor ||
-                defaultReferenceLineColor;
+                (() => 'rgb(0, 200, 0)');
         this._getReferenceLineControllable =
-            toolProps.configuration?.getReferenceLineControllable ||
-                defaultReferenceLineControllable;
+            toolProps.configuration?.getReferenceLineControllable || (() => true);
         const viewportsInfo = (0,ToolGroupManager.getToolGroup)(this.toolGroupId)?.viewportsInfo;
         esm.eventTarget.addEventListener(enums.Events.VOLUMECROPPING_TOOL_CHANGED, this._onSphereMoved);
         if (viewportsInfo && viewportsInfo.length > 0) {
             const { viewportId, renderingEngineId } = viewportsInfo[0];
-            const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
             const renderingEngine = (0,esm.getRenderingEngine)(renderingEngineId);
+            if (!renderingEngine) {
+                return;
+            }
             const viewport = renderingEngine.getViewport(viewportId);
+            if (!viewport) {
+                return;
+            }
             const volumeActors = viewport.getActors();
             if (!volumeActors || !volumeActors.length) {
                 console.warn(`VolumeCroppingControlTool: No volume actors found in viewport ${viewportId}.`);
@@ -13165,67 +13192,11 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
             }
             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();
@@ -13241,7 +13212,7 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
         if (!anyAnnotationExists) {
             this._unsubscribeToViewportNewVolumeSet(viewportsInfo);
             this._subscribeToViewportNewVolumeSet(viewportsInfo);
-            this._computeToolCenter(viewportsInfo);
+            this._initializeViewports(viewportsInfo);
             (0,esm.triggerEvent)(esm.eventTarget, enums.Events.VOLUMECROPPINGCONTROL_TOOL_CHANGED, {
                 toolGroupId: this.toolGroupId,
                 viewportsInfo: viewportsInfo,
@@ -13265,13 +13236,12 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
         }
     }
     onSetToolEnabled() {
-        console.debug(`VolumeCroppingControlTool: onSetToolEnabled called for tool ${this.getToolName()}`);
-        const viewportsInfo = this._getViewportsInfo();
+        esm.eventTarget.addEventListener(enums.Events.VOLUMECROPPING_TOOL_CHANGED, this._onSphereMoved);
     }
     onSetToolDisabled() {
-        console.debug(`VolumeCroppingControlTool: onSetToolDisabled called for tool ${this.getToolName()}`);
         const viewportsInfo = this._getViewportsInfo();
         this._unsubscribeToViewportNewVolumeSet(viewportsInfo);
+        esm.eventTarget.removeEventListener(enums.Events.VOLUMECROPPING_TOOL_CHANGED, this._onSphereMoved);
         viewportsInfo.forEach(({ renderingEngineId, viewportId }) => {
             const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
             if (!enabledElement) {
@@ -13285,176 +13255,24 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
             }
         });
     }
-    _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,esm.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,
-                        ];
+        if (!originalClippingPlanes ||
+            originalClippingPlanes.length < volumeCropping.NUM_CLIPPING_PLANES) {
+            return;
+        }
+        this.clippingPlanes = (0,volumeCropping.copyClippingPlanes)(originalClippingPlanes);
+        const viewportsInfo = this._getViewportsInfo();
+        viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+            const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
+            if (enabledElement) {
+                const annotations = this._getAnnotations(enabledElement);
+                annotations.forEach((annotation) => {
+                    if (annotation.data?.handles) {
+                        annotation.data.handles.clippingPlanes = (0,volumeCropping.copyClippingPlanes)(this.clippingPlanes);
                     }
                 });
             }
-            (0,triggerAnnotationRenderForViewportIds/* 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,triggerAnnotationRenderForViewportIds/* default */.A)(viewportsInfo.map(({ viewportId }) => viewportId));
     }
     addNewAnnotation(evt) {
@@ -13479,7 +13297,6 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
                 continue;
             }
             viewportIdArray.push(otherViewport.id);
-            i++;
         }
         data.activeViewportIds = [...viewportIdArray];
         data.handles.activeOperation = OPERATION.DRAG;
@@ -13505,51 +13322,22 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
             element.addEventListener(esm.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 = Core_Math/* default.dot */.Ay.dot(delta, normal);
-        const projectedDelta = [...normal];
-        Core_Math/* 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];
-            Core_Math/* default.add */.Ay.add(camera.focalPoint, projectedDelta, newFocalPoint);
-            Core_Math/* 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 = math_line.distanceToPoint(start1, end1, [
+                const [otherViewport, startPoint, endPoint, type, planeIndex] = referenceLines[i];
+                const distance = math_line.distanceToPoint(startPoint, endPoint, [
                     canvasCoords[0],
                     canvasCoords[1],
                 ]);
-                if (distance1 <= proximity) {
+                if (distance <= proximity) {
                     viewportIdArray.push(otherViewport.id);
-                    data.handles.activeOperation = 1;
+                    data.handles.activeOperation = OPERATION.DRAG;
                     data.handles.activeType = type;
+                    data.handles.activePlaneIndex = planeIndex;
                 }
             }
         }
@@ -13557,7 +13345,7 @@ class VolumeCroppingControlTool extends base/* AnnotationTool */.EC {
         this.editData = {
             annotation,
         };
-        return data.handles.activeOperation === 1 ? true : false;
+        return data.handles.activeOperation === OPERATION.DRAG ? true : false;
     }
 }
 VolumeCroppingControlTool.toolName = 'VolumeCroppingControl';
@@ -14439,6 +14227,8 @@ MIPJumpToClickTool.toolName = 'MIPJumpToClickTool';
 
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/MatrixBuilder.js
 var MatrixBuilder = __webpack_require__(90364);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/vec2/liangBarksyClip.js
+var liangBarksyClip = __webpack_require__(35381);
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/CrosshairsTool.js
 
 
@@ -14457,11 +14247,11 @@ var MatrixBuilder = __webpack_require__(90364);
 
 
 
-const { RENDERING_DEFAULTS: CrosshairsTool_RENDERING_DEFAULTS } = esm.CONSTANTS;
-function CrosshairsTool_defaultReferenceLineColor() {
+const { RENDERING_DEFAULTS } = esm.CONSTANTS;
+function defaultReferenceLineColor() {
     return 'rgb(0, 200, 0)';
 }
-function CrosshairsTool_defaultReferenceLineControllable() {
+function defaultReferenceLineControllable() {
     return true;
 }
 function defaultReferenceLineDraggableRotatable() {
@@ -15571,10 +15361,10 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
                             slabThicknessValue += mod;
                         }
                         slabThicknessValue = Math.abs(slabThicknessValue);
-                        slabThicknessValue = Math.max(CrosshairsTool_RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, slabThicknessValue);
+                        slabThicknessValue = Math.max(RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS, slabThicknessValue);
                         const near = this._pointNearReferenceLine(viewportAnnotation, canvasCoords, 6, otherViewport);
                         if (near) {
-                            slabThicknessValue = CrosshairsTool_RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
+                            slabThicknessValue = RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
                         }
                         const toolGroup = (0,ToolGroupManager.getToolGroupForViewport)(otherViewport.id, renderingEngine.id);
                         const crosshairsInstance = toolGroup.getToolInstance(this.getToolName());
@@ -15799,10 +15589,10 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
         };
         this._getReferenceLineColor =
             toolProps.configuration?.getReferenceLineColor ||
-                CrosshairsTool_defaultReferenceLineColor;
+                defaultReferenceLineColor;
         this._getReferenceLineControllable =
             toolProps.configuration?.getReferenceLineControllable ||
-                CrosshairsTool_defaultReferenceLineControllable;
+                defaultReferenceLineControllable;
         this._getReferenceLineDraggableRotatable =
             toolProps.configuration?.getReferenceLineDraggableRotatable ||
                 defaultReferenceLineDraggableRotatable;
@@ -15978,7 +15768,7 @@ class CrosshairsTool extends base/* AnnotationTool */.EC {
             actorUIDs = filterActorUIDsToSetSlabThickness;
         }
         let blendModeToUse = this.configuration.slabThicknessBlendMode;
-        if (slabThickness === CrosshairsTool_RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS) {
+        if (slabThickness === RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS) {
             blendModeToUse = esm.Enums.BlendModes.COMPOSITE;
         }
         const immediate = false;
@@ -29212,8 +29002,8 @@ PaintFillTool.toolName = 'PaintFill';
 
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Interaction/Widgets/OrientationMarkerWidget.js + 1 modules
 var OrientationMarkerWidget = __webpack_require__(53489);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/AnnotatedCubeActor.js + 2 modules
-var AnnotatedCubeActor = __webpack_require__(83338);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/AnnotatedCubeActor.js + 1 modules
+var AnnotatedCubeActor = __webpack_require__(91960);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Rendering/Core/AxesActor.js + 4 modules
 var AxesActor = __webpack_require__(10341);
 // EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/IO/XML/XMLPolyDataReader.js + 4 modules
@@ -29506,6 +29296,425 @@ class OrientationMarkerTool extends base/* BaseTool */.oS {
 OrientationMarkerTool.toolName = 'OrientationMarker';
 /* harmony default export */ const tools_OrientationMarkerTool = ((/* unused pure expression or super */ null && (OrientationMarkerTool)));
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/vtkjs/OrientationControllerWidget/index.js + 6 modules
+var OrientationControllerWidget = __webpack_require__(14770);
+;// ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/OrientationControllerTool.js
+
+
+
+
+
+
+const ADD_MARKER_DELAY_MS = 500;
+const POSITION_RETRY_DELAY_MS = 1000;
+const FACE_COLOR_SCHEMES = {
+    marker: {
+        topBottom: [0, 0, 255],
+        frontBack: [0, 255, 255],
+        leftRight: [255, 255, 0],
+    },
+    gray: {
+        topBottom: [180, 180, 180],
+        frontBack: [180, 180, 180],
+        leftRight: [180, 180, 180],
+    },
+    rgy: {
+        topBottom: [255, 0, 0],
+        frontBack: [0, 255, 0],
+        leftRight: [255, 255, 0],
+    },
+};
+const LETTER_COLOR_SCHEMES = {
+    mixed: {
+        zMinus: [255, 255, 255],
+        zPlus: [255, 255, 255],
+        yMinus: [255, 255, 255],
+        yPlus: [255, 255, 255],
+        xMinus: [0, 0, 0],
+        xPlus: [0, 0, 0],
+    },
+    rgy: {
+        zMinus: [255, 255, 255],
+        zPlus: [255, 255, 255],
+        yMinus: [255, 255, 255],
+        yPlus: [255, 255, 255],
+        xMinus: [0, 0, 0],
+        xPlus: [0, 0, 0],
+    },
+    white: {
+        zMinus: [255, 255, 255],
+        zPlus: [255, 255, 255],
+        yMinus: [255, 255, 255],
+        yPlus: [255, 255, 255],
+        xMinus: [255, 255, 255],
+        xPlus: [255, 255, 255],
+    },
+    black: {
+        zMinus: [0, 0, 0],
+        zPlus: [0, 0, 0],
+        yMinus: [0, 0, 0],
+        yPlus: [0, 0, 0],
+        xMinus: [0, 0, 0],
+        xPlus: [0, 0, 0],
+    },
+};
+const DEFAULT_FACE_COLOR_SCHEME = 'rgy';
+const DEFAULT_LETTER_COLOR_SCHEME = 'mixed';
+const ANIMATE_RESET_CAMERA_OPTIONS = {
+    resetZoom: false,
+    resetPan: true,
+    resetToCenter: true,
+};
+class OrientationControllerTool extends base/* BaseTool */.oS {
+    static { this.toolName = 'OrientationControllerTool'; }
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse'],
+        configuration: {
+            enabled: true,
+            opacity: 1.0,
+            size: 0.04,
+            position: 'bottom-right',
+            colorScheme: 'rgy',
+            letterColorScheme: 'mixed',
+            showEdgeFaces: true,
+            showCornerFaces: true,
+            keepOrientationUp: true,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.widget = new OrientationControllerWidget/* vtkOrientationControllerWidget */.C();
+        this.resizeObservers = new Map();
+        this.cameraHandlers = new Map();
+        this._getViewportsInfo = () => {
+            const viewports = (0,ToolGroupManager.getToolGroup)(this.toolGroupId)?.viewportsInfo;
+            return viewports || [];
+        };
+        this.onSetToolConfiguration = () => {
+            const viewportsInfo = this._getViewportsInfo();
+            const hasActiveMarkers = viewportsInfo.some(({ viewportId }) => {
+                return this.widget.getActors(viewportId) !== null;
+            });
+            if (hasActiveMarkers) {
+                this.removeMarkers();
+                this.addMarkers();
+            }
+        };
+        this.onViewportAdded = (evt) => {
+            const { viewportId, renderingEngineId, toolGroupId } = evt.detail;
+            if (toolGroupId !== this.toolGroupId) {
+                return;
+            }
+            if (this.widget.getActors(viewportId)) {
+                return;
+            }
+            setTimeout(() => {
+                this.addMarkerToViewport(viewportId, renderingEngineId);
+            }, ADD_MARKER_DELAY_MS);
+        };
+        this.onViewportRemoved = (evt) => {
+            const { viewportId, renderingEngineId, toolGroupId } = evt.detail;
+            if (toolGroupId !== this.toolGroupId) {
+                return;
+            }
+            const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
+            if (enabledElement) {
+                const { viewport } = enabledElement;
+                if (viewport.isOrientationChangeable()) {
+                    this.widget.removeActorsFromViewport(viewportId, viewport);
+                }
+                const cameraHandler = this.cameraHandlers.get(viewportId);
+                if (cameraHandler) {
+                    viewport.element.removeEventListener(esm.Enums.Events.CAMERA_MODIFIED, cameraHandler);
+                    this.cameraHandlers.delete(viewportId);
+                }
+            }
+            this.widget.cleanup(viewportId);
+            const resizeObserver = this.resizeObservers.get(viewportId);
+            if (resizeObserver) {
+                resizeObserver.disconnect();
+                this.resizeObservers.delete(viewportId);
+            }
+        };
+        this.addMarkers = () => {
+            const viewportsInfo = this._getViewportsInfo();
+            viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+                const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
+                if (!enabledElement) {
+                    return;
+                }
+                const { viewport } = enabledElement;
+                if (!viewport.isOrientationChangeable()) {
+                    return;
+                }
+                if (this.widget.getActors(viewportId)) {
+                    return;
+                }
+                setTimeout(() => {
+                    this.addMarkerToViewport(viewportId, renderingEngineId);
+                }, ADD_MARKER_DELAY_MS);
+            });
+        };
+        this.onCameraModified = (evt) => {
+            const { viewportId } = evt.detail;
+            if (!viewportId) {
+                return;
+            }
+            const actors = this.widget.getActors(viewportId);
+            if (!actors) {
+                return;
+            }
+            const viewportsInfo = this._getViewportsInfo();
+            const viewportInfo = viewportsInfo.find((vp) => vp.viewportId === viewportId);
+            if (!viewportInfo) {
+                return;
+            }
+            const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, viewportInfo.renderingEngineId);
+            if (!enabledElement) {
+                return;
+            }
+            const { viewport } = enabledElement;
+            if (!viewport.isOrientationChangeable()) {
+                return;
+            }
+            const volumeViewport = viewport;
+            this.widget.positionActors(volumeViewport, actors, this.getPositionConfig());
+            viewport.render();
+        };
+    }
+    getPositionConfig() {
+        return {
+            position: this.configuration.position || 'bottom-right',
+            size: this.configuration.size || 0.04,
+        };
+    }
+    getFaceColors() {
+        const colorScheme = this.configuration.colorScheme || 'rgy';
+        if (this.configuration.faceColors) {
+            const provided = this.configuration.faceColors;
+            if (provided.topBottom && provided.frontBack && provided.leftRight) {
+                return {
+                    topBottom: provided.topBottom,
+                    frontBack: provided.frontBack,
+                    leftRight: provided.leftRight,
+                };
+            }
+        }
+        return (FACE_COLOR_SCHEMES[colorScheme] ??
+            FACE_COLOR_SCHEMES[DEFAULT_FACE_COLOR_SCHEME]);
+    }
+    getLetterColors() {
+        const letterColorScheme = this.configuration.letterColorScheme || 'mixed';
+        return (LETTER_COLOR_SCHEMES[letterColorScheme] ??
+            LETTER_COLOR_SCHEMES[DEFAULT_LETTER_COLOR_SCHEME]);
+    }
+    onSetToolEnabled() {
+        this.removeMarkers();
+        this.addMarkers();
+        esm.eventTarget.addEventListener(enums.Events.TOOLGROUP_VIEWPORT_ADDED, this.onViewportAdded);
+        esm.eventTarget.addEventListener(enums.Events.TOOLGROUP_VIEWPORT_REMOVED, this.onViewportRemoved);
+    }
+    onSetToolDisabled() {
+        this.removeMarkers();
+        esm.eventTarget.removeEventListener(enums.Events.TOOLGROUP_VIEWPORT_ADDED, this.onViewportAdded);
+        esm.eventTarget.removeEventListener(enums.Events.TOOLGROUP_VIEWPORT_REMOVED, this.onViewportRemoved);
+    }
+    removeMarkers() {
+        const viewportsInfo = this._getViewportsInfo();
+        viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+            const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
+            if (enabledElement) {
+                const { viewport } = enabledElement;
+                if (viewport.isOrientationChangeable()) {
+                    this.widget.removeActorsFromViewport(viewportId, viewport);
+                }
+                const cameraHandler = this.cameraHandlers.get(viewportId);
+                if (cameraHandler) {
+                    viewport.element.removeEventListener(esm.Enums.Events.CAMERA_MODIFIED, cameraHandler);
+                    this.cameraHandlers.delete(viewportId);
+                }
+            }
+            const resizeObserver = this.resizeObservers.get(viewportId);
+            if (resizeObserver) {
+                resizeObserver.disconnect();
+                this.resizeObservers.delete(viewportId);
+            }
+        });
+        this.widget.cleanup();
+        this.resizeObservers.forEach((observer) => observer.disconnect());
+        this.resizeObservers.clear();
+        this.cameraHandlers.clear();
+    }
+    createAnnotatedRhombActor() {
+        const faceColors = this.getFaceColors();
+        const letterColors = this.getLetterColors();
+        return this.widget.createActors({
+            faceColors,
+            letterColors,
+            opacity: this.configuration.opacity ?? 1.0,
+            showEdgeFaces: this.configuration.showEdgeFaces !== false,
+            showCornerFaces: this.configuration.showCornerFaces !== false,
+        });
+    }
+    addMarkerToViewport(viewportId, renderingEngineId) {
+        const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
+        if (!enabledElement) {
+            console.warn('OrientationControllerTool: No enabled element found');
+            return;
+        }
+        const { viewport } = enabledElement;
+        if (!viewport.isOrientationChangeable()) {
+            console.warn('OrientationControllerTool: Viewport does not support orientation changes');
+            return;
+        }
+        const element = viewport.element;
+        const volumeViewport = viewport;
+        const actors = this.createAnnotatedRhombActor();
+        this.widget.addActorsToViewport(viewportId, volumeViewport, actors);
+        const positioned = this.widget.positionActors(volumeViewport, actors, this.getPositionConfig());
+        if (!positioned) {
+            console.warn('OrientationControllerTool: Initial positioning failed, retrying...');
+            setTimeout(() => {
+                const repositioned = this.widget.positionActors(volumeViewport, actors, this.getPositionConfig());
+                if (repositioned) {
+                    viewport.render();
+                }
+                else {
+                    console.error('OrientationControllerTool: Retry positioning also failed');
+                }
+            }, POSITION_RETRY_DELAY_MS);
+        }
+        else {
+            viewport.render();
+        }
+        this.widget.syncOverlayViewport(viewportId, volumeViewport);
+        this.widget.setupPicker(viewportId, actors);
+        this.widget.setupMouseHandlers(viewportId, element, volumeViewport, actors, {
+            onFacePicked: (result) => {
+                const orientation = this.widget.getOrientationForFace(result.cellId);
+                if (orientation) {
+                    this.animateCameraToOrientation(volumeViewport, orientation.viewPlaneNormal, orientation.viewUp);
+                }
+            },
+            onFaceHover: (result) => {
+                if (result && result.actorIndex !== 0) {
+                    this.widget.highlightFace(result.pickedActor, result.cellId, volumeViewport, false);
+                }
+                else {
+                    this.widget.clearHighlight();
+                }
+            },
+        });
+        const resizeObserver = new ResizeObserver(() => {
+            this.updateMarkerPosition(viewportId, renderingEngineId);
+        });
+        resizeObserver.observe(element);
+        this.resizeObservers.set(viewportId, resizeObserver);
+        const cameraHandler = (evt) => {
+            const detail = evt.detail;
+            if (detail.viewportId === viewportId) {
+                this.onCameraModified(evt);
+            }
+        };
+        element.addEventListener(esm.Enums.Events.CAMERA_MODIFIED, cameraHandler);
+        this.cameraHandlers.set(viewportId, cameraHandler);
+    }
+    updateMarkerPosition(viewportId, renderingEngineId) {
+        const enabledElement = (0,esm.getEnabledElementByIds)(viewportId, renderingEngineId);
+        if (!enabledElement) {
+            return;
+        }
+        const actors = this.widget.getActors(viewportId);
+        if (!actors) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        if (!viewport.isOrientationChangeable()) {
+            return;
+        }
+        this.widget.positionActors(viewport, actors, this.getPositionConfig());
+        this.widget.syncOverlayViewport(viewportId, viewport);
+        viewport.render();
+    }
+    animateCameraToOrientation(viewport, targetViewPlaneNormal, targetViewUp) {
+        const keepOrientationUp = this.configuration.keepOrientationUp !== false;
+        const renderer = viewport.getRenderer();
+        const camera = renderer.getActiveCamera();
+        const directionOfProjection = camera.getDirectionOfProjection();
+        const startViewUpArray = camera.getViewUp();
+        const startForward = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(-directionOfProjection[0], -directionOfProjection[1], -directionOfProjection[2]);
+        const startUp = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(startViewUpArray[0], startViewUpArray[1], startViewUpArray[2]);
+        const startRight = gl_matrix_esm/* vec3.create */.eR.create();
+        gl_matrix_esm/* vec3.cross */.eR.cross(startRight, startUp, startForward);
+        gl_matrix_esm/* vec3.normalize */.eR.normalize(startRight, startRight);
+        const startMatrix = gl_matrix_esm/* mat4.fromValues */.pB.fromValues(startRight[0], startRight[1], startRight[2], 0, startUp[0], startUp[1], startUp[2], 0, startForward[0], startForward[1], startForward[2], 0, 0, 0, 0, 1);
+        let targetUp;
+        if (keepOrientationUp) {
+            targetUp = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(targetViewUp[0], targetViewUp[1], targetViewUp[2]);
+        }
+        else {
+            const currentUp = gl_matrix_esm/* vec3.normalize */.eR.normalize(gl_matrix_esm/* vec3.create */.eR.create(), startUp);
+            const normalizedForward = gl_matrix_esm/* vec3.create */.eR.create();
+            gl_matrix_esm/* vec3.normalize */.eR.normalize(normalizedForward, targetViewPlaneNormal);
+            const dot = gl_matrix_esm/* vec3.dot */.eR.dot(currentUp, normalizedForward);
+            targetUp = gl_matrix_esm/* vec3.create */.eR.create();
+            gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(targetUp, currentUp, normalizedForward, -dot);
+            gl_matrix_esm/* vec3.normalize */.eR.normalize(targetUp, targetUp);
+            if (gl_matrix_esm/* vec3.length */.eR.length(targetUp) < 0.001) {
+                if (Math.abs(normalizedForward[2]) < 0.9) {
+                    targetUp = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(0, 0, 1);
+                }
+                else {
+                    targetUp = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(0, 1, 0);
+                }
+                const dot2 = gl_matrix_esm/* vec3.dot */.eR.dot(targetUp, normalizedForward);
+                gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(targetUp, targetUp, normalizedForward, -dot2);
+                gl_matrix_esm/* vec3.normalize */.eR.normalize(targetUp, targetUp);
+            }
+        }
+        const targetRight = gl_matrix_esm/* vec3.create */.eR.create();
+        gl_matrix_esm/* vec3.cross */.eR.cross(targetRight, targetUp, targetViewPlaneNormal);
+        gl_matrix_esm/* vec3.normalize */.eR.normalize(targetRight, targetRight);
+        const targetMatrix = gl_matrix_esm/* mat4.fromValues */.pB.fromValues(targetRight[0], targetRight[1], targetRight[2], 0, targetUp[0], targetUp[1], targetUp[2], 0, targetViewPlaneNormal[0], targetViewPlaneNormal[1], targetViewPlaneNormal[2], 0, 0, 0, 0, 1);
+        const startQuat = gl_matrix_esm/* mat4.getRotation */.pB.getRotation(gl_matrix_esm/* quat.create */.Yu.create(), startMatrix);
+        const targetQuat = gl_matrix_esm/* mat4.getRotation */.pB.getRotation(gl_matrix_esm/* quat.create */.Yu.create(), targetMatrix);
+        let dotProduct = gl_matrix_esm/* quat.dot */.Yu.dot(startQuat, targetQuat);
+        if (dotProduct < 0) {
+            gl_matrix_esm/* quat.scale */.Yu.scale(targetQuat, targetQuat, -1);
+            dotProduct = -dotProduct;
+        }
+        const threshold = 0.99996;
+        if (dotProduct > threshold) {
+            return;
+        }
+        const steps = 10;
+        const duration = 150;
+        const stepDuration = duration / steps;
+        let currentStep = 0;
+        const animate = () => {
+            currentStep++;
+            const t = currentStep / steps;
+            const easedT = t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+            const interpolatedQuat = gl_matrix_esm/* quat.create */.Yu.create();
+            gl_matrix_esm/* quat.slerp */.Yu.slerp(interpolatedQuat, startQuat, targetQuat, easedT);
+            const interpolatedMatrix = gl_matrix_esm/* mat4.create */.pB.create();
+            gl_matrix_esm/* mat4.fromQuat */.pB.fromQuat(interpolatedMatrix, interpolatedQuat);
+            const interpolatedForward = interpolatedMatrix.slice(8, 11);
+            const interpolatedUp = interpolatedMatrix.slice(4, 7);
+            viewport.setCamera({
+                viewPlaneNormal: interpolatedForward,
+                viewUp: interpolatedUp,
+            });
+            viewport.resetCamera(ANIMATE_RESET_CAMERA_OPTIONS);
+            viewport.render();
+            if (currentStep < steps) {
+                setTimeout(animate, stepDuration);
+            }
+        };
+        animate();
+    }
+}
+/* harmony default export */ const tools_OrientationControllerTool = ((/* unused pure expression or super */ null && (OrientationControllerTool)));
+
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/activeSegmentation.js + 1 modules
 var segmentation_activeSegmentation = __webpack_require__(26228);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/segmentIndex.js
@@ -30195,6 +30404,7 @@ class LabelMapEditWithContourTool extends PlanarFreehandContourSegmentationTool/
 
 
 
+
 
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/math/rectangle/index.js
@@ -33822,6 +34032,7 @@ function normalizeSegmentationInput(segmentationInput) {
     return {
         segmentationId,
         label: config?.label ?? null,
+        fallbackLabel: config?.fallbackLabel ?? null,
         cachedStats: config?.cachedStats ?? {},
         segments: normalizedSegments,
         representationData: {