@ohif/app 3.9.0-beta.4 → 3.9.0-beta.40

package/dist/{35.bundle.0168d78bfad0cb784112.js → 501.bundle.2f703ca4598a3be0d748.js}

@@ -1,4 +1,4 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[35],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[501],{
 
 /***/ 6203:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -260,13 +260,15 @@ class BaseVolumeViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_14__/* ["def
     static get useCustomRenderingPipeline() {
         return false;
     }
-    applyViewOrientation(orientation) {
+    applyViewOrientation(orientation, resetCamera = true) {
         const { viewPlaneNormal, viewUp } = this._getOrientationVectors(orientation);
         const camera = this.getVtkActiveCamera();
         camera.setDirectionOfProjection(-viewPlaneNormal[0], -viewPlaneNormal[1], -viewPlaneNormal[2]);
         camera.setViewUpFrom(viewUp);
         this.initialViewUp = viewUp;
-        this.resetCamera();
+        if (resetCamera) {
+            this.resetCamera();
+        }
     }
     initializeVolumeNewImageEventDispatcher() {
         const volumeNewImageHandlerBound = volumeNewImageHandler.bind(this);
@@ -495,28 +497,96 @@ class BaseVolumeViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_14__/* ["def
     }
     getViewReference(viewRefSpecifier = {}) {
         const target = super.getViewReference(viewRefSpecifier);
+        const volumeId = this.getVolumeId(viewRefSpecifier);
         if (viewRefSpecifier?.forFrameOfReference !== false) {
-            target.volumeId = this.getVolumeId(viewRefSpecifier);
+            target.volumeId = volumeId;
         }
-        return {
-            ...target,
-            sliceIndex: this.getCurrentImageIdIndex(),
-        };
+        if (typeof viewRefSpecifier?.sliceIndex !== 'number') {
+            return target;
+        }
+        const { viewPlaneNormal } = target;
+        const delta = viewRefSpecifier.sliceIndex - this.getSliceIndex();
+        const { sliceRangeInfo } = (0,_utilities__WEBPACK_IMPORTED_MODULE_11__.getVolumeViewportScrollInfo)(this, volumeId, true);
+        const { sliceRange, spacingInNormalDirection, camera } = sliceRangeInfo;
+        const { focalPoint, position } = camera;
+        const { newFocalPoint } = (0,_utilities__WEBPACK_IMPORTED_MODULE_11__.snapFocalPointToSlice)(focalPoint, position, sliceRange, viewPlaneNormal, spacingInNormalDirection, delta);
+        target.cameraFocalPoint = newFocalPoint;
+        return target;
     }
     isReferenceViewable(viewRef, options) {
+        if (!viewRef.FrameOfReferenceUID) {
+            return false;
+        }
         if (!super.isReferenceViewable(viewRef, options)) {
             return false;
         }
         if (options?.withNavigation) {
             return true;
         }
-        const currentSliceIndex = this.getCurrentImageIdIndex();
+        const currentSliceIndex = this.getSliceIndex();
         const { sliceIndex } = viewRef;
         if (Array.isArray(sliceIndex)) {
             return (sliceIndex[0] <= currentSliceIndex && currentSliceIndex <= sliceIndex[1]);
         }
         return sliceIndex === undefined || sliceIndex === currentSliceIndex;
     }
+    scroll(delta = 1) {
+        const volumeId = this.getVolumeId();
+        const { sliceRangeInfo } = (0,_utilities__WEBPACK_IMPORTED_MODULE_11__.getVolumeViewportScrollInfo)(this, volumeId, true);
+        if (!sliceRangeInfo) {
+            return;
+        }
+        const { sliceRange, spacingInNormalDirection, camera } = sliceRangeInfo;
+        const { focalPoint, viewPlaneNormal, position } = camera;
+        const { newFocalPoint, newPosition } = (0,_utilities__WEBPACK_IMPORTED_MODULE_11__.snapFocalPointToSlice)(focalPoint, position, sliceRange, viewPlaneNormal, spacingInNormalDirection, delta);
+        this.setCamera({
+            focalPoint: newFocalPoint,
+            position: newPosition,
+        });
+    }
+    setViewReference(viewRef) {
+        if (!viewRef) {
+            return;
+        }
+        const volumeId = this.getVolumeId();
+        const { viewPlaneNormal: refViewPlaneNormal, FrameOfReferenceUID: refFrameOfReference, cameraFocalPoint, viewUp, } = viewRef;
+        let { sliceIndex } = viewRef;
+        const { focalPoint, viewPlaneNormal, position } = this.getCamera();
+        const isNegativeNormal = (0,_utilities__WEBPACK_IMPORTED_MODULE_11__.isEqualNegative)(viewPlaneNormal, refViewPlaneNormal);
+        const isSameNormal = (0,_utilities__WEBPACK_IMPORTED_MODULE_11__.isEqual)(viewPlaneNormal, refViewPlaneNormal);
+        if (typeof sliceIndex === 'number' &&
+            viewRef.volumeId === volumeId &&
+            (isNegativeNormal || isSameNormal)) {
+            const { currentStepIndex, sliceRangeInfo, numScrollSteps } = (0,_utilities__WEBPACK_IMPORTED_MODULE_11__.getVolumeViewportScrollInfo)(this, volumeId, true);
+            const { sliceRange, spacingInNormalDirection } = sliceRangeInfo;
+            if (isNegativeNormal) {
+                sliceIndex = numScrollSteps - sliceIndex - 1;
+            }
+            const delta = sliceIndex - currentStepIndex;
+            const { newFocalPoint, newPosition } = (0,_utilities__WEBPACK_IMPORTED_MODULE_11__.snapFocalPointToSlice)(focalPoint, position, sliceRange, viewPlaneNormal, spacingInNormalDirection, delta);
+            this.setCamera({ focalPoint: newFocalPoint, position: newPosition });
+        }
+        else if (refFrameOfReference === this.getFrameOfReferenceUID()) {
+            if (refViewPlaneNormal && !isNegativeNormal && !isSameNormal) {
+                this.setOrientation({ viewPlaneNormal: refViewPlaneNormal, viewUp });
+                return this.setViewReference(viewRef);
+            }
+            if (cameraFocalPoint) {
+                const focalDelta = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.subtract */ .eR.subtract([0, 0, 0], cameraFocalPoint, focalPoint);
+                const useNormal = refViewPlaneNormal ?? viewPlaneNormal;
+                const normalDot = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.dot */ .eR.dot(focalDelta, useNormal);
+                if (!(0,_utilities__WEBPACK_IMPORTED_MODULE_11__.isEqual)(normalDot, 0)) {
+                    gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.scale */ .eR.scale(focalDelta, useNormal, normalDot);
+                }
+                const newFocal = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.add */ .eR.add([0, 0, 0], focalPoint, focalDelta);
+                const newPosition = gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.add */ .eR.add([0, 0, 0], position, focalDelta);
+                this.setCamera({ focalPoint: newFocal, position: newPosition });
+            }
+        }
+        else {
+            throw new Error(`Incompatible view refs: ${refFrameOfReference}!==${this.getFrameOfReferenceUID()}`);
+        }
+    }
     setProperties({ voiRange, VOILUTFunction, invert, colormap, preset, interpolationType, slabThickness, rotation, } = {}, volumeId, suppressEvents = false) {
         if (this.globalDefaultProperties == null) {
             this.setDefaultProperties({
@@ -675,7 +745,7 @@ class BaseVolumeViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_14__/* ["def
             this.render();
         }
     }
-    setOrientation(orientation, immediate = true) {
+    setOrientation(_orientation, _immediate = true) {
         console.warn('Method "setOrientation" needs implementation');
     }
     initializeColorTransferFunction(volumeInputArray) {
@@ -811,14 +881,15 @@ class BaseVolumeViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_14__/* ["def
         return volume.getScalarData()[voxelIndex];
     }
     getVolumeId(specifier) {
+        const actorEntries = this.getActors();
+        if (!actorEntries) {
+            return;
+        }
         if (!specifier?.volumeId) {
-            const actorEntries = this.getActors();
-            if (!actorEntries) {
-                return;
-            }
             return actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume')?.uid;
         }
-        return specifier.volumeId;
+        return actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume' &&
+            actorEntry.uid === specifier.volumeId)?.uid;
     }
     getReferenceId(specifier = {}) {
         let { volumeId, sliceIndex: sliceIndex } = specifier;
@@ -829,7 +900,8 @@ class BaseVolumeViewport extends _Viewport__WEBPACK_IMPORTED_MODULE_14__/* ["def
             }
             volumeId = actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume')?.uid;
         }
-        sliceIndex ??= this.getCurrentImageIdIndex();
+        const currentIndex = this.getSliceIndex();
+        sliceIndex ??= currentIndex;
         const { viewPlaneNormal, focalPoint } = this.getCamera();
         const querySeparator = volumeId.indexOf('?') > -1 ? '&' : '?';
         return `volumeId:${volumeId}${querySeparator}sliceIndex=${sliceIndex}&viewPlaneNormal=${viewPlaneNormal.join(',')}&focalPoint=${focalPoint.join(',')}`;
@@ -1968,20 +2040,8 @@ class StackViewport extends Viewport/* default */.A {
                 resize(this._cpuFallbackEnabledElement);
             }
         };
-        this.getFrameOfReferenceUID = () => {
-            const imageId = this.getCurrentImageId();
-            if (!imageId) {
-                return;
-            }
-            const imagePlaneModule = metaData.get('imagePlaneModule', imageId);
-            if (!imagePlaneModule) {
-                return;
-            }
-            return imagePlaneModule.frameOfReferenceUID;
-        };
-        this.getCornerstoneImage = () => {
-            return this.csImage;
-        };
+        this.getFrameOfReferenceUID = (sliceIndex) => this.getImagePlaneReferenceData(sliceIndex)?.FrameOfReferenceUID;
+        this.getCornerstoneImage = () => this.csImage;
         this.createActorMapper = (imageData) => {
             const mapper = vtkImageMapper$1.newInstance();
             mapper.setInputData(imageData);
@@ -2957,6 +3017,28 @@ class StackViewport extends Viewport/* default */.A {
             imagePixelModule,
         };
     }
+    getImagePlaneReferenceData(sliceIndex = this.getCurrentImageIdIndex()) {
+        const imageId = this.imageIds[sliceIndex];
+        if (!imageId) {
+            return;
+        }
+        const imagePlaneModule = metaData.get(enums.MetadataModules.IMAGE_PLANE, imageId);
+        if (!imagePlaneModule) {
+            return;
+        }
+        const { imagePositionPatient, frameOfReferenceUID: FrameOfReferenceUID } = imagePlaneModule;
+        let { rowCosines, columnCosines } = imagePlaneModule;
+        rowCosines ||= [1, 0, 0];
+        columnCosines ||= [0, 1, 0];
+        const viewPlaneNormal = (esm/* vec3.cross */.eR.cross([0, 0, 0], columnCosines, rowCosines));
+        return {
+            FrameOfReferenceUID,
+            viewPlaneNormal,
+            cameraFocalPoint: imagePositionPatient,
+            referencedImageId: imageId,
+            sliceIndex,
+        };
+    }
     _getCameraOrientation(imageDataDirection) {
         const viewPlaneNormal = imageDataDirection.slice(6, 9).map((x) => -x);
         const viewUp = imageDataDirection.slice(3, 6).map((x) => -x);
@@ -3272,7 +3354,7 @@ class StackViewport extends Viewport/* default */.A {
         this.cpuRenderingInvalidated = true;
         this._cpuFallbackEnabledElement.transform = (0,calculateTransform/* default */.A)(this._cpuFallbackEnabledElement);
     }
-    async addImages(stackInputs) {
+    addImages(stackInputs) {
         const actors = this.getActors();
         stackInputs.forEach((stackInput) => {
             const image = cache/* default */.Ay.getImage(stackInput.imageId);
@@ -3567,24 +3649,39 @@ class StackViewport extends Viewport/* default */.A {
         return referencedImageId?.endsWith(imageURI);
     }
     getViewReference(viewRefSpecifier = {}) {
-        const { sliceIndex: sliceIndex = this.currentImageIdIndex } = viewRefSpecifier;
-        return {
-            ...super.getViewReference(viewRefSpecifier),
-            referencedImageId: `${this.imageIds[sliceIndex]}`,
-            sliceIndex: sliceIndex,
-        };
-    }
-    setView(viewRef, viewPres) {
-        const camera = this.getCamera();
-        super.setView(viewRef, viewPres);
-        if (viewRef) {
-            const { viewPlaneNormal, sliceIndex } = viewRef;
-            if (viewPlaneNormal &&
-                !(0,utilities.isEqual)(viewPlaneNormal, camera.viewPlaneNormal)) {
+        const { sliceIndex = this.getCurrentImageIdIndex() } = viewRefSpecifier;
+        const reference = super.getViewReference(viewRefSpecifier);
+        const referencedImageId = this.imageIds[sliceIndex];
+        if (!referencedImageId) {
+            return;
+        }
+        reference.referencedImageId = referencedImageId;
+        if (this.getCurrentImageIdIndex() !== sliceIndex) {
+            const referenceData = this.getImagePlaneReferenceData(sliceIndex);
+            if (!referenceData) {
                 return;
             }
-            if (sliceIndex || sliceIndex === 0) {
-                this.setImageIdIndex(sliceIndex);
+            Object.assign(reference, referenceData);
+        }
+        return reference;
+    }
+    setViewReference(viewRef) {
+        if (!viewRef) {
+            return;
+        }
+        const { referencedImageId, sliceIndex, volumeId } = viewRef;
+        if (typeof sliceIndex === 'number' &&
+            referencedImageId &&
+            referencedImageId === this.imageIds[sliceIndex]) {
+            this.setImageIdIndex(sliceIndex);
+        }
+        else {
+            const foundIndex = this.imageIds.indexOf(referencedImageId);
+            if (foundIndex !== -1) {
+                this.setImageIdIndex(foundIndex);
+            }
+            else {
+                throw new Error('Unsupported - referenced image id not found');
             }
         }
     }
@@ -4480,7 +4577,7 @@ class VideoViewport extends Viewport/* default */.A {
         if (options.withNavigation) {
             return true;
         }
-        const currentIndex = this.getCurrentImageIdIndex();
+        const currentIndex = this.getSliceIndex();
         if (Array.isArray(sliceIndex)) {
             return currentIndex >= sliceIndex[0] && currentIndex <= sliceIndex[1];
         }
@@ -4517,6 +4614,9 @@ class VideoViewport extends Viewport/* default */.A {
     getCurrentImageIdIndex() {
         return Math.round(this.videoElement.currentTime * this.fps);
     }
+    getSliceIndex() {
+        return this.getCurrentImageIdIndex();
+    }
     getCamera() {
         const { parallelScale } = this.videoCamera;
         const canvasCenter = [
@@ -4920,7 +5020,7 @@ class Viewport {
             this.setDisplayAreaScale(displayArea);
         }
         else {
-            this.setInterpolationType(this.getProperties().interpolationType || _enums__WEBPACK_IMPORTED_MODULE_13__.InterpolationType.LINEAR);
+            this.setInterpolationType(this.getProperties()?.interpolationType || _enums__WEBPACK_IMPORTED_MODULE_13__.InterpolationType.LINEAR);
             this.setDisplayAreaFit(displayArea);
         }
         if (storeAsInitialCamera) {
@@ -5126,6 +5226,9 @@ class Viewport {
     getCurrentImageIdIndex() {
         throw new Error('Not implemented');
     }
+    getSliceIndex() {
+        throw new Error('Not implemented');
+    }
     getReferenceId(_specifier) {
         return null;
     }
@@ -5149,6 +5252,9 @@ class Viewport {
         }, storeAsInitialCamera);
     }
     getZoom(compareCamera = this.initialCamera) {
+        if (!compareCamera) {
+            return 1;
+        }
         const activeCamera = this.getVtkActiveCamera();
         const { parallelScale: initialParallelScale } = compareCamera;
         return initialParallelScale / activeCamera.getParallelScale();
@@ -5402,12 +5508,13 @@ class Viewport {
         return { widthWorld: maxX - minX, heightWorld: maxY - minY };
     }
     getViewReference(viewRefSpecifier = {}) {
-        const { focalPoint: cameraFocalPoint, viewPlaneNormal } = this.getCamera();
+        const { focalPoint: cameraFocalPoint, viewPlaneNormal, viewUp, } = this.getCamera();
         const target = {
             FrameOfReferenceUID: this.getFrameOfReferenceUID(),
             cameraFocalPoint,
             viewPlaneNormal,
-            sliceIndex: viewRefSpecifier.sliceIndex ?? this.getCurrentImageIdIndex(),
+            viewUp,
+            sliceIndex: viewRefSpecifier.sliceIndex ?? this.getSliceIndex(),
         };
         return target;
     }
@@ -5421,7 +5528,7 @@ class Viewport {
         if (viewPlaneNormal &&
             !(0,_utilities__WEBPACK_IMPORTED_MODULE_9__.isEqual)(viewPlaneNormal, camera.viewPlaneNormal) &&
             !(0,_utilities__WEBPACK_IMPORTED_MODULE_9__.isEqual)(gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec3.negate */ .eR.negate(camera.viewPlaneNormal, camera.viewPlaneNormal), viewPlaneNormal)) {
-            return options?.asVolume === true;
+            return options?.withOrientation === true;
         }
         return true;
     }
@@ -5449,19 +5556,22 @@ class Viewport {
         }
         return target;
     }
-    setView(viewRef, viewPres) {
-        if (viewPres) {
-            const { displayArea, zoom = this.getZoom(), pan, rotation } = viewPres;
-            if (displayArea !== this.getDisplayArea()) {
-                this.setDisplayArea(displayArea);
-            }
-            this.setZoom(zoom);
-            if (pan) {
-                this.setPan(gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec2.scale */ .Zc.scale([0, 0], pan, zoom));
-            }
-            if (rotation >= 0) {
-                this.setRotation(rotation);
-            }
+    setViewReference(viewRef) {
+    }
+    setViewPresentation(viewPres) {
+        if (!viewPres) {
+            return;
+        }
+        const { displayArea, zoom = this.getZoom(), pan, rotation } = viewPres;
+        if (displayArea !== this.getDisplayArea()) {
+            this.setDisplayArea(displayArea);
+        }
+        this.setZoom(zoom);
+        if (pan) {
+            this.setPan(gl_matrix__WEBPACK_IMPORTED_MODULE_3__/* .vec2.scale */ .Zc.scale([0, 0], pan, zoom));
+        }
+        if (rotation >= 0) {
+            this.setRotation(rotation);
         }
     }
     _shouldUseNativeDataType() {
@@ -5550,15 +5660,15 @@ class Viewport {
 /* harmony export */   A: () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
 /* harmony import */ var _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(84441);
-/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(44753);
-/* harmony import */ var _cache__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(13320);
-/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(88903);
-/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(98362);
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(35678);
-/* harmony import */ var _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(6203);
-/* harmony import */ var _helpers_setDefaultVolumeVOI__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(83853);
-/* harmony import */ var _utilities_transferFunctionUtils__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(22350);
-/* harmony import */ var _utilities_getImageSliceDataForVolumeViewport__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(97508);
+/* harmony import */ var _cache__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(13320);
+/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(88903);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(98362);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(35678);
+/* harmony import */ var _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(6203);
+/* harmony import */ var _helpers_setDefaultVolumeVOI__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(83853);
+/* harmony import */ var _utilities_transferFunctionUtils__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(22350);
+/* harmony import */ var _utilities_getImageSliceDataForVolumeViewport__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(97508);
+/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(44753);
 
 
 
@@ -5569,18 +5679,14 @@ class Viewport {
 
 
 
-class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A {
+class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A {
     constructor(props) {
         super(props);
         this._useAcquisitionPlaneForViewPlane = false;
         this.getNumberOfSlices = () => {
-            const { numberOfSlices } = (0,_utilities_getImageSliceDataForVolumeViewport__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(this);
+            const { numberOfSlices } = (0,_utilities_getImageSliceDataForVolumeViewport__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)(this);
             return numberOfSlices;
         };
-        this.getSliceIndex = () => {
-            const { imageIndex } = (0,_utilities_getImageSliceDataForVolumeViewport__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(this);
-            return imageIndex;
-        };
         this.getCurrentImageIdIndex = (volumeId) => {
             const { viewPlaneNormal, focalPoint } = this.getCamera();
             const imageData = this.getImageData(volumeId);
@@ -5588,24 +5694,28 @@ class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__/*
                 return;
             }
             const { origin, direction, spacing } = imageData;
-            const spacingInNormal = (0,_utilities__WEBPACK_IMPORTED_MODULE_5__.getSpacingInNormalDirection)({ direction, spacing }, viewPlaneNormal);
-            const sub = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.create */ .eR.create();
-            gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.sub */ .eR.sub(sub, focalPoint, origin);
-            const distance = gl_matrix__WEBPACK_IMPORTED_MODULE_1__/* .vec3.dot */ .eR.dot(sub, viewPlaneNormal);
+            const spacingInNormal = (0,_utilities__WEBPACK_IMPORTED_MODULE_4__.getSpacingInNormalDirection)({ direction, spacing }, viewPlaneNormal);
+            const sub = gl_matrix__WEBPACK_IMPORTED_MODULE_9__/* .vec3.create */ .eR.create();
+            gl_matrix__WEBPACK_IMPORTED_MODULE_9__/* .vec3.sub */ .eR.sub(sub, focalPoint, origin);
+            const distance = gl_matrix__WEBPACK_IMPORTED_MODULE_9__/* .vec3.dot */ .eR.dot(sub, viewPlaneNormal);
             return Math.round(Math.abs(distance) / spacingInNormal);
         };
+        this.getSliceIndex = () => {
+            const { imageIndex } = (0,_utilities_getImageSliceDataForVolumeViewport__WEBPACK_IMPORTED_MODULE_8__/* ["default"] */ .A)(this);
+            return imageIndex;
+        };
         this.getCurrentImageId = () => {
             const actorEntry = this.getDefaultActor();
-            if (!actorEntry || !(0,_utilities__WEBPACK_IMPORTED_MODULE_5__.actorIsA)(actorEntry, 'vtkVolume')) {
+            if (!actorEntry || !(0,_utilities__WEBPACK_IMPORTED_MODULE_4__.actorIsA)(actorEntry, 'vtkVolume')) {
                 return;
             }
             const { uid } = actorEntry;
-            const volume = _cache__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Ay.getVolume(uid);
+            const volume = _cache__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay.getVolume(uid);
             if (!volume) {
                 return;
             }
             const { viewPlaneNormal, focalPoint } = this.getCamera();
-            return (0,_utilities__WEBPACK_IMPORTED_MODULE_5__.getClosestImageId)(volume, focalPoint, viewPlaneNormal);
+            return (0,_utilities__WEBPACK_IMPORTED_MODULE_4__.getClosestImageId)(volume, focalPoint, viewPlaneNormal);
         };
         this.getSlicePlaneCoordinates = () => {
             const actorEntry = this.getDefaultActor();
@@ -5614,30 +5724,30 @@ class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__/*
                 return [];
             }
             const volumeId = actorEntry.uid;
-            const imageVolume = _cache__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Ay.getVolume(volumeId);
+            const imageVolume = _cache__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay.getVolume(volumeId);
             const camera = this.getCamera();
             const { focalPoint, position, viewPlaneNormal } = camera;
-            const spacingInNormalDirection = (0,_utilities__WEBPACK_IMPORTED_MODULE_5__.getSpacingInNormalDirection)(imageVolume, viewPlaneNormal);
-            const sliceRange = (0,_utilities__WEBPACK_IMPORTED_MODULE_5__.getSliceRange)(actorEntry.actor, viewPlaneNormal, focalPoint);
+            const spacingInNormalDirection = (0,_utilities__WEBPACK_IMPORTED_MODULE_4__.getSpacingInNormalDirection)(imageVolume, viewPlaneNormal);
+            const sliceRange = (0,_utilities__WEBPACK_IMPORTED_MODULE_4__.getSliceRange)(actorEntry.actor, viewPlaneNormal, focalPoint);
             const numSlicesBackward = Math.round((sliceRange.current - sliceRange.min) / spacingInNormalDirection);
             const numSlicesForward = Math.round((sliceRange.max - sliceRange.current) / spacingInNormalDirection);
             const currentSliceIndex = this.getSliceIndex();
             const focalPoints = [];
             for (let i = -numSlicesBackward; i <= numSlicesForward; i++) {
-                const { newFocalPoint: point } = (0,_utilities__WEBPACK_IMPORTED_MODULE_5__.snapFocalPointToSlice)(focalPoint, position, sliceRange, viewPlaneNormal, spacingInNormalDirection, i);
+                const { newFocalPoint: point } = (0,_utilities__WEBPACK_IMPORTED_MODULE_4__.snapFocalPointToSlice)(focalPoint, position, sliceRange, viewPlaneNormal, spacingInNormalDirection, i);
                 focalPoints.push({ sliceIndex: currentSliceIndex + i, point });
             }
             return focalPoints;
         };
         const { orientation } = this.options;
-        if (orientation && orientation !== _enums__WEBPACK_IMPORTED_MODULE_4__.OrientationAxis.ACQUISITION) {
+        if (orientation && orientation !== _enums__WEBPACK_IMPORTED_MODULE_3__.OrientationAxis.ACQUISITION) {
             this.applyViewOrientation(orientation);
             return;
         }
         this._useAcquisitionPlaneForViewPlane = true;
     }
     async setVolumes(volumeInputArray, immediate = false, suppressEvents = false) {
-        const firstImageVolume = _cache__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Ay.getVolume(volumeInputArray[0].volumeId);
+        const firstImageVolume = _cache__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay.getVolume(volumeInputArray[0].volumeId);
         if (!firstImageVolume) {
             throw new Error(`imageVolume with id: ${firstImageVolume.volumeId} does not exist`);
         }
@@ -5648,7 +5758,7 @@ class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__/*
         return super.setVolumes(volumeInputArray, immediate, suppressEvents);
     }
     async addVolumes(volumeInputArray, immediate = false, suppressEvents = false) {
-        const firstImageVolume = _cache__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Ay.getVolume(volumeInputArray[0].volumeId);
+        const firstImageVolume = _cache__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay.getVolume(volumeInputArray[0].volumeId);
         if (!firstImageVolume) {
             throw new Error(`imageVolume with id: ${firstImageVolume.volumeId} does not exist`);
         }
@@ -5661,8 +5771,8 @@ class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__/*
     setOrientation(orientation, immediate = true) {
         let viewPlaneNormal, viewUp;
         if (typeof orientation === 'string') {
-            if (_constants__WEBPACK_IMPORTED_MODULE_3__.MPR_CAMERA_VALUES[orientation]) {
-                ({ viewPlaneNormal, viewUp } = _constants__WEBPACK_IMPORTED_MODULE_3__.MPR_CAMERA_VALUES[orientation]);
+            if (_constants__WEBPACK_IMPORTED_MODULE_2__.MPR_CAMERA_VALUES[orientation]) {
+                ({ viewPlaneNormal, viewUp } = _constants__WEBPACK_IMPORTED_MODULE_2__.MPR_CAMERA_VALUES[orientation]);
             }
             else if (orientation === 'acquisition') {
                 ({ viewPlaneNormal, viewUp } = this._getAcquisitionPlaneOrientation());
@@ -5691,7 +5801,7 @@ class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__/*
             return;
         }
         const volumeId = actorEntry.uid;
-        const imageVolume = _cache__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Ay.getVolume(volumeId);
+        const imageVolume = _cache__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay.getVolume(volumeId);
         if (!imageVolume) {
             throw new Error(`imageVolume with id: ${volumeId} does not exist in cache`);
         }
@@ -5736,12 +5846,15 @@ class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__/*
             this.render();
         }
     }
-    resetCamera(resetPan = true, resetZoom = true, resetToCenter = true, resetRotation = false) {
+    resetCamera(resetPan = true, resetZoom = true, resetToCenter = true, resetRotation = false, supressEvents = false) {
+        const { orientation } = this.viewportProperties;
+        if (orientation) {
+            this.applyViewOrientation(orientation, false);
+        }
         super.resetCamera(resetPan, resetZoom, resetToCenter);
         this.resetVolumeViewportClippingRange();
         const activeCamera = this.getVtkActiveCamera();
         const viewPlaneNormal = activeCamera.getViewPlaneNormal();
-        const viewUp = activeCamera.getViewUp();
         const focalPoint = activeCamera.getFocalPoint();
         const actorEntries = this.getActors();
         actorEntries.forEach((actorEntry) => {
@@ -5754,7 +5867,7 @@ class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__/*
                 const clipPlane1 = _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_0__/* ["default"].newInstance */ .Ay.newInstance();
                 const clipPlane2 = _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_0__/* ["default"].newInstance */ .Ay.newInstance();
                 const newVtkPlanes = [clipPlane1, clipPlane2];
-                let slabThickness = _constants__WEBPACK_IMPORTED_MODULE_3__.RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
+                let slabThickness = _constants__WEBPACK_IMPORTED_MODULE_2__.RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
                 if (actorEntry.slabThickness) {
                     slabThickness = actorEntry.slabThickness;
                 }
@@ -5764,13 +5877,22 @@ class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__/*
             }
         });
         if (resetRotation &&
-            _constants__WEBPACK_IMPORTED_MODULE_3__.MPR_CAMERA_VALUES[this.viewportProperties.orientation] !== undefined) {
-            const viewToReset = _constants__WEBPACK_IMPORTED_MODULE_3__.MPR_CAMERA_VALUES[this.viewportProperties.orientation];
+            _constants__WEBPACK_IMPORTED_MODULE_2__.MPR_CAMERA_VALUES[this.viewportProperties.orientation] !== undefined) {
+            const viewToReset = _constants__WEBPACK_IMPORTED_MODULE_2__.MPR_CAMERA_VALUES[this.viewportProperties.orientation];
             this.setCameraNoEvent({
                 viewUp: viewToReset.viewUp,
                 viewPlaneNormal: viewToReset.viewPlaneNormal,
             });
         }
+        if (!supressEvents) {
+            const eventDetail = {
+                viewportId: this.id,
+                camera: this.getCamera(),
+                renderingEngineId: this.renderingEngineId,
+                element: this.element,
+            };
+            (0,_utilities__WEBPACK_IMPORTED_MODULE_4__.triggerEvent)(this.element, _enums__WEBPACK_IMPORTED_MODULE_3__.Events.CAMERA_RESET, eventDetail);
+        }
         return true;
     }
     setSlabThickness(slabThickness, filterActorUIDs = []) {
@@ -5784,7 +5906,7 @@ class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__/*
             });
         }
         actorEntries.forEach((actorEntry) => {
-            if ((0,_utilities__WEBPACK_IMPORTED_MODULE_5__.actorIsA)(actorEntry, 'vtkVolume')) {
+            if ((0,_utilities__WEBPACK_IMPORTED_MODULE_4__.actorIsA)(actorEntry, 'vtkVolume')) {
                 actorEntry.slabThickness = slabThickness;
             }
         });
@@ -5793,6 +5915,27 @@ class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__/*
         this.triggerCameraModifiedEventIfNecessary(currentCamera, currentCamera);
         this.viewportProperties.slabThickness = slabThickness;
     }
+    resetSlabThickness() {
+        const actorEntries = this.getActors();
+        actorEntries.forEach((actorEntry) => {
+            if ((0,_utilities__WEBPACK_IMPORTED_MODULE_4__.actorIsA)(actorEntry, 'vtkVolume')) {
+                actorEntry.slabThickness = _constants__WEBPACK_IMPORTED_MODULE_2__.RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
+            }
+        });
+        const currentCamera = this.getCamera();
+        this.updateClippingPlanesForActors(currentCamera);
+        this.triggerCameraModifiedEventIfNecessary(currentCamera, currentCamera);
+        this.viewportProperties.slabThickness = undefined;
+    }
+    getViewReference(viewRefSpecifier = {}) {
+        const viewRef = super.getViewReference(viewRefSpecifier);
+        if (!viewRef?.volumeId) {
+            return;
+        }
+        const volume = _cache__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay.getVolume(viewRef.volumeId);
+        viewRef.referencedImageId = (0,_utilities__WEBPACK_IMPORTED_MODULE_4__.getClosestImageId)(volume, viewRef.cameraFocalPoint, viewRef.viewPlaneNormal);
+        return viewRef;
+    }
     resetProperties(volumeId) {
         this._resetProperties(volumeId);
     }
@@ -5804,20 +5947,20 @@ class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__/*
             throw new Error(`No actor found for the given volumeId: ${volumeId}`);
         }
         if (volumeActor.slabThickness) {
-            volumeActor.slabThickness = _constants__WEBPACK_IMPORTED_MODULE_3__.RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
+            volumeActor.slabThickness = _constants__WEBPACK_IMPORTED_MODULE_2__.RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
             this.viewportProperties.slabThickness = undefined;
             this.updateClippingPlanesForActors(this.getCamera());
         }
-        const imageVolume = _cache__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Ay.getVolume(volumeActor.uid);
+        const imageVolume = _cache__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay.getVolume(volumeActor.uid);
         if (!imageVolume) {
             throw new Error(`imageVolume with id: ${volumeActor.uid} does not exist in cache`);
         }
-        (0,_helpers_setDefaultVolumeVOI__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .A)(volumeActor.actor, imageVolume, false);
-        if ((0,_utilities__WEBPACK_IMPORTED_MODULE_5__.isImageActor)(volumeActor)) {
+        (0,_helpers_setDefaultVolumeVOI__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .A)(volumeActor.actor, imageVolume, false);
+        if ((0,_utilities__WEBPACK_IMPORTED_MODULE_4__.isImageActor)(volumeActor)) {
             const transferFunction = volumeActor.actor
                 .getProperty()
                 .getRGBTransferFunction(0);
-            (0,_utilities_transferFunctionUtils__WEBPACK_IMPORTED_MODULE_8__.setTransferFunctionNodes)(transferFunction, this.initialTransferFunctionNodes);
+            (0,_utilities_transferFunctionUtils__WEBPACK_IMPORTED_MODULE_7__.setTransferFunctionNodes)(transferFunction, this.initialTransferFunctionNodes);
         }
         const eventDetails = {
             ...super.getVOIModifiedEventDetail(volumeId),
@@ -5827,12 +5970,12 @@ class VolumeViewport extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_6__/*
         const resetToCenter = true;
         const resetCameraRotation = true;
         this.resetCamera(resetPan, resetZoom, resetToCenter, resetCameraRotation);
-        (0,_utilities__WEBPACK_IMPORTED_MODULE_5__.triggerEvent)(this.element, _enums__WEBPACK_IMPORTED_MODULE_4__.Events.VOI_MODIFIED, eventDetails);
+        (0,_utilities__WEBPACK_IMPORTED_MODULE_4__.triggerEvent)(this.element, _enums__WEBPACK_IMPORTED_MODULE_3__.Events.VOI_MODIFIED, eventDetails);
     }
     getSlicesClippingPlanes() {
         const focalPoints = this.getSlicePlaneCoordinates();
         const { viewPlaneNormal } = this.getCamera();
-        const slabThickness = _constants__WEBPACK_IMPORTED_MODULE_3__.RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
+        const slabThickness = _constants__WEBPACK_IMPORTED_MODULE_2__.RENDERING_DEFAULTS.MINIMUM_SLAB_THICKNESS;
         return focalPoints.map(({ point, sliceIndex }) => {
             const vtkPlanes = [_kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_0__/* ["default"].newInstance */ .Ay.newInstance(), _kitware_vtk_js_Common_DataModel_Plane__WEBPACK_IMPORTED_MODULE_0__/* ["default"].newInstance */ .Ay.newInstance()];
             this.setOrientationOfClippingPlanes(vtkPlanes, slabThickness, viewPlaneNormal, point);
@@ -5895,6 +6038,9 @@ class VolumeViewport3D extends _BaseVolumeViewport__WEBPACK_IMPORTED_MODULE_1__/
     resetProperties(volumeId) {
         return null;
     }
+    resetSlabThickness() {
+        return null;
+    }
 }
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (VolumeViewport3D);
 
@@ -8220,9 +8366,7 @@ async function createVolumeActor(props, element, viewportId, suppressEvents = fa
     if (numberOfComponents === 3) {
         volumeActor.getProperty().setIndependentComponents(false);
     }
-    if (imageVolume.imageIds?.length) {
-        await (0,setDefaultVolumeVOI/* default */.A)(volumeActor, imageVolume, useNativeDataType);
-    }
+    await (0,setDefaultVolumeVOI/* default */.A)(volumeActor, imageVolume, useNativeDataType);
     if (callback) {
         callback({ volumeActor, volumeId });
     }
@@ -8313,21 +8457,19 @@ const PRIORITY = 0;
 const REQUEST_TYPE = _enums__WEBPACK_IMPORTED_MODULE_3__.RequestType.Prefetch;
 async function setDefaultVolumeVOI(volumeActor, imageVolume, useNativeDataType) {
     let voi = getVOIFromMetadata(imageVolume);
-    if (!voi) {
+    if (!voi && imageVolume?.imageIds?.length) {
         voi = await getVOIFromMinMax(imageVolume, useNativeDataType);
+        voi = handlePreScaledVolume(imageVolume, voi);
     }
-    if (!voi || voi.lower === undefined || voi.upper === undefined) {
-        throw new Error('Could not get VOI from metadata, nor from the min max of the image middle slice');
-    }
-    voi = handlePreScaledVolume(imageVolume, voi);
-    const { lower, upper } = voi;
-    if (lower === 0 && upper === 0) {
+    if ((voi?.lower === 0 && voi?.upper === 0) ||
+        voi?.lower === undefined ||
+        voi?.upper === undefined) {
         return;
     }
     volumeActor
         .getProperty()
         .getRGBTransferFunction(0)
-        .setMappingRange(lower, upper);
+        .setMappingRange(voi.lower, voi.upper);
 }
 function handlePreScaledVolume(imageVolume, voi) {
     const imageIds = imageVolume.imageIds;
@@ -8343,18 +8485,26 @@ function handlePreScaledVolume(imageVolume, voi) {
     return voi;
 }
 function getVOIFromMetadata(imageVolume) {
-    const { imageIds } = imageVolume;
-    const imageIdIndex = Math.floor(imageIds.length / 2);
-    const imageId = imageIds[imageIdIndex];
-    const voiLutModule = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('voiLutModule', imageId);
-    if (voiLutModule && voiLutModule.windowWidth && voiLutModule.windowCenter) {
-        const { windowWidth, windowCenter } = voiLutModule;
-        const voi = {
-            windowWidth: Array.isArray(windowWidth) ? windowWidth[0] : windowWidth,
-            windowCenter: Array.isArray(windowCenter)
-                ? windowCenter[0]
-                : windowCenter,
-        };
+    const { imageIds, metadata } = imageVolume;
+    let voi;
+    if (imageIds.length) {
+        const imageIdIndex = Math.floor(imageIds.length / 2);
+        const imageId = imageIds[imageIdIndex];
+        const voiLutModule = _metaData__WEBPACK_IMPORTED_MODULE_1__.get('voiLutModule', imageId);
+        if (voiLutModule && voiLutModule.windowWidth && voiLutModule.windowCenter) {
+            const { windowWidth, windowCenter } = voiLutModule;
+            voi = {
+                windowWidth: Array.isArray(windowWidth) ? windowWidth[0] : windowWidth,
+                windowCenter: Array.isArray(windowCenter)
+                    ? windowCenter[0]
+                    : windowCenter,
+            };
+        }
+    }
+    else {
+        voi = metadata?.voiLut?.[0];
+    }
+    if (voi) {
         const { lower, upper } = _utilities__WEBPACK_IMPORTED_MODULE_2__.windowLevel.toLowHighRange(Number(voi.windowWidth), Number(voi.windowCenter));
         return {
             lower,
@@ -8417,13 +8567,13 @@ async function getVOIFromMinMax(imageVolume, useNativeDataType) {
 }
 function _getImageScalarDataFromImageVolume(imageVolume, byteOffset, bytePerPixel, voxelsPerImage) {
     const { scalarData } = imageVolume;
-    const { volumeBuffer } = scalarData;
+    const { buffer } = scalarData;
     if (scalarData.BYTES_PER_ELEMENT !== bytePerPixel) {
         byteOffset *= scalarData.BYTES_PER_ELEMENT / bytePerPixel;
     }
     const TypedArray = scalarData.constructor;
     const imageScalarData = new TypedArray(voxelsPerImage);
-    const volumeBufferView = new TypedArray(volumeBuffer, byteOffset, voxelsPerImage);
+    const volumeBufferView = new TypedArray(buffer, byteOffset, voxelsPerImage);
     imageScalarData.set(volumeBufferView);
     return imageScalarData;
 }
@@ -8849,7 +8999,12 @@ class RenderingEngine {
             const prevCamera = vp.getCamera();
             const rotation = vp.getRotation();
             const { flipHorizontal } = prevCamera;
-            vp.resetCamera();
+            const resetPan = true;
+            const resetZoom = true;
+            const resetToCenter = true;
+            const resetRotation = false;
+            const supressEvents = true;
+            vp.resetCamera(resetPan, resetZoom, resetToCenter, resetRotation, supressEvents);
             const displayArea = vp.getDisplayArea();
             if (keepCamera) {
                 if (displayArea) {
@@ -15318,7 +15473,7 @@ class Cache {
         this._imageCacheSize = 0;
         this._volumeCacheSize = 0;
         this._maxCacheSize = 3 * ONE_GB;
-        this._maxInstanceSize = 2 * ONE_GB - 8;
+        this._maxInstanceSize = 4 * ONE_GB - 8;
         this.setMaxCacheSize = (newMaxCacheSize) => {
             if (!newMaxCacheSize || typeof newMaxCacheSize !== 'number') {
                 const errorMessage = `New max cacheSize ${this._maxCacheSize} should be defined and should be a number.`;
@@ -24383,7 +24538,7 @@ function findMatchingColormap(rgbPoints, actor) {
             return false;
         }
         for (let i = 0; i < presetRGBPoints.length; i += 4) {
-            if (!(0,_isEqual__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A)(presetRGBPoints.slice(i + 1, i + 4), rgbPoints.slice(i + 1, i + 4))) {
+            if (!(0,_isEqual__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Ay)(presetRGBPoints.slice(i + 1, i + 4), rgbPoints.slice(i + 1, i + 4))) {
                 return false;
             }
         }
@@ -24412,6 +24567,7 @@ function findMatchingColormap(rgbPoints, actor) {
     }
     return {
         name: matchedColormap.Name,
+        opacity,
     };
 }
 
@@ -24746,6 +24902,7 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
   PointsManager: () => (/* reexport */ PointsManager),
   ProgressiveIterator: () => (/* reexport */ ProgressiveIterator),
+  RLEVoxelMap: () => (/* reexport */ RLEVoxelMap),
   VoxelManager: () => (/* reexport */ VoxelManager),
   actorIsA: () => (/* reexport */ actorCheck/* actorIsA */.N),
   applyPreset: () => (/* reexport */ applyPreset),
@@ -24801,7 +24958,9 @@ __webpack_require__.d(__webpack_exports__, {
   imageToWorldCoords: () => (/* reexport */ imageToWorldCoords),
   indexWithinDimensions: () => (/* reexport */ indexWithinDimensions),
   invertRgbTransferFunction: () => (/* reexport */ invertRgbTransferFunction),
-  isEqual: () => (/* reexport */ isEqual/* default */.A),
+  isEqual: () => (/* reexport */ isEqual/* isEqual */.n4),
+  isEqualAbs: () => (/* reexport */ isEqual/* isEqualAbs */.Ph),
+  isEqualNegative: () => (/* reexport */ isEqual/* isEqualNegative */.WC),
   isImageActor: () => (/* reexport */ actorCheck/* isImageActor */.e),
   isOpposite: () => (/* reexport */ isOpposite),
   isPTPrescaledWithSUV: () => (/* reexport */ utilities_isPTPrescaledWithSUV),
@@ -25232,6 +25391,9 @@ function createUint8SharedArray(length) {
 
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/createFloat32SharedArray.js
 
+const SMALL_MEMORY_LIMIT = 2 * 1024 * 1024 * 1024 - 2;
+const BIG_MEMORY_LIMIT = SMALL_MEMORY_LIMIT * 2;
+const PAGE_SIZE = 65536;
 function createFloat32SharedArray(length) {
     if (!(0,init/* getShouldUseSharedArrayBuffer */.TB)()) {
         throw new Error('Your page is NOT cross-origin isolated, see https://developer.mozilla.org/en-US/docs/Web/API/crossOriginIsolated');
@@ -25239,8 +25401,20 @@ function createFloat32SharedArray(length) {
     if (window.SharedArrayBuffer === undefined) {
         throw new Error('SharedArrayBuffer is NOT supported in your browser see https://developer.chrome.com/blog/enabling-shared-array-buffer/');
     }
-    const sharedArrayBuffer = new SharedArrayBuffer(length * 4);
-    return new Float32Array(sharedArrayBuffer);
+    const byteLength = length * 4;
+    if (byteLength < SMALL_MEMORY_LIMIT) {
+        const sharedArrayBuffer = new SharedArrayBuffer(byteLength);
+        return new Float32Array(sharedArrayBuffer);
+    }
+    else if (byteLength < BIG_MEMORY_LIMIT) {
+        const pages = Math.ceil(byteLength / PAGE_SIZE);
+        const memory = new WebAssembly.Memory({
+            initial: pages,
+            maximum: pages,
+            shared: true,
+        });
+        return new Float32Array(memory.buffer, 0, length);
+    }
 }
 /* harmony default export */ const utilities_createFloat32SharedArray = (createFloat32SharedArray);
 
@@ -25428,23 +25602,28 @@ const isPTPrescaledWithSUV = (image) => {
 
 
 
-function renderToCanvasGPU(canvas, image, modality = undefined, renderingEngineId = '_thumbnails', viewportOptions = { displayArea: { imageArea: [1, 1] } }) {
+function renderToCanvasGPU(canvas, imageOrVolume, modality = undefined, renderingEngineId = '_thumbnails', viewportOptions = {
+    displayArea: { imageArea: [1, 1] },
+}) {
     if (!canvas || !(canvas instanceof HTMLCanvasElement)) {
         throw new Error('canvas element is required');
     }
-    const imageIdToPrint = image.imageId;
+    const isVolume = !imageOrVolume.imageId;
+    const image = !isVolume && imageOrVolume;
+    const volume = isVolume && imageOrVolume;
+    const imageIdToPrint = image?.imageId || volume?.volumeId;
     const viewportId = `renderGPUViewport-${imageIdToPrint}`;
-    const imageId = image.imageId;
     const element = document.createElement('div');
     const devicePixelRatio = window.devicePixelRatio || 1;
+    if (!viewportOptions.displayArea) {
+        viewportOptions.displayArea = { imageArea: [1, 1] };
+    }
     const originalWidth = canvas.width;
     const originalHeight = canvas.height;
-    element.style.width = `${originalWidth + getOrCreateCanvas/* EPSILON */.p8}px`;
-    element.style.height = `${originalHeight + getOrCreateCanvas/* EPSILON */.p8}px`;
+    element.style.width = `${originalWidth / devicePixelRatio + getOrCreateCanvas/* EPSILON */.p8}px`;
+    element.style.height = `${originalHeight / devicePixelRatio + getOrCreateCanvas/* EPSILON */.p8}px`;
     element.style.visibility = 'hidden';
     element.style.position = 'absolute';
-    canvas.width = originalWidth * devicePixelRatio;
-    canvas.height = originalHeight * devicePixelRatio;
     document.body.appendChild(element);
     const uniqueId = viewportId.split(':').join('-');
     element.setAttribute('viewport-id-for-remove', uniqueId);
@@ -25453,26 +25632,44 @@ function renderToCanvasGPU(canvas, image, modality = undefined, renderingEngineI
         new RenderingEngine/* default */.Ay(renderingEngineId);
     let viewport = renderingEngine.getViewport(viewportId);
     if (!viewport) {
-        const stackViewportInput = {
+        const viewportInput = {
             viewportId,
-            type: enums.ViewportType.STACK,
+            type: isVolume ? enums.ViewportType.ORTHOGRAPHIC : enums.ViewportType.STACK,
             element,
             defaultOptions: {
                 ...viewportOptions,
                 suppressEvents: true,
             },
         };
-        renderingEngine.enableElement(stackViewportInput);
+        renderingEngine.enableElement(viewportInput);
         viewport = renderingEngine.getViewport(viewportId);
     }
     return new Promise((resolve) => {
         let elementRendered = false;
+        let { viewReference } = viewportOptions;
         const onImageRendered = (eventDetail) => {
             if (elementRendered) {
                 return;
             }
+            if (viewReference) {
+                const useViewRef = viewReference;
+                viewReference = null;
+                viewport.setViewReference(useViewRef);
+                viewport.render();
+                return;
+            }
             const context = canvas.getContext('2d');
             context.drawImage(temporaryCanvas, 0, 0, temporaryCanvas.width, temporaryCanvas.height, 0, 0, canvas.width, canvas.height);
+            const origin = viewport.canvasToWorld([0, 0]);
+            const topRight = viewport.canvasToWorld([
+                temporaryCanvas.width / devicePixelRatio,
+                0,
+            ]);
+            const bottomLeft = viewport.canvasToWorld([
+                0,
+                temporaryCanvas.height / devicePixelRatio,
+            ]);
+            const thicknessMm = 1;
             elementRendered = true;
             element.removeEventListener(enums.Events.IMAGE_RENDERED, onImageRendered);
             setTimeout(() => {
@@ -25482,10 +25679,20 @@ function renderToCanvasGPU(canvas, image, modality = undefined, renderingEngineI
                     element.remove();
                 });
             }, 0);
-            resolve(imageId);
+            resolve({
+                origin,
+                bottomLeft,
+                topRight,
+                thicknessMm,
+            });
         };
         element.addEventListener(enums.Events.IMAGE_RENDERED, onImageRendered);
-        viewport.renderImageObject(image);
+        if (isVolume) {
+            viewport.setVolumes([volume], false, true);
+        }
+        else {
+            viewport.renderImageObject(imageOrVolume);
+        }
         viewport.resetCamera();
         if (modality === 'PT' && !utilities_isPTPrescaledWithSUV(image)) {
             viewport.setProperties({
@@ -25509,7 +25716,12 @@ var drawImageSync = __webpack_require__(49892);
 
 
 
-function renderToCanvasCPU(canvas, image, modality, _renderingEngineId, _viewportOptions) {
+function renderToCanvasCPU(canvas, imageOrVolume, modality, _renderingEngineId, _viewportOptions) {
+    const volume = imageOrVolume;
+    if (volume.volumeId) {
+        throw new Error('Unsupported volume rendering for CPU');
+    }
+    const image = imageOrVolume;
     const viewport = (0,getDefaultViewport/* default */.A)(canvas, image, modality);
     const enabledElement = {
         canvas,
@@ -25521,7 +25733,7 @@ function renderToCanvasCPU(canvas, image, modality, _renderingEngineId, _viewpor
     const invalidated = true;
     return new Promise((resolve, reject) => {
         (0,drawImageSync/* default */.A)(enabledElement, invalidated);
-        resolve(image.imageId);
+        resolve(null);
     });
 }
 
@@ -25533,28 +25745,36 @@ function renderToCanvasCPU(canvas, image, modality, _renderingEngineId, _viewpor
 
 
 
+
 function loadImageToCanvas(options) {
-    const { canvas, imageId, requestType = enums.RequestType.Thumbnail, priority = -5, renderingEngineId = '_thumbnails', useCPURendering = false, thumbnail = false, imageAspect = false, physicalPixels = false, viewportOptions, } = options;
-    const devicePixelRatio = window.devicePixelRatio || 1;
+    const { canvas, imageId, viewReference, requestType = enums.RequestType.Thumbnail, priority = -5, renderingEngineId = '_thumbnails', useCPURendering = false, thumbnail = false, imageAspect = false, viewportOptions: baseViewportOptions, } = options;
+    const volumeId = viewReference?.volumeId;
+    const isVolume = volumeId && !imageId;
+    const viewportOptions = viewReference && baseViewportOptions
+        ? { ...baseViewportOptions, viewReference }
+        : baseViewportOptions;
     const renderFn = useCPURendering ? renderToCanvasCPU : renderToCanvasGPU;
     return new Promise((resolve, reject) => {
-        function successCallback(image, imageId) {
+        function successCallback(imageOrVolume, imageId) {
             const { modality } = metaData.get('generalSeriesModule', imageId) || {};
-            image.isPreScaled = image.isPreScaled || image.preScale?.scaled;
+            const image = !isVolume && imageOrVolume;
+            const volume = isVolume && imageOrVolume;
+            if (image) {
+                image.isPreScaled = image.isPreScaled || image.preScale?.scaled;
+            }
             if (thumbnail) {
                 canvas.height = 256;
                 canvas.width = 256;
             }
-            if (physicalPixels) {
-                canvas.width = canvas.offsetWidth * devicePixelRatio;
-                canvas.height = canvas.offsetHeight * devicePixelRatio;
+            if (imageAspect && image) {
+                canvas.width = image && (canvas.height * image.width) / image.height;
             }
-            if (imageAspect) {
-                canvas.width = (canvas.height * image.width) / image.height;
+            canvas.style.width = `${canvas.width / devicePixelRatio}px`;
+            canvas.style.height = `${canvas.height / devicePixelRatio}px`;
+            if (volume && useCPURendering) {
+                reject(new Error('CPU rendering of volume not supported'));
             }
-            renderFn(canvas, image, modality, renderingEngineId, viewportOptions).then(() => {
-                resolve(imageId);
-            });
+            renderFn(canvas, imageOrVolume, modality, renderingEngineId, viewportOptions).then(resolve);
         }
         function errorCallback(error, imageId) {
             console.error(error, imageId);
@@ -25567,20 +25787,28 @@ function loadImageToCanvas(options) {
                 errorCallback.call(this, error, imageId);
             });
         }
-        const { useNorm16Texture, preferSizeOverAccuracy } = (0,init/* getConfiguration */.D0)().rendering;
-        const useNativeDataType = useNorm16Texture || preferSizeOverAccuracy;
+        const { useNorm16Texture } = (0,init/* getConfiguration */.D0)().rendering;
         const options = {
             targetBuffer: {
-                type: useNativeDataType ? undefined : 'Float32Array',
+                type: useNorm16Texture ? undefined : 'Float32Array',
             },
             preScale: {
                 enabled: true,
             },
-            useNativeDataType,
             useRGBA: !!useCPURendering,
             requestType,
         };
-        imageLoadPoolManager/* default */.A.addRequest(sendRequest.bind(null, imageId, null, options), requestType, { imageId }, priority);
+        if (volumeId) {
+            const volume = cache/* default */.Ay.getVolume(volumeId);
+            if (!volume) {
+                reject(new Error(`Volume id ${volumeId} not found in cache`));
+            }
+            const useImageId = volume.imageIds[0];
+            successCallback(volume, useImageId);
+        }
+        else {
+            imageLoadPoolManager/* default */.A.addRequest(sendRequest.bind(null, imageId, null, options), requestType, { imageId }, priority);
+        }
     });
 }
 
@@ -26348,8 +26576,8 @@ function getScalingParameters(imageId) {
     const generalSeriesModule = (0,metaData.get)('generalSeriesModule', imageId) || {};
     const { modality } = generalSeriesModule;
     const scalingParameters = {
-        rescaleSlope: modalityLutModule.rescaleSlope,
-        rescaleIntercept: modalityLutModule.rescaleIntercept,
+        rescaleSlope: modalityLutModule.rescaleSlope || 1,
+        rescaleIntercept: modalityLutModule.rescaleIntercept ?? 0,
         modality,
     };
     const suvFactor = (0,metaData.get)('scalingModule', imageId) || {};
@@ -26462,11 +26690,15 @@ function sortImageIdsAndGetSpacing(imageIds, scanAxisNormal) {
             Math.abs(distanceBetweenFirstAndMiddleImages) /
                 Math.floor(imageIds.length / 2);
     }
-    const { imagePositionPatient: origin, sliceThickness } = dist_esm.metaData.get('imagePlaneModule', sortedImageIds[0]);
+    const { imagePositionPatient: origin, sliceThickness, spacingBetweenSlices, } = dist_esm.metaData.get('imagePlaneModule', sortedImageIds[0]);
     const { strictZSpacingForVolumeViewport } = (0,dist_esm.getConfiguration)().rendering;
     if (zSpacing === 0 && !strictZSpacingForVolumeViewport) {
-        if (sliceThickness) {
-            console.log('Could not calculate zSpacing. Using sliceThickness');
+        if (sliceThickness && spacingBetweenSlices) {
+            console.log('Could not calculate zSpacing. Using spacingBetweenSlices');
+            zSpacing = spacingBetweenSlices;
+        }
+        else if (sliceThickness) {
+            console.log('Could not calculate zSpacing and no spacingBetweenSlices. Using sliceThickness');
             zSpacing = sliceThickness;
         }
         else {
@@ -26579,8 +26811,8 @@ function isValidVolume(imageIds) {
             modality === baseMetadata.modality &&
             columns === baseMetadata.columns &&
             rows === baseMetadata.rows &&
-            (0,isEqual/* default */.A)(imageOrientationPatient, baseMetadata.imageOrientationPatient) &&
-            (0,isEqual/* default */.A)(pixelSpacing, baseMetadata.pixelSpacing));
+            (0,isEqual/* default */.Ay)(imageOrientationPatient, baseMetadata.imageOrientationPatient) &&
+            (0,isEqual/* default */.Ay)(pixelSpacing, baseMetadata.pixelSpacing));
     });
     return validVolume;
 }
@@ -27024,9 +27256,11 @@ async function convertStackToVolumeViewport({ viewport, options, }) {
         },
     ], [viewportId]);
     const volumeViewportNewVolumeHandler = () => {
-        volumeViewport.setCamera({
-            ...prevCamera,
-        });
+        if (!options.orientation) {
+            volumeViewport.setCamera({
+                ...prevCamera,
+            });
+        }
         volumeViewport.render();
         element.removeEventListener(enums.Events.VOLUME_VIEWPORT_NEW_VOLUME, volumeViewportNewVolumeHandler);
     };
@@ -27413,7 +27647,7 @@ class VoxelManager {
             return [scalarData[index++], scalarData[index++], scalarData[index++]];
         }, (index, v) => {
             index *= 3;
-            const isChanged = !(0,isEqual/* default */.A)(scalarData[index], v);
+            const isChanged = !(0,isEqual/* default */.Ay)(scalarData[index], v);
             scalarData[index++] = v[0];
             scalarData[index++] = v[1];
             scalarData[index++] = v[2];
@@ -27767,6 +28001,7 @@ function hexToRgb(hex) {
 
 
 
+
 
 
 /***/ }),
@@ -27776,7 +28011,10 @@ function hexToRgb(hex) {
 
 "use strict";
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   A: () => (/* binding */ isEqual)
+/* harmony export */   Ay: () => (/* binding */ isEqual),
+/* harmony export */   Ph: () => (/* binding */ isEqualAbs),
+/* harmony export */   WC: () => (/* binding */ isEqualNegative),
+/* harmony export */   n4: () => (/* binding */ isEqual)
 /* harmony export */ });
 function areNumbersEqualWithTolerance(num1, num2, tolerance) {
     return Math.abs(num1 - num2) <= tolerance;
@@ -27810,6 +28048,11 @@ function isEqual(v1, v2, tolerance = 1e-5) {
     }
     return false;
 }
+const negative = (v) => typeof v === 'number' ? -v : v?.map ? v.map(negative) : !v;
+const abs = (v) => typeof v === 'number' ? Math.abs(v) : v?.map ? v.map(abs) : v;
+const isEqualNegative = (v1, v2, tolerance = undefined) => isEqual(v1, negative(v2), tolerance);
+const isEqualAbs = (v1, v2, tolerance = undefined) => isEqual(abs(v1), abs(v2), tolerance);
+
 
 
 /***/ }),
@@ -28830,7 +29073,7 @@ const CursorNames = [...svgCursorNames, ...standardCursorNames];
 
 /***/ }),
 
-/***/ 2746:
+/***/ 49574:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -28848,6 +29091,7 @@ __webpack_require__.d(__webpack_exports__, {
   drawPath: () => (/* reexport */ drawPath),
   drawPolyline: () => (/* reexport */ drawPolyline),
   drawRect: () => (/* reexport */ drawRect),
+  drawRectByCoordinates: () => (/* reexport */ drawRectByCoordinates),
   drawRedactionRect: () => (/* reexport */ drawRedactionRect),
   drawTextBox: () => (/* reexport */ drawingSvg_drawTextBox)
 });
@@ -29367,11 +29611,11 @@ function drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLine
 }
 /* harmony default export */ const drawingSvg_drawLinkedTextBox = (drawLinkedTextBox);
 
-;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/drawRect.js
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/drawRectByCoordinates.js
 
 
 
-function drawRect(svgDrawingHelper, annotationUID, rectangleUID, start, end, options = {}, dataId = '') {
+function drawRectByCoordinates(svgDrawingHelper, annotationUID, rectangleUID, canvasCoordinates, options = {}, dataId = '') {
     const { color, width: _width, lineWidth, lineDash, } = Object.assign({
         color: 'rgb(0, 255, 0)',
         width: '2',
@@ -29382,16 +29626,28 @@ function drawRect(svgDrawingHelper, annotationUID, rectangleUID, start, end, opt
     const svgns = 'http://www.w3.org/2000/svg';
     const svgNodeHash = drawingSvg_getHash(annotationUID, 'rect', rectangleUID);
     const existingRect = svgDrawingHelper.getSvgNode(svgNodeHash);
-    const tlhc = [Math.min(start[0], end[0]), Math.min(start[1], end[1])];
-    const width = Math.abs(start[0] - end[0]);
-    const height = Math.abs(start[1] - end[1]);
+    const [topLeft, topRight, bottomLeft, bottomRight] = canvasCoordinates;
+    const width = Math.hypot(topLeft[0] - topRight[0], topLeft[1] - topRight[1]);
+    const height = Math.hypot(topLeft[0] - bottomLeft[0], topLeft[1] - bottomLeft[1]);
+    const center = [
+        (bottomRight[0] + topLeft[0]) / 2,
+        (bottomRight[1] + topLeft[1]) / 2,
+    ];
+    const leftEdgeCenter = [
+        (bottomLeft[0] + topLeft[0]) / 2,
+        (bottomLeft[1] + topLeft[1]) / 2,
+    ];
+    const angle = (Math.atan2(center[1] - leftEdgeCenter[1], center[0] - leftEdgeCenter[0]) *
+        180) /
+        Math.PI;
     const attributes = {
-        x: `${tlhc[0]}`,
-        y: `${tlhc[1]}`,
+        x: `${center[0] - width / 2}`,
+        y: `${center[1] - height / 2}`,
         width: `${width}`,
         height: `${height}`,
         stroke: color,
         fill: 'transparent',
+        transform: `rotate(${angle} ${center[0]} ${center[1]})`,
         'stroke-width': strokeWidth,
         'stroke-dasharray': lineDash,
     };
@@ -29409,6 +29665,16 @@ function drawRect(svgDrawingHelper, annotationUID, rectangleUID, start, end, opt
     }
 }
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/drawRect.js
+
+function drawRect(svgDrawingHelper, annotationUID, rectangleUID, start, end, options = {}, dataId = '') {
+    const topLeft = [start[0], start[1]];
+    const topRight = [end[0], start[1]];
+    const bottomLeft = [start[0], end[1]];
+    const bottomRight = [end[0], end[1]];
+    drawRectByCoordinates(svgDrawingHelper, annotationUID, rectangleUID, [topLeft, topRight, bottomLeft, bottomRight], options, dataId);
+}
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/drawingSvg/drawArrow.js
 
 function drawArrow(svgDrawingHelper, annotationUID, arrowUID, start, end, options = {}) {
@@ -29514,6 +29780,7 @@ function drawRedactionRect(svgDrawingHelper, annotationUID, rectangleUID, start,
 
 
 
+
 /***/ }),
 
 /***/ 42111:
@@ -29749,12 +30016,12 @@ var WorkerTypes_ChangeTypes;
 
 /***/ }),
 
-/***/ 44926:
+/***/ 94101:
 /***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {
 
 "use strict";
 
-// UNUSED EXPORTS: annotationInterpolationEventDispatcher, cameraModifiedEventDispatcher, imageRenderedEventDispatcher, imageSpacingCalibratedEventDispatcher, keyboardToolEventDispatcher, mouseToolEventDispatcher, touchToolEventDispatcher
+// UNUSED EXPORTS: annotationInterpolationEventDispatcher, cameraModifiedEventDispatcher, cameraResetEventDispatcher, imageRenderedEventDispatcher, imageSpacingCalibratedEventDispatcher, keyboardToolEventDispatcher, mouseToolEventDispatcher, touchToolEventDispatcher
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
 var esm = __webpack_require__(92136);
@@ -29936,6 +30203,34 @@ const annotationInterpolationEventDispatcher_disable = function () {
     disable: annotationInterpolationEventDispatcher_disable,
 });
 
+;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/eventDispatchers/cameraResetEventDispatcher.js
+
+
+
+const { Active: cameraResetEventDispatcher_Active, Passive: cameraResetEventDispatcher_Passive, Enabled: cameraResetEventDispatcher_Enabled } = enums.ToolModes;
+const onCameraReset = function (evt) {
+    const enabledTools = (0,getToolsWithModesForMouseEvent/* default */.A)(evt, [
+        cameraResetEventDispatcher_Active,
+        cameraResetEventDispatcher_Passive,
+        cameraResetEventDispatcher_Enabled,
+    ]);
+    enabledTools.forEach((tool) => {
+        if (tool.onResetCamera) {
+            tool.onResetCamera(evt);
+        }
+    });
+};
+const cameraResetEventDispatcher_enable = function (element) {
+    element.addEventListener(esm.Enums.Events.CAMERA_RESET, onCameraReset);
+};
+const cameraResetEventDispatcher_disable = function (element) {
+    element.removeEventListener(esm.Enums.Events.CAMERA_RESET, onCameraReset);
+};
+/* harmony default export */ const cameraResetEventDispatcher = ({
+    enable: cameraResetEventDispatcher_enable,
+    disable: cameraResetEventDispatcher_disable,
+});
+
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/eventDispatchers/index.js
 
 
@@ -29947,6 +30242,7 @@ const annotationInterpolationEventDispatcher_disable = function () {
 
 
 
+
 /***/ }),
 
 /***/ 90202:
@@ -29962,7 +30258,7 @@ const annotationInterpolationEventDispatcher_disable = function () {
 /* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(74119);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(90252);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(38296);
-/* harmony import */ var _utilities_contours__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(75534);
+/* harmony import */ var _utilities_contours__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(75908);
 /* harmony import */ var _utilities_contourSegmentation__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(7259);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(61738);
 /* harmony import */ var _tools__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(81848);
@@ -30065,12 +30361,14 @@ function findIntersectingContour(viewport, sourcePolyline, contourSegmentationAn
 function createPolylineHole(viewport, targetAnnotation, holeAnnotation) {
     const { windingDirection: targetWindingDirection } = targetAnnotation.data.contour;
     const { windingDirection: holeWindingDirection } = holeAnnotation.data.contour;
-    if (targetWindingDirection === holeWindingDirection) {
-        holeAnnotation.data.contour.polyline.reverse();
-        holeAnnotation.data.contour.windingDirection = targetWindingDirection * -1;
-    }
     (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_4__.addChildAnnotation)(targetAnnotation, holeAnnotation);
     _utilities_contourSegmentation__WEBPACK_IMPORTED_MODULE_6__.removeContourSegmentationAnnotation(holeAnnotation);
+    const { contour: holeContour } = holeAnnotation.data;
+    const holePolyline = convertContourPolylineToCanvasSpace(holeContour.polyline, viewport);
+    _utilities_contours__WEBPACK_IMPORTED_MODULE_5__.updateContourPolyline(holeAnnotation, {
+        points: holePolyline,
+        closed: holeContour.closed,
+    }, viewport);
     const { element } = viewport;
     const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
     const { renderingEngine } = enabledElement;
@@ -30558,7 +30856,7 @@ function _imageChangeEventListener(evt) {
                         imageActor.getMapper().setInputData(imageData);
                     },
                 },
-            ], true, false);
+            ]);
             (0,segmentation_triggerSegmentationRender/* default */.Ay)(toolGroup.id);
             return;
         }
@@ -30684,7 +30982,7 @@ function annotationRemovedListener(evt) {
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(61738);
 /* harmony import */ var _store_state__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(55588);
 /* harmony import */ var _eventListeners__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(60878);
-/* harmony import */ var _eventDispatchers__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(44926);
+/* harmony import */ var _eventDispatchers__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(94101);
 /* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(52610);
 
 
@@ -30850,6 +31148,8 @@ class AnnotationGroup {
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(92136);
 /* harmony import */ var _annotationLocking__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(48428);
 /* harmony import */ var _annotationVisibility__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(21009);
+/* harmony import */ var _utilities_defineProperties__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(99595);
+
 
 
 
@@ -30946,6 +31246,8 @@ class FrameOfReferenceSpecificAnnotationManager {
             toolSpecificAnnotations.push(annotation);
             (0,_annotationLocking__WEBPACK_IMPORTED_MODULE_2__.checkAndDefineIsLockedProperty)(annotation);
             (0,_annotationVisibility__WEBPACK_IMPORTED_MODULE_3__.checkAndDefineIsVisibleProperty)(annotation);
+            (0,_utilities_defineProperties__WEBPACK_IMPORTED_MODULE_4__/* .checkAndDefineTextBoxProperty */ .Q)(annotation);
+            (0,_utilities_defineProperties__WEBPACK_IMPORTED_MODULE_4__/* .checkAndDefineCachedStatsProperty */ .d)(annotation);
         };
         this.removeAnnotation = (annotationUID) => {
             const { annotations } = this;
@@ -30968,14 +31270,27 @@ class FrameOfReferenceSpecificAnnotationManager {
         };
         this.removeAnnotations = (groupKey, toolName) => {
             const annotations = this.annotations;
-            if (annotations[groupKey]) {
-                if (toolName) {
-                    delete annotations[groupKey][toolName];
+            const removedAnnotations = [];
+            if (!annotations[groupKey]) {
+                return removedAnnotations;
+            }
+            if (toolName) {
+                const annotationsForTool = annotations[groupKey][toolName];
+                for (const annotation of annotationsForTool) {
+                    this.removeAnnotation(annotation.annotationUID);
+                    removedAnnotations.push(annotation);
                 }
-                else {
-                    delete annotations[groupKey];
+            }
+            else {
+                for (const toolName in annotations[groupKey]) {
+                    const annotationsForTool = annotations[groupKey][toolName];
+                    for (const annotation of annotationsForTool) {
+                        this.removeAnnotation(annotation.annotationUID);
+                        removedAnnotations.push(annotation);
+                    }
                 }
             }
+            return removedAnnotations;
         };
         this.saveAnnotations = (groupKey, toolName) => {
             const annotations = this.annotations;
@@ -31028,7 +31343,12 @@ class FrameOfReferenceSpecificAnnotationManager {
             return count;
         };
         this.removeAllAnnotations = () => {
-            this.annotations = {};
+            const removedAnnotations = [];
+            for (const annotation of this.getAllAnnotations()) {
+                this.removeAnnotation(annotation.annotationUID);
+                removedAnnotations.push(annotation);
+            }
+            return removedAnnotations;
         };
         if (!uid) {
             uid = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities.uuidv4();
@@ -31254,18 +31574,17 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   invalidateAnnotation: () => (/* binding */ invalidateAnnotation),
 /* harmony export */   removeAllAnnotations: () => (/* binding */ removeAllAnnotations),
 /* harmony export */   removeAnnotation: () => (/* binding */ removeAnnotation),
+/* harmony export */   removeAnnotations: () => (/* binding */ removeAnnotations),
 /* harmony export */   resetAnnotationManager: () => (/* binding */ resetAnnotationManager),
 /* harmony export */   setAnnotationManager: () => (/* binding */ setAnnotationManager)
 /* harmony export */ });
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(92136);
-/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(84901);
-/* harmony import */ var _FrameOfReferenceSpecificAnnotationManager__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(22581);
-/* harmony import */ var _helpers_state__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(54177);
+/* harmony import */ var _FrameOfReferenceSpecificAnnotationManager__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(22581);
+/* harmony import */ var _helpers_state__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(54177);
 
 
 
-
-let defaultManager = _FrameOfReferenceSpecificAnnotationManager__WEBPACK_IMPORTED_MODULE_2__/* .defaultFrameOfReferenceSpecificAnnotationManager */ .H;
+let defaultManager = _FrameOfReferenceSpecificAnnotationManager__WEBPACK_IMPORTED_MODULE_1__/* .defaultFrameOfReferenceSpecificAnnotationManager */ .H;
 function getAnnotationManager() {
     return defaultManager;
 }
@@ -31273,7 +31592,7 @@ function setAnnotationManager(annotationManager) {
     defaultManager = annotationManager;
 }
 function resetAnnotationManager() {
-    defaultManager = _FrameOfReferenceSpecificAnnotationManager__WEBPACK_IMPORTED_MODULE_2__/* .defaultFrameOfReferenceSpecificAnnotationManager */ .H;
+    defaultManager = _FrameOfReferenceSpecificAnnotationManager__WEBPACK_IMPORTED_MODULE_1__/* .defaultFrameOfReferenceSpecificAnnotationManager */ .H;
 }
 function getAnnotations(toolName, annotationGroupSelector) {
     const manager = getAnnotationManager();
@@ -31323,11 +31642,11 @@ function addAnnotation(annotation, annotationGroupSelector) {
     if (annotationGroupSelector instanceof HTMLDivElement) {
         const groupKey = manager.getGroupKey(annotationGroupSelector);
         manager.addAnnotation(annotation, groupKey);
-        (0,_helpers_state__WEBPACK_IMPORTED_MODULE_3__/* .triggerAnnotationAddedForElement */ .$f)(annotation, annotationGroupSelector);
+        (0,_helpers_state__WEBPACK_IMPORTED_MODULE_2__/* .triggerAnnotationAddedForElement */ .$f)(annotation, annotationGroupSelector);
     }
     else {
         manager.addAnnotation(annotation);
-        (0,_helpers_state__WEBPACK_IMPORTED_MODULE_3__/* .triggerAnnotationAddedForFOR */ ._3)(annotation);
+        (0,_helpers_state__WEBPACK_IMPORTED_MODULE_2__/* .triggerAnnotationAddedForFOR */ ._3)(annotation);
     }
     return annotation.annotationUID;
 }
@@ -31347,12 +31666,7 @@ function removeAnnotation(annotationUID) {
     }
     annotation.childAnnotationUIDs?.forEach((childAnnotationUID) => removeAnnotation(childAnnotationUID));
     manager.removeAnnotation(annotationUID);
-    const eventType = _enums__WEBPACK_IMPORTED_MODULE_1__.Events.ANNOTATION_REMOVED;
-    const eventDetail = {
-        annotation,
-        annotationManagerUID: manager.uid,
-    };
-    (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.eventTarget, eventType, eventDetail);
+    (0,_helpers_state__WEBPACK_IMPORTED_MODULE_2__/* .triggerAnnotationRemoved */ .SH)({ annotation, annotationManagerUID: manager.uid });
 }
 function getAnnotation(annotationUID) {
     const manager = getAnnotationManager();
@@ -31361,7 +31675,24 @@ function getAnnotation(annotationUID) {
 }
 function removeAllAnnotations() {
     const manager = getAnnotationManager();
-    manager.removeAllAnnotations();
+    const removedAnnotations = manager.removeAllAnnotations();
+    for (const annotation of removedAnnotations) {
+        (0,_helpers_state__WEBPACK_IMPORTED_MODULE_2__/* .triggerAnnotationRemoved */ .SH)({
+            annotation,
+            annotationManagerUID: manager.uid,
+        });
+    }
+}
+function removeAnnotations(toolName, annotationGroupSelector) {
+    const manager = getAnnotationManager();
+    const groupKey = manager.getGroupKey(annotationGroupSelector);
+    const removedAnnotations = manager.removeAnnotations(groupKey, toolName);
+    for (const annotation of removedAnnotations) {
+        (0,_helpers_state__WEBPACK_IMPORTED_MODULE_2__/* .triggerAnnotationRemoved */ .SH)({
+            annotation,
+            annotationManagerUID: manager.uid,
+        });
+    }
 }
 function invalidateAnnotation(annotation) {
     let currAnnotation = annotation;
@@ -31716,6 +32047,7 @@ function getStyleProperty(property, styleSpecifier, state, mode) {
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   $f: () => (/* binding */ triggerAnnotationAddedForElement),
 /* harmony export */   PS: () => (/* binding */ triggerContourAnnotationCompleted),
+/* harmony export */   SH: () => (/* binding */ triggerAnnotationRemoved),
 /* harmony export */   XF: () => (/* binding */ triggerAnnotationModified),
 /* harmony export */   _3: () => (/* binding */ triggerAnnotationAddedForFOR),
 /* harmony export */   dZ: () => (/* binding */ triggerAnnotationCompleted)
@@ -31765,6 +32097,10 @@ function triggerAnnotationAddedForFOR(annotation) {
         (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.eventTarget, eventType, eventDetail);
     });
 }
+function triggerAnnotationRemoved(eventDetail) {
+    const eventType = _enums__WEBPACK_IMPORTED_MODULE_1__.Events.ANNOTATION_REMOVED;
+    (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.triggerEvent)(_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.eventTarget, eventType, eventDetail);
+}
 function triggerAnnotationModified(annotation, element, changeType = _enums__WEBPACK_IMPORTED_MODULE_1__.ChangeTypes.HandlesUpdated) {
     const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(element);
     const { viewportId, renderingEngineId } = enabledElement;
@@ -34678,8 +35014,8 @@ function removeTool(ToolClass) {
 
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/eventListeners/index.js + 17 modules
 var eventListeners = __webpack_require__(60878);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/eventDispatchers/index.js + 7 modules
-var eventDispatchers = __webpack_require__(44926);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/eventDispatchers/index.js + 8 modules
+var eventDispatchers = __webpack_require__(94101);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/triggerAnnotationRender.js
 var triggerAnnotationRender = __webpack_require__(6805);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/store/addEnabledElement.js
@@ -34701,6 +35037,7 @@ function addEnabledElement(evt) {
     imageRenderedEventDispatcher.enable(element);
     cameraModifiedEventDispatcher.enable(element);
     imageSpacingCalibratedEventDispatcher.enable(element);
+    cameraResetEventDispatcher.enable(element);
     mouseToolEventDispatcher.enable(element);
     keyboardToolEventDispatcher.enable(element);
     touchToolEventDispatcher.enable(element);
@@ -34791,6 +35128,7 @@ function removeEnabledElement(elementDisabledEvt) {
     imageRenderedEventDispatcher.disable(element);
     cameraModifiedEventDispatcher.disable(element);
     imageSpacingCalibratedEventDispatcher.disable(element);
+    cameraResetEventDispatcher.disable(element);
     mouseToolEventDispatcher.disable(element);
     keyboardToolEventDispatcher.disable(element);
     touchToolEventDispatcher.disable(element);
@@ -34997,7 +35335,7 @@ function presentationViewSyncCallback_presentationViewSyncCallback(_synchronizer
     const tViewport = renderingEngine.getViewport(targetViewport.viewportId);
     const sViewport = renderingEngine.getViewport(sourceViewport.viewportId);
     const presentationView = sViewport.getViewPresentation(options);
-    tViewport.setView(null, presentationView);
+    tViewport.setViewPresentation(presentationView);
     tViewport.render();
 }
 
@@ -35240,7 +35578,7 @@ const createStackImageSynchronizer = (/* unused pure expression or super */ null
 /* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(48428);
 /* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(21009);
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(54177);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(61738);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(84901);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(90252);
@@ -35729,10 +36067,10 @@ class AnnotationEraserTool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .BaseToo
                 continue;
             }
             const annotations = (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_2__.getAnnotations)(toolName, element);
-            if (!annotations) {
+            if (!annotations.length) {
                 continue;
             }
-            const interactableAnnotations = toolInstance.filterInteractableAnnotationsForElement(element, annotations);
+            const interactableAnnotations = toolInstance.filterInteractableAnnotationsForElement(element, annotations) || [];
             for (const annotation of interactableAnnotations) {
                 if (toolInstance.isPointNearTool(element, annotation, currentPoints.canvas, 10, interactionType)) {
                     annotationsToRemove.push(annotation.annotationUID);
@@ -35764,7 +36102,7 @@ AnnotationEraserTool.toolName = 'Eraser';
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(92136);
 /* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(52610);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(38296);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(61738);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(84901);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(90252);
@@ -35814,7 +36152,12 @@ class CrosshairsTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .AnnotationToo
         supportedInteractionTypes: ['Mouse'],
         configuration: {
             shadow: true,
-            viewportIndicators: true,
+            viewportIndicators: false,
+            viewportIndicatorsConfig: {
+                radius: 5,
+                x: null,
+                y: null,
+            },
             autoPan: {
                 enabled: false,
                 panSize: 10,
@@ -35878,12 +36221,20 @@ class CrosshairsTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .AnnotationToo
             viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
                 const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_4__.getEnabledElementByIds)(viewportId, renderingEngineId);
                 const { viewport } = enabledElement;
+                const resetPan = true;
+                const resetZoom = true;
+                const resetToCenter = true;
+                const resetRotation = true;
+                const supressEvents = true;
+                viewport.resetCamera(resetPan, resetZoom, resetToCenter, resetRotation, supressEvents);
+                viewport.resetSlabThickness();
                 const { element } = viewport;
                 let annotations = this._getAnnotations(enabledElement);
                 annotations = this.filterInteractableAnnotationsForElement(element, annotations);
                 if (annotations.length) {
                     (0,_stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_6__.removeAnnotation)(annotations[0].annotationUID);
                 }
+                viewport.render();
             });
             this.computeToolCenter(viewportsInfo);
         };
@@ -36021,6 +36372,9 @@ class CrosshairsTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .AnnotationToo
             const viewportIdsToRender = (0,_utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_10__.getViewportIdsWithToolToRender)(element, this.getToolName(), requireSameOrientation);
             (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_15__/* ["default"] */ .A)(renderingEngine, viewportIdsToRender);
         };
+        this.onResetCamera = (evt) => {
+            this.resetCrosshairs();
+        };
         this.mouseMoveCallback = (evt, filteredToolAnnotations) => {
             const { element, currentPoints } = evt.detail;
             const canvasCoords = currentPoints.canvas;
@@ -36402,12 +36756,16 @@ class CrosshairsTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .AnnotationToo
             renderStatus = true;
             data.handles.rotationPoints = newRtpoints;
             data.handles.slabThicknessPoints = newStpoints;
+            debugger;
             if (this.configuration.viewportIndicators) {
+                const { viewportIndicatorsConfig } = this.configuration;
+                const xOffset = viewportIndicatorsConfig?.xOffset || 0.95;
+                const yOffset = viewportIndicatorsConfig?.yOffset || 0.05;
                 const referenceColorCoordinates = [
-                    clientWidth * 0.95,
-                    clientHeight * 0.05,
+                    clientWidth * xOffset,
+                    clientHeight * yOffset,
                 ];
-                const circleRadius = canvasDiagonalLength * 0.01;
+                const circleRadius = viewportIndicatorsConfig?.circleRadius || canvasDiagonalLength * 0.01;
                 const circleUID = '0';
                 (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_7__.drawCircle)(svgDrawingHelper, annotationUID, circleUID, referenceColorCoordinates, circleRadius, { color, fill: color });
             }
@@ -37773,7 +38131,7 @@ OrientationMarkerTool.toolName = 'OrientationMarker';
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(92136);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(38296);
 /* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(52610);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(49574);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(23072);
 /* harmony import */ var _base_AnnotationDisplayTool__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(28062);
 
@@ -38062,7 +38420,7 @@ PlanarRotateTool.toolName = 'PlanarRotate';
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(92136);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(38296);
 /* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(21009);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(49574);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(90252);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(23072);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(44753);
@@ -38390,7 +38748,7 @@ ReferenceCursors.toolName = 'ReferenceCursors';
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(44753);
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(92136);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(38296);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(49574);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(90252);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(23072);
 /* harmony import */ var _base_AnnotationDisplayTool__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(28062);
@@ -38629,7 +38987,7 @@ ReferenceLines.toolName = 'ReferenceLines';
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(44753);
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(92136);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(38296);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(49574);
 /* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(52610);
 
 
@@ -38931,8 +39289,8 @@ class ScaleOverlayTool extends _base_AnnotationDisplayTool__WEBPACK_IMPORTED_MOD
             viewportId: enabledElement.viewport.id,
         };
         const canvasSize = {
-            width: canvas.width,
-            height: canvas.height,
+            width: canvas.width / window.devicePixelRatio || 1,
+            height: canvas.height / window.devicePixelRatio || 1,
         };
         const topLeft = annotation.data.handles.points[0];
         const topRight = annotation.data.handles.points[1];
@@ -39345,7 +39703,7 @@ SculptorTool.toolName = 'SculptorTool';
 "use strict";
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(92136);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(38296);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(49574);
 /* harmony import */ var _store_ToolGroupManager__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(52610);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(23072);
 /* harmony import */ var _base_AnnotationDisplayTool__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(28062);
@@ -39672,6 +40030,7 @@ class TrackballRotateTool extends _base__WEBPACK_IMPORTED_MODULE_4__/* .BaseTool
     }) {
         super(toolProps, defaultToolProps);
         this._resizeObservers = new Map();
+        this._hasResolutionChanged = false;
         this.preMouseDownCallback = (evt) => {
             const eventDetail = evt.detail;
             const { element } = eventDetail;
@@ -39681,15 +40040,19 @@ class TrackballRotateTool extends _base__WEBPACK_IMPORTED_MODULE_4__/* .BaseTool
             const actor = actorEntry.actor;
             const mapper = actor.getMapper();
             const originalSampleDistance = mapper.getSampleDistance();
-            mapper.setSampleDistance(originalSampleDistance * 2);
-            if (this.cleanUp !== null) {
-                document.removeEventListener('mouseup', this.cleanUp);
+            if (!this._hasResolutionChanged) {
+                mapper.setSampleDistance(originalSampleDistance * 2);
+                this._hasResolutionChanged = true;
+                if (this.cleanUp !== null) {
+                    document.removeEventListener('mouseup', this.cleanUp);
+                }
+                this.cleanUp = () => {
+                    mapper.setSampleDistance(originalSampleDistance);
+                    viewport.render();
+                    this._hasResolutionChanged = false;
+                };
+                document.addEventListener('mouseup', this.cleanUp, { once: true });
             }
-            this.cleanUp = () => {
-                mapper.setSampleDistance(originalSampleDistance);
-                viewport.render();
-            };
-            document.addEventListener('mouseup', this.cleanUp, { once: true });
             return true;
         };
         this._getViewportsInfo = () => {
@@ -39890,6 +40253,248 @@ VolumeRotateMouseWheelTool.toolName = 'VolumeRotateMouseWheel';
 /* unused harmony default export */ var __WEBPACK_DEFAULT_EXPORT__ = ((/* unused pure expression or super */ null && (VolumeRotateMouseWheelTool)));
 
 
+/***/ }),
+
+/***/ 60747:
+/***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony import */ var _base__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(96214);
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(92136);
+/* harmony import */ var _stateManagement__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(95778);
+/* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(54177);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(49574);
+/* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(61738);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(84901);
+/* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(90252);
+/* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(40233);
+/* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(23072);
+/* harmony import */ var _utilities_voi__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(14149);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(74119);
+
+
+
+
+
+
+
+
+
+
+
+
+class WindowLevelRegionTool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .AnnotationTool */ .EC {
+    constructor(toolProps = {}, defaultToolProps = {
+        supportedInteractionTypes: ['Mouse', 'Touch'],
+        configuration: {
+            minWindowWidth: 10,
+        },
+    }) {
+        super(toolProps, defaultToolProps);
+        this.addNewAnnotation = (evt) => {
+            const eventDetail = evt.detail;
+            const { currentPoints, element } = eventDetail;
+            const worldPos = currentPoints.world;
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
+            const { viewport, renderingEngine } = enabledElement;
+            this.isDrawing = true;
+            const camera = viewport.getCamera();
+            const { viewPlaneNormal, viewUp } = camera;
+            const referencedImageId = this.getReferencedImageId(viewport, worldPos, viewPlaneNormal, viewUp);
+            const FrameOfReferenceUID = viewport.getFrameOfReferenceUID();
+            const annotation = {
+                invalidated: true,
+                highlighted: true,
+                metadata: {
+                    toolName: this.getToolName(),
+                    viewPlaneNormal: [...viewPlaneNormal],
+                    viewUp: [...viewUp],
+                    FrameOfReferenceUID,
+                    referencedImageId,
+                },
+                data: {
+                    handles: {
+                        points: [
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                            [...worldPos],
+                        ],
+                    },
+                    cachedStats: {},
+                },
+            };
+            (0,_stateManagement__WEBPACK_IMPORTED_MODULE_2__/* .addAnnotation */ .lC)(annotation, element);
+            const viewportIdsToRender = (0,_utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_7__.getViewportIdsWithToolToRender)(element, this.getToolName());
+            this.editData = {
+                annotation,
+                viewportIdsToRender,
+            };
+            this._activateDraw(element);
+            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_8__.hideElementCursor)(element);
+            evt.preventDefault();
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(renderingEngine, viewportIdsToRender);
+            return annotation;
+        };
+        this._endCallback = (evt) => {
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender } = this.editData;
+            this._deactivateDraw(element);
+            (0,_cursors_elementCursor__WEBPACK_IMPORTED_MODULE_8__.resetElementCursor)(element);
+            const { renderingEngine } = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
+            this.editData = null;
+            this.isDrawing = false;
+            (0,_stateManagement__WEBPACK_IMPORTED_MODULE_2__/* .removeAnnotation */ .O8)(annotation.annotationUID);
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(renderingEngine, viewportIdsToRender);
+            (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_3__/* .triggerAnnotationCompleted */ .dZ)(annotation);
+            this.applyWindowLevelRegion(annotation, element);
+        };
+        this._dragCallback = (evt) => {
+            this.isDrawing = true;
+            const eventDetail = evt.detail;
+            const { element } = eventDetail;
+            const { annotation, viewportIdsToRender } = this.editData;
+            const { data } = annotation;
+            const { currentPoints } = eventDetail;
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
+            const { worldToCanvas, canvasToWorld } = enabledElement.viewport;
+            const worldPos = currentPoints.world;
+            const { points } = data.handles;
+            const DEFAULT_HANDLE_INDEX = 3;
+            points[DEFAULT_HANDLE_INDEX] = [...worldPos];
+            const bottomLeftCanvas = worldToCanvas(points[0]);
+            const topRightCanvas = worldToCanvas(points[3]);
+            const bottomRightCanvas = [
+                topRightCanvas[0],
+                bottomLeftCanvas[1],
+            ];
+            const topLeftCanvas = [
+                bottomLeftCanvas[0],
+                topRightCanvas[1],
+            ];
+            const bottomRightWorld = canvasToWorld(bottomRightCanvas);
+            const topLeftWorld = canvasToWorld(topLeftCanvas);
+            points[1] = bottomRightWorld;
+            points[2] = topLeftWorld;
+            annotation.invalidated = true;
+            const { renderingEngine } = enabledElement;
+            (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(renderingEngine, viewportIdsToRender);
+        };
+        this._activateDraw = (element) => {
+            _store__WEBPACK_IMPORTED_MODULE_5__/* .state */ .wk.isInteractingWithTool = true;
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.MOUSE_UP, this._endCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.MOUSE_DRAG, this._dragCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.MOUSE_MOVE, this._dragCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.MOUSE_CLICK, this._endCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.TOUCH_END, this._endCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.TOUCH_DRAG, this._dragCallback);
+            element.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.TOUCH_TAP, this._endCallback);
+        };
+        this._deactivateDraw = (element) => {
+            _store__WEBPACK_IMPORTED_MODULE_5__/* .state */ .wk.isInteractingWithTool = false;
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.MOUSE_UP, this._endCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.MOUSE_DRAG, this._dragCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.MOUSE_MOVE, this._dragCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.MOUSE_CLICK, this._endCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.TOUCH_END, this._endCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.TOUCH_DRAG, this._dragCallback);
+            element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_6__.Events.TOUCH_TAP, this._endCallback);
+        };
+        this.renderAnnotation = (enabledElement, svgDrawingHelper) => {
+            let renderStatus = false;
+            const { viewport } = enabledElement;
+            const { element } = viewport;
+            let annotations = (0,_stateManagement__WEBPACK_IMPORTED_MODULE_2__/* .getAnnotations */ .Rh)(this.getToolName(), element);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            annotations = this.filterInteractableAnnotationsForElement(element, annotations);
+            if (!annotations?.length) {
+                return renderStatus;
+            }
+            const styleSpecifier = {
+                toolGroupId: this.toolGroupId,
+                toolName: this.getToolName(),
+                viewportId: enabledElement.viewport.id,
+            };
+            for (let i = 0; i < annotations.length; i++) {
+                const annotation = annotations[i];
+                const { annotationUID, data } = annotation;
+                const { points } = data.handles;
+                const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+                styleSpecifier.annotationUID = annotationUID;
+                const { color, lineWidth, lineDash } = this.getAnnotationStyle({
+                    annotation,
+                    styleSpecifier,
+                });
+                if (!viewport.getRenderingEngine()) {
+                    console.warn('Rendering Engine has been destroyed');
+                    return renderStatus;
+                }
+                const dataId = `${annotationUID}-rect`;
+                const rectangleUID = '0';
+                (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_4__.drawRect)(svgDrawingHelper, annotationUID, rectangleUID, canvasCoordinates[0], canvasCoordinates[3], {
+                    color,
+                    lineDash,
+                    lineWidth,
+                }, dataId);
+                renderStatus = true;
+            }
+            return renderStatus;
+        };
+        this.applyWindowLevelRegion = (annotation, element) => {
+            const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
+            const { viewport } = enabledElement;
+            const imageData = _utilities_voi__WEBPACK_IMPORTED_MODULE_10__.windowLevel.extractWindowLevelRegionToolData(viewport);
+            const { data } = annotation;
+            const { points } = data.handles;
+            const canvasCoordinates = points.map((p) => viewport.worldToCanvas(p));
+            const startCanvas = canvasCoordinates[0];
+            const endCanvas = canvasCoordinates[3];
+            let left = Math.min(startCanvas[0], endCanvas[0]);
+            let top = Math.min(startCanvas[1], endCanvas[1]);
+            let width = Math.abs(startCanvas[0] - endCanvas[0]);
+            let height = Math.abs(startCanvas[1] - endCanvas[1]);
+            left = (0,_utilities__WEBPACK_IMPORTED_MODULE_11__.clip)(left, 0, imageData.width);
+            top = (0,_utilities__WEBPACK_IMPORTED_MODULE_11__.clip)(top, 0, imageData.height);
+            width = Math.floor(Math.min(width, Math.abs(imageData.width - left)));
+            height = Math.floor(Math.min(height, Math.abs(imageData.height - top)));
+            const pixelLuminanceData = _utilities_voi__WEBPACK_IMPORTED_MODULE_10__.windowLevel.getLuminanceFromRegion(imageData, Math.round(left), Math.round(top), width, height);
+            const minMaxMean = _utilities_voi__WEBPACK_IMPORTED_MODULE_10__.windowLevel.calculateMinMaxMean(pixelLuminanceData, imageData.minPixelValue, imageData.maxPixelValue);
+            if (this.configuration.minWindowWidth === undefined) {
+                this.configuration.minWindowWidth = 10;
+            }
+            const windowWidth = Math.max(Math.abs(minMaxMean.max - minMaxMean.min), this.configuration.minWindowWidth);
+            const windowCenter = minMaxMean.mean;
+            const voiRange = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.utilities.windowLevel.toLowHighRange(windowWidth, windowCenter);
+            viewport.setProperties({ voiRange });
+            viewport.render();
+        };
+        this.cancel = () => {
+            return null;
+        };
+        this.isPointNearTool = () => {
+            return null;
+        };
+        this.toolSelectedCallback = () => {
+            return null;
+        };
+        this.handleSelectedCallback = () => {
+            return null;
+        };
+        this._activateModify = () => {
+            return null;
+        };
+        this._deactivateModify = () => {
+            return null;
+        };
+    }
+}
+WindowLevelRegionTool.toolName = 'WindowLevelRegion';
+/* unused harmony default export */ var __WEBPACK_DEFAULT_EXPORT__ = ((/* unused pure expression or super */ null && (WindowLevelRegionTool)));
+
+
 /***/ }),
 
 /***/ 455:
@@ -40301,7 +40906,7 @@ ZoomTool.toolName = 'Zoom';
 /* harmony import */ var _utilities_math_line__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(21954);
 /* harmony import */ var _utilities_math_angle_angleBetweenLines__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(52475);
 /* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(74119);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(61738);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(90252);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(23072);
@@ -40357,6 +40962,7 @@ class AngleTool extends _base__WEBPACK_IMPORTED_MODULE_2__/* .AnnotationTool */
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     handles: {
@@ -40770,7 +41376,7 @@ AngleTool.toolName = 'Angle';
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(38296);
 /* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(48428);
 /* harmony import */ var _utilities_math_line__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(21954);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(61738);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(90252);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(23072);
@@ -40822,6 +41428,7 @@ class ArrowAnnotateTool extends _base__WEBPACK_IMPORTED_MODULE_2__/* .Annotation
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     text: '',
@@ -41219,7 +41826,7 @@ ArrowAnnotateTool.toolName = 'ArrowAnnotate';
 /* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(48428);
 /* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(21009);
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(54177);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(61738);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(84901);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(90252);
@@ -41289,6 +41896,7 @@ class CircleROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .AnnotationTool
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     label: '',
@@ -41838,7 +42446,7 @@ CircleROITool.toolName = 'CircleROI';
 /* harmony import */ var _utilities_math_line__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(21954);
 /* harmony import */ var _utilities_math_angle_angleBetweenLines__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(52475);
 /* harmony import */ var _utilities_math_midPoint__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(76727);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(61738);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(90252);
 /* harmony import */ var _utilities_drawing__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(10910);
@@ -41897,6 +42505,7 @@ class CobbAngleTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .AnnotationTool
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     handles: {
@@ -42536,7 +43145,7 @@ CobbAngleTool.toolName = 'CobbAngle';
 
 "use strict";
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(92136);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(49574);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(90252);
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(40233);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(23072);
@@ -42694,7 +43303,7 @@ DragProbeTool.toolName = 'DragProbe';
 /* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(48428);
 /* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(21009);
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(54177);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(61738);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(84901);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(90252);
@@ -42763,6 +43372,7 @@ class EllipticalROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .Annotation
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     label: '',
@@ -43271,63 +43881,55 @@ class EllipticalROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .Annotation
                 post2Index[0] = Math.floor(post2Index[0]);
                 post2Index[1] = Math.floor(post2Index[1]);
                 post2Index[2] = Math.floor(post2Index[2]);
-                if (this._isInsideVolume(pos1Index, post2Index, dimensions)) {
-                    this.isHandleOutsideImage = false;
-                    const iMin = Math.min(pos1Index[0], post2Index[0]);
-                    const iMax = Math.max(pos1Index[0], post2Index[0]);
-                    const jMin = Math.min(pos1Index[1], post2Index[1]);
-                    const jMax = Math.max(pos1Index[1], post2Index[1]);
-                    const kMin = Math.min(pos1Index[2], post2Index[2]);
-                    const kMax = Math.max(pos1Index[2], post2Index[2]);
-                    const boundsIJK = [
-                        [iMin, iMax],
-                        [jMin, jMax],
-                        [kMin, kMax],
-                    ];
-                    const center = [
-                        (topLeftWorld[0] + bottomRightWorld[0]) / 2,
-                        (topLeftWorld[1] + bottomRightWorld[1]) / 2,
-                        (topLeftWorld[2] + bottomRightWorld[2]) / 2,
-                    ];
-                    const ellipseObj = {
-                        center,
-                        xRadius: Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2,
-                        yRadius: Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2,
-                        zRadius: Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2,
-                    };
-                    const { worldWidth, worldHeight } = (0,_utilities_planar_getWorldWidthAndHeightFromTwoPoints__WEBPACK_IMPORTED_MODULE_14__/* ["default"] */ .A)(viewPlaneNormal, viewUp, worldPos1, worldPos2);
-                    const isEmptyArea = worldWidth === 0 && worldHeight === 0;
-                    const handles = [pos1Index, post2Index];
-                    const { scale, areaUnits } = (0,_utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__/* .getCalibratedLengthUnitsAndScale */ .Op)(image, handles);
-                    const area = Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2)) /
-                        scale /
-                        scale;
-                    const modalityUnitOptions = {
-                        isPreScaled: (0,_utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_19__/* .isViewportPreScaled */ .u)(viewport, targetId),
-                        isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
-                    };
-                    const modalityUnit = (0,_utilities_getModalityUnit__WEBPACK_IMPORTED_MODULE_18__/* .getModalityUnit */ .c)(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
-                    const pointsInShape = (0,_utilities__WEBPACK_IMPORTED_MODULE_3__.pointInShapeCallback)(imageData, (pointLPS) => (0,_utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_15__.pointInEllipse)(ellipseObj, pointLPS, { fast: true }), this.configuration.statsCalculator.statsCallback, boundsIJK);
-                    const stats = this.configuration.statsCalculator.getStatistics();
-                    cachedStats[targetId] = {
-                        Modality: metadata.Modality,
-                        area,
-                        mean: stats.mean?.value,
-                        max: stats.max?.value,
-                        stdDev: stats.stdDev?.value,
-                        statsArray: stats.array,
-                        pointsInShape,
-                        isEmptyArea,
-                        areaUnit: areaUnits,
-                        modalityUnit,
-                    };
-                }
-                else {
-                    this.isHandleOutsideImage = true;
-                    cachedStats[targetId] = {
-                        Modality: metadata.Modality,
-                    };
-                }
+                this.isHandleOutsideImage = !this._isInsideVolume(pos1Index, post2Index, dimensions);
+                const iMin = Math.min(pos1Index[0], post2Index[0]);
+                const iMax = Math.max(pos1Index[0], post2Index[0]);
+                const jMin = Math.min(pos1Index[1], post2Index[1]);
+                const jMax = Math.max(pos1Index[1], post2Index[1]);
+                const kMin = Math.min(pos1Index[2], post2Index[2]);
+                const kMax = Math.max(pos1Index[2], post2Index[2]);
+                const boundsIJK = [
+                    [iMin, iMax],
+                    [jMin, jMax],
+                    [kMin, kMax],
+                ];
+                const center = [
+                    (topLeftWorld[0] + bottomRightWorld[0]) / 2,
+                    (topLeftWorld[1] + bottomRightWorld[1]) / 2,
+                    (topLeftWorld[2] + bottomRightWorld[2]) / 2,
+                ];
+                const ellipseObj = {
+                    center,
+                    xRadius: Math.abs(topLeftWorld[0] - bottomRightWorld[0]) / 2,
+                    yRadius: Math.abs(topLeftWorld[1] - bottomRightWorld[1]) / 2,
+                    zRadius: Math.abs(topLeftWorld[2] - bottomRightWorld[2]) / 2,
+                };
+                const { worldWidth, worldHeight } = (0,_utilities_planar_getWorldWidthAndHeightFromTwoPoints__WEBPACK_IMPORTED_MODULE_14__/* ["default"] */ .A)(viewPlaneNormal, viewUp, worldPos1, worldPos2);
+                const isEmptyArea = worldWidth === 0 && worldHeight === 0;
+                const handles = [pos1Index, post2Index];
+                const { scale, areaUnits } = (0,_utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_2__/* .getCalibratedLengthUnitsAndScale */ .Op)(image, handles);
+                const area = Math.abs(Math.PI * (worldWidth / 2) * (worldHeight / 2)) /
+                    scale /
+                    scale;
+                const modalityUnitOptions = {
+                    isPreScaled: (0,_utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_19__/* .isViewportPreScaled */ .u)(viewport, targetId),
+                    isSuvScaled: this.isSuvScaled(viewport, targetId, annotation.metadata.referencedImageId),
+                };
+                const modalityUnit = (0,_utilities_getModalityUnit__WEBPACK_IMPORTED_MODULE_18__/* .getModalityUnit */ .c)(metadata.Modality, annotation.metadata.referencedImageId, modalityUnitOptions);
+                const pointsInShape = (0,_utilities__WEBPACK_IMPORTED_MODULE_3__.pointInShapeCallback)(imageData, (pointLPS) => (0,_utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_15__.pointInEllipse)(ellipseObj, pointLPS, { fast: true }), this.configuration.statsCalculator.statsCallback, boundsIJK);
+                const stats = this.configuration.statsCalculator.getStatistics();
+                cachedStats[targetId] = {
+                    Modality: metadata.Modality,
+                    area,
+                    mean: stats.mean?.value,
+                    max: stats.max?.value,
+                    stdDev: stats.stdDev?.value,
+                    statsArray: stats.array,
+                    pointsInShape,
+                    isEmptyArea,
+                    areaUnit: areaUnits,
+                    modalityUnit,
+                };
             }
             annotation.invalidated = false;
             (0,_stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_8__/* .triggerAnnotationModified */ .XF)(annotation, element);
@@ -43398,7 +44000,7 @@ EllipticalROITool.toolName = 'EllipticalROI';
 /* harmony import */ var _base__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(96214);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(38296);
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(54177);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(61738);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(90252);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(23072);
@@ -43597,7 +44199,7 @@ KeyImageTool.toolName = 'KeyImage';
 /* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(21009);
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(54177);
 /* harmony import */ var _utilities_math_line__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(21954);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(61738);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(90252);
 /* harmony import */ var _utilities_drawing__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(10910);
@@ -44043,7 +44645,7 @@ LengthTool.toolName = 'Length';
 /* harmony import */ var _utilities_livewire_LiveWirePath__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(1320);
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(54177);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(84901);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(49574);
 
 
 
@@ -44096,7 +44698,7 @@ class LivewireContourSegmentationTool extends _LivewireContourTool__WEBPACK_IMPO
             }
             this.updateAnnotation(acceptedPath);
             this.scissors = null;
-            this.scissorsRight = null;
+            this.scissorsNext = null;
             this.editData = null;
             annotation.data.handles.interpolationSources = null;
             if (repeatInterpolation) {
@@ -44147,7 +44749,7 @@ LivewireContourSegmentationTool.toolName = 'LivewireContourSegmentationTool';
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(44753);
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(92136);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(38296);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(61738);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(84901);
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(40233);
@@ -44442,7 +45044,7 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
             element.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_5__.Events.TOUCH_TAP, this._mouseDownCallback);
         };
     }
-    setupBaseEditData(worldPos, element, annotation, rightPos, contourHoleProcessingEnabled) {
+    setupBaseEditData(worldPos, element, annotation, nextPos, contourHoleProcessingEnabled) {
         const enabledElement = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_1__.getEnabledElement)(element);
         const { viewport } = enabledElement;
         this.isDrawing = true;
@@ -44485,12 +45087,12 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
         const { voiRange } = viewport.getProperties();
         const startPos = worldToSlice(worldPos);
         this.scissors = _utilities_livewire_LivewireScissors__WEBPACK_IMPORTED_MODULE_12__/* .LivewireScissors */ .f.createInstanceFromRawPixelData(scalarData, width, height, voiRange);
-        if (rightPos) {
-            this.scissorsRight = _utilities_livewire_LivewireScissors__WEBPACK_IMPORTED_MODULE_12__/* .LivewireScissors */ .f.createInstanceFromRawPixelData(scalarData, width, height, voiRange);
-            this.scissorsRight.startSearch(worldToSlice(rightPos));
+        if (nextPos) {
+            this.scissorsNext = _utilities_livewire_LivewireScissors__WEBPACK_IMPORTED_MODULE_12__/* .LivewireScissors */ .f.createInstanceFromRawPixelData(scalarData, width, height, voiRange);
+            this.scissorsNext.startSearch(worldToSlice(nextPos));
         }
         this.scissors.startSearch(startPos);
-        const newAnnotation = !rightPos;
+        const newAnnotation = !nextPos;
         const confirmedPath = new _utilities_livewire_LiveWirePath__WEBPACK_IMPORTED_MODULE_13__/* .LivewirePath */ .j();
         const currentPath = new _utilities_livewire_LiveWirePath__WEBPACK_IMPORTED_MODULE_13__/* .LivewirePath */ .j();
         const currentPathNext = newAnnotation ? undefined : new _utilities_livewire_LiveWirePath__WEBPACK_IMPORTED_MODULE_13__/* .LivewirePath */ .j();
@@ -44506,7 +45108,7 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
             lastCanvasPoint,
             confirmedPath,
             currentPath,
-            confirmedPathRight: currentPathNext,
+            confirmedPathNext: currentPathNext,
             closed: false,
             handleIndex: this.editData?.handleIndex ?? annotation.handles?.activeHandleIndex,
             worldToSlice,
@@ -44532,7 +45134,7 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
     clearEditData() {
         this.editData = null;
         this.scissors = null;
-        this.scissorsRight = null;
+        this.scissorsNext = null;
         this.isDrawing = false;
     }
     editHandle(worldPos, element, annotation, handleIndex) {
@@ -44541,11 +45143,11 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
         const { length: numHandles } = handlePoints;
         const previousHandle = handlePoints[(handleIndex - 1 + numHandles) % numHandles];
         const nextHandle = handlePoints[(handleIndex + 1) % numHandles];
-        if (!this.editData?.confirmedPathRight) {
+        if (!this.editData?.confirmedPathNext) {
             this.setupBaseEditData(previousHandle, element, annotation, nextHandle);
             const { polyline } = data.contour;
             const confirmedPath = new _utilities_livewire_LiveWirePath__WEBPACK_IMPORTED_MODULE_13__/* .LivewirePath */ .j();
-            const confirmedPathRight = new _utilities_livewire_LiveWirePath__WEBPACK_IMPORTED_MODULE_13__/* .LivewirePath */ .j();
+            const confirmedPathNext = new _utilities_livewire_LiveWirePath__WEBPACK_IMPORTED_MODULE_13__/* .LivewirePath */ .j();
             const { worldToSlice } = this.editData;
             const previousIndex = (0,_utilities_contours_findHandlePolylineIndex__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(annotation, handleIndex - 1);
             const nextIndex = (0,_utilities_contours_findHandlePolylineIndex__WEBPACK_IMPORTED_MODULE_9__/* ["default"] */ .A)(annotation, handleIndex + 1);
@@ -44553,17 +45155,14 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
                 throw new Error(`Can't find handle index ${nextIndex === -1 && nextHandle} ${previousIndex === -1 && previousHandle}`);
             }
             if (handleIndex === 0) {
-                confirmedPathRight.addPoints(polyline.slice(nextIndex + 1, previousIndex).map(worldToSlice));
-            }
-            else if (nextIndex < previousIndex) {
-                throw new Error(`Expected right index after left index, but were: ${previousIndex} ${nextIndex}`);
+                confirmedPathNext.addPoints(polyline.slice(nextIndex + 1, previousIndex).map(worldToSlice));
             }
             else {
                 confirmedPath.addPoints(polyline.slice(0, previousIndex + 1).map(worldToSlice));
-                confirmedPathRight.addPoints(polyline.slice(nextIndex, polyline.length).map(worldToSlice));
+                confirmedPathNext.addPoints(polyline.slice(nextIndex, polyline.length).map(worldToSlice));
             }
             this.editData.confirmedPath = confirmedPath;
-            this.editData.confirmedPathRight = confirmedPathRight;
+            this.editData.confirmedPathNext = confirmedPathNext;
         }
         const { editData, scissors } = this;
         const { worldToSlice, sliceToWorld } = editData;
@@ -44583,14 +45182,14 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
         }
         handlePoints[handleIndex] = sliceToWorld(slicePos);
         const pathPointsLeft = scissors.findPathToPoint(slicePos);
-        const pathPointsRight = this.scissorsRight.findPathToPoint(slicePos);
+        const pathPointsRight = this.scissorsNext.findPathToPoint(slicePos);
         const currentPath = new _utilities_livewire_LiveWirePath__WEBPACK_IMPORTED_MODULE_13__/* .LivewirePath */ .j();
         currentPath.prependPath(editData.confirmedPath);
         if (handleIndex !== 0) {
             currentPath.addPoints(pathPointsLeft);
         }
         currentPath.addPoints(pathPointsRight.reverse());
-        currentPath.appendPath(editData.confirmedPathRight);
+        currentPath.appendPath(editData.confirmedPathNext);
         if (handleIndex === 0) {
             currentPath.addPoints(pathPointsLeft);
         }
@@ -44649,17 +45248,19 @@ class LivewireContourTool extends _base_ContourSegmentationBaseTool__WEBPACK_IMP
         if (!this.editData || !livewirePath) {
             return;
         }
-        const { annotation, sliceToWorld } = this.editData;
+        const { annotation, sliceToWorld, worldToSlice, closed, newAnnotation } = this.editData;
         let { pointArray: imagePoints } = livewirePath;
         if (imagePoints.length > 1) {
             imagePoints = [...imagePoints, imagePoints[0]];
         }
+        const targetWindingDirection = newAnnotation && closed ? _types_ContourAnnotation__WEBPACK_IMPORTED_MODULE_10__/* .ContourWindingDirection */ .W.Clockwise : undefined;
         this.updateContourPolyline(annotation, {
             points: imagePoints,
-            closed: annotation.data.contour.closed,
-            targetWindingDirection: _types_ContourAnnotation__WEBPACK_IMPORTED_MODULE_10__/* .ContourWindingDirection */ .W.Clockwise,
+            closed,
+            targetWindingDirection,
         }, {
             canvasToWorld: sliceToWorld,
+            worldToCanvas: worldToSlice,
         });
     }
 }
@@ -44726,7 +45327,7 @@ PlanarFreehandContourSegmentationTool.toolName =
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(38296);
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(54177);
 /* harmony import */ var _utilities_getCalibratedUnits__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(24592);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(61738);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(84901);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(90252);
@@ -45106,7 +45707,7 @@ ProbeTool.toolName = 'Probe';
 /* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(48428);
 /* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(21009);
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(54177);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(61738);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(84901);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(90252);
@@ -45172,6 +45773,7 @@ class RectangleROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .AnnotationT
                     viewUp: [...viewUp],
                     FrameOfReferenceUID,
                     referencedImageId,
+                    ...viewport.getViewReference({ points: [worldPos] }),
                 },
                 data: {
                     label: '',
@@ -45519,7 +46121,7 @@ class RectangleROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .AnnotationT
                 }
                 const dataId = `${annotationUID}-rect`;
                 const rectangleUID = '0';
-                (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_9__.drawRect)(svgDrawingHelper, annotationUID, rectangleUID, canvasCoordinates[0], canvasCoordinates[3], {
+                (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_9__.drawRectByCoordinates)(svgDrawingHelper, annotationUID, rectangleUID, canvasCoordinates, {
                     color,
                     lineDash,
                     lineWidth,
@@ -45703,7 +46305,7 @@ SplineContourSegmentationTool.toolName = 'SplineContourSegmentationTool';
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(92136);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(44753);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(38296);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(61738);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(84901);
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(40233);
@@ -46457,7 +47059,7 @@ SplineROITool.toolName = 'SplineROI';
 /* harmony import */ var _utilities_throttle__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(21090);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(38296);
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(54177);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(61738);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(90252);
 /* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(74119);
@@ -46942,7 +47544,7 @@ UltrasoundDirectionalTool.toolName = 'UltrasoundDirectionalTool';
 /* harmony import */ var _base__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(96214);
 /* harmony import */ var _utilities_throttle__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(21090);
 /* harmony import */ var _stateManagement__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(95778);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(49574);
 /* harmony import */ var _store__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(61738);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(84901);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(90252);
@@ -47967,7 +48569,7 @@ async function _addLabelmapToViewport(viewport, labelmapData, segmentationRepres
 /* harmony import */ var _strategies_fillCircle__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(4069);
 /* harmony import */ var _strategies_eraseCircle__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(11852);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(84901);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(49574);
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(40233);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(23072);
 /* harmony import */ var _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(63421);
@@ -48439,7 +49041,7 @@ BrushTool.toolName = 'Brush';
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(84901);
 /* harmony import */ var _stateManagement_annotation_annotationState__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(38296);
 /* harmony import */ var _stateManagement_annotation_annotationLocking__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(48428);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(49574);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(90252);
 /* harmony import */ var _utilities_throttle__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(21090);
 /* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(21009);
@@ -48803,7 +49405,7 @@ CircleROIStartEndThresholdTool.toolName = 'CircleROIStartEndThreshold';
 /* harmony import */ var _strategies_fillCircle__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(4069);
 /* harmony import */ var _strategies_eraseCircle__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(11852);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(84901);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(49574);
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(40233);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(23072);
 /* harmony import */ var _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(63421);
@@ -49300,7 +49902,7 @@ PaintFillTool.toolName = 'PaintFill';
 /* harmony import */ var _strategies_eraseRectangle__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(66211);
 /* harmony import */ var _utilities_viewportFilters__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(90252);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(84901);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(49574);
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(40233);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(23072);
 /* harmony import */ var _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(63421);
@@ -49670,7 +50272,7 @@ SegmentSelectTool.toolName = 'SegmentSelectTool';
 /* harmony import */ var _strategies_fillSphere__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(61604);
 /* harmony import */ var _strategies_eraseSphere__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4373);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(84901);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(49574);
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(40233);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(23072);
 /* harmony import */ var _stateManagement_segmentation__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(63421);
@@ -50271,7 +50873,7 @@ function triggerSegmentationRender(toolGroupId) {
 /* unused harmony exports annotationRenderingEngine, triggerAnnotationRender */
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(92136);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(84901);
-/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2746);
+/* harmony import */ var _drawingSvg__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(49574);
 /* harmony import */ var _getToolsWithModesForElement__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(42360);