@cornerstonejs/tools 4.22.13 → 5.0.0

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

@@ -14,4 +14,5 @@ import { updateLabelmapSegmentationImageReferences } from './updateLabelmapSegme
 import { getStackSegmentationImageIdsForViewport } from './getStackSegmentationImageIdsForViewport';
 import { getSegmentationRepresentation, getSegmentationRepresentations, getSegmentationRepresentationsBySegmentationId } from './getSegmentationRepresentation';
 declare function destroy(): void;
-export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, getViewportSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };
+declare function getDefaultSegmentationStateManager(): import("./SegmentationStateManager").default;
+export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, getViewportSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, getDefaultSegmentationStateManager, };

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

@@ -17,4 +17,7 @@ import { defaultSegmentationStateManager } from './SegmentationStateManager';
 function destroy() {
     defaultSegmentationStateManager.resetState();
 }
-export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, getViewportSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, };
+function getDefaultSegmentationStateManager() {
+    return defaultSegmentationStateManager;
+}
+export { getColorLUT, getCurrentLabelmapImageIdForViewport, getCurrentLabelmapImageIdsForViewport, getNextColorLUTIndex, getSegmentation, getSegmentations, getStackSegmentationImageIdsForViewport, getViewportIdsWithSegmentation, getSegmentationRepresentation, getSegmentationRepresentations, getViewportSegmentationRepresentations, removeColorLUT, getViewportSegmentations, removeSegmentation, removeLabelmapRepresentation, removeContourRepresentation, removeSurfaceRepresentation, removeSegmentationRepresentation, removeAllSegmentationRepresentations, removeAllSegmentations, addColorLUT, addSegmentations, updateLabelmapSegmentationImageReferences, getSegmentationRepresentationsBySegmentationId, destroy, getDefaultSegmentationStateManager, };

package/dist/esm/store/state.js

@@ -1,3 +1,4 @@
+import { utilities } from '@cornerstonejs/core';
 import svgNodeCache, { resetSvgNodeCache } from './svgNodeCache';
 const defaultState = {
     isInteractingWithTool: false,
@@ -22,7 +23,7 @@ let state = {
 function resetCornerstoneToolsState() {
     resetSvgNodeCache();
     state = {
-        ...structuredClone({
+        ...utilities.deepClone({
             ...defaultState,
             svgNodeCache: {},
         }),

package/dist/esm/synchronizers/callbacks/imageSliceSyncCallback.js

@@ -1,7 +1,16 @@
 import { vec3, mat4 } from 'gl-matrix';
-import { getRenderingEngine, metaData, utilities, VolumeViewport, } from '@cornerstonejs/core';
+import { ActorRenderMode, getRenderingEngine, metaData, utilities, VolumeViewport, } from '@cornerstonejs/core';
 import areViewportsCoplanar from './areViewportsCoplanar';
 const getSpatialRegistration = (targetId, sourceId) => utilities.spatialRegistrationMetadataProvider.get('spatialRegistrationModule', targetId, sourceId);
+function isVolumeSliceViewport(viewport) {
+    if (viewport instanceof VolumeViewport) {
+        return true;
+    }
+    const getDefaultActor = viewport.getDefaultActor;
+    const renderMode = getDefaultActor?.call(viewport)?.actorMapper?.renderMode;
+    return (renderMode === ActorRenderMode.CPU_VOLUME ||
+        renderMode === ActorRenderMode.VTK_VOLUME_SLICE);
+}
 export default async function imageSliceSyncCallback(synchronizerInstance, sourceViewport, targetViewport) {
     const renderingEngine = getRenderingEngine(targetViewport.renderingEngineId);
     if (!renderingEngine) {
@@ -39,11 +48,11 @@ export default async function imageSliceSyncCallback(synchronizerInstance, sourc
     const targetImagePositionPatientWithRegistrationMatrix = vec3.transformMat4(vec3.create(), sourceImagePositionPatient, registrationMatrixMat4);
     const closestImageIdIndex2 = _getClosestImageIdIndex(targetImagePositionPatientWithRegistrationMatrix, targetImageIds);
     let imageIndexToSet = closestImageIdIndex2.index;
-    if (tViewport instanceof VolumeViewport) {
+    if (isVolumeSliceViewport(tViewport)) {
         imageIndexToSet = targetImageIds.length - closestImageIdIndex2.index - 1;
     }
     if (closestImageIdIndex2.index !== -1 &&
-        tViewport.getCurrentImageIdIndex() !== closestImageIdIndex2.index) {
+        tViewport.getCurrentImageIdIndex() !== imageIndexToSet) {
         await utilities.jumpToSlice(tViewport.element, {
             imageIndex: imageIndexToSet,
         });

package/dist/esm/synchronizers/callbacks/presentationViewSyncCallback.js

@@ -1,4 +1,5 @@
 import { getRenderingEngine } from '@cornerstonejs/core';
+import { applyViewportPresentation, getViewportPresentation, } from '../../utilities/viewportPresentation';
 export default function presentationViewSyncCallback(_synchronizerInstance, sourceViewport, targetViewport, _sourceEvent, options) {
     const renderingEngine = getRenderingEngine(targetViewport.renderingEngineId);
     if (!renderingEngine) {
@@ -6,7 +7,9 @@ export default function presentationViewSyncCallback(_synchronizerInstance, sour
     }
     const tViewport = renderingEngine.getViewport(targetViewport.viewportId);
     const sViewport = renderingEngine.getViewport(sourceViewport.viewportId);
-    const presentationView = sViewport.getViewPresentation(options);
-    tViewport.setViewPresentation(presentationView);
+    const presentationView = getViewportPresentation(sViewport, options);
+    if (!applyViewportPresentation(tViewport, presentationView)) {
+        return;
+    }
     tViewport.render();
 }

package/dist/esm/synchronizers/callbacks/zoomPanSyncCallback.js

@@ -1,4 +1,43 @@
-import { getRenderingEngine } from '@cornerstonejs/core';
+import { getRenderingEngine, viewportHasPan, viewportHasZoom, viewportProjection, } from '@cornerstonejs/core';
+const zoomPanProjectionSelector = {
+    pan: true,
+    zoom: true,
+};
+function viewportHasViewStateSetter(viewport) {
+    return (Boolean(viewport) &&
+        typeof viewport === 'object' &&
+        'setViewState' in viewport &&
+        typeof viewport.setViewState === 'function');
+}
+function syncProjectionZoomPan(sourceViewport, targetViewport, options) {
+    if (!viewportHasViewStateSetter(targetViewport)) {
+        return false;
+    }
+    const sourcePresentation = viewportProjection.getPresentation(sourceViewport, {
+        selector: zoomPanProjectionSelector,
+    });
+    if (!sourcePresentation) {
+        return false;
+    }
+    const presentationPatch = {};
+    if (options?.syncZoom !== false &&
+        typeof sourcePresentation.zoom === 'number') {
+        presentationPatch.zoom = sourcePresentation.zoom;
+    }
+    if (options?.syncPan !== false && sourcePresentation.pan) {
+        presentationPatch.pan = sourcePresentation.pan;
+    }
+    if (presentationPatch.zoom === undefined &&
+        presentationPatch.pan === undefined) {
+        return false;
+    }
+    const nextViewState = viewportProjection.withPresentation(targetViewport, presentationPatch);
+    if (!nextViewState) {
+        return false;
+    }
+    targetViewport.setViewState(nextViewState);
+    return true;
+}
 export default function zoomPanSyncCallback(synchronizerInstance, sourceViewport, targetViewport) {
     const renderingEngine = getRenderingEngine(targetViewport.renderingEngineId);
     if (!renderingEngine) {
@@ -7,11 +46,20 @@ export default function zoomPanSyncCallback(synchronizerInstance, sourceViewport
     const options = synchronizerInstance.getOptions(targetViewport.viewportId);
     const tViewport = renderingEngine.getViewport(targetViewport.viewportId);
     const sViewport = renderingEngine.getViewport(sourceViewport.viewportId);
-    if (options?.syncZoom !== false) {
+    const syncedByProjection = syncProjectionZoomPan(sViewport, tViewport, options);
+    if (syncedByProjection) {
+        tViewport.render();
+        return;
+    }
+    if (options?.syncZoom !== false &&
+        viewportHasZoom(sViewport) &&
+        viewportHasZoom(tViewport)) {
         const srcZoom = sViewport.getZoom();
         tViewport.setZoom(srcZoom);
     }
-    if (options?.syncPan !== false) {
+    if (options?.syncPan !== false &&
+        viewportHasPan(sViewport) &&
+        viewportHasPan(tViewport)) {
         const srcPan = sViewport.getPan();
         tViewport.setPan(srcPan);
     }

package/dist/esm/tools/AdvancedMagnifyTool.js

@@ -27,7 +27,6 @@ var AdvancedMagnifyToolActions;
 const ADVANCED_MAGNIFY_TOOL_NAME = 'AdvancedMagnify';
 const PARALLEL_THRESHOLD = 1 - CONSTANTS.EPSILON;
 class AdvancedMagnifyTool extends AnnotationTool {
-    static { this.Actions = AdvancedMagnifyToolActions; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
         configuration: {
@@ -455,6 +454,7 @@ class AdvancedMagnifyTool extends AnnotationTool {
         }
     }
 }
+AdvancedMagnifyTool.Actions = AdvancedMagnifyToolActions;
 class AdvancedMagnifyViewportManager {
     constructor() {
         this.createViewport = (annotation, viewportInfo) => {

package/dist/esm/tools/CrosshairsTool.js

@@ -34,11 +34,6 @@ const OPERATION = {
     SLAB: 3,
 };
 class CrosshairsTool extends AnnotationTool {
-    static { this.minimalModeExamples = new Map([
-        ['Default', { enabled: false, lineLengthInPx: 40 }],
-        ['Minimal 40px', { enabled: true, lineLengthInPx: 40 }],
-        ['Minimal 80px', { enabled: true, lineLengthInPx: 80 }],
-    ]); }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse'],
         configuration: {
@@ -1765,6 +1760,11 @@ class CrosshairsTool extends AnnotationTool {
         return data.handles.activeOperation === OPERATION.DRAG ? true : false;
     }
 }
+CrosshairsTool.minimalModeExamples = new Map([
+    ['Default', { enabled: false, lineLengthInPx: 40 }],
+    ['Minimal 40px', { enabled: true, lineLengthInPx: 40 }],
+    ['Minimal 80px', { enabled: true, lineLengthInPx: 80 }],
+]);
 function getMinimalCrosshairConfig(configuration) {
     const minimal = configuration?.minimal;
     if (!minimal?.enabled) {

package/dist/esm/tools/OrientationControllerTool.js

@@ -65,7 +65,6 @@ const ANIMATE_RESET_CAMERA_OPTIONS = {
     resetToCenter: true,
 };
 class OrientationControllerTool extends BaseTool {
-    static { this.toolName = 'OrientationControllerTool'; }
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse'],
         configuration: {
@@ -451,4 +450,5 @@ class OrientationControllerTool extends BaseTool {
         this.animationFrameHandles.set(viewportId, handle);
     }
 }
+OrientationControllerTool.toolName = 'OrientationControllerTool';
 export default OrientationControllerTool;

package/dist/esm/tools/OrientationMarkerTool.js

@@ -17,10 +17,6 @@ var OverlayMarkerType;
     OverlayMarkerType[OverlayMarkerType["CUSTOM"] = 3] = "CUSTOM";
 })(OverlayMarkerType || (OverlayMarkerType = {}));
 class OrientationMarkerTool extends BaseTool {
-    static { this.CUBE = 1; }
-    static { this.AXIS = 2; }
-    static { this.VTPFILE = 3; }
-    static { this.OVERLAY_MARKER_TYPES = OverlayMarkerType; }
     constructor(toolProps = {}, defaultToolProps = {
         configuration: {
             orientationWidget: {
@@ -282,5 +278,9 @@ class OrientationMarkerTool extends BaseTool {
         return axes;
     }
 }
+OrientationMarkerTool.CUBE = 1;
+OrientationMarkerTool.AXIS = 2;
+OrientationMarkerTool.VTPFILE = 3;
+OrientationMarkerTool.OVERLAY_MARKER_TYPES = OverlayMarkerType;
 OrientationMarkerTool.toolName = 'OrientationMarker';
 export default OrientationMarkerTool;

package/dist/esm/tools/PanTool.js

@@ -1,5 +1,5 @@
 import { BaseTool } from './base';
-import { getEnabledElement, utilities as csUtils } from '@cornerstonejs/core';
+import { getEnabledElement, utilities as csUtils, viewportHasPan, } from '@cornerstonejs/core';
 class PanTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -7,7 +7,7 @@ class PanTool extends BaseTool {
             limitToViewport: false,
             ignoreX: false,
             ignoreY: false,
-            ignoreZ: false
+            ignoreZ: false,
         },
     }) {
         super(toolProps, defaultToolProps);
@@ -92,7 +92,19 @@ class PanTool extends BaseTool {
             deltaPointsWorld[2] = 0;
         }
         const viewport = enabledElement.viewport;
-        const camera = viewport.getCamera();
+        const camera = getLegacyCamera(viewport);
+        if (!hasLegacyCameraPosition(camera)) {
+            if (!viewportHasPan(viewport)) {
+                return;
+            }
+            const pan = viewport.getPan();
+            viewport.setPan([
+                pan[0] + deltaPointsCanvas[0],
+                pan[1] + deltaPointsCanvas[1],
+            ]);
+            viewport.render();
+            return;
+        }
         const { focalPoint, position } = camera;
         if (this.configuration.limitToViewport &&
             !this._checkImageInViewport(viewport, deltaPointsCanvas)) {
@@ -115,5 +127,16 @@ class PanTool extends BaseTool {
         viewport.render();
     }
 }
+function getLegacyCamera(viewport) {
+    const maybeViewport = viewport;
+    return typeof maybeViewport.getCamera === 'function'
+        ? maybeViewport.getCamera()
+        : undefined;
+}
+function hasLegacyCameraPosition(camera) {
+    return Boolean(camera &&
+        Array.isArray(camera.focalPoint) &&
+        Array.isArray(camera.position));
+}
 PanTool.toolName = 'Pan';
 export default PanTool;

package/dist/esm/tools/PlanarRotateTool.js

@@ -2,6 +2,8 @@ import { BaseVolumeViewport, getEnabledElement } from '@cornerstonejs/core';
 import { mat4, vec3 } from 'gl-matrix';
 import { BaseTool } from './base';
 import angleBetweenLines from '../utilities/math/angle/angleBetweenLines';
+import getViewportICamera from '../utilities/getViewportICamera';
+import { applyViewportPresentation, getViewportPresentation, } from '../utilities/viewportPresentation';
 class PlanarRotateTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -24,13 +26,16 @@ class PlanarRotateTool extends BaseTool {
         const startPointWorld = startPoints.world;
         const enabledElement = getEnabledElement(element);
         const { viewport } = enabledElement;
-        const camera = viewport.getCamera();
+        const camera = getViewportICamera(viewport);
         const width = element.clientWidth;
         const height = element.clientHeight;
         const centerCanvas = [width * 0.5, height * 0.5];
         const centerWorld = viewport.canvasToWorld(centerCanvas);
         let angle = angleBetweenLines([startPointWorld, centerWorld], [centerWorld, currentPointWorld]);
         const { viewPlaneNormal } = camera;
+        if (!viewPlaneNormal) {
+            return;
+        }
         const v1 = vec3.sub(vec3.create(), centerWorld, startPointWorld);
         const v2 = vec3.sub(vec3.create(), centerWorld, currentPointWorld);
         const cross = vec3.cross(vec3.create(), v1, v2);
@@ -43,7 +48,10 @@ class PlanarRotateTool extends BaseTool {
         this.setAngle(viewport, angle);
     }
     setAngle(viewport, angle) {
-        const { viewPlaneNormal, viewUp } = viewport.getCamera();
+        const { viewPlaneNormal, viewUp } = getViewportICamera(viewport);
+        if (!viewPlaneNormal || !viewUp) {
+            return;
+        }
         if (viewport instanceof BaseVolumeViewport) {
             const rotAngle = (((angle + 360) % 360) * Math.PI) / 180;
             const rotMat = mat4.identity(new Float32Array(16));
@@ -52,10 +60,17 @@ class PlanarRotateTool extends BaseTool {
             viewport.setCamera({ viewUp: rotatedViewUp });
         }
         else {
-            const { rotation } = viewport.getViewPresentation();
-            viewport.setViewPresentation({
+            const presentation = getViewportPresentation(viewport);
+            if (!presentation) {
+                return;
+            }
+            const { rotation = 0 } = presentation;
+            const didApply = applyViewportPresentation(viewport, {
                 rotation: (rotation + angle + 360) % 360,
             });
+            if (!didApply) {
+                return;
+            }
         }
         viewport.render();
     }

package/dist/esm/tools/ReferenceCursors.js

@@ -96,7 +96,13 @@ class ReferenceCursors extends AnnotationDisplayTool {
         };
         this.onCameraModified = (evt) => {
             const eventDetail = evt.detail;
-            const { element, previousCamera, camera } = eventDetail;
+            const { previousCamera, camera } = eventDetail;
+            const element = eventDetail.element ||
+                evt.currentTarget ||
+                evt.target;
+            if (!element || !previousCamera) {
+                return;
+            }
             const enabledElement = getEnabledElement(element);
             const viewport = enabledElement.viewport;
             if (element !== this._elementWithCursor) {

package/dist/esm/tools/SculptorTool/CircleSculptCursor.js

@@ -11,7 +11,6 @@ class CircleSculptCursor {
             maxToolSize: null,
         };
     }
-    static { this.shapeName = 'Circle'; }
     renderShape(svgDrawingHelper, canvasLocation, options) {
         const circleUID = '0';
         drawCircleSvg(svgDrawingHelper, 'SculptorTool', circleUID, canvasLocation, this.toolInfo.toolSize, options);
@@ -74,4 +73,5 @@ class CircleSculptCursor {
         return vec3.distance(point, mousePoint) < this.toolInfo.radius;
     }
 }
+CircleSculptCursor.shapeName = 'Circle';
 export default CircleSculptCursor;

package/dist/esm/tools/TrackballRotateTool.js

@@ -4,6 +4,7 @@ import { eventTarget, getEnabledElement, getEnabledElementByIds, } from '@corner
 import { mat4, vec3 } from 'gl-matrix';
 import { BaseTool } from './base';
 import { getToolGroup } from '../store/ToolGroupManager';
+import { applyViewportPresentation, getViewportPresentation, } from '../utilities/viewportPresentation';
 class TrackballRotateTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -64,9 +65,9 @@ class TrackballRotateTool extends BaseTool {
                                 return;
                             }
                             const { viewport } = element;
-                            const viewPresentation = viewport.getViewPresentation();
+                            const viewPresentation = getViewportPresentation(viewport);
                             viewport.resetCamera();
-                            viewport.setViewPresentation(viewPresentation);
+                            applyViewportPresentation(viewport, viewPresentation);
                             viewport.render();
                         });
                         resizeObserver.observe(element);

package/dist/esm/tools/VolumeCroppingTool.js

@@ -12,6 +12,7 @@ import { Events } from '../enums';
 import { PLANEINDEX, SPHEREINDEX, NUM_CLIPPING_PLANES, extractVolumeDirectionVectors, parseCornerKey, copyClippingPlanes, } from '../utilities/volumeCropping';
 import { addLine3DBetweenPoints, calculateAdaptiveSphereRadius, } from '../utilities/draw3D';
 import { isDragOwnedBy } from '../utilities/interactionDragCoordinator';
+import { applyViewportPresentation, getViewportPresentation, } from '../utilities/viewportPresentation';
 class VolumeCroppingTool extends BaseTool {
     constructor(toolProps = {}, defaultToolProps = {
         configuration: {
@@ -708,9 +709,9 @@ class VolumeCroppingTool extends BaseTool {
                             return;
                         }
                         const { viewport } = element;
-                        const viewPresentation = viewport.getViewPresentation();
+                        const viewPresentation = getViewportPresentation(viewport);
                         viewport.resetCamera();
-                        viewport.setViewPresentation(viewPresentation);
+                        applyViewportPresentation(viewport, viewPresentation);
                         viewport.render();
                     });
                     resizeObserver.observe(element);

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

@@ -19,12 +19,13 @@ declare class WindowLevelTool extends BaseTool {
         lower: any;
         upper: any;
     };
-    getNewRange({ viewport, deltaPointsCanvas, volumeId, lower, upper }: {
+    getNewRange({ viewport, deltaPointsCanvas, volumeId, lower, upper, voiLutFunction, }: {
         viewport: any;
         deltaPointsCanvas: any;
         volumeId: any;
         lower: any;
         upper: any;
+        voiLutFunction: any;
     }): {
         lower: number;
         upper: number;

package/dist/esm/tools/WindowLevelTool.js

@@ -45,7 +45,10 @@ class WindowLevelTool extends BaseTool {
         const { viewport } = enabledElement;
         let volumeId, lower, upper, modality, newRange, viewportsContainingVolumeUID;
         let isPreScaled = false;
-        const properties = viewport.getProperties();
+        const properties = getViewportVOIProperties(viewport);
+        if (!properties?.voiRange) {
+            throw new Error('Viewport is not a valid type');
+        }
         if (viewport instanceof VolumeViewport) {
             volumeId = viewport.getVolumeId();
             viewportsContainingVolumeUID =
@@ -86,12 +89,13 @@ class WindowLevelTool extends BaseTool {
                 volumeId,
                 lower,
                 upper,
+                voiLutFunction: properties.VOILUTFunction,
             });
         }
         if (newRange.lower >= newRange.upper) {
             return;
         }
-        viewport.setProperties({
+        setViewportVOIProperties(viewport, {
             voiRange: newRange,
         });
         viewport.render();
@@ -120,7 +124,7 @@ class WindowLevelTool extends BaseTool {
         upper = isPreScaled ? Math.max(upper, 0.1) : upper;
         return { lower, upper };
     }
-    getNewRange({ viewport, deltaPointsCanvas, volumeId, lower, upper }) {
+    getNewRange({ viewport, deltaPointsCanvas, volumeId, lower, upper, voiLutFunction, }) {
         const multiplier = this._getMultiplierFromDynamicRange(viewport, volumeId) ||
             DEFAULT_MULTIPLIER;
         const wwDelta = deltaPointsCanvas[0] * multiplier;
@@ -129,7 +133,6 @@ class WindowLevelTool extends BaseTool {
         windowWidth += wwDelta;
         windowCenter += wcDelta;
         windowWidth = Math.max(windowWidth, 1);
-        const voiLutFunction = viewport.getProperties().VOILUTFunction;
         return utilities.windowLevel.toLowHighRange(windowWidth, windowCenter, voiLutFunction);
     }
     _getMultiplierFromDynamicRange(viewport, volumeId) {
@@ -206,3 +209,44 @@ class WindowLevelTool extends BaseTool {
 }
 WindowLevelTool.toolName = 'WindowLevel';
 export default WindowLevelTool;
+function getViewportVOIProperties(viewport) {
+    const legacyViewport = viewport;
+    if (typeof legacyViewport.getProperties === 'function') {
+        return legacyViewport.getProperties();
+    }
+    const target = getDataPresentationTarget(viewport);
+    if (!target) {
+        return;
+    }
+    const dataPresentation = target.viewport.getDisplaySetPresentation?.(target.dataId);
+    const defaultVOIRange = target.viewport.getDefaultVOIRange?.(target.dataId);
+    return {
+        ...(dataPresentation || {}),
+        voiRange: dataPresentation?.voiRange ?? defaultVOIRange,
+    };
+}
+function setViewportVOIProperties(viewport, props) {
+    const legacyViewport = viewport;
+    if (typeof legacyViewport.setProperties === 'function') {
+        legacyViewport.setProperties(props);
+        return;
+    }
+    const target = getDataPresentationTarget(viewport);
+    if (!target) {
+        return;
+    }
+    target.viewport.setDisplaySetPresentation?.(target.dataId, props);
+}
+function getDataPresentationTarget(viewport) {
+    const genericViewport = viewport;
+    const dataId = genericViewport.getSourceDataId?.();
+    if (!dataId ||
+        typeof genericViewport.getDisplaySetPresentation !== 'function' ||
+        typeof genericViewport.setDisplaySetPresentation !== 'function') {
+        return;
+    }
+    return {
+        viewport: genericViewport,
+        dataId,
+    };
+}

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

@@ -17,5 +17,13 @@ declare class ZoomTool extends BaseTool {
     _dragPerspectiveProjection: (evt: EventTypes.InteractionEventType, viewport: Types.IStackViewport | Types.IVolumeViewport, camera: Types.ICamera, pinch?: boolean) => void;
     _zoom(evt: EventTypes.MouseWheelEventType): void;
     _panCallback(evt: EventTypes.InteractionEventType): void;
+    _dragViewportZoom(evt: EventTypes.InteractionEventType, viewport: {
+        getZoom(): number;
+        setZoom(...args: unknown[]): void;
+    }): void;
+    _applyViewportZoomDelta(viewport: {
+        getZoom(): number;
+        setZoom(...args: unknown[]): void;
+    }, element: HTMLDivElement, deltaY: number, canvasPoint?: Types.Point2): void;
 }
 export default ZoomTool;