@cornerstonejs/tools 4.18.4 → 4.19.0

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/stateManagement/segmentation/helpers/normalizeSegmentationInput.js

@@ -15,6 +15,7 @@ function normalizeSegmentationInput(segmentationInput) {
     return {
         segmentationId,
         label: config?.label ?? null,
+        fallbackLabel: config?.fallbackLabel ?? null,
         cachedStats: config?.cachedStats ?? {},
         segments: normalizedSegments,
         representationData: {

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/index.d.ts

@@ -55,9 +55,10 @@ import CircleROIStartEndThresholdTool from './segmentation/CircleROIStartEndThre
 import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
+import OrientationControllerTool from './OrientationControllerTool';
 import SegmentSelectTool from './segmentation/SegmentSelectTool';
 import SegmentBidirectionalTool from './segmentation/SegmentBidirectionalTool';
 import * as strategies from './segmentation/strategies';
 import SegmentLabelTool from './segmentation/SegmentLabelTool';
 import LabelMapEditWithContourTool from './segmentation/LabelmapEditWithContour';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };

package/dist/esm/tools/index.js

@@ -55,9 +55,10 @@ import CircleROIStartEndThresholdTool from './segmentation/CircleROIStartEndThre
 import BrushTool from './segmentation/BrushTool';
 import PaintFillTool from './segmentation/PaintFillTool';
 import OrientationMarkerTool from './OrientationMarkerTool';
+import OrientationControllerTool from './OrientationControllerTool';
 import SegmentSelectTool from './segmentation/SegmentSelectTool';
 import SegmentBidirectionalTool from './segmentation/SegmentBidirectionalTool';
 import * as strategies from './segmentation/strategies';
 import SegmentLabelTool from './segmentation/SegmentLabelTool';
 import LabelMapEditWithContourTool from './segmentation/LabelmapEditWithContour';
-export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };
+export { BaseTool, AnnotationTool, AnnotationDisplayTool, PanTool, TrackballRotateTool, VolumeCroppingTool, VolumeCroppingControlTool, DragProbeTool, WindowLevelTool, WindowLevelRegionTool, StackScrollTool, PlanarRotateTool, ZoomTool, MIPJumpToClickTool, ReferenceCursors, CrosshairsTool, ReferenceLinesTool, OverlayGridTool, SegmentationIntersectionTool, BidirectionalTool, LabelTool, LengthTool, HeightTool, ProbeTool, RectangleROITool, EllipticalROITool, CircleROITool, ETDRSGridTool, SplineROITool, PlanarFreehandROITool, PlanarFreehandContourSegmentationTool, LivewireContourTool, LivewireContourSegmentationTool, ArrowAnnotateTool, AngleTool, CobbAngleTool, UltrasoundDirectionalTool, UltrasoundPleuraBLineTool, KeyImageTool, AnnotationEraserTool as EraserTool, RectangleScissorsTool, CircleScissorsTool, SphereScissorsTool, RectangleROIThresholdTool, RectangleROIStartEndThresholdTool, CircleROIStartEndThresholdTool, SplineContourSegmentationTool, BrushTool, MagnifyTool, AdvancedMagnifyTool, PaintFillTool, ScaleOverlayTool, OrientationMarkerTool, OrientationControllerTool, SculptorTool, SegmentSelectTool, VolumeRotateTool, RegionSegmentTool, RegionSegmentPlusTool, WholeBodySegmentTool, LabelmapBaseTool, SegmentBidirectionalTool, SegmentLabelTool, LabelMapEditWithContourTool, strategies, };

package/dist/esm/types/SegmentationStateTypes.d.ts

@@ -23,6 +23,7 @@ export type Segment = {
 export type Segmentation = {
     segmentationId: string;
     label: string;
+    fallbackLabel?: string;
     segments: {
         [segmentIndex: number]: Segment;
     };
@@ -80,6 +81,7 @@ export type SegmentationPublicInput = {
             [segmentIndex: number]: Partial<Segment>;
         };
         label?: string;
+        fallbackLabel?: string;
         cachedStats?: {
             [key: string]: unknown;
         };

package/dist/esm/utilities/vtkjs/AnnotatedRhombicuboctahedronActor/index.d.ts

@@ -0,0 +1,31 @@
+export function extend(publicAPI: any, model: any, initialValues?: {}): void;
+export namespace DEFAULT_VALUES {
+    namespace defaultStyle {
+        let text: string;
+        let faceColor: string;
+        let faceRotation: number;
+        let fontFamily: string;
+        let fontColor: string;
+        let fontStyle: string;
+        function fontSizeScale(resolution: any): number;
+        let edgeThickness: number;
+        let edgeColor: string;
+        let resolution: number;
+    }
+    let xPlusFaceProperty: {};
+    let xMinusFaceProperty: {};
+    let yPlusFaceProperty: {};
+    let yMinusFaceProperty: {};
+    let zPlusFaceProperty: {};
+    let zMinusFaceProperty: {};
+    let showMainFaces: boolean;
+    let showEdgeFaces: boolean;
+    let showCornerFaces: boolean;
+    let scale: number;
+}
+export const newInstance: any;
+declare namespace _default {
+    export { newInstance };
+    export { extend };
+}
+export default _default;