@cornerstonejs/tools 2.0.0-beta.20 → 2.0.0-beta.21

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',

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

@@ -1,5 +1,5 @@
 import type { Types } from '@cornerstonejs/core';
-import { PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../types';
+import type { PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../types';
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
 export interface OverlayGridAnnotation extends Annotation {
     data: {
@@ -9,9 +9,7 @@ export interface OverlayGridAnnotation extends Annotation {
 }
 declare class OverlayGridTool extends AnnotationDisplayTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     isDrawing: boolean;
     isHandleOutsideImage: boolean;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);

package/dist/esm/tools/OverlayGridTool.js

@@ -1,5 +1,5 @@
 import { vec3 } from 'gl-matrix';
-import { metaData, CONSTANTS, utilities as csUtils, } from '@cornerstonejs/core';
+import { metaData, CONSTANTS, getRenderingEngine, utilities as csUtils, } from '@cornerstonejs/core';
 import { addAnnotation, getAnnotations, } from '../stateManagement/annotation/annotationState';
 import { getToolGroup } from '../store/ToolGroupManager';
 import { drawLine as drawLineSvg } from '../drawingSvg';

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

@@ -1,5 +1,5 @@
 import { BaseTool } from './base';
-import { EventTypes, PublicToolProps, ToolProps } from '../types';
+import type { EventTypes, PublicToolProps, ToolProps } from '../types';
 declare class PanTool extends BaseTool {
     static toolName: any;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);

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 = [

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

@@ -1,10 +1,12 @@
 import { BaseTool } from './base';
-import { PublicToolProps, ToolProps, EventTypes } from '../types';
+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,8 +40,12 @@ 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);
@@ -41,7 +53,9 @@ class PlanarRotateTool extends BaseTool {
         }
         else {
             const { rotation } = viewport.getViewPresentation();
-            viewport.setViewPresentation({ rotation: rotation + angle });
+            viewport.setViewPresentation({
+                rotation: (rotation + angle + 360) % 360,
+            });
         }
         viewport.render();
     }

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

@@ -1,11 +1,8 @@
 import type { Types } from '@cornerstonejs/core';
-import { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation, Annotations } from '../types';
+import type { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation, Annotations } from '../types';
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
 declare class ReferenceCursors extends AnnotationDisplayTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
     isDrawing: boolean;
     isHandleOutsideImage: boolean;
     _elementWithCursor: null | HTMLDivElement;
@@ -19,7 +16,7 @@ declare class ReferenceCursors extends AnnotationDisplayTool {
     createInitialAnnotation: (worldPos: Types.Point3, element: HTMLDivElement) => void;
     getActiveAnnotation(element: HTMLDivElement): null | Annotation;
     updateAnnotationPosition(element: HTMLDivElement, annotation: Annotation): void;
-    onCameraModified: (evt: any) => 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;

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

@@ -1,14 +1,12 @@
 import { type Types } from '@cornerstonejs/core';
-import { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
-import { ReferenceLineAnnotation } from '../types/ToolSpecificAnnotationTypes';
+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;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        renderingEngine: any;
+        renderingEngine: Types.IRenderingEngine;
         sourceViewportId: string;
         annotation: ReferenceLineAnnotation;
     } | null;

package/dist/esm/tools/ReferenceLinesTool.js

@@ -16,7 +16,7 @@ class ReferenceLines extends AnnotationDisplayTool {
         },
     }) {
         super(toolProps, defaultToolProps);
-        this.editData = {};
+        this.editData = null;
         this._init = () => {
             const renderingEngines = getRenderingEngines();
             const renderingEngine = renderingEngines[0];

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

@@ -1,15 +1,13 @@
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
-import { ScaleOverlayAnnotation } from '../types/ToolSpecificAnnotationTypes';
+import type { ScaleOverlayAnnotation } from '../types/ToolSpecificAnnotationTypes';
 import type { Types } from '@cornerstonejs/core';
-import { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import type { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
 declare class ScaleOverlayTool extends AnnotationDisplayTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        renderingEngine: any;
-        viewport: any;
+        renderingEngine: Types.IRenderingEngine;
+        viewport: Types.IViewport;
         annotation: ScaleOverlayAnnotation;
     } | null;
     isDrawing: boolean;
@@ -20,12 +18,12 @@ declare class ScaleOverlayTool extends AnnotationDisplayTool {
     onCameraModified: (evt: Types.EventTypes.CameraModifiedEvent) => void;
     renderAnnotation(enabledElement: Types.IEnabledElement, svgDrawingHelper: SVGDrawingHelper): boolean;
     _getTextLines(scaleSize: number): string[] | undefined;
-    computeScaleSize: (worldWidthViewport: number, worldHeightViewport: number, location: any) => any;
+    computeScaleSize: (worldWidthViewport: number, worldHeightViewport: number, location: string) => any;
     computeEndScaleTicks: (canvasCoordinates: any, location: any) => {
         endTick1: any[][];
         endTick2: any[][];
     };
-    computeInnerScaleTicks: (scaleSize: number, location: string, annotationUID: string, leftTick: any[][], rightTick: any[][]) => {
+    computeInnerScaleTicks: (scaleSize: number, location: string, annotationUID: string, leftTick: Types.Point2[], rightTick: Types.Point2[]) => {
         tickIds: any[];
         tickUIDs: any[];
         tickCoordinates: any[];

package/dist/esm/tools/ScaleOverlayTool.js

@@ -4,7 +4,6 @@ import { getEnabledElementByIds, getRenderingEngines, utilities as csUtils, } fr
 import { addAnnotation, getAnnotations, } from '../stateManagement/annotation/annotationState';
 import { drawLine as drawLineSvg, drawTextBox as drawTextBoxSvg, } from '../drawingSvg';
 import { getToolGroup } from '../store/ToolGroupManager';
-const SCALEOVERLAYTOOL_ID = 'scaleoverlay-viewport';
 const viewportsWithAnnotations = [];
 class ScaleOverlayTool extends AnnotationDisplayTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -14,7 +13,7 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
         },
     }) {
         super(toolProps, defaultToolProps);
-        this.editData = {};
+        this.editData = null;
         this._init = () => {
             const renderingEngines = getRenderingEngines();
             const renderingEngine = renderingEngines[0];

package/dist/esm/tools/SculptorTool/CircleSculptCursor.d.ts

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
-import { ISculptToolShape } from '../../types/ISculptToolShape';
-import { SculptData } from '../SculptorTool';
-import { SVGDrawingHelper, EventTypes, ContourAnnotationData } from '../../types';
+import type { ISculptToolShape } from '../../types/ISculptToolShape';
+import type { SculptData } from '../SculptorTool';
+import type { SVGDrawingHelper, EventTypes, ContourAnnotationData } from '../../types';
 export type PushedHandles = {
     first?: number;
     last?: number;
@@ -9,7 +9,7 @@ export type PushedHandles = {
 declare class CircleSculptCursor implements ISculptToolShape {
     static shapeName: string;
     private toolInfo;
-    renderShape(svgDrawingHelper: SVGDrawingHelper, canvasLocation: Types.Point2, options: any): void;
+    renderShape(svgDrawingHelper: SVGDrawingHelper, canvasLocation: Types.Point2, options: unknown): void;
     pushHandles(viewport: Types.IViewport, sculptData: SculptData): PushedHandles;
     configureToolSize(evt: EventTypes.InteractionEventType): void;
     updateToolSize(canvasCoords: Types.Point2, viewport: Types.IViewport, activeAnnotation: ContourAnnotationData): void;

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

@@ -1,6 +1,6 @@
 import type { Types } from '@cornerstonejs/core';
 import { BaseTool } from './base';
-import { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import type { EventTypes, PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
 import type { ISculptToolShape } from '../types/ISculptToolShape';
 export type SculptData = {
     mousePoint: Types.Point3;

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

@@ -1,7 +1,7 @@
 import type { Types } from '@cornerstonejs/core';
-import { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
+import type { PublicToolProps, ToolProps, SVGDrawingHelper } from '../types';
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
-import { Annotation } from '../types';
+import type { Annotation } from '../types';
 export interface SegmentationIntersectionAnnotation extends Annotation {
     data: {
         actorsWorldPointsMap: Map<string, Map<string, object>>;

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

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

package/dist/esm/tools/StackScrollTool.js

@@ -1,4 +1,4 @@
-import { getEnabledElementByIds, VolumeViewport } from '@cornerstonejs/core';
+import { getEnabledElementByIds, getEnabledElement, VolumeViewport, } from '@cornerstonejs/core';
 import { BaseTool } from './base';
 import { scroll } from '../utilities';
 class StackScrollTool extends BaseTool {
@@ -13,6 +13,21 @@ class StackScrollTool extends BaseTool {
         super(toolProps, defaultToolProps);
         this.deltaY = 1;
     }
+    mouseWheelCallback(evt) {
+        const { wheel, element } = evt.detail;
+        const { direction } = wheel;
+        const { invert } = this.configuration;
+        const { viewport } = getEnabledElement(element);
+        const delta = direction * (invert ? -1 : 1);
+        const volumeId = this.getTargetVolumeId(viewport);
+        scroll(viewport, {
+            delta,
+            debounceLoading: this.configuration.debounceIfNotLoaded,
+            loop: this.configuration.loop,
+            volumeId,
+            scrollSlabs: this.configuration.scrollSlabs,
+        });
+    }
     mouseDragCallback(evt) {
         this._dragCallback(evt);
     }
@@ -22,12 +37,11 @@ class StackScrollTool extends BaseTool {
     _dragCallback(evt) {
         const { deltaPoints, viewportId, renderingEngineId } = evt.detail;
         const { viewport } = getEnabledElementByIds(viewportId, renderingEngineId);
-        const targetId = this.getTargetId(viewport);
         const { debounceIfNotLoaded, invert, loop } = this.configuration;
         const deltaPointY = deltaPoints.canvas[1];
         let volumeId;
         if (viewport instanceof VolumeViewport) {
-            volumeId = targetId.split(/volumeId:|\?/)[1];
+            volumeId = this.getTargetVolumeId(viewport);
         }
         const pixelsPerImage = this._getPixelPerImage(viewport);
         const deltaY = deltaPointY + this.deltaY;

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

@@ -1,8 +1,7 @@
 import { BaseTool } from './base';
-import { MouseWheelEventType } from '../types/EventTypes';
+import type { MouseWheelEventType } from '../types/EventTypes';
 declare class StackScrollMouseWheelTool extends BaseTool {
     static toolName: any;
-    _configuration: any;
     constructor(toolProps?: {}, defaultToolProps?: {
         supportedInteractionTypes: string[];
         configuration: {

package/dist/esm/tools/StackScrollToolMouseWheelTool.js

@@ -19,8 +19,7 @@ class StackScrollMouseWheelTool extends BaseTool {
         const { invert } = this.configuration;
         const { viewport } = getEnabledElement(element);
         const delta = direction * (invert ? -1 : 1);
-        const targetId = this.getTargetId(viewport);
-        const volumeId = utilities.getVolumeId(targetId);
+        const volumeId = this.getTargetVolumeId(viewport);
         scroll(viewport, {
             delta,
             debounceLoading: this.configuration.debounceIfNotLoaded,

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

@@ -1,4 +1,4 @@
-import { EventTypes, PublicToolProps, ToolProps } from '../types';
+import type { EventTypes, PublicToolProps, ToolProps } from '../types';
 import { BaseTool } from './base';
 declare class TrackballRotateTool extends BaseTool {
     static toolName: any;

package/dist/esm/tools/TrackballRotateTool.js

@@ -22,6 +22,10 @@ class TrackballRotateTool extends BaseTool {
             const actorEntry = viewport.getDefaultActor();
             const actor = actorEntry.actor;
             const mapper = actor.getMapper();
+            const hasSampleDistance = 'getSampleDistance' in mapper || 'getCurrentSampleDistance' in mapper;
+            if (!hasSampleDistance) {
+                return true;
+            }
             const originalSampleDistance = mapper.getSampleDistance();
             if (!this._hasResolutionChanged) {
                 mapper.setSampleDistance(originalSampleDistance * 2);

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

@@ -1,9 +1,8 @@
 import { BaseTool } from './base';
-import { PublicToolProps, ToolProps } from '../types';
-import { MouseWheelEventType } from '../types/EventTypes';
+import type { PublicToolProps, ToolProps } from '../types';
+import type { MouseWheelEventType } from '../types/EventTypes';
 declare class VolumeRotateMouseWheelTool extends BaseTool {
     static toolName: any;
-    _configuration: any;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
     mouseWheelCallback(evt: MouseWheelEventType): void;
 }

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

@@ -1,15 +1,15 @@
 import { AnnotationTool } from './base';
 import type { Types } from '@cornerstonejs/core';
-import { EventTypes, ToolProps, PublicToolProps, SVGDrawingHelper } from '../types';
+import type { EventTypes, ToolProps, PublicToolProps, SVGDrawingHelper, Annotation } from '../types';
 declare class WindowLevelRegionTool extends AnnotationTool {
     static toolName: any;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: string[];
     } | null;
     isDrawing: boolean;
     constructor(toolProps?: PublicToolProps, defaultToolProps?: ToolProps);
-    addNewAnnotation: (evt: EventTypes.InteractionEventType) => any;
+    addNewAnnotation: (evt: EventTypes.InteractionEventType) => Annotation;
     _endCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragCallback: (evt: EventTypes.InteractionEventType) => void;
     _activateDraw: (element: any) => void;

package/dist/esm/tools/WindowLevelRegionTool.js

@@ -23,7 +23,7 @@ class WindowLevelRegionTool extends AnnotationTool {
             const { currentPoints, element } = eventDetail;
             const worldPos = currentPoints.world;
             const enabledElement = getEnabledElement(element);
-            const { viewport, renderingEngine } = enabledElement;
+            const { viewport } = enabledElement;
             this.isDrawing = true;
             const camera = viewport.getCamera();
             const { viewPlaneNormal, viewUp } = camera;
@@ -69,7 +69,6 @@ class WindowLevelRegionTool extends AnnotationTool {
             const { annotation, viewportIdsToRender } = this.editData;
             this._deactivateDraw(element);
             resetElementCursor(element);
-            const { renderingEngine } = getEnabledElement(element);
             this.editData = null;
             this.isDrawing = false;
             removeAnnotation(annotation.annotationUID);
@@ -105,7 +104,6 @@ class WindowLevelRegionTool extends AnnotationTool {
             points[1] = bottomRightWorld;
             points[2] = topLeftWorld;
             annotation.invalidated = true;
-            const { renderingEngine } = enabledElement;
             triggerAnnotationRenderForViewportIds(viewportIdsToRender);
         };
         this._activateDraw = (element) => {

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

@@ -1,5 +1,5 @@
 import { BaseTool } from './base';
-import { EventTypes } from '../types';
+import type { EventTypes } from '../types';
 declare class WindowLevelTool extends BaseTool {
     static toolName: any;
     constructor(toolProps?: {}, defaultToolProps?: {

package/dist/esm/tools/WindowLevelTool.js

@@ -47,8 +47,7 @@ class WindowLevelTool extends BaseTool {
         let isPreScaled = false;
         const properties = viewport.getProperties();
         if (viewport instanceof VolumeViewport) {
-            const targetId = this.getTargetId(viewport);
-            volumeId = utilities.getVolumeId(targetId);
+            volumeId = this.getTargetVolumeId(viewport);
             viewportsContainingVolumeUID = utilities.getViewportsWithVolumeId(volumeId, renderingEngine.id);
             ({ lower, upper } = properties.voiRange);
             const volume = cache.getVolume(volumeId);
@@ -135,9 +134,11 @@ class WindowLevelTool extends BaseTool {
         let imageDynamicRange;
         if (volumeId) {
             const imageVolume = cache.getVolume(volumeId);
-            const { dimensions } = imageVolume;
-            const scalarData = imageVolume.getScalarData();
-            const calculatedDynamicRange = this._getImageDynamicRangeFromMiddleSlice(scalarData, dimensions);
+            const { voxelManager } = viewport.getImageData();
+            const middleSlicePixelData = voxelManager.getMiddleSliceData();
+            const calculatedDynamicRange = middleSlicePixelData.reduce((acc, pixel) => {
+                return [Math.min(acc[0], pixel), Math.max(acc[1], pixel)];
+            }, [Infinity, -Infinity]);
             const BitsStored = imageVolume?.metadata?.BitsStored;
             const metadataDynamicRange = BitsStored ? 2 ** BitsStored : Infinity;
             imageDynamicRange = Math.min(calculatedDynamicRange, metadataDynamicRange);
@@ -149,7 +150,11 @@ class WindowLevelTool extends BaseTool {
         return ratio > 1 ? Math.round(ratio) : ratio;
     }
     _getImageDynamicRangeFromViewport(viewport) {
-        const { imageData } = viewport.getImageData();
+        const { imageData, voxelManager } = viewport.getImageData();
+        if (voxelManager?.getRange) {
+            const range = voxelManager.getRange();
+            return range[1] - range[0];
+        }
         const dimensions = imageData.getDimensions();
         if (imageData.getRange) {
             const imageDataRange = imageData.getRange();
@@ -160,7 +165,7 @@ class WindowLevelTool extends BaseTool {
             scalarData = imageData.getScalarData();
         }
         else {
-            scalarData = imageData.getPointData().getScalars();
+            scalarData = imageData.getPointData().getScalars().getData();
         }
         if (dimensions[2] !== 1) {
             return this._getImageDynamicRangeFromMiddleSlice(scalarData, dimensions);

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

@@ -1,6 +1,6 @@
-import { Types } from '@cornerstonejs/core';
+import type { Types } from '@cornerstonejs/core';
 import { BaseTool } from './base';
-import { EventTypes, PublicToolProps, ToolProps } from '../types';
+import type { EventTypes, PublicToolProps, ToolProps } from '../types';
 declare class ZoomTool extends BaseTool {
     static toolName: any;
     touchDragCallback: (evt: EventTypes.InteractionEventType) => void;

package/dist/esm/tools/ZoomTool.js

@@ -7,8 +7,8 @@ class ZoomTool extends BaseTool {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
             zoomToCenter: false,
-            minZoomScale: 0.1,
-            maxZoomScale: 30,
+            minZoomScale: 0.001,
+            maxZoomScale: 3000,
             pinchToZoom: true,
             pan: true,
             invert: false,

package/dist/esm/tools/annotation/AngleTool.d.ts

@@ -1,15 +1,13 @@
 import type { Types } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
-import { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
-import { AngleAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../../types';
+import type { AngleAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 declare class AngleTool extends AnnotationTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
     angleStartedNotYetCompleted: boolean;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: string[];
         handleIndex?: number;
         movingTextBox?: boolean;
@@ -25,7 +23,7 @@ declare class AngleTool extends AnnotationTool {
     handleSelectedCallback(evt: EventTypes.InteractionEventType, annotation: AngleAnnotation, handle: ToolHandle): void;
     _endCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragCallback: (evt: EventTypes.InteractionEventType) => void;
-    cancel: (element: HTMLDivElement) => any;
+    cancel: (element: HTMLDivElement) => string;
     _activateModify: (element: HTMLDivElement) => void;
     _deactivateModify: (element: HTMLDivElement) => void;
     _activateDraw: (element: HTMLDivElement) => void;

package/dist/esm/tools/annotation/ArrowAnnotateTool.d.ts

@@ -1,14 +1,12 @@
 import type { Types } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
-import { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
-import { ArrowAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../../types';
+import type { ArrowAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 declare class ArrowAnnotateTool extends AnnotationTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: string[];
         handleIndex?: number;
         movingTextBox?: boolean;
@@ -27,7 +25,7 @@ declare class ArrowAnnotateTool extends AnnotationTool {
     touchTapCallback: (evt: EventTypes.TouchTapEventType) => void;
     doubleClickCallback: (evt: EventTypes.TouchTapEventType) => void;
     _doneChangingTextCallback(element: any, annotation: any, updatedText: any): void;
-    cancel: (element: HTMLDivElement) => any;
+    cancel: (element: HTMLDivElement) => string;
     _activateModify: (element: HTMLDivElement) => void;
     _deactivateModify: (element: HTMLDivElement) => void;
     _activateDraw: (element: HTMLDivElement) => void;

package/dist/esm/tools/annotation/BidirectionalTool.d.ts

@@ -1,14 +1,12 @@
 import type { Types } from '@cornerstonejs/core';
 import { AnnotationTool } from '../base';
-import { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper } from '../../types';
-import { BidirectionalAnnotation } from '../../types/ToolSpecificAnnotationTypes';
+import type { EventTypes, ToolHandle, PublicToolProps, ToolProps, SVGDrawingHelper, Annotation } from '../../types';
+import type { BidirectionalAnnotation } from '../../types/ToolSpecificAnnotationTypes';
 declare class BidirectionalTool extends AnnotationTool {
     static toolName: any;
-    touchDragCallback: any;
-    mouseDragCallback: any;
-    _throttledCalculateCachedStats: any;
+    _throttledCalculateCachedStats: Function;
     editData: {
-        annotation: any;
+        annotation: Annotation;
         viewportIdsToRender: string[];
         handleIndex?: number;
         movingTextBox: boolean;
@@ -27,7 +25,7 @@ declare class BidirectionalTool extends AnnotationTool {
     _dragDrawCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragModifyCallback: (evt: EventTypes.InteractionEventType) => void;
     _dragModifyHandle: (evt: EventTypes.InteractionEventType) => void;
-    cancel: (element: HTMLDivElement) => any;
+    cancel: (element: HTMLDivElement) => string;
     _activateDraw: (element: any) => void;
     _deactivateDraw: (element: any) => void;
     _activateModify: (element: any) => void;