@cornerstonejs/tools 4.18.4 → 5.0.0-beta.1

package/dist/esm/tools/VolumeCroppingTool.js

@@ -1,4 +1,6 @@
 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';
@@ -9,8 +11,30 @@ import { BaseTool } from './base';
 import { getRenderingEngine, getEnabledElementByIds, getEnabledElement, Enums, triggerEvent, eventTarget, } from '@cornerstonejs/core';
 import { getToolGroup } from '../store/ToolGroupManager';
 import { Events } from '../enums';
-import { PLANEINDEX, SPHEREINDEX, NUM_CLIPPING_PLANES, extractVolumeDirectionVectors, parseCornerKey, copyClippingPlanes, } from '../utilities/volumeCropping';
-import { addLine3DBetweenPoints, calculateAdaptiveSphereRadius, } from '../utilities/draw3D';
+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 BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         configuration: {
@@ -32,7 +56,6 @@ class VolumeCroppingTool extends BaseTool {
             grabSpherePixelDistance: 20,
             rotateIncrementDegrees: 2,
             rotateSampleDistanceFactor: 2,
-            rotateClippingPlanesIncrementDegrees: 5,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -40,15 +63,16 @@ class VolumeCroppingTool extends BaseTool {
         this._hasResolutionChanged = false;
         this.originalClippingPlanes = [];
         this.draggingSphereIndex = null;
-        this.rotatePlanesOnDrag = false;
+        this.toolCenter = [0, 0, 0];
         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
@@ -91,16 +115,9 @@ class VolumeCroppingTool extends BaseTool {
                         this.faceDragOffset = null;
                     }
                     else {
-                        const directionVector = this._getDirectionVectorForAxis(sphereState.axis);
-                        const delta = [
-                            sphereState.point[0] - mouseWorld[0],
-                            sphereState.point[1] - mouseWorld[1],
-                            sphereState.point[2] - mouseWorld[2],
-                        ];
+                        const axisIdx = { x: 0, y: 1, z: 2 }[sphereState.axis];
                         this.faceDragOffset =
-                            delta[0] * directionVector[0] +
-                                delta[1] * directionVector[1] +
-                                delta[2] * directionVector[2];
+                            sphereState.point[axisIdx] - mouseWorld[axisIdx];
                         this.cornerDragOffset = null;
                     }
                     return true;
@@ -155,143 +172,118 @@ class VolumeCroppingTool extends BaseTool {
                 return false;
             }
             if (sphereState.isCorner) {
-                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();
+                const newCorner = this._calculateNewCornerPosition(world);
+                this._updateSpherePosition(sphereState, newCorner);
+                const axisFlags = this._parseCornerKey(sphereState.uid);
+                this._updateRelatedCorners(sphereState, newCorner, axisFlags);
                 this._updateFaceSpheresFromCorners();
+                this._updateCornerSpheres();
             }
             else {
-                const 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);
+                const axisIdx = { x: 0, y: 1, z: 2 }[sphereState.axis];
+                let newValue = world[axisIdx];
+                if (this.faceDragOffset !== null) {
+                    newValue += this.faceDragOffset;
+                }
+                sphereState.point[axisIdx] = newValue;
+                sphereState.sphereSource.setCenter(...sphereState.point);
+                sphereState.sphereSource.modified();
                 this._updateCornerSpheresFromFaces();
                 this._updateFaceSpheresFromCorners();
                 this._updateCornerSpheres();
             }
             this._updateClippingPlanesFromFaceSpheres(viewport);
             viewport.render();
-            this._notifyClippingPlanesChanged();
+            this._triggerToolChangedEvent(sphereState);
             return true;
         };
         this._onControlToolChange = (evt) => {
             const viewport = this._getViewport();
-            if (evt.detail.seriesInstanceUID !== this.seriesInstanceUID) {
-                return;
+            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.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);
+            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());
+                        }
+                    }
+                }
+                this._updateCornerSpheres();
                 viewport.render();
-                this._notifyClippingPlanesChanged(viewport);
-            }
-            else {
-                this._notifyClippingPlanesChanged(viewport);
             }
         };
         this._getViewportsInfo = () => {
-            const toolGroup = getToolGroup(this.toolGroupId);
-            return toolGroup?.viewportsInfo || [];
+            const viewports = getToolGroup(this.toolGroupId).viewportsInfo;
+            return viewports;
         };
         this._initialize3DViewports = (viewportsInfo) => {
-            if (!viewportsInfo?.length || !viewportsInfo[0]) {
+            if (!viewportsInfo || !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.');
@@ -303,85 +295,78 @@ class VolumeCroppingTool extends BaseTool {
                 return;
             }
             this.seriesInstanceUID = imageData.seriesInstanceUID || 'unknown';
-            this.volumeDirectionVectors = extractVolumeDirectionVectors(imageData);
-            const { xDir, yDir, zDir } = this.volumeDirectionVectors;
-            const dimensions = imageData.getDimensions();
+            const worldBounds = imageData.getBounds();
             const cropFactor = this.configuration.initialCropFactor || 0.1;
-            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 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 planeXMax = vtkPlane.newInstance({
-                origin: faceXMax,
-                normal: [-xDir[0], -xDir[1], -xDir[2]],
+            const planeXmax = vtkPlane.newInstance({
+                origin: [xMax, 0, 0],
+                normal: [-1, 0, 0],
             });
-            const planeYMin = vtkPlane.newInstance({
-                origin: faceYMin,
-                normal: yDir,
+            const planeYmin = vtkPlane.newInstance({
+                origin: [0, yMin, 0],
+                normal: [0, 1, 0],
             });
-            const planeYMax = vtkPlane.newInstance({
-                origin: faceYMax,
-                normal: [-yDir[0], -yDir[1], -yDir[2]],
+            const planeYmax = vtkPlane.newInstance({
+                origin: [0, yMax, 0],
+                normal: [0, -1, 0],
             });
-            const planeZMin = vtkPlane.newInstance({
-                origin: faceZMin,
-                normal: zDir,
+            const planeZmin = vtkPlane.newInstance({
+                origin: [0, 0, zMin],
+                normal: [0, 0, 1],
             });
-            const planeZMax = vtkPlane.newInstance({
-                origin: faceZMax,
-                normal: [-zDir[0], -zDir[1], -zDir[2]],
+            const planeZmax = vtkPlane.newInstance({
+                origin: [0, 0, zMax],
+                normal: [0, 0, -1],
             });
-            const planes = [
-                planeXMin,
-                planeXMax,
-                planeYMin,
-                planeYMax,
-                planeZMin,
-                planeZMax,
-            ];
+            const mapper = viewport
+                .getDefaultActor()
+                .actor.getMapper();
+            planes.push(planeXmin);
+            planes.push(planeXmax);
+            planes.push(planeYmin);
+            planes.push(planeYmax);
+            planes.push(planeZmin);
+            planes.push(planeZmax);
             const originalPlanes = planes.map((plane) => ({
                 origin: [...plane.getOrigin()],
                 normal: [...plane.getNormal()],
             }));
             this.originalClippingPlanes = originalPlanes;
-            const 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 sphereXminPoint = [xMin, (yMax + yMin) / 2, (zMax + zMin) / 2];
+            const sphereXmaxPoint = [xMax, (yMax + yMin) / 2, (zMax + zMin) / 2];
+            const sphereYminPoint = [(xMax + xMin) / 2, yMin, (zMax + zMin) / 2];
+            const sphereYmaxPoint = [(xMax + xMin) / 2, yMax, (zMax + zMin) / 2];
+            const sphereZminPoint = [(xMax + xMin) / 2, (yMax + yMin) / 2, zMin];
+            const sphereZmaxPoint = [(xMax + xMin) / 2, (yMax + yMin) / 2, zMax];
+            const adaptiveRadius = this._calculateAdaptiveSphereRadius(Math.sqrt(xRange * xRange + yRange * yRange + zRange * zRange));
+            this._addSphere(viewport, sphereXminPoint, 'x', 'min', null, adaptiveRadius);
+            this._addSphere(viewport, sphereXmaxPoint, 'x', 'max', null, adaptiveRadius);
+            this._addSphere(viewport, sphereYminPoint, 'y', 'min', null, adaptiveRadius);
+            this._addSphere(viewport, sphereYmaxPoint, 'y', 'max', null, adaptiveRadius);
+            this._addSphere(viewport, sphereZminPoint, 'z', 'min', null, adaptiveRadius);
+            this._addSphere(viewport, sphereZmaxPoint, 'z', 'max', null, adaptiveRadius);
             const corners = [
-                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]),
+                [xMin, yMin, zMin],
+                [xMin, yMin, zMax],
+                [xMin, yMax, zMin],
+                [xMin, yMax, zMax],
+                [xMax, yMin, zMin],
+                [xMax, yMin, zMax],
+                [xMax, yMax, zMin],
+                [xMax, yMax, zMax],
             ];
             const cornerKeys = [
                 'XMIN_YMIN_ZMIN',
@@ -410,24 +395,21 @@ class VolumeCroppingTool extends BaseTool {
                 ['XMAX_YMIN_ZMIN', 'XMAX_YMIN_ZMAX'],
                 ['XMAX_YMAX_ZMIN', 'XMAX_YMAX_ZMAX'],
             ];
-            edgeCornerPairs.forEach(([key1, key2]) => {
+            edgeCornerPairs.forEach(([key1, key2], i) => {
                 const state1 = this.sphereStates.find((s) => s.uid === `corner_${key1}`);
                 const state2 = this.sphereStates.find((s) => s.uid === `corner_${key2}`);
                 if (state1 && state2) {
                     const uid = `edge_${key1}_${key2}`;
-                    const { actor, source } = addLine3DBetweenPoints(viewport, state1.point, state2.point, [0.7, 0.7, 0.7], uid, this.configuration.showHandles);
+                    const { actor, source } = this._addLine3DBetweenPoints(viewport, state1.point, state2.point, [0.7, 0.7, 0.7], uid);
                     this.edgeLines[uid] = { actor, source, key1, key2 };
                 }
             });
-            const mapper = viewport
-                .getDefaultActor()
-                .actor.getMapper();
-            mapper.addClippingPlane(planeXMin);
-            mapper.addClippingPlane(planeXMax);
-            mapper.addClippingPlane(planeYMin);
-            mapper.addClippingPlane(planeYMax);
-            mapper.addClippingPlane(planeZMin);
-            mapper.addClippingPlane(planeZMax);
+            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);
             });
@@ -441,14 +423,107 @@ class VolumeCroppingTool extends BaseTool {
             return { viewport, world };
         };
         this._getViewport = () => {
-            const viewportsInfo = this._getViewportsInfo();
-            if (!viewportsInfo || viewportsInfo.length === 0) {
-                return null;
-            }
-            const [viewport3D] = viewportsInfo;
+            const [viewport3D] = this._getViewportsInfo();
             const renderingEngine = getRenderingEngine(viewport3D.renderingEngineId);
-            const viewport = renderingEngine?.getViewport(viewport3D.viewportId);
-            return viewport || null;
+            return renderingEngine.getViewport(viewport3D.viewportId);
+        };
+        this._handleCornerSphereMovement = (sphereState, world, viewport) => {
+            const newCorner = this._calculateNewCornerPosition(world);
+            this._updateSpherePosition(sphereState, newCorner);
+            const axisFlags = this._parseCornerKey(sphereState.uid);
+            this._updateRelatedCorners(sphereState, newCorner, axisFlags);
+            this._updateAfterCornerMovement(viewport);
+        };
+        this._handleFaceSphereMovement = (sphereState, world, viewport) => {
+            const axisIdx = { x: 0, y: 1, z: 2 }[sphereState.axis];
+            let newValue = world[axisIdx];
+            if (this.faceDragOffset !== null) {
+                newValue += this.faceDragOffset;
+            }
+            sphereState.point[axisIdx] = newValue;
+            sphereState.sphereSource.setCenter(...sphereState.point);
+            sphereState.sphereSource.modified();
+            this._updateAfterFaceMovement(viewport);
+        };
+        this._calculateNewCornerPosition = (world) => {
+            let newCorner = [world[0], world[1], world[2]];
+            if (this.cornerDragOffset) {
+                newCorner = [
+                    world[0] + this.cornerDragOffset[0],
+                    world[1] + this.cornerDragOffset[1],
+                    world[2] + this.cornerDragOffset[2],
+                ];
+            }
+            return newCorner;
+        };
+        this._parseCornerKey = (uid) => {
+            const cornerKey = uid.replace('corner_', '');
+            return {
+                isXMin: cornerKey.includes('XMIN'),
+                isXMax: cornerKey.includes('XMAX'),
+                isYMin: cornerKey.includes('YMIN'),
+                isYMax: cornerKey.includes('YMAX'),
+                isZMin: cornerKey.includes('ZMIN'),
+                isZMax: cornerKey.includes('ZMAX'),
+            };
+        };
+        this._updateSpherePosition = (sphereState, newPosition) => {
+            sphereState.point = newPosition;
+            sphereState.sphereSource.setCenter(...newPosition);
+            sphereState.sphereSource.modified();
+        };
+        this._updateRelatedCorners = (draggedSphere, newCorner, axisFlags) => {
+            this.sphereStates.forEach((state) => {
+                if (!state.isCorner || state === draggedSphere) {
+                    return;
+                }
+                const key = state.uid.replace('corner_', '');
+                const shouldUpdate = this._shouldUpdateCorner(key, axisFlags);
+                if (shouldUpdate) {
+                    this._updateCornerCoordinates(state, newCorner, key, axisFlags);
+                }
+            });
+        };
+        this._shouldUpdateCorner = (cornerKey, axisFlags) => {
+            return ((axisFlags.isXMin && cornerKey.includes('XMIN')) ||
+                (axisFlags.isXMax && cornerKey.includes('XMAX')) ||
+                (axisFlags.isYMin && cornerKey.includes('YMIN')) ||
+                (axisFlags.isYMax && cornerKey.includes('YMAX')) ||
+                (axisFlags.isZMin && cornerKey.includes('ZMIN')) ||
+                (axisFlags.isZMax && cornerKey.includes('ZMAX')));
+        };
+        this._updateCornerCoordinates = (state, newCorner, cornerKey, axisFlags) => {
+            if ((axisFlags.isXMin && cornerKey.includes('XMIN')) ||
+                (axisFlags.isXMax && cornerKey.includes('XMAX'))) {
+                state.point[0] = newCorner[0];
+            }
+            if ((axisFlags.isYMin && cornerKey.includes('YMIN')) ||
+                (axisFlags.isYMax && cornerKey.includes('YMAX'))) {
+                state.point[1] = newCorner[1];
+            }
+            if ((axisFlags.isZMin && cornerKey.includes('ZMIN')) ||
+                (axisFlags.isZMax && cornerKey.includes('ZMAX'))) {
+                state.point[2] = newCorner[2];
+            }
+            state.sphereSource.setCenter(...state.point);
+            state.sphereSource.modified();
+        };
+        this._updateAfterCornerMovement = (viewport) => {
+            this._updateFaceSpheresFromCorners();
+            this._updateCornerSpheres();
+            this._updateClippingPlanesFromFaceSpheres(viewport);
+        };
+        this._updateAfterFaceMovement = (viewport) => {
+            this._updateCornerSpheresFromFaces();
+            this._updateClippingPlanesFromFaceSpheres(viewport);
+        };
+        this._triggerToolChangedEvent = (sphereState) => {
+            triggerEvent(eventTarget, Events.VOLUMECROPPING_TOOL_CHANGED, {
+                toolCenter: sphereState.point,
+                axis: sphereState.isCorner ? 'corner' : sphereState.axis,
+                draggingSphereIndex: this.draggingSphereIndex,
+                seriesInstanceUID: this.seriesInstanceUID,
+            });
         };
         this._onNewVolume = () => {
             const viewportsInfo = this._getViewportsInfo();
@@ -457,207 +532,6 @@ 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();
@@ -689,55 +563,59 @@ class VolumeCroppingTool extends BaseTool {
         this.mouseDragCallback = this._dragCallback.bind(this);
     }
     onSetToolActive() {
-        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) {
+        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) {
                             return;
                         }
-                        const { viewport } = element;
-                        const viewPresentation = viewport.getViewPresentation();
-                        viewport.resetCamera();
-                        viewport.setViewPresentation(viewPresentation);
-                        viewport.render();
-                    });
-                    resizeObserver.observe(element);
-                    this._resizeObservers.set(viewportId, resizeObserver);
+                        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();
                 }
-            });
-        };
-        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 = [];
+            };
+            eventTarget.addEventListener(Events.TOOLGROUP_VIEWPORT_ADDED, this._viewportAddedListener);
+            this._unsubscribeToViewportNewVolumeSet(viewportsInfo);
+            this._subscribeToViewportNewVolumeSet(viewportsInfo);
             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._updateHandlesVisibility();
+                this.setHandlesVisible(true);
+            }
+            else {
+                this.originalClippingPlanes = [];
+                this._initialize3DViewports(viewportsInfo);
             }
-            viewport.render();
         }
     }
     onSetToolDisabled() {
@@ -755,7 +633,30 @@ class VolumeCroppingTool extends BaseTool {
     setHandlesVisible(visible) {
         this.configuration.showHandles = visible;
         if (visible) {
-            this._updateFaceSpheresFromClippingPlanes();
+            this.sphereStates[SPHEREINDEX.XMIN].point[0] =
+                this.originalClippingPlanes[PLANEINDEX.XMIN].origin[0];
+            this.sphereStates[SPHEREINDEX.XMAX].point[0] =
+                this.originalClippingPlanes[PLANEINDEX.XMAX].origin[0];
+            this.sphereStates[SPHEREINDEX.YMIN].point[1] =
+                this.originalClippingPlanes[PLANEINDEX.YMIN].origin[1];
+            this.sphereStates[SPHEREINDEX.YMAX].point[1] =
+                this.originalClippingPlanes[PLANEINDEX.YMAX].origin[1];
+            this.sphereStates[SPHEREINDEX.ZMIN].point[2] =
+                this.originalClippingPlanes[PLANEINDEX.ZMIN].origin[2];
+            this.sphereStates[SPHEREINDEX.ZMAX].point[2] =
+                this.originalClippingPlanes[PLANEINDEX.ZMAX].origin[2];
+            [
+                SPHEREINDEX.XMIN,
+                SPHEREINDEX.XMAX,
+                SPHEREINDEX.YMIN,
+                SPHEREINDEX.YMAX,
+                SPHEREINDEX.ZMIN,
+                SPHEREINDEX.ZMAX,
+            ].forEach((idx) => {
+                const s = this.sphereStates[idx];
+                s.sphereSource.setCenter(...s.point);
+                s.sphereSource.modified();
+            });
             this._updateCornerSpheres();
         }
         this._updateHandlesVisibility();
@@ -775,38 +676,14 @@ 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._rotateClippingPlanes(evt);
-                return;
-            }
             const currentPointsCanvas = currentPoints.canvas;
             const lastPointsCanvas = lastPoints.canvas;
             const { rotateIncrementDegrees } = this.configuration;
@@ -862,6 +739,13 @@ 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;
+            }
+            return;
+        }
         const actor = actorEntry.actor;
         const mapper = actor.getMapper();
         const matrix = actor.getMatrix();
@@ -913,6 +797,35 @@ 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);
@@ -941,10 +854,9 @@ 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: pointCopy,
+                point: point.slice(),
                 axis,
                 uid,
                 sphereSource,
@@ -954,144 +866,88 @@ class VolumeCroppingTool extends BaseTool {
             });
         }
         else {
-            this.sphereStates[idx].point = pointCopy;
+            this.sphereStates[idx].point = point.slice();
             this.sphereStates[idx].sphereSource = sphereSource;
         }
+        const existingActors = viewport.getActors();
+        const existing = existingActors.find((a) => a.uid === uid);
+        if (existing) {
+            return;
+        }
         sphereActor.getProperty().setColor(color);
         sphereActor.setVisibility(this.configuration.showHandles);
         viewport.addActor({ actor: sphereActor, uid: uid });
     }
-    _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?.getDefaultActor()?.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);
-        }
+    _calculateAdaptiveSphereRadius(diagonal) {
+        const baseRadius = this.configuration.sphereRadius !== undefined
+            ? this.configuration.sphereRadius
+            : 8;
+        const scaleFactor = this.configuration.sphereRadiusScale || 0.01;
+        const adaptiveRadius = diagonal * scaleFactor;
+        const minRadius = this.configuration.minSphereRadius || 2;
+        const maxRadius = this.configuration.maxSphereRadius || 50;
+        return Math.max(minRadius, Math.min(maxRadius, adaptiveRadius));
     }
     _updateClippingPlanesFromFaceSpheres(viewport) {
         const mapper = viewport.getDefaultActor().actor.getMapper();
-        this.originalClippingPlanes[PLANEINDEX.XMIN].origin = [
+        this.originalClippingPlanes[0].origin = [
             ...this.sphereStates[SPHEREINDEX.XMIN].point,
         ];
-        this.originalClippingPlanes[PLANEINDEX.XMAX].origin = [
+        this.originalClippingPlanes[1].origin = [
             ...this.sphereStates[SPHEREINDEX.XMAX].point,
         ];
-        this.originalClippingPlanes[PLANEINDEX.YMIN].origin = [
+        this.originalClippingPlanes[2].origin = [
             ...this.sphereStates[SPHEREINDEX.YMIN].point,
         ];
-        this.originalClippingPlanes[PLANEINDEX.YMAX].origin = [
+        this.originalClippingPlanes[3].origin = [
             ...this.sphereStates[SPHEREINDEX.YMAX].point,
         ];
-        this.originalClippingPlanes[PLANEINDEX.ZMIN].origin = [
+        this.originalClippingPlanes[4].origin = [
             ...this.sphereStates[SPHEREINDEX.ZMIN].point,
         ];
-        this.originalClippingPlanes[PLANEINDEX.ZMAX].origin = [
+        this.originalClippingPlanes[5].origin = [
             ...this.sphereStates[SPHEREINDEX.ZMAX].point,
         ];
-        this._applyClippingPlanesToMapper(mapper);
+        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);
+        }
     }
     _updateCornerSpheresFromFaces() {
-        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 xMin = this.sphereStates[SPHEREINDEX.XMIN].point[0];
+        const xMax = this.sphereStates[SPHEREINDEX.XMAX].point[0];
+        const yMin = this.sphereStates[SPHEREINDEX.YMIN].point[1];
+        const yMax = this.sphereStates[SPHEREINDEX.YMAX].point[1];
+        const zMin = this.sphereStates[SPHEREINDEX.ZMIN].point[2];
+        const zMax = this.sphereStates[SPHEREINDEX.ZMAX].point[2];
         const corners = [
-            {
-                key: 'XMIN_YMIN_ZMIN',
-                pos: 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),
-            },
+            { key: 'XMIN_YMIN_ZMIN', pos: [xMin, yMin, zMin] },
+            { key: 'XMIN_YMIN_ZMAX', pos: [xMin, yMin, zMax] },
+            { key: 'XMIN_YMAX_ZMIN', pos: [xMin, yMax, zMin] },
+            { key: 'XMIN_YMAX_ZMAX', pos: [xMin, yMax, zMax] },
+            { key: 'XMAX_YMIN_ZMIN', pos: [xMax, yMin, zMin] },
+            { key: 'XMAX_YMIN_ZMAX', pos: [xMax, yMin, zMax] },
+            { key: 'XMAX_YMAX_ZMIN', pos: [xMax, yMax, zMin] },
+            { key: 'XMAX_YMAX_ZMAX', pos: [xMax, yMax, zMax] },
         ];
         for (const corner of corners) {
-            const stateIndex = this.sphereStates.findIndex((s) => s.uid === `corner_${corner.key}`);
-            if (stateIndex !== -1) {
-                this._updateSpherePosition(stateIndex, corner.pos);
+            const state = this.sphereStates.find((s) => s.uid === `corner_${corner.key}`);
+            if (state) {
+                state.point[0] = corner.pos[0];
+                state.point[1] = corner.pos[1];
+                state.point[2] = corner.pos[2];
+                state.sphereSource.setCenter(...state.point);
+                state.sphereSource.modified();
             }
         }
     }
     _updateFaceSpheresFromCorners() {
-        if (!this.volumeDirectionVectors)
-            return;
         const corners = [
             this.sphereStates[SPHEREINDEX.XMIN_YMIN_ZMIN].point,
             this.sphereStates[SPHEREINDEX.XMIN_YMIN_ZMAX].point,
@@ -1102,100 +958,93 @@ class VolumeCroppingTool extends BaseTool {
             this.sphereStates[SPHEREINDEX.XMAX_YMAX_ZMIN].point,
             this.sphereStates[SPHEREINDEX.XMAX_YMAX_ZMAX].point,
         ];
-        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);
+        const xs = corners.map((p) => p[0]);
+        const ys = corners.map((p) => p[1]);
+        const zs = corners.map((p) => p[2]);
+        const xMin = Math.min(...xs), xMax = Math.max(...xs);
+        const yMin = Math.min(...ys), yMax = Math.max(...ys);
+        const zMin = Math.min(...zs), zMax = Math.max(...zs);
+        this.sphereStates[SPHEREINDEX.XMIN].point = [
+            xMin,
+            (yMin + yMax) / 2,
+            (zMin + zMax) / 2,
+        ];
+        this.sphereStates[SPHEREINDEX.XMAX].point = [
+            xMax,
+            (yMin + yMax) / 2,
+            (zMin + zMax) / 2,
+        ];
+        this.sphereStates[SPHEREINDEX.YMIN].point = [
+            (xMin + xMax) / 2,
+            yMin,
+            (zMin + zMax) / 2,
+        ];
+        this.sphereStates[SPHEREINDEX.YMAX].point = [
+            (xMin + xMax) / 2,
+            yMax,
+            (zMin + zMax) / 2,
+        ];
+        this.sphereStates[SPHEREINDEX.ZMIN].point = [
+            (xMin + xMax) / 2,
+            (yMin + yMax) / 2,
+            zMin,
+        ];
+        this.sphereStates[SPHEREINDEX.ZMAX].point = [
+            (xMin + xMax) / 2,
+            (yMin + yMax) / 2,
+            zMax,
+        ];
+        [
+            SPHEREINDEX.XMIN,
+            SPHEREINDEX.XMAX,
+            SPHEREINDEX.YMIN,
+            SPHEREINDEX.YMAX,
+            SPHEREINDEX.ZMIN,
+            SPHEREINDEX.ZMAX,
+        ].forEach((idx) => {
+            const s = this.sphereStates[idx];
+            s.sphereSource.setCenter(...s.point);
+            s.sphereSource.modified();
+        });
     }
     _updateCornerSpheres() {
-        const { 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 xMin = this.sphereStates[SPHEREINDEX.XMIN].point[0];
+        const xMax = this.sphereStates[SPHEREINDEX.XMAX].point[0];
+        const yMin = this.sphereStates[SPHEREINDEX.YMIN].point[1];
+        const yMax = this.sphereStates[SPHEREINDEX.YMAX].point[1];
+        const zMin = this.sphereStates[SPHEREINDEX.ZMIN].point[2];
+        const zMax = this.sphereStates[SPHEREINDEX.ZMAX].point[2];
         const corners = [
-            {
-                key: 'XMIN_YMIN_ZMIN',
-                pos: 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),
-            },
+            { key: 'XMIN_YMIN_ZMIN', pos: [xMin, yMin, zMin] },
+            { key: 'XMIN_YMIN_ZMAX', pos: [xMin, yMin, zMax] },
+            { key: 'XMIN_YMAX_ZMIN', pos: [xMin, yMax, zMin] },
+            { key: 'XMIN_YMAX_ZMAX', pos: [xMin, yMax, zMax] },
+            { key: 'XMAX_YMIN_ZMIN', pos: [xMax, yMin, zMin] },
+            { key: 'XMAX_YMIN_ZMAX', pos: [xMax, yMin, zMax] },
+            { key: 'XMAX_YMAX_ZMIN', pos: [xMax, yMax, zMin] },
+            { key: 'XMAX_YMAX_ZMAX', pos: [xMax, yMax, zMax] },
         ];
         for (const corner of corners) {
-            const stateIndex = this.sphereStates.findIndex((s) => s.uid === `corner_${corner.key}`);
-            if (stateIndex !== -1) {
-                this._updateSpherePosition(stateIndex, corner.pos);
+            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();
             }
         }
-        this._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();
+            }
+        });
     }
     _unsubscribeToViewportNewVolumeSet(viewportsInfo) {
         viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
@@ -1211,105 +1060,6 @@ 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;