@cornerstonejs/tools 2.0.0-beta.8 → 2.0.0

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

@@ -0,0 +1,73 @@
+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;
+    };
+}
+declare class CrosshairsTool extends AnnotationTool {
+    static toolName: any;
+    toolCenter: Types.Point3;
+    _getReferenceLineColor?: (viewportId: string) => string;
+    _getReferenceLineControllable?: (viewportId: string) => boolean;
+    _getReferenceLineDraggableRotatable?: (viewportId: string) => boolean;
+    _getReferenceLineSlabThicknessControlsOn?: (viewportId: string) => boolean;
+    editData: {
+        annotation: Annotation;
+    } | null;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    initializeViewport: ({ renderingEngineId, viewportId, }: Types.IViewportId) => {
+        normal: Types.Point3;
+        point: Types.Point3;
+    };
+    _getViewportsInfo: () => any[];
+    onSetToolActive(): void;
+    onSetToolPassive(): void;
+    onSetToolEnabled(): void;
+    onSetToolDisabled(): void;
+    resetCrosshairs: () => void;
+    computeToolCenter: (viewportsInfo: any) => void;
+    addNewAnnotation: (evt: EventTypes.InteractionEventType) => CrosshairsAnnotation;
+    cancel: () => void;
+    getHandleNearImagePoint(element: HTMLDivElement, annotation: Annotation, canvasCoords: Types.Point2, proximity: number): ToolHandle | undefined;
+    handleSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: Annotation) => void;
+    isPointNearTool: (element: HTMLDivElement, annotation: CrosshairsAnnotation, canvasCoords: Types.Point2, proximity: number) => boolean;
+    toolSelectedCallback: (evt: EventTypes.InteractionEventType, annotation: Annotation, interactionType: InteractionTypes) => void;
+    onCameraModified: (evt: any) => 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[];
+    _onNewVolume: () => void;
+    _unsubscribeToViewportNewVolumeSet(viewportsInfo: any): void;
+    _subscribeToViewportNewVolumeSet(viewports: any): void;
+    _autoPanViewportIfNecessary(viewportId: string, renderingEngine: Types.IRenderingEngine): void;
+    _areViewportIdArraysEqual: (viewportIdArrayOne: any, viewportIdArrayTwo: any) => boolean;
+    _getAnnotationsForViewportsWithDifferentCameras: (enabledElement: any, annotations: any) => any;
+    _filterViewportWithSameOrientation: (enabledElement: any, referenceAnnotation: any, annotations: any) => any;
+    _filterAnnotationsByUniqueViewportOrientations: (enabledElement: any, annotations: any) => any[];
+    _checkIfViewportsRenderingSameScene: (viewport: any, otherViewport: any) => boolean;
+    _jump: (enabledElement: any, jumpWorld: any) => boolean;
+    _activateModify: (element: any) => void;
+    _deactivateModify: (element: any) => void;
+    _endCallback: (evt: EventTypes.InteractionEventType) => void;
+    _dragCallback: (evt: EventTypes.InteractionEventType) => void;
+    setSlabThickness(viewport: any, slabThickness: any): void;
+    _isClockWise(a: any, b: any, c: any): boolean;
+    _applyDeltaShiftToSelectedViewportCameras(renderingEngine: any, viewportsAnnotationsToUpdate: any, delta: any): void;
+    _applyDeltaShiftToViewportCamera(renderingEngine: Types.IRenderingEngine, annotation: any, delta: any): void;
+    _pointNearReferenceLine: (annotation: any, canvasCoords: any, proximity: any, lineViewport: any) => boolean;
+    _getRotationHandleNearImagePoint(viewport: any, annotation: any, canvasCoords: any, proximity: any): any;
+    _getSlabThicknessHandleNearImagePoint(viewport: any, annotation: any, canvasCoords: any, proximity: any): any;
+    _pointNearTool(element: any, annotation: any, canvasCoords: any, proximity: any): boolean;
+}
+export default CrosshairsTool;

package/dist/esm/tools/CrosshairsTool.js

@@ -2,11 +2,11 @@ import { vec2, vec3 } from 'gl-matrix';
 import vtkMath from '@kitware/vtk.js/Common/Core/Math';
 import vtkMatrixBuilder from '@kitware/vtk.js/Common/Core/MatrixBuilder';
 import { AnnotationTool } from './base';
-import { getEnabledElementByIds, getEnabledElement, utilities as csUtils, Enums, } from '@cornerstonejs/core';
+import { getEnabledElementByIds, getEnabledElement, utilities as csUtils, Enums, CONSTANTS, } from '@cornerstonejs/core';
 import { getToolGroup, getToolGroupForViewport, } from '../store/ToolGroupManager';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../stateManagement/annotation/annotationState';
 import { drawCircle as drawCircleSvg, drawHandles as drawHandlesSvg, drawLine as drawLineSvg, } from '../drawingSvg';
-import { state } from '../store';
+import { state } from '../store/state';
 import { Events } from '../enums';
 import { getViewportIdsWithToolToRender } from '../utilities/viewportFilters';
 import { resetElementCursor, hideElementCursor, } from '../cursors/elementCursor';
@@ -14,7 +14,6 @@ import liangBarksyClip from '../utilities/math/vec2/liangBarksyClip';
 import * as lineSegment from '../utilities/math/line';
 import { isAnnotationLocked } from '../stateManagement/annotation/annotationLocking';
 import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
-import { CONSTANTS } from '@cornerstonejs/core';
 const { RENDERING_DEFAULTS } = CONSTANTS;
 function defaultReferenceLineColor() {
     return 'rgb(0, 200, 0)';
@@ -105,15 +104,22 @@ class CrosshairsTool extends AnnotationTool {
         };
         this.resetCrosshairs = () => {
             const viewportsInfo = this._getViewportsInfo();
-            viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+            for (const viewportInfo of viewportsInfo) {
+                const { viewportId, renderingEngineId } = viewportInfo;
                 const enabledElement = getEnabledElementByIds(viewportId, renderingEngineId);
-                const { viewport } = enabledElement;
+                const viewport = enabledElement.viewport;
                 const resetPan = true;
                 const resetZoom = true;
                 const resetToCenter = true;
                 const resetRotation = true;
-                const supressEvents = true;
-                viewport.resetCamera(resetPan, resetZoom, resetToCenter, resetRotation, supressEvents);
+                const suppressEvents = true;
+                viewport.resetCamera({
+                    resetPan,
+                    resetZoom,
+                    resetToCenter,
+                    resetRotation,
+                    suppressEvents,
+                });
                 viewport.resetSlabThickness();
                 const { element } = viewport;
                 let annotations = this._getAnnotations(enabledElement);
@@ -122,7 +128,7 @@ class CrosshairsTool extends AnnotationTool {
                     removeAnnotation(annotations[0].annotationUID);
                 }
                 viewport.render();
-            });
+            }
             this.computeToolCenter(viewportsInfo);
         };
         this.computeToolCenter = (viewportsInfo) => {
@@ -148,8 +154,7 @@ class CrosshairsTool extends AnnotationTool {
             const secondPlane = csUtils.planar.planeEquation(normal2, point2);
             const thirdPlane = csUtils.planar.planeEquation(normal3, point3);
             this.toolCenter = csUtils.planar.threePlaneIntersection(firstPlane, secondPlane, thirdPlane);
-            const { renderingEngine } = getEnabledElementByIds(viewportsInfo[0].viewportId, viewportsInfo[0].renderingEngineId);
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportsInfo.map(({ viewportId }) => viewportId));
+            triggerAnnotationRenderForViewportIds(viewportsInfo.map(({ viewportId }) => viewportId));
         };
         this.addNewAnnotation = (evt) => {
             const eventDetail = evt.detail;
@@ -257,7 +262,7 @@ class CrosshairsTool extends AnnotationTool {
             }
             const requireSameOrientation = false;
             const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName(), requireSameOrientation);
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this.onResetCamera = (evt) => {
             this.resetCrosshairs();
@@ -268,7 +273,7 @@ class CrosshairsTool extends AnnotationTool {
             let imageNeedsUpdate = false;
             for (let i = 0; i < filteredToolAnnotations.length; i++) {
                 const annotation = filteredToolAnnotations[i];
-                if (isAnnotationLocked(annotation)) {
+                if (isAnnotationLocked(annotation.annotationUID)) {
                     continue;
                 }
                 const { data, highlighted } = annotation;
@@ -667,7 +672,7 @@ class CrosshairsTool extends AnnotationTool {
             });
             return toolGroupAnnotations;
         };
-        this._onNewVolume = (e) => {
+        this._onNewVolume = () => {
             const viewportsInfo = this._getViewportsInfo();
             this.computeToolCenter(viewportsInfo);
         };
@@ -897,11 +902,9 @@ class CrosshairsTool extends AnnotationTool {
             this._deactivateModify(element);
             resetElementCursor(element);
             this.editData = null;
-            const enabledElement = getEnabledElement(element);
-            const { renderingEngine } = enabledElement;
             const requireSameOrientation = false;
             const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName(), requireSameOrientation);
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this._dragCallback = (evt) => {
             const eventDetail = evt.detail;
@@ -1442,4 +1445,3 @@ class CrosshairsTool extends AnnotationTool {
 }
 CrosshairsTool.toolName = 'Crosshairs';
 export default CrosshairsTool;
-//# sourceMappingURL=CrosshairsTool.js.map

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

@@ -0,0 +1,8 @@
+import { BaseTool } from './base';
+import type { PublicToolProps, ToolProps } from '../types';
+declare class MIPJumpToClickTool extends BaseTool {
+    static toolName: any;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    mouseClickCallback(evt: any): void;
+}
+export default MIPJumpToClickTool;

package/dist/esm/tools/MIPJumpToClickTool.js

@@ -2,7 +2,6 @@ import { BaseTool } from './base';
 import { getEnabledElement, VolumeViewport } from '@cornerstonejs/core';
 import { utilities } from '@cornerstonejs/core';
 import { getPointInLineOfSightWithCriteria } from '../utilities/planar';
-import jumpToWorld from '../utilities/viewport/jumpToWorld';
 import { getToolGroupForViewport } from '../store/ToolGroupManager';
 class MIPJumpToClickTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -17,11 +16,10 @@ class MIPJumpToClickTool extends BaseTool {
         const { element, currentPoints } = evt.detail;
         const enabledElement = getEnabledElement(element);
         const { viewport, renderingEngine } = enabledElement;
-        const targetId = this.getTargetId(viewport);
-        if (!targetId.startsWith('volumeId')) {
+        const volumeId = viewport.getVolumeId();
+        if (!volumeId) {
             throw new Error(`MIPJumpToClickTool: targetId is not a volumeId, you should only use MIPJumpToClickTool with a volumeId as the targetId`);
         }
-        const volumeId = utilities.getVolumeId(targetId);
         let maxIntensity = -Infinity;
         const maxFn = (intensity, point) => {
             if (intensity > maxIntensity) {
@@ -46,7 +44,7 @@ class MIPJumpToClickTool extends BaseTool {
         });
         viewports.forEach((viewport) => {
             if (viewport instanceof VolumeViewport) {
-                jumpToWorld(viewport, brightestPoint);
+                viewport.jumpToWorld(brightestPoint);
             }
             else {
                 console.warn('Cannot jump to specified world coordinates for a viewport that is not a VolumeViewport');
@@ -56,4 +54,3 @@ class MIPJumpToClickTool extends BaseTool {
 }
 MIPJumpToClickTool.toolName = 'MIPJumpToClickTool';
 export default MIPJumpToClickTool;
-//# sourceMappingURL=MIPJumpToClickTool.js.map

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

@@ -0,0 +1,25 @@
+import { BaseTool } from './base';
+import type { Types } from '@cornerstonejs/core';
+import type { EventTypes, PublicToolProps, ToolProps } from '../types';
+import type { IPoints } from '../types';
+declare class MagnifyTool extends BaseTool {
+    static toolName: any;
+    editData: {
+        referencedImageId: string;
+        viewportIdsToRender: string[];
+        enabledElement: Types.IEnabledElement;
+        renderingEngine: Types.IRenderingEngine;
+        currentPoints: IPoints;
+    } | null;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    private _hasBeenRemoved;
+    _getReferencedImageId(viewport: Types.IStackViewport | Types.IVolumeViewport): string;
+    preMouseDownCallback: (evt: EventTypes.InteractionEventType) => boolean;
+    preTouchStartCallback: (evt: EventTypes.InteractionEventType) => void;
+    _createMagnificationViewport: () => void;
+    _dragCallback: (evt: EventTypes.InteractionEventType) => void;
+    _dragEndCallback: (evt: EventTypes.InteractionEventType) => void;
+    _activateDraw: (element: HTMLDivElement) => void;
+    _deactivateDraw: (element: HTMLDivElement) => void;
+}
+export default MagnifyTool;

package/dist/esm/tools/MagnifyTool.js

@@ -3,7 +3,7 @@ import { Events } from '../enums';
 import { getEnabledElement, StackViewport } from '@cornerstonejs/core';
 import { getViewportIdsWithToolToRender } from '../utilities/viewportFilters';
 import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
-import { state } from '../store';
+import { state } from '../store/state';
 import { Enums } from '@cornerstonejs/core';
 import { hideElementCursor, resetElementCursor, } from '../cursors/elementCursor';
 const MAGNIFY_VIEWPORT_ID = 'magnify-viewport';
@@ -42,7 +42,7 @@ class MagnifyTool extends BaseTool {
             this._activateDraw(element);
             hideElementCursor(element);
             evt.preventDefault();
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
             return true;
         };
         this.preTouchStartCallback = (evt) => {
@@ -104,7 +104,7 @@ class MagnifyTool extends BaseTool {
                 magnifyViewport.render();
             });
             magnifyToolElement.style.display = 'block';
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this._dragCallback = (evt) => {
             const eventDetail = evt.detail;
@@ -178,4 +178,3 @@ class MagnifyTool extends BaseTool {
 }
 MagnifyTool.toolName = 'Magnify';
 export default MagnifyTool;
-//# sourceMappingURL=MagnifyTool.js.map

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

@@ -0,0 +1,77 @@
+import vtkAnnotatedCubeActor from '@kitware/vtk.js/Rendering/Core/AnnotatedCubeActor';
+import { BaseTool } from './base';
+declare enum OverlayMarkerType {
+    ANNOTATED_CUBE = 1,
+    AXES = 2,
+    CUSTOM = 3
+}
+type FaceProperty = {
+    text?: string;
+    faceColor?: string;
+    fontColor?: string;
+    faceRotation?: number;
+};
+type AnnotatedCubeConfig = {
+    faceProperties: {
+        xPlus: FaceProperty;
+        xMinus: FaceProperty;
+        yPlus: FaceProperty;
+        yMinus: FaceProperty;
+        zPlus: FaceProperty;
+        zMinus: FaceProperty;
+    };
+    defaultStyle: {
+        fontStyle?: string;
+        fontFamily?: string;
+        fontColor?: string;
+        fontSizeScale?: (res: number) => number;
+        faceColor?: string;
+        edgeThickness?: number;
+        edgeColor?: string;
+        resolution?: number;
+    };
+};
+type OverlayConfiguration = {
+    [OverlayMarkerType.ANNOTATED_CUBE]: AnnotatedCubeConfig;
+    [OverlayMarkerType.AXES]: Record<string, never>;
+    [OverlayMarkerType.CUSTOM]: {
+        polyDataURL: string;
+    };
+};
+declare class OrientationMarkerTool extends BaseTool {
+    static toolName: any;
+    static CUBE: number;
+    static AXIS: number;
+    static VTPFILE: number;
+    orientationMarkers: any;
+    polyDataURL: any;
+    _resizeObservers: Map<any, any>;
+    static OVERLAY_MARKER_TYPES: typeof OverlayMarkerType;
+    constructor(toolProps?: {}, defaultToolProps?: {
+        configuration: {
+            orientationWidget: {
+                enabled: boolean;
+                viewportCorner: import("@kitware/vtk.js/Interaction/Widgets/OrientationMarkerWidget/Constants").Corners;
+                viewportSize: number;
+                minPixelSize: number;
+                maxPixelSize: number;
+            };
+            overlayMarkerType: OverlayMarkerType;
+            overlayConfiguration: OverlayConfiguration;
+        };
+    });
+    onSetToolEnabled: () => void;
+    onSetToolActive: () => void;
+    onSetToolDisabled: () => void;
+    _getViewportsInfo: () => any[];
+    resize: (viewportId: any) => void;
+    _unsubscribeToViewportNewVolumeSet(): void;
+    _subscribeToViewportEvents(): void;
+    private cleanUpData;
+    private initViewports;
+    addAxisActorInViewport(viewport: any): Promise<void>;
+    private createCustomActor;
+    private createAnnotationCube;
+    createAnnotatedCubeActor(): Promise<vtkAnnotatedCubeActor>;
+}
+export default OrientationMarkerTool;

package/dist/esm/tools/OrientationMarkerTool.js

@@ -10,11 +10,12 @@ import { Enums, eventTarget, getEnabledElementByIds, getRenderingEngines, } from
 import { filterViewportsWithToolEnabled } from '../utilities/viewportFilters';
 import { getToolGroup } from '../store/ToolGroupManager';
 import { Events } from '../enums';
-const OverlayMarkerType = {
-    ANNOTATED_CUBE: 1,
-    AXES: 2,
-    CUSTOM: 3,
-};
+var OverlayMarkerType;
+(function (OverlayMarkerType) {
+    OverlayMarkerType[OverlayMarkerType["ANNOTATED_CUBE"] = 1] = "ANNOTATED_CUBE";
+    OverlayMarkerType[OverlayMarkerType["AXES"] = 2] = "AXES";
+    OverlayMarkerType[OverlayMarkerType["CUSTOM"] = 3] = "CUSTOM";
+})(OverlayMarkerType || (OverlayMarkerType = {}));
 class OrientationMarkerTool extends BaseTool {
     static { this.CUBE = 1; }
     static { this.AXIS = 2; }
@@ -33,8 +34,8 @@ class OrientationMarkerTool extends BaseTool {
             overlayConfiguration: {
                 [OrientationMarkerTool.OVERLAY_MARKER_TYPES.ANNOTATED_CUBE]: {
                     faceProperties: {
-                        xPlus: { text: 'R', faceColor: '#ffff00', faceRotation: 90 },
-                        xMinus: { text: 'L', faceColor: '#ffff00', faceRotation: 270 },
+                        xPlus: { text: 'L', faceColor: '#ffff00', faceRotation: 90 },
+                        xMinus: { text: 'R', faceColor: '#ffff00', faceRotation: 270 },
                         yPlus: {
                             text: 'P',
                             faceColor: '#00ffff',
@@ -275,4 +276,3 @@ class OrientationMarkerTool extends BaseTool {
 }
 OrientationMarkerTool.toolName = 'OrientationMarker';
 export default OrientationMarkerTool;
-//# sourceMappingURL=OrientationMarkerTool.js.map

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

@@ -0,0 +1,29 @@
+import type { Types } from '@cornerstonejs/core';
+import type { PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../types';
+import AnnotationDisplayTool from './base/AnnotationDisplayTool';
+export interface OverlayGridAnnotation extends Annotation {
+    data: {
+        viewportData: Map<string, object>;
+        pointSets: Array<object>;
+    };
+}
+declare class OverlayGridTool extends AnnotationDisplayTool {
+    static toolName: any;
+    _throttledCalculateCachedStats: Function;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    onSetToolEnabled: () => void;
+    onSetToolActive: () => void;
+    _init: () => void;
+    calculateImageIdPointSets: (imageId: string) => {
+        pointSet1: Types.Point3[];
+        pointSet2: Types.Point3[];
+    };
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+    private initializeViewportData;
+    private isPerpendicular;
+    private isParallel;
+    private getImageIdNormal;
+}
+export default OverlayGridTool;

package/dist/esm/tools/OverlayGridTool.js

@@ -57,7 +57,7 @@ class OverlayGridTool extends AnnotationDisplayTool {
                 };
                 addAnnotation(newAnnotation, frameOfReferenceUID);
             }
-            triggerAnnotationRenderForViewportIds(getRenderingEngine(viewportsInfo[0].renderingEngineId), viewportsInfo.map(({ viewportId }) => viewportId));
+            triggerAnnotationRenderForViewportIds(viewportsInfo.map(({ viewportId }) => viewportId));
         };
         this.calculateImageIdPointSets = (imageId) => {
             const { imagePositionPatient, rows, columns, rowCosines, columnCosines, rowPixelSpacing, columnPixelSpacing, } = metaData.get('imagePlaneModule', imageId);
@@ -162,4 +162,3 @@ class OverlayGridTool extends AnnotationDisplayTool {
 }
 OverlayGridTool.toolName = 'OverlayGrid';
 export default OverlayGridTool;
-//# sourceMappingURL=OverlayGridTool.js.map

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

@@ -0,0 +1,10 @@
+import { BaseTool } from './base';
+import type { EventTypes, PublicToolProps, ToolProps } from '../types';
+declare class PanTool extends BaseTool {
+    static toolName: any;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    touchDragCallback(evt: EventTypes.InteractionEventType): void;
+    mouseDragCallback(evt: EventTypes.InteractionEventType): void;
+    _dragCallback(evt: EventTypes.InteractionEventType): void;
+}
+export default PanTool;

package/dist/esm/tools/PanTool.js

@@ -16,6 +16,11 @@ class PanTool extends BaseTool {
         const { element, deltaPoints } = evt.detail;
         const enabledElement = getEnabledElement(element);
         const deltaPointsWorld = deltaPoints.world;
+        if (deltaPointsWorld[0] === 0 &&
+            deltaPointsWorld[1] === 0 &&
+            deltaPointsWorld[2] === 0) {
+            return;
+        }
         const camera = enabledElement.viewport.getCamera();
         const { focalPoint, position } = camera;
         const updatedPosition = [
@@ -37,4 +42,3 @@ class PanTool extends BaseTool {
 }
 PanTool.toolName = 'Pan';
 export default PanTool;
-//# sourceMappingURL=PanTool.js.map

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

@@ -0,0 +1,12 @@
+import { BaseTool } from './base';
+import type { PublicToolProps, ToolProps, EventTypes } from '../types';
+declare class PlanarRotateTool extends BaseTool {
+    static toolName: any;
+    touchDragCallback: (evt: EventTypes.MouseDragEventType) => void;
+    mouseDragCallback: (evt: EventTypes.MouseDragEventType) => void;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    mouseWheelCallback: (evt: EventTypes.MouseWheelEventType) => void;
+    _dragCallback(evt: EventTypes.MouseDragEventType): void;
+    setAngle(viewport: any, angle: any): void;
+}
+export default PlanarRotateTool;

package/dist/esm/tools/PlanarRotateTool.js

@@ -1,4 +1,4 @@
-import { BaseVolumeViewport, getEnabledElement, } from '@cornerstonejs/core';
+import { BaseVolumeViewport, getEnabledElement } from '@cornerstonejs/core';
 import { mat4, vec3 } from 'gl-matrix';
 import { BaseTool } from './base';
 import angleBetweenLines from '../utilities/math/angle/angleBetweenLines';
@@ -7,6 +7,14 @@ class PlanarRotateTool extends BaseTool {
         supportedInteractionTypes: ['Mouse', 'Touch'],
     }) {
         super(toolProps, defaultToolProps);
+        this.mouseWheelCallback = (evt) => {
+            const { element, wheel } = evt.detail;
+            const enabledElement = getEnabledElement(element);
+            const { viewport } = enabledElement;
+            const { invert } = this.configuration;
+            const angle = wheel.direction * 10 * (invert ? -1 : 1);
+            this.setAngle(viewport, angle);
+        };
         this.touchDragCallback = this._dragCallback.bind(this);
         this.mouseDragCallback = this._dragCallback.bind(this);
     }
@@ -22,7 +30,7 @@ class PlanarRotateTool extends BaseTool {
         const centerCanvas = [width * 0.5, height * 0.5];
         const centerWorld = viewport.canvasToWorld(centerCanvas);
         let angle = angleBetweenLines([startPointWorld, centerWorld], [centerWorld, currentPointWorld]);
-        const { viewPlaneNormal, viewUp } = camera;
+        const { viewPlaneNormal } = camera;
         const v1 = vec3.sub(vec3.create(), centerWorld, startPointWorld);
         const v2 = vec3.sub(vec3.create(), centerWorld, currentPointWorld);
         const cross = vec3.cross(vec3.create(), v1, v2);
@@ -32,20 +40,25 @@ class PlanarRotateTool extends BaseTool {
         if (Number.isNaN(angle)) {
             return;
         }
+        this.setAngle(viewport, angle);
+    }
+    setAngle(viewport, angle) {
+        const { viewPlaneNormal, viewUp } = viewport.getCamera();
         if (viewport instanceof BaseVolumeViewport) {
-            const rotAngle = (angle * Math.PI) / 180;
+            const rotAngle = (((angle + 360) % 360) * Math.PI) / 180;
             const rotMat = mat4.identity(new Float32Array(16));
             mat4.rotate(rotMat, rotMat, rotAngle, viewPlaneNormal);
             const rotatedViewUp = vec3.transformMat4(vec3.create(), viewUp, rotMat);
             viewport.setCamera({ viewUp: rotatedViewUp });
         }
         else {
-            const { rotation } = viewport.getProperties();
-            viewport.setProperties({ rotation: rotation + angle });
+            const { rotation } = viewport.getViewPresentation();
+            viewport.setViewPresentation({
+                rotation: (rotation + angle + 360) % 360,
+            });
         }
         viewport.render();
     }
 }
 PlanarRotateTool.toolName = 'PlanarRotate';
 export default PlanarRotateTool;
-//# sourceMappingURL=PlanarRotateTool.js.map

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

@@ -0,0 +1,24 @@
+import type { Types } from '@cornerstonejs/core';
+import type { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation, Annotations } from '../types';
+import AnnotationDisplayTool from './base/AnnotationDisplayTool';
+declare class ReferenceCursors extends AnnotationDisplayTool {
+    static toolName: any;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    _elementWithCursor: null | HTMLDivElement;
+    _currentCursorWorldPosition: null | Types.Point3;
+    _currentCanvasPosition: null | Types.Point2;
+    _disableCursorEnabled: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    mouseMoveCallback: (evt: EventTypes.InteractionEventType) => boolean;
+    onSetToolActive(): void;
+    onSetToolDisabled(): void;
+    createInitialAnnotation: (worldPos: Types.Point3, element: HTMLDivElement) => void;
+    getActiveAnnotation(element: HTMLDivElement): null | Annotation;
+    updateAnnotationPosition(element: HTMLDivElement, annotation: Annotation): void;
+    onCameraModified: (evt: Types.EventTypes.CameraModifiedEvent) => void;
+    filterInteractableAnnotationsForElement(element: HTMLDivElement, annotations: Annotations): Annotations;
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+    updateViewportImage(viewport: Types.IStackViewport | Types.IVolumeViewport): void;
+}
+export default ReferenceCursors;

package/dist/esm/tools/ReferenceCursors.js

@@ -92,7 +92,7 @@ class ReferenceCursors extends AnnotationDisplayTool {
                 return;
             }
             const viewportIdsToRender = getViewportIdsWithToolToRender(element, this.getToolName(), false);
-            triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+            triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this.onCameraModified = (evt) => {
             const eventDetail = evt.detail;
@@ -241,8 +241,7 @@ class ReferenceCursors extends AnnotationDisplayTool {
         if (!enabledElement) {
             return;
         }
-        const { renderingEngine } = enabledElement;
-        triggerAnnotationRenderForViewportIds(renderingEngine, viewportIdsToRender);
+        triggerAnnotationRenderForViewportIds(viewportIdsToRender);
     }
     filterInteractableAnnotationsForElement(element, annotations) {
         if (!(annotations instanceof Array) || annotations.length === 0) {
@@ -307,4 +306,3 @@ class ReferenceCursors extends AnnotationDisplayTool {
 }
 ReferenceCursors.toolName = 'ReferenceCursors';
 export default ReferenceCursors;
-//# sourceMappingURL=ReferenceCursors.js.map

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

@@ -0,0 +1,27 @@
+import { type Types } from '@cornerstonejs/core';
+import type { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import type { ReferenceLineAnnotation } from '../types/ToolSpecificAnnotationTypes';
+import AnnotationDisplayTool from './base/AnnotationDisplayTool';
+declare class ReferenceLines extends AnnotationDisplayTool {
+    static toolName: any;
+    _throttledCalculateCachedStats: Function;
+    editData: {
+        renderingEngine: Types.IRenderingEngine;
+        sourceViewportId: string;
+        annotation: ReferenceLineAnnotation;
+    } | null;
+    isDrawing: boolean;
+    isHandleOutsideImage: boolean;
+    constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
+    _init: () => void;
+    onSetToolEnabled: () => void;
+    onSetToolConfiguration: () => void;
+    onCameraModified: (evt: Types.EventTypes.CameraModifiedEvent) => void;
+    renderAnnotation: (enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper) => boolean;
+    isPerpendicular: (vec1: Types.Point3, vec2: Types.Point3) => boolean;
+    private handleFullDimension;
+    intersectInfiniteLines(line1Start: Types.Point2, line1End: Types.Point2, line2Start: Types.Point2, line2End: Types.Point2): number[];
+    isParallel(vec1: Types.Point3, vec2: Types.Point3): boolean;
+    isInBound(point: number[], dimensions: Types.Point3): boolean;
+}
+export default ReferenceLines;