@cornerstonejs/tools 5.0.16 → 5.1.1

package/dist/esm/tools/MagnifyTool.js

@@ -1,9 +1,11 @@
 import { BaseTool } from './base';
 import { Events } from '../enums';
-import { getEnabledElement, StackViewport, Enums } from '@cornerstonejs/core';
+import { getEnabledElement, StackViewport, Enums, utilities as csUtils, } from '@cornerstonejs/core';
 import { getViewportIdsWithToolToRender } from '../utilities/viewportFilters';
 import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
+import { getNativeSourceProperties } from '../utilities/genericViewportToolHelpers';
 import { state } from '../store/state';
+import { vec3 } from 'gl-matrix';
 import { hideElementCursor, resetElementCursor, } from '../cursors/elementCursor';
 const MAGNIFY_VIEWPORT_ID = 'magnify-viewport';
 class MagnifyTool extends BaseTool {
@@ -22,8 +24,9 @@ class MagnifyTool extends BaseTool {
             const { element, currentPoints } = eventDetail;
             const enabledElement = getEnabledElement(element);
             const { viewport, renderingEngine } = enabledElement;
-            if (!(viewport instanceof StackViewport)) {
-                throw new Error('MagnifyTool only works on StackViewports');
+            if (!(viewport instanceof StackViewport) &&
+                !csUtils.isGenericViewport(viewport)) {
+                throw new Error('MagnifyTool only works on Stack or native planar viewports');
             }
             const referencedImageId = this._getReferencedImageId(viewport);
             if (!referencedImageId) {
@@ -51,8 +54,13 @@ class MagnifyTool extends BaseTool {
             const { enabledElement, referencedImageId, viewportIdsToRender, renderingEngine, currentPoints, } = this.editData;
             const { viewport } = enabledElement;
             const { element } = viewport;
-            const viewportProperties = viewport.getProperties();
-            const { rotation: originalViewportRotation, flipHorizontal: originalViewportFlipHorizontal, flipVertical: originalViewportFlipVertical, } = viewport.getViewPresentation();
+            const native = csUtils.isGenericViewport(viewport)
+                ? getNativeSourceProperties(viewport)
+                : undefined;
+            const viewportProperties = native
+                ? native.properties
+                : viewport.getProperties();
+            const { rotation: originalViewportRotation, flipHorizontal: originalViewportFlipHorizontal, flipVertical: originalViewportFlipVertical, } = native ?? viewport.getViewPresentation();
             const { canvas: canvasPos, world: worldPos } = currentPoints;
             let magnifyToolElement;
             magnifyToolElement = element.querySelector('.magnifyTool');
@@ -86,8 +94,18 @@ class MagnifyTool extends BaseTool {
                     flipHorizontal: originalViewportFlipHorizontal,
                     flipVertical: originalViewportFlipVertical,
                 });
-                const { parallelScale } = viewport.getCamera();
                 const { focalPoint, position, viewPlaneNormal } = magnifyViewport.getCamera();
+                let parallelScale;
+                if (csUtils.isGenericViewport(viewport)) {
+                    const sourceElement = viewport.element;
+                    const worldTop = viewport.canvasToWorld([0, 0]);
+                    const worldBottom = viewport.canvasToWorld([0, 1]);
+                    const worldPerPixel = vec3.distance(worldTop, worldBottom);
+                    parallelScale = (worldPerPixel * sourceElement.clientHeight) / 2;
+                }
+                else {
+                    ({ parallelScale } = viewport.getCamera());
+                }
                 const distance = Math.sqrt(Math.pow(focalPoint[0] - position[0], 2) +
                     Math.pow(focalPoint[1] - position[1], 2) +
                     Math.pow(focalPoint[2] - position[2], 2));
@@ -190,6 +208,9 @@ class MagnifyTool extends BaseTool {
         if (viewport instanceof StackViewport) {
             referencedImageId = targetId.split('imageId:')[1];
         }
+        else if (csUtils.isGenericViewport(viewport)) {
+            referencedImageId = getNativeSourceProperties(viewport).currentImageId;
+        }
         return referencedImageId;
     }
 }

package/dist/esm/tools/OrientationControllerTool.js

@@ -1,6 +1,7 @@
 import { BaseTool } from './base';
 import { getEnabledElementByIds, Enums, eventTarget, } from '@cornerstonejs/core';
 import { getToolGroup } from '../store/ToolGroupManager';
+import setViewportCamera, { resetViewportCamera, } from '../utilities/setViewportCamera';
 import * as ToolsEnums from '../enums';
 import { vec3, mat4, quat } from 'gl-matrix';
 import { vtkOrientationControllerWidget } from '../utilities/vtkjs/OrientationControllerWidget';
@@ -432,11 +433,11 @@ class OrientationControllerTool extends BaseTool {
             mat4.fromQuat(interpolatedMatrix, interpolatedQuat);
             const interpolatedForward = interpolatedMatrix.slice(8, 11);
             const interpolatedUp = interpolatedMatrix.slice(4, 7);
-            viewport.setCamera({
+            setViewportCamera(viewport, {
                 viewPlaneNormal: isLastStep ? finalNormal : interpolatedForward,
                 viewUp: isLastStep ? finalUp : interpolatedUp,
             });
-            viewport.resetCamera(ANIMATE_RESET_CAMERA_OPTIONS);
+            resetViewportCamera(viewport, ANIMATE_RESET_CAMERA_OPTIONS);
             viewport.render();
             if (!isLastStep) {
                 const handle = requestAnimationFrame(animate);

package/dist/esm/tools/OrientationMarkerTool.js

@@ -171,6 +171,9 @@ class OrientationMarkerTool extends BaseTool {
         let viewports = renderingEngine.getViewports();
         viewports = filterViewportsWithToolEnabled(viewports, this.getToolName());
         viewports.forEach((viewport) => {
+            if (typeof viewport.getWidget !== 'function') {
+                return;
+            }
             const widget = viewport.getWidget(this.getToolName());
             if (!widget || widget.isDeleted()) {
                 this.addAxisActorInViewport(viewport);

package/dist/esm/tools/OverlayGridTool.js

@@ -3,6 +3,7 @@ import { metaData, CONSTANTS, getRenderingEngine, utilities as csUtils, } from '
 import { addAnnotation, getAnnotations, } from '../stateManagement/annotation/annotationState';
 import { getToolGroup } from '../store/ToolGroupManager';
 import { drawLine as drawLineSvg } from '../drawingSvg';
+import getViewportICamera from '../utilities/getViewportICamera';
 import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
 const { EPSILON } = CONSTANTS;
@@ -89,7 +90,7 @@ class OverlayGridTool extends AnnotationDisplayTool {
             }
             const annotation = annotations[0];
             const { annotationUID } = annotation;
-            const { focalPoint, viewPlaneNormal } = targetViewport.getCamera();
+            const { focalPoint, viewPlaneNormal } = getViewportICamera(targetViewport);
             const styleSpecifier = {
                 toolGroupId: this.toolGroupId,
                 toolName: this.getToolName(),

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

@@ -19,6 +19,6 @@ declare class ReferenceCursors extends AnnotationDisplayTool {
     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;
+    updateViewportImage(viewport: Types.IViewport): void;
 }
 export default ReferenceCursors;

package/dist/esm/tools/ReferenceCursors.js

@@ -3,12 +3,14 @@ import { addAnnotation, getAnnotations, } from '../stateManagement/annotation/an
 import { isAnnotationVisible } from '../stateManagement/annotation/annotationVisibility';
 import { drawLine } from '../drawingSvg';
 import { getViewportIdsWithToolToRender } from '../utilities/viewportFilters';
+import getViewportICamera from '../utilities/getViewportICamera';
 import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
 import { vec3 } from 'gl-matrix';
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
 import vtkMath from '@kitware/vtk.js/Common/Core/Math';
 import { hideElementCursor, resetElementCursor, } from '../cursors/elementCursor';
 import { getToolGroup } from '../store/ToolGroupManager';
+import { jumpToFocalPoint } from '../utilities/genericViewportToolHelpers';
 class ReferenceCursors extends AnnotationDisplayTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -48,7 +50,7 @@ class ReferenceCursors extends AnnotationDisplayTool {
             }
             const { viewport, renderingEngine } = enabledElement;
             this.isDrawing = true;
-            const camera = viewport.getCamera();
+            const camera = getViewportICamera(viewport);
             const { viewPlaneNormal, viewUp } = camera;
             if (!viewPlaneNormal || !viewUp) {
                 throw new Error('Camera not found');
@@ -258,7 +260,7 @@ class ReferenceCursors extends AnnotationDisplayTool {
         if (!viewport) {
             return [];
         }
-        const camera = viewport.getCamera();
+        const camera = getViewportICamera(viewport);
         const { viewPlaneNormal, focalPoint } = camera;
         if (!viewPlaneNormal || !focalPoint) {
             return [];
@@ -287,7 +289,7 @@ class ReferenceCursors extends AnnotationDisplayTool {
             }
         }
         else if (viewport instanceof VolumeViewport) {
-            const { focalPoint, viewPlaneNormal } = viewport.getCamera();
+            const { focalPoint, viewPlaneNormal } = getViewportICamera(viewport);
             if (!focalPoint || !viewPlaneNormal) {
                 return;
             }
@@ -308,6 +310,25 @@ class ReferenceCursors extends AnnotationDisplayTool {
                 }
             }
         }
+        else if (utilities.isGenericViewport(viewport)) {
+            const { focalPoint, viewPlaneNormal } = getViewportICamera(viewport);
+            if (!focalPoint || !viewPlaneNormal) {
+                return;
+            }
+            const plane = utilities.planar.planeEquation(viewPlaneNormal, focalPoint);
+            const currentDistance = utilities.planar.planeDistanceToPoint(plane, currentMousePosition, true);
+            if (Math.abs(currentDistance) < 0.5) {
+                return;
+            }
+            const normalizedViewPlane = vec3.normalize(vec3.create(), vec3.fromValues(...viewPlaneNormal));
+            const scaledPlaneNormal = vec3.scale(vec3.create(), normalizedViewPlane, currentDistance);
+            const newFocalPoint = vec3.add(vec3.create(), vec3.fromValues(...focalPoint), scaledPlaneNormal);
+            jumpToFocalPoint(viewport, newFocalPoint);
+            const renderingEngine = viewport.getRenderingEngine();
+            if (renderingEngine) {
+                renderingEngine.renderViewport(viewport.id);
+            }
+        }
     }
 }
 ReferenceCursors.toolName = 'ReferenceCursors';

package/dist/esm/tools/ReferenceLinesTool.js

@@ -5,6 +5,7 @@ import { addAnnotation } from '../stateManagement/annotation/annotationState';
 import { drawLine as drawLineSvg } from '../drawingSvg';
 import { filterViewportsWithToolEnabled } from '../utilities/viewportFilters';
 import triggerAnnotationRenderForViewportIds from '../utilities/triggerAnnotationRenderForViewportIds';
+import getViewportICamera from '../utilities/getViewportICamera';
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
 const { EPSILON } = CONSTANTS;
 class ReferenceLines extends AnnotationDisplayTool {
@@ -27,11 +28,11 @@ class ReferenceLines extends AnnotationDisplayTool {
             let viewports = renderingEngine.getViewports();
             viewports = filterViewportsWithToolEnabled(viewports, this.getToolName());
             const sourceViewport = renderingEngine.getViewport(this.configuration.sourceViewportId);
-            if (!sourceViewport?.getImageData()) {
+            if (!sourceViewport?.getImageData?.()) {
                 return;
             }
             const { element } = sourceViewport;
-            const { viewUp, viewPlaneNormal } = sourceViewport.getCamera();
+            const { viewUp, viewPlaneNormal } = getViewportICamera(sourceViewport);
             const sourceViewportCanvasCornersInWorld = csUtils.getViewportImageCornersInWorld(sourceViewport);
             let annotation = this.editData?.annotation;
             const FrameOfReferenceUID = sourceViewport.getFrameOfReferenceUID();
@@ -108,8 +109,8 @@ class ReferenceLines extends AnnotationDisplayTool {
             const topRight = annotation.data.handles.points[1];
             const bottomLeft = annotation.data.handles.points[2];
             const bottomRight = annotation.data.handles.points[3];
-            const { focalPoint, viewPlaneNormal, viewUp } = targetViewport.getCamera();
-            const { viewPlaneNormal: sourceViewPlaneNormal } = sourceViewport.getCamera();
+            const { focalPoint, viewPlaneNormal, viewUp } = getViewportICamera(targetViewport);
+            const { viewPlaneNormal: sourceViewPlaneNormal } = getViewportICamera(sourceViewport);
             if (this.isParallel(viewPlaneNormal, sourceViewPlaneNormal)) {
                 return renderStatus;
             }

package/dist/esm/tools/ScaleOverlayTool.js

@@ -1,4 +1,5 @@
 import AnnotationDisplayTool from './base/AnnotationDisplayTool';
+import getViewportICamera from '../utilities/getViewportICamera';
 import { vec3 } from 'gl-matrix';
 import { getEnabledElementByIds, getRenderingEngines, utilities as csUtils, } from '@cornerstonejs/core';
 import { addAnnotation, getAnnotations, } from '../stateManagement/annotation/annotationState';
@@ -37,7 +38,7 @@ class ScaleOverlayTool extends AnnotationDisplayTool {
             if (!viewport) {
                 return;
             }
-            const { viewUp, viewPlaneNormal } = viewport.getCamera();
+            const { viewUp, viewPlaneNormal } = getViewportICamera(viewport);
             const viewportCanvasCornersInWorld = csUtils.getViewportImageCornersInWorld(viewport);
             let annotation = this.editData?.annotation;
             const annotations = getAnnotations(this.getToolName(), viewport.element);

package/dist/esm/tools/TrackballRotateTool.js

@@ -1,9 +1,11 @@
 import vtkMath from '@kitware/vtk.js/Common/Core/Math';
 import { Events } from '../enums';
-import { eventTarget, getEnabledElement, getEnabledElementByIds, } from '@cornerstonejs/core';
+import { eventTarget, getEnabledElement, getEnabledElementByIds, utilities as csUtils, } from '@cornerstonejs/core';
 import { mat4, vec3 } from 'gl-matrix';
 import { BaseTool } from './base';
 import { getToolGroup } from '../store/ToolGroupManager';
+import getViewportICamera from '../utilities/getViewportICamera';
+import setViewportCamera, { resetViewportCamera, } from '../utilities/setViewportCamera';
 import { applyViewportPresentation, getViewportPresentation, } from '../utilities/viewportPresentation';
 class TrackballRotateTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -66,7 +68,7 @@ class TrackballRotateTool extends BaseTool {
                             }
                             const { viewport } = element;
                             const viewPresentation = getViewportPresentation(viewport);
-                            viewport.resetCamera();
+                            resetViewportCamera(viewport);
                             applyViewportPresentation(viewport, viewPresentation);
                             viewport.render();
                         });
@@ -114,7 +116,7 @@ class TrackballRotateTool extends BaseTool {
             mat4.identity(transform);
             mat4.rotate(transform, transform, angle, axis);
             vec3.transformMat4(newViewUp, viewUp, transform);
-            viewport.setCamera({
+            setViewportCamera(viewport, {
                 position: newPosition,
                 viewUp: newViewUp,
                 focalPoint: newFocalPoint,
@@ -130,7 +132,7 @@ class TrackballRotateTool extends BaseTool {
         const { rotateIncrementDegrees } = this.configuration;
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
-        const camera = viewport.getCamera();
+        const camera = getViewportICamera(viewport);
         const width = element.clientWidth;
         const height = element.clientHeight;
         const normalizedPosition = [

package/dist/esm/tools/VolumeCroppingControlTool.js

@@ -3,6 +3,8 @@ import vtkMath from '@kitware/vtk.js/Common/Core/Math';
 import { AnnotationTool } from './base';
 import { getRenderingEngine, getEnabledElementByIds, getEnabledElement, Enums, CONSTANTS, triggerEvent, eventTarget, convertColorArrayToRgbString, } from '@cornerstonejs/core';
 import { getToolGroup } from '../store/ToolGroupManager';
+import getViewportICamera from '../utilities/getViewportICamera';
+import { resetViewportCamera } from '../utilities/setViewportCamera';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../stateManagement/annotation/annotationState';
 import { drawCircle as drawCircleSvg, drawLine as drawLineSvg, } from '../drawingSvg';
 import { state } from '../store/state';
@@ -64,13 +66,13 @@ class VolumeCroppingControlTool extends AnnotationTool {
                 }
             }
             const { element } = viewport;
-            const { position, focalPoint } = viewport.getCamera();
+            const { position, focalPoint } = getViewportICamera(viewport);
             let annotations = this._getAnnotations(enabledElement);
             annotations = this.filterInteractableAnnotationsForElement(element, annotations);
             if (annotations?.length) {
                 removeAnnotation(annotations[0].annotationUID);
             }
-            const orientation = getOrientationFromNormal(viewport.getCamera().viewPlaneNormal);
+            const orientation = getOrientationFromNormal(getViewportICamera(viewport).viewPlaneNormal);
             const annotation = {
                 highlighted: false,
                 metadata: {
@@ -108,7 +110,7 @@ class VolumeCroppingControlTool extends AnnotationTool {
                 const resetToCenter = true;
                 const resetRotation = true;
                 const suppressEvents = true;
-                viewport.resetCamera({
+                resetViewportCamera(viewport, {
                     resetPan,
                     resetZoom,
                     resetToCenter,
@@ -188,8 +190,11 @@ class VolumeCroppingControlTool extends AnnotationTool {
             }
             const enabledElement = getEnabledElement(element);
             let orientation = null;
-            if (enabledElement.viewport && enabledElement.viewport.getCamera) {
-                orientation = getOrientationFromNormal(enabledElement.viewport.getCamera().viewPlaneNormal);
+            if (enabledElement.viewport) {
+                const { viewPlaneNormal } = getViewportICamera(enabledElement.viewport);
+                if (viewPlaneNormal) {
+                    orientation = getOrientationFromNormal(viewPlaneNormal);
+                }
             }
             const filtered = annotations.filter((annotation) => {
                 if (annotation.data.orientation &&
@@ -226,7 +231,7 @@ class VolumeCroppingControlTool extends AnnotationTool {
             const { viewport, renderingEngine } = enabledElement;
             const { element } = viewport;
             const annotations = this._getAnnotations(enabledElement);
-            const camera = viewport.getCamera();
+            const camera = getViewportICamera(viewport);
             const filteredToolAnnotations = this.filterInteractableAnnotationsForElement(element, annotations);
             const viewportAnnotation = filteredToolAnnotations[0];
             if (!viewportAnnotation || !viewportAnnotation.data) {

package/dist/esm/tools/VolumeCroppingTool.js

@@ -8,6 +8,8 @@ import vtkPlane from '@kitware/vtk.js/Common/DataModel/Plane';
 import { BaseTool } from './base';
 import { getRenderingEngine, getEnabledElementByIds, getEnabledElement, Enums, triggerEvent, eventTarget, } from '@cornerstonejs/core';
 import { getToolGroup } from '../store/ToolGroupManager';
+import getViewportICamera from '../utilities/getViewportICamera';
+import setViewportCamera, { resetViewportCamera, } from '../utilities/setViewportCamera';
 import { Events } from '../enums';
 import { PLANEINDEX, SPHEREINDEX, NUM_CLIPPING_PLANES, extractVolumeDirectionVectors, parseCornerKey, copyClippingPlanes, } from '../utilities/volumeCropping';
 import { addLine3DBetweenPoints, calculateAdaptiveSphereRadius, } from '../utilities/draw3D';
@@ -471,7 +473,7 @@ class VolumeCroppingTool extends BaseTool {
                 5;
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
-            const camera = viewport.getCamera();
+            const camera = getViewportICamera(viewport);
             const width = element.clientWidth;
             const height = element.clientHeight;
             const normalizedPosition = [
@@ -684,7 +686,7 @@ class VolumeCroppingTool extends BaseTool {
             mat4.identity(transform);
             mat4.rotate(transform, transform, angle, axis);
             vec3.transformMat4(newViewUp, viewUp, transform);
-            viewport.setCamera({
+            setViewportCamera(viewport, {
                 position: newPosition,
                 viewUp: newViewUp,
                 focalPoint: newFocalPoint,
@@ -710,7 +712,7 @@ class VolumeCroppingTool extends BaseTool {
                         }
                         const { viewport } = element;
                         const viewPresentation = getViewportPresentation(viewport);
-                        viewport.resetCamera();
+                        resetViewportCamera(viewport);
                         applyViewportPresentation(viewport, viewPresentation);
                         viewport.render();
                     });
@@ -835,7 +837,7 @@ class VolumeCroppingTool extends BaseTool {
             const { rotateIncrementDegrees } = this.configuration;
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
-            const camera = viewport.getCamera();
+            const camera = getViewportICamera(viewport);
             const width = element.clientWidth;
             const height = element.clientHeight;
             const normalizedPosition = [

package/dist/esm/tools/VolumeRotateTool.js

@@ -1,6 +1,8 @@
 import { BaseTool } from './base';
 import { getEnabledElement } from '@cornerstonejs/core';
 import { mat4, vec3 } from 'gl-matrix';
+import getViewportICamera from '../utilities/getViewportICamera';
+import setViewportCamera from '../utilities/setViewportCamera';
 const DIRECTIONS = {
     X: [1, 0, 0],
     Y: [0, 1, 0],
@@ -22,7 +24,7 @@ class VolumeRotateTool extends BaseTool {
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
         const { direction, rotateIncrementDegrees } = this.configuration;
-        const camera = viewport.getCamera();
+        const camera = getViewportICamera(viewport);
         const { viewUp, position, focalPoint } = camera;
         const { direction: deltaY } = wheel;
         const [cx, cy, cz] = focalPoint;
@@ -40,7 +42,7 @@ class VolumeRotateTool extends BaseTool {
         mat4.identity(transform);
         mat4.rotate(transform, transform, angle, [ax, ay, az]);
         vec3.transformMat4(newViewUp, viewUp, transform);
-        viewport.setCamera({
+        setViewportCamera(viewport, {
             position: newPosition,
             viewUp: newViewUp,
             focalPoint: newFocalPoint,

package/dist/esm/tools/WindowLevelRegionTool.js

@@ -1,4 +1,5 @@
 import { AnnotationTool } from './base';
+import getViewportICamera from '../utilities/getViewportICamera';
 import { getEnabledElement, utilities } from '@cornerstonejs/core';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../stateManagement';
 import { triggerAnnotationCompleted } from '../stateManagement/annotation/helpers/state';
@@ -24,7 +25,7 @@ class WindowLevelRegionTool extends AnnotationTool {
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
             this.isDrawing = true;
-            const camera = viewport.getCamera();
+            const camera = getViewportICamera(viewport);
             const { viewPlaneNormal, viewUp } = camera;
             const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
             const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
@@ -171,6 +172,9 @@ class WindowLevelRegionTool extends AnnotationTool {
             const enabledElement = getEnabledElement(element);
             const { viewport } = enabledElement;
             const imageData = windowLevel.extractWindowLevelRegionToolData(viewport);
+            if (!imageData) {
+                return;
+            }
             const { data } = annotation;
             const { points } = data.handles;
             const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
@@ -191,9 +195,29 @@ class WindowLevelRegionTool extends AnnotationTool {
             }
             const windowWidth = Math.max(Math.abs(minMaxMean.max - minMaxMean.min), this.configuration.minWindowWidth);
             const windowCenter = minMaxMean.mean;
-            const voiLutFunction = viewport.getProperties().VOILUTFunction;
+            const presentationViewport = utilities.viewportSupportsDisplaySetPresentation(viewport)
+                ? viewport
+                : undefined;
+            const sourceDataId = presentationViewport?.getSourceDataId();
+            const voiLutFunction = presentationViewport
+                ? sourceDataId
+                    ? presentationViewport.getDisplaySetPresentation(sourceDataId)?.voiLUTFunction
+                    : undefined
+                : viewport.getProperties().VOILUTFunction;
             const voiRange = utilities.windowLevel.toLowHighRange(windowWidth, windowCenter, voiLutFunction);
-            viewport.setProperties({ voiRange });
+            if (presentationViewport) {
+                if (sourceDataId) {
+                    presentationViewport.setDisplaySetPresentation(sourceDataId, {
+                        voiRange,
+                    });
+                }
+                else {
+                    presentationViewport.setDisplaySetPresentation({ voiRange });
+                }
+            }
+            else {
+                viewport.setProperties({ voiRange });
+            }
             viewport.render();
         };
         this.cancel = () => {

package/dist/esm/tools/WindowLevelTool.js

@@ -54,23 +54,19 @@ class WindowLevelTool extends BaseTool {
             viewportsContainingVolumeUID =
                 utilities.getViewportsWithVolumeId(volumeId);
             ({ lower, upper } = properties.voiRange);
-            const volume = cache.getVolume(volumeId);
-            if (!volume) {
+            if (!cache.getVolume(volumeId)) {
                 throw new Error('Volume not found ' + volumeId);
             }
-            modality = volume.metadata.Modality;
-            isPreScaled = volume.scaling && Object.keys(volume.scaling).length > 0;
         }
         else if (properties.voiRange) {
-            modality = viewport.modality;
             ({ lower, upper } = properties.voiRange);
-            const { preScale = { scaled: false } } = viewport.getImageData?.() || {};
-            isPreScaled =
-                preScale.scaled && preScale.scalingParameters?.suvbw !== undefined;
         }
         else {
             throw new Error('Viewport is not a valid type');
         }
+        const descriptor = utilities.getScalingDescriptor(viewport, volumeId);
+        modality = descriptor?.modality;
+        isPreScaled = !!descriptor?.isPreScaled;
         if (modality === PT && isPreScaled) {
             newRange = this.getPTScaledNewRange({
                 deltaPointsCanvas: deltaPoints.canvas,

package/dist/esm/tools/annotation/DragProbeTool.js

@@ -3,6 +3,7 @@ import { drawHandles as drawHandlesSvg, drawTextBox as drawTextBoxSvg, } from '.
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
 import { hideElementCursor } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
+import getViewportICamera from '../../utilities/getViewportICamera';
 import ProbeTool from './ProbeTool';
 class DragProbeTool extends ProbeTool {
     constructor(toolProps = {}, defaultToolProps = {
@@ -21,7 +22,7 @@ class DragProbeTool extends ProbeTool {
             const enabledElement = getEnabledElement(element);
             const { viewport, renderingEngine } = enabledElement;
             this.isDrawing = true;
-            const camera = viewport.getCamera();
+            const camera = getViewportICamera(viewport);
             const { viewPlaneNormal, viewUp } = camera;
             const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
             const annotation = {

package/dist/esm/tools/annotation/ETDRSGridTool.js

@@ -1,4 +1,5 @@
 import { AnnotationTool } from '../base';
+import getViewportICamera from '../../utilities/getViewportICamera';
 import { getEnabledElement } from '@cornerstonejs/core';
 import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateManagement/annotation/annotationState';
 import { isAnnotationVisible } from '../../stateManagement/annotation/annotationVisibility';
@@ -31,7 +32,7 @@ class ETDRSGridTool extends AnnotationTool {
             const enabledElement = getEnabledElement(element);
             const { viewport, renderingEngine } = enabledElement;
             this.isDrawing = true;
-            const camera = viewport.getCamera();
+            const camera = getViewportICamera(viewport);
             const { viewPlaneNormal, viewUp } = camera;
             const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
             const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
@@ -341,7 +342,7 @@ class ETDRSGridTool extends AnnotationTool {
             viewport.canvas.width / 2,
             viewport.canvas.height / 2,
         ]);
-        const { viewUp } = viewport.getCamera();
+        const { viewUp } = getViewportICamera(viewport);
         const p2 = vec3.scaleAndAdd(vec3.create(), p1, viewUp, measurement);
         const p1Canvas = viewport.worldToCanvas(p1);
         const p2Canvas = viewport.worldToCanvas(p2);

package/dist/esm/tools/annotation/EllipticalROITool.js

@@ -11,6 +11,7 @@ import { drawCircle as drawCircleSvg, drawEllipseByCoordinates as drawEllipseSvg
 import { state } from '../../store/state';
 import { ChangeTypes, Events } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
+import getViewportICamera from '../../utilities/getViewportICamera';
 import getWorldWidthAndHeightFromTwoPoints from '../../utilities/planar/getWorldWidthAndHeightFromTwoPoints';
 import { pointInEllipse, getCanvasEllipseCorners, } from '../../utilities/math/ellipse';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
@@ -499,7 +500,7 @@ class EllipticalROITool extends AnnotationTool {
             const { element } = viewport;
             const { points } = data.handles;
             const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
-            const { viewPlaneNormal, viewUp } = viewport.getCamera();
+            const { viewPlaneNormal, viewUp } = getViewportICamera(viewport);
             const [topLeftCanvas, bottomRightCanvas] = (getCanvasEllipseCorners(canvasCoordinates));
             const topLeftWorld = viewport.canvasToWorld(topLeftCanvas);
             const bottomRightWorld = viewport.canvasToWorld(bottomRightCanvas);

package/dist/esm/tools/annotation/LabelTool.js

@@ -7,6 +7,7 @@ import { addAnnotation, getAnnotations, removeAnnotation, } from '../../stateMan
 import { drawTextBox as drawTextBoxSvg } from '../../drawingSvg';
 import { state } from '../../store/state';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
+import getViewportICamera from '../../utilities/getViewportICamera';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
 import { triggerAnnotationCompleted, triggerAnnotationModified, } from '../../stateManagement/annotation/helpers/state';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
@@ -278,7 +279,7 @@ LabelTool.hydrate = (viewportId, position, label, options) => {
     }
     const { viewport } = enabledElement;
     const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
-    const { viewPlaneNormal, viewUp } = viewport.getCamera();
+    const { viewPlaneNormal, viewUp } = getViewportICamera(viewport);
     const instance = new _a();
     const referencedImageId = instance.getReferencedImageId(viewport, position, viewPlaneNormal, viewUp);
     const annotation = {

package/dist/esm/tools/annotation/LivewireContourTool.js

@@ -441,7 +441,18 @@ class LivewireContourTool extends ContourSegmentationBaseTool {
             throw new Error('Viewport not supported');
         }
         scalarData = csUtils.convertToGrayscale(scalarData, width, height);
-        const { voiRange } = viewport.getProperties();
+        let voiRange;
+        const sourceViewport = viewport;
+        if (csUtils.viewportSupportsDisplaySetPresentation(sourceViewport)) {
+            const dataId = sourceViewport.getSourceDataId();
+            voiRange = (((dataId
+                ? sourceViewport.getDisplaySetPresentation(dataId)?.voiRange
+                : undefined) ?? sourceViewport.getDefaultVOIRange(dataId)) ??
+                undefined);
+        }
+        else {
+            ({ voiRange } = viewport.getProperties());
+        }
         const startPos = worldToSlice(worldPos);
         this.scissors = LivewireScissors.createInstanceFromRawPixelData(scalarData, width, height, voiRange);
         if (nextPos) {

package/dist/esm/tools/annotation/RectangleROITool.js

@@ -12,6 +12,7 @@ import { drawHandles as drawHandlesSvg, drawRectByCoordinates as drawRectSvg, }
 import { state } from '../../store/state';
 import { ChangeTypes, Events } from '../../enums';
 import { getViewportIdsWithToolToRender } from '../../utilities/viewportFilters';
+import getViewportICamera from '../../utilities/getViewportICamera';
 import * as rectangle from '../../utilities/math/rectangle';
 import { resetElementCursor, hideElementCursor, } from '../../cursors/elementCursor';
 import triggerAnnotationRenderForViewportIds from '../../utilities/triggerAnnotationRenderForViewportIds';
@@ -334,7 +335,7 @@ class RectangleROITool extends AnnotationTool {
                     annotation,
                     styleSpecifier,
                 });
-                const { viewPlaneNormal, viewUp } = viewport.getCamera();
+                const { viewPlaneNormal, viewUp } = getViewportICamera(viewport);
                 if (!data.cachedStats[targetId] ||
                     data.cachedStats[targetId].areaUnit == null) {
                     data.cachedStats[targetId] = {

package/dist/esm/tools/annotation/UltrasoundPleuraBLineTool/UltrasoundPleuraBLineTool.js

@@ -10,6 +10,7 @@ import * as lineSegment from '../../../utilities/math/line';
 import { drawHandles as drawHandlesSvg, drawLine as drawLineSvg, drawFan as drawFanSvg, } from '../../../drawingSvg';
 import { state } from '../../../store/state';
 import { getViewportIdsWithToolToRender } from '../../../utilities/viewportFilters';
+import getViewportICamera from '../../../utilities/getViewportICamera';
 import triggerAnnotationRenderForViewportIds from '../../../utilities/triggerAnnotationRenderForViewportIds';
 import { resetElementCursor, hideElementCursor, } from '../../../cursors/elementCursor';
 import { angleFromCenter, calculateInnerFanPercentage, clipInterval, intervalFromPoints, mergeIntervals, subtractIntervals, } from '../../../utilities/math/fan/fanUtils';
@@ -61,7 +62,7 @@ class UltrasoundPleuraBLineTool extends AnnotationTool {
             const { viewport } = enabledElement;
             hideElementCursor(element);
             this.isDrawing = true;
-            const { viewPlaneNormal, viewUp, position: cameraPosition, } = viewport.getCamera();
+            const { viewPlaneNormal, viewUp, position: cameraPosition, } = getViewportICamera(viewport);
             const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
             const annotation = {
                 highlighted: true,