@cornerstonejs/tools 4.18.3 → 4.18.5

package/dist/esm/index.d.ts

@@ -12,7 +12,7 @@ import * as Types from './types';
 import * as annotation from './stateManagement/annotation';
 import * as segmentation from './stateManagement/segmentation';
 import * as splines from './tools/annotation/splines';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, SegmentBidirectionalTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentLabelTool, LabelMapEditWithContourTool } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, SegmentBidirectionalTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentLabelTool, LabelMapEditWithContourTool } from './tools';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
 import * as Enums from './enums';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, SegmentBidirectionalTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, SegmentLabelTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, LabelMapEditWithContourTool, splines, version, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, SegmentBidirectionalTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, OrientationControllerTool, SegmentSelectTool, SegmentLabelTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, LabelMapEditWithContourTool, splines, version, };

package/dist/esm/index.js

@@ -12,7 +12,7 @@ import * as Types from './types';
 import * as annotation from './stateManagement/annotation';
 import * as segmentation from './stateManagement/segmentation';
 import * as splines from './tools/annotation/splines';
-import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, SegmentBidirectionalTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentLabelTool, LabelMapEditWithContourTool, } from './tools';
+import { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, ZoomTool, StackScrollTool, SegmentBidirectionalTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, KeyImageTool, CrosshairsTool, ReferenceLinesTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, OverlayGridTool, SegmentationIntersectionTool, EraserTool, SculptorTool, SegmentSelectTool, WindowLevelRegionTool, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentLabelTool, LabelMapEditWithContourTool, } from './tools';
 import VideoRedactionTool from './tools/annotation/VideoRedactionTool';
 import * as Enums from './enums';
-export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, SegmentBidirectionalTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, SegmentSelectTool, SegmentLabelTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, LabelMapEditWithContourTool, splines, version, };
+export { VideoRedactionTool, init, destroy, addTool, removeTool, cancelActiveManipulations, BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, SegmentBidirectionalTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, ZoomTool, StackScrollTool, PlanarRotateTool, MIPJumpToClickTool, LabelTool, LengthTool, HeightTool, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, SplineContourSegmentationTool, BidirectionalTool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, MagnifyTool, AdvancedMagnifyTool, ReferenceCursors, ScaleOverlayTool, SculptorTool, EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, BrushTool, OrientationMarkerTool, OrientationControllerTool, SegmentSelectTool, SegmentLabelTool, synchronizers, Synchronizer, SynchronizerManager, PaintFillTool, Types, state, ToolGroupManager, store, Enums, CONSTANTS, drawing, annotation, segmentation, utilities, cursors, VolumeRotateTool, RegionSegmentPlusTool, RegionSegmentTool, WholeBodySegmentTool, LabelmapBaseTool, LabelMapEditWithContourTool, splines, version, };

package/dist/esm/tools/OrientationControllerTool.d.ts

@@ -0,0 +1,38 @@
+import { BaseTool } from './base';
+declare class OrientationControllerTool extends BaseTool {
+    static toolName: string;
+    private widget;
+    private resizeObservers;
+    private cameraHandlers;
+    constructor(toolProps?: {}, defaultToolProps?: {
+        supportedInteractionTypes: string[];
+        configuration: {
+            enabled: boolean;
+            opacity: number;
+            size: number;
+            position: string;
+            colorScheme: string;
+            letterColorScheme: string;
+            showEdgeFaces: boolean;
+            showCornerFaces: boolean;
+            keepOrientationUp: boolean;
+        };
+    });
+    private _getViewportsInfo;
+    private getPositionConfig;
+    private getFaceColors;
+    private getLetterColors;
+    onSetToolEnabled(): void;
+    onSetToolDisabled(): void;
+    onSetToolConfiguration: () => void;
+    private onViewportAdded;
+    private onViewportRemoved;
+    private removeMarkers;
+    private addMarkers;
+    private createAnnotatedRhombActor;
+    private addMarkerToViewport;
+    private onCameraModified;
+    private updateMarkerPosition;
+    private animateCameraToOrientation;
+}
+export default OrientationControllerTool;

package/dist/esm/tools/OrientationControllerTool.js

@@ -0,0 +1,415 @@
+import { BaseTool } from './base';
+import { getEnabledElementByIds, Enums, eventTarget, } from '@cornerstonejs/core';
+import { getToolGroup } from '../store/ToolGroupManager';
+import * as ToolsEnums from '../enums';
+import { vec3, mat4, quat } from 'gl-matrix';
+import { vtkOrientationControllerWidget } from '../utilities/vtkjs/OrientationControllerWidget';
+const ADD_MARKER_DELAY_MS = 500;
+const POSITION_RETRY_DELAY_MS = 1000;
+const FACE_COLOR_SCHEMES = {
+    marker: {
+        topBottom: [0, 0, 255],
+        frontBack: [0, 255, 255],
+        leftRight: [255, 255, 0],
+    },
+    gray: {
+        topBottom: [180, 180, 180],
+        frontBack: [180, 180, 180],
+        leftRight: [180, 180, 180],
+    },
+    rgy: {
+        topBottom: [255, 0, 0],
+        frontBack: [0, 255, 0],
+        leftRight: [255, 255, 0],
+    },
+};
+const LETTER_COLOR_SCHEMES = {
+    mixed: {
+        zMinus: [255, 255, 255],
+        zPlus: [255, 255, 255],
+        yMinus: [255, 255, 255],
+        yPlus: [255, 255, 255],
+        xMinus: [0, 0, 0],
+        xPlus: [0, 0, 0],
+    },
+    rgy: {
+        zMinus: [255, 255, 255],
+        zPlus: [255, 255, 255],
+        yMinus: [255, 255, 255],
+        yPlus: [255, 255, 255],
+        xMinus: [0, 0, 0],
+        xPlus: [0, 0, 0],
+    },
+    white: {
+        zMinus: [255, 255, 255],
+        zPlus: [255, 255, 255],
+        yMinus: [255, 255, 255],
+        yPlus: [255, 255, 255],
+        xMinus: [255, 255, 255],
+        xPlus: [255, 255, 255],
+    },
+    black: {
+        zMinus: [0, 0, 0],
+        zPlus: [0, 0, 0],
+        yMinus: [0, 0, 0],
+        yPlus: [0, 0, 0],
+        xMinus: [0, 0, 0],
+        xPlus: [0, 0, 0],
+    },
+};
+const DEFAULT_FACE_COLOR_SCHEME = 'rgy';
+const DEFAULT_LETTER_COLOR_SCHEME = 'mixed';
+const ANIMATE_RESET_CAMERA_OPTIONS = {
+    resetZoom: false,
+    resetPan: true,
+    resetToCenter: true,
+};
+class OrientationControllerTool extends BaseTool {
+    static { this.toolName = 'OrientationControllerTool'; }
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse'],
+        configuration: {
+            enabled: true,
+            opacity: 1.0,
+            size: 0.04,
+            position: 'bottom-right',
+            colorScheme: 'rgy',
+            letterColorScheme: 'mixed',
+            showEdgeFaces: true,
+            showCornerFaces: true,
+            keepOrientationUp: true,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.widget = new vtkOrientationControllerWidget();
+        this.resizeObservers = new Map();
+        this.cameraHandlers = new Map();
+        this._getViewportsInfo = () => {
+            const viewports = getToolGroup(this.toolGroupId)?.viewportsInfo;
+            return viewports || [];
+        };
+        this.onSetToolConfiguration = () => {
+            const viewportsInfo = this._getViewportsInfo();
+            const hasActiveMarkers = viewportsInfo.some(({ viewportId }) => {
+                return this.widget.getActors(viewportId) !== null;
+            });
+            if (hasActiveMarkers) {
+                this.removeMarkers();
+                this.addMarkers();
+            }
+        };
+        this.onViewportAdded = (evt) => {
+            const { viewportId, renderingEngineId, toolGroupId } = evt.detail;
+            if (toolGroupId !== this.toolGroupId) {
+                return;
+            }
+            if (this.widget.getActors(viewportId)) {
+                return;
+            }
+            setTimeout(() => {
+                this.addMarkerToViewport(viewportId, renderingEngineId);
+            }, ADD_MARKER_DELAY_MS);
+        };
+        this.onViewportRemoved = (evt) => {
+            const { viewportId, renderingEngineId, toolGroupId } = evt.detail;
+            if (toolGroupId !== this.toolGroupId) {
+                return;
+            }
+            const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
+            if (enabledElement) {
+                const { viewport } = enabledElement;
+                if (viewport.isOrientationChangeable()) {
+                    this.widget.removeActorsFromViewport(viewportId, viewport);
+                }
+                const cameraHandler = this.cameraHandlers.get(viewportId);
+                if (cameraHandler) {
+                    viewport.element.removeEventListener(Enums.Events.CAMERA_MODIFIED, cameraHandler);
+                    this.cameraHandlers.delete(viewportId);
+                }
+            }
+            this.widget.cleanup(viewportId);
+            const resizeObserver = this.resizeObservers.get(viewportId);
+            if (resizeObserver) {
+                resizeObserver.disconnect();
+                this.resizeObservers.delete(viewportId);
+            }
+        };
+        this.addMarkers = () => {
+            const viewportsInfo = this._getViewportsInfo();
+            viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+                const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
+                if (!enabledElement) {
+                    return;
+                }
+                const { viewport } = enabledElement;
+                if (!viewport.isOrientationChangeable()) {
+                    return;
+                }
+                if (this.widget.getActors(viewportId)) {
+                    return;
+                }
+                setTimeout(() => {
+                    this.addMarkerToViewport(viewportId, renderingEngineId);
+                }, ADD_MARKER_DELAY_MS);
+            });
+        };
+        this.onCameraModified = (evt) => {
+            const { viewportId } = evt.detail;
+            if (!viewportId) {
+                return;
+            }
+            const actors = this.widget.getActors(viewportId);
+            if (!actors) {
+                return;
+            }
+            const viewportsInfo = this._getViewportsInfo();
+            const viewportInfo = viewportsInfo.find((vp) => vp.viewportId === viewportId);
+            if (!viewportInfo) {
+                return;
+            }
+            const enabledElement = getEnabledElementByIds(viewportId, viewportInfo.renderingEngineId);
+            if (!enabledElement) {
+                return;
+            }
+            const { viewport } = enabledElement;
+            if (!viewport.isOrientationChangeable()) {
+                return;
+            }
+            const volumeViewport = viewport;
+            this.widget.positionActors(volumeViewport, actors, this.getPositionConfig());
+            viewport.render();
+        };
+    }
+    getPositionConfig() {
+        return {
+            position: this.configuration.position || 'bottom-right',
+            size: this.configuration.size || 0.04,
+        };
+    }
+    getFaceColors() {
+        const colorScheme = this.configuration.colorScheme || 'rgy';
+        if (this.configuration.faceColors) {
+            const provided = this.configuration.faceColors;
+            if (provided.topBottom && provided.frontBack && provided.leftRight) {
+                return {
+                    topBottom: provided.topBottom,
+                    frontBack: provided.frontBack,
+                    leftRight: provided.leftRight,
+                };
+            }
+        }
+        return (FACE_COLOR_SCHEMES[colorScheme] ??
+            FACE_COLOR_SCHEMES[DEFAULT_FACE_COLOR_SCHEME]);
+    }
+    getLetterColors() {
+        const letterColorScheme = this.configuration.letterColorScheme || 'mixed';
+        return (LETTER_COLOR_SCHEMES[letterColorScheme] ??
+            LETTER_COLOR_SCHEMES[DEFAULT_LETTER_COLOR_SCHEME]);
+    }
+    onSetToolEnabled() {
+        this.removeMarkers();
+        this.addMarkers();
+        eventTarget.addEventListener(ToolsEnums.Events.TOOLGROUP_VIEWPORT_ADDED, this.onViewportAdded);
+        eventTarget.addEventListener(ToolsEnums.Events.TOOLGROUP_VIEWPORT_REMOVED, this.onViewportRemoved);
+    }
+    onSetToolDisabled() {
+        this.removeMarkers();
+        eventTarget.removeEventListener(ToolsEnums.Events.TOOLGROUP_VIEWPORT_ADDED, this.onViewportAdded);
+        eventTarget.removeEventListener(ToolsEnums.Events.TOOLGROUP_VIEWPORT_REMOVED, this.onViewportRemoved);
+    }
+    removeMarkers() {
+        const viewportsInfo = this._getViewportsInfo();
+        viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+            const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
+            if (enabledElement) {
+                const { viewport } = enabledElement;
+                if (viewport.isOrientationChangeable()) {
+                    this.widget.removeActorsFromViewport(viewportId, viewport);
+                }
+                const cameraHandler = this.cameraHandlers.get(viewportId);
+                if (cameraHandler) {
+                    viewport.element.removeEventListener(Enums.Events.CAMERA_MODIFIED, cameraHandler);
+                    this.cameraHandlers.delete(viewportId);
+                }
+            }
+            const resizeObserver = this.resizeObservers.get(viewportId);
+            if (resizeObserver) {
+                resizeObserver.disconnect();
+                this.resizeObservers.delete(viewportId);
+            }
+        });
+        this.widget.cleanup();
+        this.resizeObservers.forEach((observer) => observer.disconnect());
+        this.resizeObservers.clear();
+        this.cameraHandlers.clear();
+    }
+    createAnnotatedRhombActor() {
+        const faceColors = this.getFaceColors();
+        const letterColors = this.getLetterColors();
+        return this.widget.createActors({
+            faceColors,
+            letterColors,
+            opacity: this.configuration.opacity ?? 1.0,
+            showEdgeFaces: this.configuration.showEdgeFaces !== false,
+            showCornerFaces: this.configuration.showCornerFaces !== false,
+        });
+    }
+    addMarkerToViewport(viewportId, renderingEngineId) {
+        const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
+        if (!enabledElement) {
+            console.warn('OrientationControllerTool: No enabled element found');
+            return;
+        }
+        const { viewport } = enabledElement;
+        if (!viewport.isOrientationChangeable()) {
+            console.warn('OrientationControllerTool: Viewport does not support orientation changes');
+            return;
+        }
+        const element = viewport.element;
+        const volumeViewport = viewport;
+        const actors = this.createAnnotatedRhombActor();
+        this.widget.addActorsToViewport(viewportId, volumeViewport, actors);
+        const positioned = this.widget.positionActors(volumeViewport, actors, this.getPositionConfig());
+        if (!positioned) {
+            console.warn('OrientationControllerTool: Initial positioning failed, retrying...');
+            setTimeout(() => {
+                const repositioned = this.widget.positionActors(volumeViewport, actors, this.getPositionConfig());
+                if (repositioned) {
+                    viewport.render();
+                }
+                else {
+                    console.error('OrientationControllerTool: Retry positioning also failed');
+                }
+            }, POSITION_RETRY_DELAY_MS);
+        }
+        else {
+            viewport.render();
+        }
+        this.widget.syncOverlayViewport(viewportId, volumeViewport);
+        this.widget.setupPicker(viewportId, actors);
+        this.widget.setupMouseHandlers(viewportId, element, volumeViewport, actors, {
+            onFacePicked: (result) => {
+                const orientation = this.widget.getOrientationForFace(result.cellId);
+                if (orientation) {
+                    this.animateCameraToOrientation(volumeViewport, orientation.viewPlaneNormal, orientation.viewUp);
+                }
+            },
+            onFaceHover: (result) => {
+                if (result && result.actorIndex !== 0) {
+                    this.widget.highlightFace(result.pickedActor, result.cellId, volumeViewport, false);
+                }
+                else {
+                    this.widget.clearHighlight();
+                }
+            },
+        });
+        const resizeObserver = new ResizeObserver(() => {
+            this.updateMarkerPosition(viewportId, renderingEngineId);
+        });
+        resizeObserver.observe(element);
+        this.resizeObservers.set(viewportId, resizeObserver);
+        const cameraHandler = (evt) => {
+            const detail = evt.detail;
+            if (detail.viewportId === viewportId) {
+                this.onCameraModified(evt);
+            }
+        };
+        element.addEventListener(Enums.Events.CAMERA_MODIFIED, cameraHandler);
+        this.cameraHandlers.set(viewportId, cameraHandler);
+    }
+    updateMarkerPosition(viewportId, renderingEngineId) {
+        const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
+        if (!enabledElement) {
+            return;
+        }
+        const actors = this.widget.getActors(viewportId);
+        if (!actors) {
+            return;
+        }
+        const { viewport } = enabledElement;
+        if (!viewport.isOrientationChangeable()) {
+            return;
+        }
+        this.widget.positionActors(viewport, actors, this.getPositionConfig());
+        this.widget.syncOverlayViewport(viewportId, viewport);
+        viewport.render();
+    }
+    animateCameraToOrientation(viewport, targetViewPlaneNormal, targetViewUp) {
+        const keepOrientationUp = this.configuration.keepOrientationUp !== false;
+        const renderer = viewport.getRenderer();
+        const camera = renderer.getActiveCamera();
+        const directionOfProjection = camera.getDirectionOfProjection();
+        const startViewUpArray = camera.getViewUp();
+        const startForward = vec3.fromValues(-directionOfProjection[0], -directionOfProjection[1], -directionOfProjection[2]);
+        const startUp = vec3.fromValues(startViewUpArray[0], startViewUpArray[1], startViewUpArray[2]);
+        const startRight = vec3.create();
+        vec3.cross(startRight, startUp, startForward);
+        vec3.normalize(startRight, startRight);
+        const startMatrix = mat4.fromValues(startRight[0], startRight[1], startRight[2], 0, startUp[0], startUp[1], startUp[2], 0, startForward[0], startForward[1], startForward[2], 0, 0, 0, 0, 1);
+        let targetUp;
+        if (keepOrientationUp) {
+            targetUp = vec3.fromValues(targetViewUp[0], targetViewUp[1], targetViewUp[2]);
+        }
+        else {
+            const currentUp = vec3.normalize(vec3.create(), startUp);
+            const normalizedForward = vec3.create();
+            vec3.normalize(normalizedForward, targetViewPlaneNormal);
+            const dot = vec3.dot(currentUp, normalizedForward);
+            targetUp = vec3.create();
+            vec3.scaleAndAdd(targetUp, currentUp, normalizedForward, -dot);
+            vec3.normalize(targetUp, targetUp);
+            if (vec3.length(targetUp) < 0.001) {
+                if (Math.abs(normalizedForward[2]) < 0.9) {
+                    targetUp = vec3.fromValues(0, 0, 1);
+                }
+                else {
+                    targetUp = vec3.fromValues(0, 1, 0);
+                }
+                const dot2 = vec3.dot(targetUp, normalizedForward);
+                vec3.scaleAndAdd(targetUp, targetUp, normalizedForward, -dot2);
+                vec3.normalize(targetUp, targetUp);
+            }
+        }
+        const targetRight = vec3.create();
+        vec3.cross(targetRight, targetUp, targetViewPlaneNormal);
+        vec3.normalize(targetRight, targetRight);
+        const targetMatrix = mat4.fromValues(targetRight[0], targetRight[1], targetRight[2], 0, targetUp[0], targetUp[1], targetUp[2], 0, targetViewPlaneNormal[0], targetViewPlaneNormal[1], targetViewPlaneNormal[2], 0, 0, 0, 0, 1);
+        const startQuat = mat4.getRotation(quat.create(), startMatrix);
+        const targetQuat = mat4.getRotation(quat.create(), targetMatrix);
+        let dotProduct = quat.dot(startQuat, targetQuat);
+        if (dotProduct < 0) {
+            quat.scale(targetQuat, targetQuat, -1);
+            dotProduct = -dotProduct;
+        }
+        const threshold = 0.99996;
+        if (dotProduct > threshold) {
+            return;
+        }
+        const steps = 10;
+        const duration = 150;
+        const stepDuration = duration / steps;
+        let currentStep = 0;
+        const animate = () => {
+            currentStep++;
+            const t = currentStep / steps;
+            const easedT = t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+            const interpolatedQuat = quat.create();
+            quat.slerp(interpolatedQuat, startQuat, targetQuat, easedT);
+            const interpolatedMatrix = mat4.create();
+            mat4.fromQuat(interpolatedMatrix, interpolatedQuat);
+            const interpolatedForward = interpolatedMatrix.slice(8, 11);
+            const interpolatedUp = interpolatedMatrix.slice(4, 7);
+            viewport.setCamera({
+                viewPlaneNormal: interpolatedForward,
+                viewUp: interpolatedUp,
+            });
+            viewport.resetCamera(ANIMATE_RESET_CAMERA_OPTIONS);
+            viewport.render();
+            if (currentStep < steps) {
+                setTimeout(animate, stepDuration);
+            }
+        };
+        animate();
+    }
+}
+export default OrientationControllerTool;

package/dist/esm/tools/VolumeCroppingControlTool.d.ts

@@ -1,7 +1,7 @@
-import type vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
 import { AnnotationTool } from './base';
 import type { Types } from '@cornerstonejs/core';
 import type { Annotation, Annotations, EventTypes, ToolHandle, PublicToolProps, ToolProps, InteractionTypes, SVGDrawingHelper } from '../types';
+import { type ClippingPlane } from '../utilities/volumeCropping';
 type ReferenceLine = [
     viewport: {
         id: string;
@@ -10,60 +10,39 @@ type ReferenceLine = [
     },
     startPoint: Types.Point2,
     endPoint: Types.Point2,
-    type: 'min' | 'max'
+    type: 'min' | 'max',
+    planeIndex?: number
 ];
 interface VolumeCroppingAnnotation extends Annotation {
     data: {
         handles: {
             activeOperation: number | null;
-            toolCenter: Types.Point3;
-            toolCenterMin: Types.Point3;
-            toolCenterMax: Types.Point3;
+            activeType?: 'min' | 'max';
+            activePlaneIndex?: number;
+            clippingPlanes: ClippingPlane[];
         };
         activeViewportIds: string[];
         viewportId: string;
         referenceLines: ReferenceLine[];
-        clippingPlanes?: vtkPlane[];
-        clippingPlaneReferenceLines?: ReferenceLine[];
         orientation?: string;
     };
-    isVirtual?: boolean;
-    virtualNormal?: Types.Point3;
 }
 declare class VolumeCroppingControlTool extends AnnotationTool {
-    _virtualAnnotations: VolumeCroppingAnnotation[];
     static toolName: any;
     seriesInstanceUID?: string;
-    sphereStates: {
-        point: Types.Point3;
-        axis: string;
-        uid: string;
-        sphereSource: any;
-        sphereActor: any;
-    }[];
-    draggingSphereIndex: number | null;
-    toolCenter: Types.Point3;
-    toolCenterMin: Types.Point3;
-    toolCenterMax: Types.Point3;
+    clippingPlanes: ClippingPlane[];
     _getReferenceLineColor?: (viewportId: string) => string;
     _getReferenceLineControllable?: (viewportId: string) => boolean;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
-    _updateToolCentersFromViewport(viewport: any): void;
-    initializeViewport: ({ renderingEngineId, viewportId, }: Types.IViewportId) => {
-        normal: Types.Point3;
-        point: Types.Point3;
-    };
+    initializeViewport: ({ renderingEngineId, viewportId, }: Types.IViewportId) => void;
     _getViewportsInfo: () => any[];
     onSetToolInactive(): void;
     onSetToolActive(): void;
     onSetToolEnabled(): void;
     onSetToolDisabled(): void;
     resetCroppingSpheres: () => void;
-    computeToolCenter: () => void;
-    _computeToolCenter: (viewportsInfo: any) => void;
-    _getOrientationFromNormal(normal: Types.Point3): string | null;
-    _syncWithVolumeCroppingTool(originalClippingPlanes: any): void;
-    setToolCenter(toolCenter: Types.Point3, handleType: any): void;
+    _initializeViewports: (viewportsInfo: Types.IViewportId[]) => void;
+    _syncWithVolumeCroppingTool(originalClippingPlanes: ClippingPlane[]): void;
     addNewAnnotation(evt: EventTypes.InteractionEventType): VolumeCroppingAnnotation;
     cancel: () => void;
     isPointNearTool: (element: HTMLDivElement, annotation: VolumeCroppingAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
@@ -78,14 +57,10 @@ declare class VolumeCroppingControlTool extends AnnotationTool {
     _onNewVolume: () => void;
     _unsubscribeToViewportNewVolumeSet(viewportsInfo: any): void;
     _subscribeToViewportNewVolumeSet(viewports: any): void;
-    _getAnnotationsForViewportsWithDifferentCameras: (enabledElement: any, annotations: any) => any;
-    _filterViewportWithSameOrientation: (enabledElement: any, referenceAnnotation: any, annotations: any) => any;
     _activateModify: (element: any) => void;
     _deactivateModify: (element: any) => void;
     _endCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragCallback: (evt: EventTypes.InteractionEventType) => void;
-    _applyDeltaShiftToSelectedViewportCameras(renderingEngine: any, viewportsAnnotationsToUpdate: any, delta: any): void;
-    _applyDeltaShiftToViewportCamera(renderingEngine: Types.IRenderingEngine, annotation: any, delta: any): void;
     _pointNearTool(element: any, annotation: any, canvasCoords: any, proximity: any): boolean;
 }
 export default VolumeCroppingControlTool;