@cornerstonejs/tools 4.0.0-beta.2 → 4.0.0-beta.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Open Health Imaging Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/esm/enums/Events.d.ts

@@ -4,6 +4,8 @@ declare enum Events {
     TOOLGROUP_VIEWPORT_REMOVED = "CORNERSTONE_TOOLS_TOOLGROUP_VIEWPORT_REMOVED",
     TOOL_MODE_CHANGED = "CORNERSTONE_TOOLS_TOOL_MODE_CHANGED",
     CROSSHAIR_TOOL_CENTER_CHANGED = "CORNERSTONE_TOOLS_CROSSHAIR_TOOL_CENTER_CHANGED",
+    VOLUMECROPPINGCONTROL_TOOL_CHANGED = "CORNERSTONE_TOOLS_VOLUMECROPPINGCONTROL_TOOL_CHANGED",
+    VOLUMECROPPING_TOOL_CHANGED = "CORNERSTONE_TOOLS_VOLUMECROPPING_TOOL_CHANGED",
     ANNOTATION_ADDED = "CORNERSTONE_TOOLS_ANNOTATION_ADDED",
     ANNOTATION_COMPLETED = "CORNERSTONE_TOOLS_ANNOTATION_COMPLETED",
     ANNOTATION_MODIFIED = "CORNERSTONE_TOOLS_ANNOTATION_MODIFIED",

package/dist/esm/enums/Events.js

@@ -5,6 +5,8 @@ var Events;
     Events["TOOLGROUP_VIEWPORT_REMOVED"] = "CORNERSTONE_TOOLS_TOOLGROUP_VIEWPORT_REMOVED";
     Events["TOOL_MODE_CHANGED"] = "CORNERSTONE_TOOLS_TOOL_MODE_CHANGED";
     Events["CROSSHAIR_TOOL_CENTER_CHANGED"] = "CORNERSTONE_TOOLS_CROSSHAIR_TOOL_CENTER_CHANGED";
+    Events["VOLUMECROPPINGCONTROL_TOOL_CHANGED"] = "CORNERSTONE_TOOLS_VOLUMECROPPINGCONTROL_TOOL_CHANGED";
+    Events["VOLUMECROPPING_TOOL_CHANGED"] = "CORNERSTONE_TOOLS_VOLUMECROPPING_TOOL_CHANGED";
     Events["ANNOTATION_ADDED"] = "CORNERSTONE_TOOLS_ANNOTATION_ADDED";
     Events["ANNOTATION_COMPLETED"] = "CORNERSTONE_TOOLS_ANNOTATION_COMPLETED";
     Events["ANNOTATION_MODIFIED"] = "CORNERSTONE_TOOLS_ANNOTATION_MODIFIED";

package/dist/esm/eventListeners/segmentation/imageChangeEventListener.js

@@ -65,6 +65,7 @@ function _imageChangeEventListener(evt) {
         if (!derivedImageIds) {
             return;
         }
+        let shouldTriggerSegmentationRender = false;
         const updateSegmentationActor = (derivedImageId) => {
             const derivedImage = cache.getImage(derivedImageId);
             if (!derivedImage) {
@@ -103,7 +104,7 @@ function _imageChangeEventListener(evt) {
                         },
                     },
                 ]);
-                triggerSegmentationRender(viewportId);
+                shouldTriggerSegmentationRender = true;
                 return;
             }
             else {
@@ -119,6 +120,9 @@ function _imageChangeEventListener(evt) {
             }
         };
         derivedImageIds.forEach(updateSegmentationActor);
+        if (shouldTriggerSegmentationRender) {
+            triggerSegmentationRender(viewportId);
+        }
         viewport.render();
         if (evt.type === Enums.Events.IMAGE_RENDERED) {
             viewport.element.removeEventListener(Enums.Events.IMAGE_RENDERED, _imageChangeEventListener);

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, 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, 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, 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, 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, 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, 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, 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, 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/annotation/annotationVisibility.js

@@ -49,6 +49,8 @@ function hide(annotationUID, annotationUIDsSet, detail) {
             deselectAnnotation(annotationUID);
         }
         detail.lastHidden.push(annotationUID);
+        const annotation = getAnnotation(annotationUID);
+        annotation.isVisible = false;
     }
 }
 function publish(detail) {

package/dist/esm/stateManagement/segmentation/SegmentationRenderingEngine.d.ts

@@ -1,5 +1,6 @@
 declare class SegmentationRenderingEngine {
     private _needsRender;
+    private _pendingRenderQueue;
     private _animationFrameSet;
     private _animationFrameHandle;
     hasBeenDestroyed: boolean;

package/dist/esm/stateManagement/segmentation/SegmentationRenderingEngine.js

@@ -18,6 +18,7 @@ const planarContourToolName = PlanarFreehandContourSegmentationTool.toolName;
 class SegmentationRenderingEngine {
     constructor() {
         this._needsRender = new Set();
+        this._pendingRenderQueue = [];
         this._animationFrameSet = false;
         this._animationFrameHandle = null;
         this._getAllViewports = () => {
@@ -33,6 +34,12 @@ class SegmentationRenderingEngine {
             this._needsRender.clear();
             this._animationFrameSet = false;
             this._animationFrameHandle = null;
+            if (this._pendingRenderQueue.length > 0) {
+                const nextViewportIds = this._pendingRenderQueue.shift();
+                if (nextViewportIds && nextViewportIds.length > 0) {
+                    this._setViewportsToBeRenderedNextFrame(nextViewportIds);
+                }
+            }
         };
     }
     renderSegmentationsForViewport(viewportId) {
@@ -71,6 +78,10 @@ class SegmentationRenderingEngine {
         }
     }
     _setViewportsToBeRenderedNextFrame(viewportIds) {
+        if (this._animationFrameSet) {
+            this._pendingRenderQueue.push(viewportIds);
+            return;
+        }
         viewportIds.forEach((viewportId) => {
             this._needsRender.add(viewportId);
         });

package/dist/esm/stateManagement/segmentation/config/segmentationVisibility.js

@@ -24,6 +24,9 @@ function setSegmentIndexVisibility(viewportId, specifier, segmentIndex, visibili
         return;
     }
     representations.forEach((representation) => {
+        if (!representation.segments || !representation.segments[segmentIndex]) {
+            return;
+        }
         representation.segments[segmentIndex].visible = visibility;
     });
     triggerSegmentationRenderBySegmentationId(specifier.segmentationId);

package/dist/esm/stateManagement/segmentation/helpers/normalizeSegmentationInput.js

@@ -44,6 +44,9 @@ function normalizeSegments(segmentsConfig, type, data) {
             normalizedSegments[segmentIndex] = normalizedSegment;
         });
     }
+    else if (type === SegmentationRepresentations.Contour) {
+        normalizeContourSegments(normalizedSegments, data);
+    }
     else if (type === SegmentationRepresentations.Surface) {
         normalizeSurfaceSegments(normalizedSegments, data);
     }
@@ -52,6 +55,16 @@ function normalizeSegments(segmentsConfig, type, data) {
     }
     return normalizedSegments;
 }
+function normalizeContourSegments(normalizedSegments, contourData) {
+    const { geometryIds } = contourData;
+    geometryIds?.forEach((geometryId) => {
+        const geometry = cache.getGeometry(geometryId);
+        if (geometry?.data) {
+            const { segmentIndex } = geometry.data;
+            normalizedSegments[segmentIndex] = { segmentIndex };
+        }
+    });
+}
 function normalizeSurfaceSegments(normalizedSegments, surfaceData) {
     const { geometryIds } = surfaceData;
     geometryIds?.forEach((geometryId) => {

package/dist/esm/stateManagement/segmentation/internalAddSegmentationRepresentation.js

@@ -4,6 +4,7 @@ import { SegmentationRepresentations } from '../../enums';
 import { triggerSegmentationModified } from './triggerSegmentationEvents';
 import { addColorLUT } from './addColorLUT';
 import { defaultSegmentationStateManager } from './SegmentationStateManager';
+import { getActiveSegmentIndex, setActiveSegmentIndex } from './segmentIndex';
 function internalAddSegmentationRepresentation(viewportId, representationInput) {
     const { segmentationId, config } = representationInput;
     const renderingConfig = {
@@ -11,6 +12,16 @@ function internalAddSegmentationRepresentation(viewportId, representationInput)
         ...config,
     };
     defaultSegmentationStateManager.addSegmentationRepresentation(viewportId, segmentationId, representationInput.type, renderingConfig);
+    if (!getActiveSegmentIndex(segmentationId)) {
+        const segmentation = defaultSegmentationStateManager.getSegmentation(segmentationId);
+        if (segmentation) {
+            const segmentKeys = Object.keys(segmentation.segments);
+            if (segmentKeys.length > 0) {
+                const firstSegmentIndex = segmentKeys.map((k) => Number(k)).sort()[0];
+                setActiveSegmentIndex(segmentationId, firstSegmentIndex);
+            }
+        }
+    }
     if (representationInput.type === SegmentationRepresentations.Contour) {
         triggerAnnotationRenderForViewportIds([viewportId]);
     }

package/dist/esm/store/ToolGroupManager/ToolGroup.js

@@ -91,10 +91,7 @@ export default class ToolGroup {
             });
         }
         const toolName = this.getActivePrimaryMouseButtonTool();
-        const runtimeSettings = Settings.getRuntimeSettings();
-        if (runtimeSettings.get('useCursors')) {
-            this.setViewportsCursorByToolName(toolName);
-        }
+        this.setViewportsCursorByToolName(toolName);
         const eventDetail = {
             toolGroupId: this.id,
             viewportId,
@@ -190,18 +187,16 @@ export default class ToolGroup {
         };
         this.toolOptions[toolName] = toolOptions;
         this._toolInstances[toolName].mode = Active;
-        const runtimeSettings = Settings.getRuntimeSettings();
-        const useCursor = runtimeSettings.get('useCursors');
-        if (this._hasMousePrimaryButtonBinding(toolBindingsOptions) && useCursor) {
-            this.setViewportsCursorByToolName(toolName);
-        }
-        else {
+        if (!this._hasMousePrimaryButtonBinding(toolBindingsOptions)) {
             const activeToolIdentifier = this.getActivePrimaryMouseButtonTool();
-            if (!activeToolIdentifier && useCursor) {
+            if (!activeToolIdentifier) {
                 const cursor = MouseCursor.getDefinedCursor('default');
                 this._setCursorForViewports(cursor);
             }
         }
+        else {
+            this.setViewportsCursorByToolName(toolName);
+        }
         if (this._hasMousePrimaryButtonBinding(toolBindingsOptions)) {
             if (this.prevActivePrimaryToolName === null) {
                 this.prevActivePrimaryToolName = toolName;
@@ -331,6 +326,10 @@ export default class ToolGroup {
         return MouseCursor.getDefinedCursor('default');
     }
     _setCursorForViewports(cursor) {
+        const runtimeSettings = Settings.getRuntimeSettings();
+        if (!runtimeSettings.get('useCursors')) {
+            return;
+        }
         this.viewportsInfo.forEach(({ renderingEngineId, viewportId }) => {
             const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
             if (!enabledElement) {

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

@@ -1,18 +1,19 @@
 import { AnnotationTool } from './base';
 import type { Types } from '@cornerstonejs/core';
-import type { Annotation, Annotations, EventTypes, ToolHandle, PublicToolProps, ToolProps, InteractionTypes, SVGDrawingHelper } from '../types';
-interface CrosshairsAnnotation extends Annotation {
-    data: {
-        handles: {
-            rotationPoints: Types.Point3[];
-            slabThicknessPoints: Types.Point3[];
-            activeOperation: number | null;
-            toolCenter: Types.Point3;
-        };
-        activeViewportIds: string[];
-        viewportId: string;
+import type { Annotation, AnnotationData, Annotations, EventTypes, ToolHandle, PublicToolProps, ToolProps, InteractionTypes, SVGDrawingHelper } from '../types';
+export type CrosshairsAnnotationData = AnnotationData & {
+    handles: {
+        rotationPoints: Types.Point3[];
+        slabThicknessPoints: Types.Point3[];
+        activeOperation: number | null;
+        toolCenter: Types.Point3;
     };
-}
+    activeViewportIds: string[];
+    viewportId: string;
+};
+export type CrosshairsAnnotation = Annotation & {
+    data: CrosshairsAnnotationData;
+};
 declare class CrosshairsTool extends AnnotationTool {
     static toolName: any;
     toolCenter: Types.Point3;

package/dist/esm/tools/CrosshairsTool.js

@@ -32,7 +32,6 @@ const OPERATION = {
     ROTATE: 2,
     SLAB: 3,
 };
-const EPSILON = 1e-3;
 class CrosshairsTool extends AnnotationTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse'],
@@ -51,12 +50,14 @@ class CrosshairsTool extends AnnotationTool {
             handleRadius: 3,
             enableHDPIHandles: false,
             referenceLinesCenterGapRadius: 20,
+            referenceLinesCenterGapRatio: null,
             filterActorUIDsToSetSlabThickness: [],
             slabThicknessBlendMode: Enums.BlendModes.MAXIMUM_INTENSITY_BLEND,
             mobile: {
                 enabled: false,
                 opacity: 0.8,
                 handleRadius: 9,
+                referenceLinesCenterGapRatio: 0.05,
             },
         },
     }) {
@@ -384,7 +385,13 @@ class CrosshairsTool extends AnnotationTool {
                 const canvasVectorFromCenterShort = vec2.create();
                 vec2.scale(canvasVectorFromCenterShort, canvasUnitVectorFromCenter, canvasMinDimensionLength * 0.2);
                 const canvasVectorFromCenterStart = vec2.create();
-                const centerGap = this.configuration.referenceLinesCenterGapRadius;
+                const mobileConfig = this.configuration.mobile;
+                const { referenceLinesCenterGapRatio } = mobileConfig?.enabled
+                    ? mobileConfig
+                    : this.configuration;
+                const centerGap = referenceLinesCenterGapRatio > 0
+                    ? canvasMinDimensionLength * referenceLinesCenterGapRatio
+                    : this.configuration.referenceLinesCenterGapRadius;
                 vec2.scale(canvasVectorFromCenterStart, canvasUnitVectorFromCenter, otherViewportAnnotations.length === 2 ? centerGap : 0);
                 const refLinePointOne = vec2.create();
                 const refLinePointTwo = vec2.create();
@@ -1044,7 +1051,7 @@ class CrosshairsTool extends AnnotationTool {
                         ];
                         const viewportDraggableRotatable = this._getReferenceLineDraggableRotatable(otherViewport.id);
                         if (!viewportDraggableRotatable) {
-                            const { rotationPoints } = this.editData.annotation.data.handles;
+                            const { rotationPoints } = (this.editData.annotation.data).handles;
                             const otherViewportRotationPoints = rotationPoints.filter((point) => point[1].uid === otherViewport.id);
                             if (otherViewportRotationPoints.length === 2) {
                                 const point1 = viewport.canvasToWorld(otherViewportRotationPoints[0][3]);

package/dist/esm/tools/OrientationMarkerTool.js

@@ -159,7 +159,8 @@ class OrientationMarkerTool extends BaseTool {
             actor?.delete();
             const renderWindow = viewport
                 .getRenderingEngine()
-                .offscreenMultiRenderWindow.getRenderWindow();
+                .getOffscreenMultiRenderWindow(viewport.id)
+                .getRenderWindow();
             renderWindow.render();
             viewport.getRenderingEngine().render();
             delete this.orientationMarkers[viewport.id];
@@ -204,7 +205,8 @@ class OrientationMarkerTool extends BaseTool {
             const renderer = viewport.getRenderer();
             const renderWindow = viewport
                 .getRenderingEngine()
-                .offscreenMultiRenderWindow.getRenderWindow();
+                .getOffscreenMultiRenderWindow(viewportId)
+                .getRenderWindow();
             const { enabled, viewportCorner, viewportSize, minPixelSize, maxPixelSize, } = this.configuration.orientationWidget;
             const orientationWidget = vtkOrientationMarkerWidget.newInstance({
                 actor,

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

@@ -1,12 +1,12 @@
 import type { Types } from '@cornerstonejs/core';
 import type { PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../types';
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
-export interface OverlayGridAnnotation extends Annotation {
+export type OverlayGridAnnotation = Annotation & {
     data: {
         viewportData: Map<string, object>;
         pointSets: Array<object>;
     };
-}
+};
 declare class OverlayGridTool extends AnnotationDisplayTool {
     static toolName: any;
     _throttledCalculateCachedStats: Function;

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

@@ -1,12 +1,15 @@
 import type { Types } from '@cornerstonejs/core';
-import type { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import type { PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../types';
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
-import type { Annotation } from '../types';
-export interface SegmentationIntersectionAnnotation extends Annotation {
+export type WorldPointSet = {
+    worldPointsSet: any;
+    color: any;
+};
+export type SegmentationIntersectionAnnotation = Annotation & {
     data: {
-        actorsWorldPointsMap: Map<string, Map<string, object>>;
+        actorsWorldPointsMap: Map<string, Map<string, WorldPointSet>>;
     };
-}
+};
 declare class SegmentationIntersectionTool extends AnnotationDisplayTool {
     static toolName: any;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);

package/dist/esm/tools/SegmentationIntersectionTool.js

@@ -60,7 +60,7 @@ class SegmentationIntersectionTool extends AnnotationDisplayTool {
             }
             const annotation = annotations[0];
             const { annotationUID } = annotation;
-            const actorsWorldPointsMap = annotation.data.actorsWorldPointsMap;
+            const actorsWorldPointsMap = (annotation).data.actorsWorldPointsMap;
             calculateSurfaceSegmentationIntersectionsForViewport(actorsWorldPointsMap, viewport);
             const actorEntries = viewport.getActors();
             const cacheId = getCacheId(viewport);

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

@@ -0,0 +1,91 @@
+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';
+type ReferenceLine = [
+    viewport: {
+        id: string;
+        canvas?: HTMLCanvasElement;
+        canvasToWorld?: (...args: unknown[]) => Types.Point3;
+    },
+    startPoint: Types.Point2,
+    endPoint: Types.Point2,
+    type: 'min' | 'max'
+];
+interface VolumeCroppingAnnotation extends Annotation {
+    data: {
+        handles: {
+            activeOperation: number | null;
+            toolCenter: Types.Point3;
+            toolCenterMin: Types.Point3;
+            toolCenterMax: Types.Point3;
+        };
+        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;
+    _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;
+    };
+    _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;
+    addNewAnnotation(evt: EventTypes.InteractionEventType): VolumeCroppingAnnotation;
+    cancel: () => void;
+    isPointNearTool: (element: HTMLDivElement, annotation: VolumeCroppingAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
+    toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: Annotation, interactionType: InteractionTypes) => void;
+    handleSelectedCallback(evt: EventTypes.InteractionEventType, annotation: Annotation, handle: ToolHandle, interactionType: InteractionTypes): void;
+    onResetCamera: (evt: any) => void;
+    mouseMoveCallback: (evt: EventTypes.MouseMoveEventType, filteredToolAnnotations: Annotations) => boolean;
+    filterInteractableAnnotationsForElement: (element: any, annotations: any) => any;
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+    _getAnnotations: (enabledElement: Types.IEnabledElement) => Annotation[];
+    _onSphereMoved: (evt: any) => void;
+    _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;