@cornerstonejs/tools 5.0.0-beta.1 → 5.0.1

package/dist/esm/tools/VolumeCroppingTool.js

@@ -1,6 +1,4 @@
 import vtkPolyData from '@kitware/vtk.js/Common/DataModel/PolyData';
-import vtkPoints from '@kitware/vtk.js/Common/Core/Points';
-import vtkCellArray from '@kitware/vtk.js/Common/Core/CellArray';
 import { mat3, mat4, vec3 } from 'gl-matrix';
 import vtkMath from '@kitware/vtk.js/Common/Core/Math';
 import vtkActor from '@kitware/vtk.js/Rendering/Core/Actor';
@@ -11,30 +9,10 @@ import { BaseTool } from './base';
 import { getRenderingEngine, getEnabledElementByIds, getEnabledElement, Enums, triggerEvent, eventTarget, } from '@cornerstonejs/core';
 import { getToolGroup } from '../store/ToolGroupManager';
 import { Events } from '../enums';
-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,
-};
+import { PLANEINDEX, SPHEREINDEX, NUM_CLIPPING_PLANES, extractVolumeDirectionVectors, parseCornerKey, copyClippingPlanes, } from '../utilities/volumeCropping';
+import { addLine3DBetweenPoints, calculateAdaptiveSphereRadius, } from '../utilities/draw3D';
+import { isDragOwnedBy } from '../utilities/interactionDragCoordinator';
+import { applyViewportPresentation, getViewportPresentation, } from '../utilities/viewportPresentation';
 class VolumeCroppingTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         configuration: {
@@ -56,6 +34,7 @@ class VolumeCroppingTool extends BaseTool {
             grabSpherePixelDistance: 20,
             rotateIncrementDegrees: 2,
             rotateSampleDistanceFactor: 2,
+            rotateClippingPlanesIncrementDegrees: 5,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -63,16 +42,16 @@ class VolumeCroppingTool extends BaseTool {
         this._hasResolutionChanged = false;
         this.originalClippingPlanes = [];
         this.draggingSphereIndex = null;
-        this.toolCenter = [0, 0, 0];
+        this.rotatePlanesOnDrag = false;
+        this.suppressPlaneRotationForCurrentDrag = 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
@@ -87,8 +66,11 @@ class VolumeCroppingTool extends BaseTool {
             const { element } = eventDetail;
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
-            const actorEntry = viewport.getDefaultActor();
-            const actor = actorEntry.actor;
+            this.suppressPlaneRotationForCurrentDrag = isDragOwnedBy(viewport.id, 'orientation-controller');
+            const actor = this._getVolumeActor(viewport);
+            if (!actor) {
+                return false;
+            }
             const mapper = actor.getMapper();
             const mouseCanvas = [
                 evt.detail.currentPoints.canvas[0],
@@ -115,9 +97,16 @@ class VolumeCroppingTool extends BaseTool {
                         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;
@@ -152,6 +141,7 @@ class VolumeCroppingTool extends BaseTool {
                     this.draggingSphereIndex = null;
                     this.cornerDragOffset = null;
                     this.faceDragOffset = null;
+                    this.suppressPlaneRotationForCurrentDrag = false;
                     viewport.render();
                     this._hasResolutionChanged = false;
                 };
@@ -172,201 +162,233 @@ class VolumeCroppingTool extends BaseTool {
                 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
+                    ? vec3.add([0, 0, 0], world, this.cornerDragOffset)
+                    : world;
+                const oldCorner = sphereState.point;
+                const axisFlags = 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[SPHEREINDEX.XMIN];
+                    const newPoint = [
+                        faceXMin.point[0] + deltaX * xDir[0],
+                        faceXMin.point[1] + deltaX * xDir[1],
+                        faceXMin.point[2] + deltaX * xDir[2],
+                    ];
+                    this._updateSpherePosition(SPHEREINDEX.XMIN, newPoint);
+                }
+                else if (axisFlags.isXMax) {
+                    const faceXMax = this.sphereStates[SPHEREINDEX.XMAX];
+                    const newPoint = [
+                        faceXMax.point[0] + deltaX * xDir[0],
+                        faceXMax.point[1] + deltaX * xDir[1],
+                        faceXMax.point[2] + deltaX * xDir[2],
+                    ];
+                    this._updateSpherePosition(SPHEREINDEX.XMAX, newPoint);
+                }
+                if (axisFlags.isYMin) {
+                    const faceYMin = this.sphereStates[SPHEREINDEX.YMIN];
+                    const newPoint = [
+                        faceYMin.point[0] + deltaY * yDir[0],
+                        faceYMin.point[1] + deltaY * yDir[1],
+                        faceYMin.point[2] + deltaY * yDir[2],
+                    ];
+                    this._updateSpherePosition(SPHEREINDEX.YMIN, newPoint);
+                }
+                else if (axisFlags.isYMax) {
+                    const faceYMax = this.sphereStates[SPHEREINDEX.YMAX];
+                    const newPoint = [
+                        faceYMax.point[0] + deltaY * yDir[0],
+                        faceYMax.point[1] + deltaY * yDir[1],
+                        faceYMax.point[2] + deltaY * yDir[2],
+                    ];
+                    this._updateSpherePosition(SPHEREINDEX.YMAX, newPoint);
+                }
+                if (axisFlags.isZMin) {
+                    const faceZMin = this.sphereStates[SPHEREINDEX.ZMIN];
+                    const newPoint = [
+                        faceZMin.point[0] + deltaZ * zDir[0],
+                        faceZMin.point[1] + deltaZ * zDir[1],
+                        faceZMin.point[2] + deltaZ * zDir[2],
+                    ];
+                    this._updateSpherePosition(SPHEREINDEX.ZMIN, newPoint);
+                }
+                else if (axisFlags.isZMax) {
+                    const faceZMax = this.sphereStates[SPHEREINDEX.ZMAX];
+                    const newPoint = [
+                        faceZMax.point[0] + deltaZ * zDir[0],
+                        faceZMax.point[1] + deltaZ * zDir[1],
+                        faceZMax.point[2] + deltaZ * zDir[2],
+                    ];
+                    this._updateSpherePosition(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) {
-                triggerEvent(eventTarget, 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 = [
-                    Enums.OrientationAxis.SAGITTAL,
-                    Enums.OrientationAxis.CORONAL,
-                    Enums.OrientationAxis.AXIAL,
-                ];
-                for (let i = 0; i < 3; ++i) {
-                    const origin = [0, 0, 0];
-                    origin[i] = toolCenter[i];
-                    const plane = vtkPlane.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 >= NUM_CLIPPING_PLANES) {
+                this.originalClippingPlanes = 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 = getToolGroup(this.toolGroupId).viewportsInfo;
-            return viewports;
+            const toolGroup = 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();
-            const volumeActors = viewport.getActors();
-            if (!volumeActors || volumeActors.length === 0) {
+            if (!viewport) {
+                return;
+            }
+            const volumeActor = this._getVolumeActor(viewport);
+            if (!volumeActor) {
                 console.warn('VolumeCroppingTool: No volume actors found in the viewport.');
                 return;
             }
-            const imageData = volumeActors[0].actor.getMapper().getInputData();
+            const imageData = volumeActor.getMapper().getInputData();
             if (!imageData) {
                 console.warn('VolumeCroppingTool: No image data found for volume actor.');
                 return;
             }
             this.seriesInstanceUID = imageData.seriesInstanceUID || 'unknown';
-            const worldBounds = imageData.getBounds();
+            this.volumeDirectionVectors = 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 = vtkPlane.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 = vtkPlane.newInstance({
+                origin: faceXMin,
+                normal: xDir,
             });
-            const planeXmax = vtkPlane.newInstance({
-                origin: [xMax, 0, 0],
-                normal: [-1, 0, 0],
+            const planeXMax = vtkPlane.newInstance({
+                origin: faceXMax,
+                normal: [-xDir[0], -xDir[1], -xDir[2]],
             });
-            const planeYmin = vtkPlane.newInstance({
-                origin: [0, yMin, 0],
-                normal: [0, 1, 0],
+            const planeYMin = vtkPlane.newInstance({
+                origin: faceYMin,
+                normal: yDir,
             });
-            const planeYmax = vtkPlane.newInstance({
-                origin: [0, yMax, 0],
-                normal: [0, -1, 0],
+            const planeYMax = vtkPlane.newInstance({
+                origin: faceYMax,
+                normal: [-yDir[0], -yDir[1], -yDir[2]],
             });
-            const planeZmin = vtkPlane.newInstance({
-                origin: [0, 0, zMin],
-                normal: [0, 0, 1],
+            const planeZMin = vtkPlane.newInstance({
+                origin: faceZMin,
+                normal: zDir,
             });
-            const planeZmax = vtkPlane.newInstance({
-                origin: [0, 0, zMax],
-                normal: [0, 0, -1],
+            const planeZMax = vtkPlane.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 = vec3.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',
@@ -395,21 +417,22 @@ class VolumeCroppingTool extends BaseTool {
                 ['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 = volumeActor.getMapper();
+            mapper.addClippingPlane(planeXMin);
+            mapper.addClippingPlane(planeXMax);
+            mapper.addClippingPlane(planeYMin);
+            mapper.addClippingPlane(planeYMax);
+            mapper.addClippingPlane(planeZMin);
+            mapper.addClippingPlane(planeZMax);
             eventTarget.addEventListener(Events.VOLUMECROPPINGCONTROL_TOOL_CHANGED, (evt) => {
                 this._onControlToolChange(evt);
             });
@@ -423,107 +446,14 @@ class VolumeCroppingTool extends BaseTool {
             return { viewport, world };
         };
         this._getViewport = () => {
-            const [viewport3D] = this._getViewportsInfo();
-            const renderingEngine = 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) => {
-            triggerEvent(eventTarget, Events.VOLUMECROPPING_TOOL_CHANGED, {
-                toolCenter: sphereState.point,
-                axis: sphereState.isCorner ? 'corner' : sphereState.axis,
-                draggingSphereIndex: this.draggingSphereIndex,
-                seriesInstanceUID: this.seriesInstanceUID,
-            });
+            const [viewport3D] = viewportsInfo;
+            const renderingEngine = getRenderingEngine(viewport3D.renderingEngineId);
+            const viewport = renderingEngine?.getViewport(viewport3D.viewportId);
+            return viewport || null;
         };
         this._onNewVolume = () => {
             const viewportsInfo = this._getViewportsInfo();
@@ -532,6 +462,207 @@ class VolumeCroppingTool extends BaseTool {
             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 = 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];
+            vtkMath.normalize(nop);
+            const noe = [oe[0], 0, loe];
+            vtkMath.normalize(noe);
+            const dot = vtkMath.dot(nop, noe);
+            if (Math.abs(dot) > 0.0001) {
+                const angleX = 20 *
+                    Math.acos(vtkMath.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];
+                vtkMath.cross(upVec, atV, rightV);
+                vtkMath.normalize(rightV);
+                vtkMath.cross(atV, rightV, forwardV);
+                vtkMath.normalize(forwardV);
+                const angleY = 20 *
+                    (normalizedPosition[1] - normalizedPreviousPosition[1]) *
+                    rotateIncrementDegrees;
+                let rotationCenter;
+                if (this.sphereStates.length >= NUM_CLIPPING_PLANES) {
+                    const faces = [
+                        this.sphereStates[SPHEREINDEX.XMIN],
+                        this.sphereStates[SPHEREINDEX.XMAX],
+                        this.sphereStates[SPHEREINDEX.YMIN],
+                        this.sphereStates[SPHEREINDEX.YMAX],
+                        this.sphereStates[SPHEREINDEX.ZMIN],
+                        this.sphereStates[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]) /
+                            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]) /
+                            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]) /
+                            NUM_CLIPPING_PLANES,
+                    ];
+                }
+                else {
+                    rotationCenter = [0, 0, 0];
+                }
+                const transformX = mat4.identity(new Float32Array(16));
+                mat4.translate(transformX, transformX, rotationCenter);
+                mat4.rotate(transformX, transformX, (angleX * Math.PI) / 180, forwardV);
+                mat4.translate(transformX, transformX, [
+                    -rotationCenter[0],
+                    -rotationCenter[1],
+                    -rotationCenter[2],
+                ]);
+                const transformY = mat4.identity(new Float32Array(16));
+                mat4.translate(transformY, transformY, rotationCenter);
+                mat4.rotate(transformY, transformY, (angleY * Math.PI) / 180, rightV);
+                mat4.translate(transformY, transformY, [
+                    -rotationCenter[0],
+                    -rotationCenter[1],
+                    -rotationCenter[2],
+                ]);
+                const transform = mat4.create();
+                mat4.multiply(transform, transformY, transformX);
+                const normalTransformX4 = mat4.identity(new Float32Array(16));
+                mat4.rotate(normalTransformX4, normalTransformX4, (angleX * Math.PI) / 180, forwardV);
+                const normalTransformX = mat3.create();
+                mat3.fromMat4(normalTransformX, normalTransformX4);
+                const normalTransformY4 = mat4.identity(new Float32Array(16));
+                mat4.rotate(normalTransformY4, normalTransformY4, (angleY * Math.PI) / 180, rightV);
+                const normalTransformY = mat3.create();
+                mat3.fromMat4(normalTransformY, normalTransformY4);
+                const normalTransform = mat3.create();
+                mat3.multiply(normalTransform, normalTransformY, normalTransformX);
+                for (let i = 0; i < this.originalClippingPlanes.length; ++i) {
+                    const plane = this.originalClippingPlanes[i];
+                    const originVec = vec3.fromValues(plane.origin[0], plane.origin[1], plane.origin[2]);
+                    vec3.transformMat4(originVec, originVec, transform);
+                    plane.origin = [originVec[0], originVec[1], originVec[2]];
+                    const normalVec = vec3.fromValues(plane.normal[0], plane.normal[1], plane.normal[2]);
+                    vec3.transformMat3(normalVec, normalVec, normalTransform);
+                    vec3.normalize(normalVec, normalVec);
+                    plane.normal = [normalVec[0], normalVec[1], normalVec[2]];
+                }
+                if (this.sphereStates.length >= NUM_CLIPPING_PLANES) {
+                    this.sphereStates[SPHEREINDEX.XMIN].point = [
+                        ...this.originalClippingPlanes[PLANEINDEX.XMIN].origin,
+                    ];
+                    this.sphereStates[SPHEREINDEX.XMAX].point = [
+                        ...this.originalClippingPlanes[PLANEINDEX.XMAX].origin,
+                    ];
+                    this.sphereStates[SPHEREINDEX.YMIN].point = [
+                        ...this.originalClippingPlanes[PLANEINDEX.YMIN].origin,
+                    ];
+                    this.sphereStates[SPHEREINDEX.YMAX].point = [
+                        ...this.originalClippingPlanes[PLANEINDEX.YMAX].origin,
+                    ];
+                    this.sphereStates[SPHEREINDEX.ZMIN].point = [
+                        ...this.originalClippingPlanes[PLANEINDEX.ZMIN].origin,
+                    ];
+                    this.sphereStates[SPHEREINDEX.ZMAX].point = [
+                        ...this.originalClippingPlanes[PLANEINDEX.ZMAX].origin,
+                    ];
+                    [
+                        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 cornerIndices = [
+                        SPHEREINDEX.XMIN_YMIN_ZMIN,
+                        SPHEREINDEX.XMIN_YMIN_ZMAX,
+                        SPHEREINDEX.XMIN_YMAX_ZMIN,
+                        SPHEREINDEX.XMIN_YMAX_ZMAX,
+                        SPHEREINDEX.XMAX_YMIN_ZMIN,
+                        SPHEREINDEX.XMAX_YMIN_ZMAX,
+                        SPHEREINDEX.XMAX_YMAX_ZMIN,
+                        SPHEREINDEX.XMAX_YMAX_ZMAX,
+                    ];
+                    cornerIndices.forEach((idx) => {
+                        const cornerState = this.sphereStates[idx];
+                        if (cornerState) {
+                            const cornerVec = vec3.fromValues(cornerState.point[0], cornerState.point[1], cornerState.point[2]);
+                            vec3.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();
+                triggerEvent(eventTarget, 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();
@@ -563,59 +694,55 @@ class VolumeCroppingTool extends BaseTool {
         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 } = getEnabledElementByIds(viewportId, renderingEngineId) || { viewport: null };
-                        if (!viewport) {
+        const viewportsInfo = this._getViewportsInfo();
+        const subscribeToElementResize = () => {
+            viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+                if (!this._resizeObservers.has(viewportId)) {
+                    const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId) || { viewport: null };
+                    if (!viewport) {
+                        return;
+                    }
+                    const { element } = viewport;
+                    const resizeObserver = new ResizeObserver(() => {
+                        const element = getEnabledElementByIds(viewportId, renderingEngineId);
+                        if (!element) {
                             return;
                         }
-                        const { element } = viewport;
-                        const resizeObserver = new ResizeObserver(() => {
-                            const element = 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 = getViewportPresentation(viewport);
+                        viewport.resetCamera();
+                        applyViewportPresentation(viewport, viewPresentation);
+                        viewport.render();
+                    });
+                    resizeObserver.observe(element);
+                    this._resizeObservers.set(viewportId, resizeObserver);
                 }
-            };
-            eventTarget.addEventListener(Events.TOOLGROUP_VIEWPORT_ADDED, this._viewportAddedListener);
-            this._unsubscribeToViewportNewVolumeSet(viewportsInfo);
-            this._subscribeToViewportNewVolumeSet(viewportsInfo);
+            });
+        };
+        subscribeToElementResize();
+        this._viewportAddedListener = (evt) => {
+            if (evt.detail.toolGroupId === this.toolGroupId) {
+                subscribeToElementResize();
+            }
+        };
+        eventTarget.addEventListener(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() {
@@ -633,30 +760,7 @@ class VolumeCroppingTool extends BaseTool {
     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();
@@ -669,6 +773,23 @@ class VolumeCroppingTool extends BaseTool {
     getHandlesVisible() {
         return this.configuration.showHandles;
     }
+    setHandleRadius(radius) {
+        this.configuration.sphereRadius = radius;
+        this.sphereStates.forEach((state) => {
+            if (state?.sphereSource?.setRadius) {
+                state.sphereSource.setRadius(radius);
+                state.sphereSource.modified();
+            }
+        });
+        const viewportsInfo = this._getViewportsInfo();
+        const [viewport3D] = viewportsInfo;
+        if (!viewport3D) {
+            return;
+        }
+        const renderingEngine = getRenderingEngine(viewport3D.renderingEngineId);
+        const viewport = renderingEngine?.getViewport(viewport3D.viewportId);
+        viewport?.render();
+    }
     getClippingPlanesVisible() {
         return this.configuration.showClippingPlanes;
     }
@@ -676,14 +797,39 @@ class VolumeCroppingTool extends BaseTool {
         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 >= 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.suppressPlaneRotationForCurrentDrag) {
+                this._rotateClippingPlanes(evt);
+                return;
+            }
             const currentPointsCanvas = currentPoints.canvas;
             const lastPointsCanvas = lastPoints.canvas;
             const { rotateIncrementDegrees } = this.configuration;
@@ -738,16 +884,11 @@ class VolumeCroppingTool extends BaseTool {
         }
     }
     _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;
-            }
+        const actor = this._getVolumeActor(viewport);
+        const mapper = this._getVolumeMapper(viewport);
+        if (!actor || !mapper) {
             return;
         }
-        const actor = actorEntry.actor;
-        const mapper = actor.getMapper();
         const matrix = actor.getMatrix();
         if (!this.configuration.showClippingPlanes) {
             mapper.removeAllClippingPlanes();
@@ -797,35 +938,6 @@ class VolumeCroppingTool extends BaseTool {
             }
         });
     }
-    _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 = vtkPoints.newInstance();
-        points.setNumberOfPoints(2);
-        points.setPoint(0, point1[0], point1[1], point1[2]);
-        points.setPoint(1, point2[0], point2[1], point2[2]);
-        const lines = vtkCellArray.newInstance({ values: [2, 0, 1] });
-        const polyData = vtkPolyData.newInstance();
-        polyData.setPoints(points);
-        polyData.setLines(lines);
-        const mapper = vtkMapper.newInstance();
-        mapper.setInputData(polyData);
-        const actor = vtkActor.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);
@@ -854,9 +966,10 @@ class VolumeCroppingTool extends BaseTool {
             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,
@@ -866,88 +979,150 @@ class VolumeCroppingTool extends BaseTool {
             });
         }
         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 >= NUM_CLIPPING_PLANES) {
+            switch (axis) {
+                case 'x':
+                    return this.originalClippingPlanes[PLANEINDEX.XMIN]
+                        .normal;
+                case 'y':
+                    return this.originalClippingPlanes[PLANEINDEX.YMIN]
+                        .normal;
+                case 'z':
+                    return this.originalClippingPlanes[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
+            ?.getActors?.()
+            ?.find((entry) => entry.actor?.getClassName?.() === 'vtkVolume')
+            ?.actor;
+    }
+    _getVolumeMapper(viewport) {
+        const actor = this._getVolumeActor(viewport);
+        return actor?.getMapper();
+    }
+    _applyClippingPlanesToMapper(mapper) {
+        mapper.removeAllClippingPlanes();
+        for (let i = 0; i < NUM_CLIPPING_PLANES; ++i) {
+            const plane = vtkPlane.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 = [
+        const mapper = this._getVolumeMapper(viewport);
+        if (!mapper) {
+            return;
+        }
+        this.originalClippingPlanes[PLANEINDEX.XMIN].origin = [
             ...this.sphereStates[SPHEREINDEX.XMIN].point,
         ];
-        this.originalClippingPlanes[1].origin = [
+        this.originalClippingPlanes[PLANEINDEX.XMAX].origin = [
             ...this.sphereStates[SPHEREINDEX.XMAX].point,
         ];
-        this.originalClippingPlanes[2].origin = [
+        this.originalClippingPlanes[PLANEINDEX.YMIN].origin = [
             ...this.sphereStates[SPHEREINDEX.YMIN].point,
         ];
-        this.originalClippingPlanes[3].origin = [
+        this.originalClippingPlanes[PLANEINDEX.YMAX].origin = [
             ...this.sphereStates[SPHEREINDEX.YMAX].point,
         ];
-        this.originalClippingPlanes[4].origin = [
+        this.originalClippingPlanes[PLANEINDEX.ZMIN].origin = [
             ...this.sphereStates[SPHEREINDEX.ZMIN].point,
         ];
-        this.originalClippingPlanes[5].origin = [
+        this.originalClippingPlanes[PLANEINDEX.ZMAX].origin = [
             ...this.sphereStates[SPHEREINDEX.ZMAX].point,
         ];
-        mapper.removeAllClippingPlanes();
-        for (let i = 0; i < 6; ++i) {
-            const origin = this.originalClippingPlanes[i].origin;
-            const normal = this.originalClippingPlanes[i].normal;
-            const plane = vtkPlane.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[SPHEREINDEX.XMIN].point;
+        const faceXMax = this.sphereStates[SPHEREINDEX.XMAX].point;
+        const faceYMin = this.sphereStates[SPHEREINDEX.YMIN].point;
+        const faceYMax = this.sphereStates[SPHEREINDEX.YMAX].point;
+        const faceZMin = this.sphereStates[SPHEREINDEX.ZMIN].point;
+        const faceZMax = this.sphereStates[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,
@@ -958,93 +1133,100 @@ class VolumeCroppingTool extends BaseTool {
             this.sphereStates[SPHEREINDEX.XMAX_YMAX_ZMIN].point,
             this.sphereStates[SPHEREINDEX.XMAX_YMAX_ZMAX].point,
         ];
-        const xs = corners.map((p) => p[0]);
-        const ys = corners.map((p) => p[1]);
-        const zs = corners.map((p) => p[2]);
-        const xMin = Math.min(...xs), xMax = Math.max(...xs);
-        const yMin = Math.min(...ys), yMax = Math.max(...ys);
-        const zMin = Math.min(...zs), zMax = Math.max(...zs);
-        this.sphereStates[SPHEREINDEX.XMIN].point = [
-            xMin,
-            (yMin + yMax) / 2,
-            (zMin + zMax) / 2,
-        ];
-        this.sphereStates[SPHEREINDEX.XMAX].point = [
-            xMax,
-            (yMin + yMax) / 2,
-            (zMin + zMax) / 2,
-        ];
-        this.sphereStates[SPHEREINDEX.YMIN].point = [
-            (xMin + xMax) / 2,
-            yMin,
-            (zMin + zMax) / 2,
-        ];
-        this.sphereStates[SPHEREINDEX.YMAX].point = [
-            (xMin + xMax) / 2,
-            yMax,
-            (zMin + zMax) / 2,
-        ];
-        this.sphereStates[SPHEREINDEX.ZMIN].point = [
-            (xMin + xMax) / 2,
-            (yMin + yMax) / 2,
-            zMin,
-        ];
-        this.sphereStates[SPHEREINDEX.ZMAX].point = [
-            (xMin + xMax) / 2,
-            (yMin + yMax) / 2,
-            zMax,
-        ];
-        [
-            SPHEREINDEX.XMIN,
-            SPHEREINDEX.XMAX,
-            SPHEREINDEX.YMIN,
-            SPHEREINDEX.YMAX,
-            SPHEREINDEX.ZMIN,
-            SPHEREINDEX.ZMAX,
-        ].forEach((idx) => {
-            const s = this.sphereStates[idx];
-            s.sphereSource.setCenter(...s.point);
-            s.sphereSource.modified();
-        });
+        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(SPHEREINDEX.XMIN, faceXMin);
+        this._updateSpherePosition(SPHEREINDEX.XMAX, faceXMax);
+        this._updateSpherePosition(SPHEREINDEX.YMIN, faceYMin);
+        this._updateSpherePosition(SPHEREINDEX.YMAX, faceYMax);
+        this._updateSpherePosition(SPHEREINDEX.ZMIN, faceZMin);
+        this._updateSpherePosition(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[SPHEREINDEX.XMIN].point;
+        const faceXMax = this.sphereStates[SPHEREINDEX.XMAX].point;
+        const faceYMin = this.sphereStates[SPHEREINDEX.YMIN].point;
+        const faceYMax = this.sphereStates[SPHEREINDEX.YMAX].point;
+        const faceZMin = this.sphereStates[SPHEREINDEX.ZMIN].point;
+        const faceZMax = this.sphereStates[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 }) => {
@@ -1060,6 +1242,105 @@ class VolumeCroppingTool extends BaseTool {
             element.addEventListener(Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, this._onNewVolume);
         });
     }
+    _getDirectionVectors() {
+        const hasPlanes = this.originalClippingPlanes?.length >= NUM_CLIPPING_PLANES;
+        return {
+            xDir: hasPlanes
+                ? this.originalClippingPlanes[PLANEINDEX.XMIN].normal
+                : this.volumeDirectionVectors?.xDir || [1, 0, 0],
+            yDir: hasPlanes
+                ? this.originalClippingPlanes[PLANEINDEX.YMIN].normal
+                : this.volumeDirectionVectors?.yDir || [0, 1, 0],
+            zDir: hasPlanes
+                ? this.originalClippingPlanes[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: SPHEREINDEX.XMIN, planeIdx: PLANEINDEX.XMIN },
+            { sphereIdx: SPHEREINDEX.XMAX, planeIdx: PLANEINDEX.XMAX },
+            { sphereIdx: SPHEREINDEX.YMIN, planeIdx: PLANEINDEX.YMIN },
+            { sphereIdx: SPHEREINDEX.YMAX, planeIdx: PLANEINDEX.YMAX },
+            { sphereIdx: SPHEREINDEX.ZMIN, planeIdx: PLANEINDEX.ZMIN },
+            { sphereIdx: SPHEREINDEX.ZMAX, planeIdx: 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;
+        }
+        triggerEvent(eventTarget, 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';
 export default VolumeCroppingTool;