@ohif/app 3.12.0-beta.99 → 3.12.0

package/dist/{5448.bundle.9a36e001169ea3bfeb6c.js → 4410.bundle.c5224cd7d6238a7d4660.js}

@@ -1,4 +1,4 @@
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[5448],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[4410],{
 
 /***/ 86871:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -1142,7 +1142,7 @@ class BaseVolumeViewport extends Viewport/* default */.A {
     getSliceViewInfo() {
         throw new Error('Method not implemented.');
     }
-    applyViewOrientation(orientation, resetCamera = true) {
+    applyViewOrientation(orientation, resetCamera = true, suppressEvents = false) {
         const { viewPlaneNormal, viewUp } = this._getOrientationVectors(orientation) || {};
         if (!viewPlaneNormal || !viewUp) {
             return;
@@ -1153,7 +1153,11 @@ class BaseVolumeViewport extends Viewport/* default */.A {
         this.initialViewUp = viewUp;
         if (resetCamera) {
             const t = this;
-            t.resetCamera({ resetOrientation: false, resetRotation: false });
+            t.resetCamera({
+                resetOrientation: false,
+                resetRotation: false,
+                suppressEvents,
+            });
         }
     }
     initializeVolumeNewImageEventDispatcher() {
@@ -1457,10 +1461,14 @@ class BaseVolumeViewport extends Viewport/* default */.A {
     setViewPlane(planeRestriction) {
         const { point, inPlaneVector1, inPlaneVector2, FrameOfReferenceUID } = planeRestriction;
         this.setBestOrentation(inPlaneVector1, inPlaneVector2);
+        const { focalPoint, viewPlaneNormal } = this.getCamera();
+        const deltaFocal = esm/* vec3.subtract */.eR.subtract(esm/* vec3.create */.eR.create(), point, focalPoint);
+        const alongNormal = esm/* vec3.dot */.eR.dot(deltaFocal, viewPlaneNormal);
+        const deltaNormal = esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(esm/* vec3.create */.eR.create(), focalPoint, viewPlaneNormal, alongNormal);
         this.setViewReference({
             FrameOfReferenceUID,
-            cameraFocalPoint: point,
-            viewPlaneNormal: this.getCamera().viewPlaneNormal,
+            cameraFocalPoint: deltaNormal,
+            viewPlaneNormal: viewPlaneNormal,
         });
     }
     setViewReference(viewRef) {
@@ -1491,7 +1499,7 @@ class BaseVolumeViewport extends Viewport/* default */.A {
         }
         else if (refFrameOfReference === this.getFrameOfReferenceUID()) {
             if (refViewPlaneNormal && !isNegativeNormal && !isSameNormal) {
-                this.setOrientation({ viewPlaneNormal: refViewPlaneNormal, viewUp });
+                this.setOrientation({ viewPlaneNormal: refViewPlaneNormal, viewUp }, true, true);
                 this.setViewReference(viewRef);
                 return;
             }
@@ -1555,6 +1563,7 @@ class BaseVolumeViewport extends Viewport/* default */.A {
                 colormap,
                 preset,
                 slabThickness,
+                sampleDistanceMultiplier,
             });
         }
         if (invert !== undefined && this.viewportProperties.invert !== invert) {
@@ -1727,7 +1736,7 @@ class BaseVolumeViewport extends Viewport/* default */.A {
             this.render();
         }
     }
-    setOrientation(_orientation, _immediate = true) {
+    setOrientation(_orientation, _immediate = true, _suppressEvents = false) {
         console.warn('Method "setOrientation" needs implementation');
     }
     initializeColorTransferFunction(volumeInputArray) {
@@ -1796,7 +1805,7 @@ class BaseVolumeViewport extends Viewport/* default */.A {
         }
         volumeId ||= this.getVolumeId();
         const actorEntry = this.getActors()?.find((actor) => actor.referencedId === volumeId);
-        if (!(0,actorCheck/* actorIsA */.N)(actorEntry, 'vtkVolume')) {
+        if (!actorEntry || !(0,actorCheck/* actorIsA */.N)(actorEntry, 'vtkVolume')) {
             return;
         }
         const actor = actorEntry.actor;
@@ -1955,6 +1964,9 @@ class BaseVolumeViewport extends Viewport/* default */.A {
                 return;
             }
             volumeId = actorEntries.find((actorEntry) => actorEntry.actor.getClassName() === 'vtkVolume')?.referencedId;
+            if (!volumeId) {
+                return;
+            }
         }
         const currentIndex = this.getSliceIndex();
         sliceIndex ??= currentIndex;
@@ -6375,7 +6387,9 @@ class VideoViewport extends Viewport/* default */.A {
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(71851);
 /* harmony import */ var _utilities_deepClone__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(99949);
 /* harmony import */ var _utilities_updatePlaneRestriction__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(41365);
-/* harmony import */ var _init__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(26896);
+/* harmony import */ var _utilities_getPlaneCubeIntersectionDimensions__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(52623);
+/* harmony import */ var _init__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(26896);
+
 
 
 
@@ -6406,7 +6420,7 @@ class Viewport {
         paletteLut: true,
     }; }
     constructor(props) {
-        this.insetImageMultiplier = (0,_init__WEBPACK_IMPORTED_MODULE_17__/* .getConfiguration */ .D0)().rendering
+        this.insetImageMultiplier = (0,_init__WEBPACK_IMPORTED_MODULE_18__/* .getConfiguration */ .D0)().rendering
             ?.useLegacyCameraFOV
             ? 1.1
             : 1;
@@ -6892,15 +6906,6 @@ class Viewport {
         }
         const focalPoint = [0, 0, 0];
         const imageData = this.getDefaultImageData();
-        if (imageData) {
-            const spc = imageData.getSpacing();
-            bounds[0] = bounds[0] + spc[0] / 2;
-            bounds[1] = bounds[1] - spc[0] / 2;
-            bounds[2] = bounds[2] + spc[1] / 2;
-            bounds[3] = bounds[3] - spc[1] / 2;
-            bounds[4] = bounds[4] + spc[2] / 2;
-            bounds[5] = bounds[5] - spc[2] / 2;
-        }
         const activeCamera = this.getVtkActiveCamera();
         const viewPlaneNormal = activeCamera.getViewPlaneNormal();
         const viewUp = activeCamera.getViewUp();
@@ -6913,18 +6918,13 @@ class Viewport {
             const idx = [middleIJK[0], middleIJK[1], middleIJK[2]];
             imageData.indexToWorld(idx, focalPoint);
         }
-        let widthWorld;
-        let heightWorld;
-        const config = (0,_init__WEBPACK_IMPORTED_MODULE_17__/* .getConfiguration */ .D0)();
-        const useLegacyMethod = config.rendering?.useLegacyCameraFOV ?? false;
-        if (imageData && !useLegacyMethod) {
-            const extent = imageData.getExtent();
+        let { widthWorld, heightWorld } = imageData
+            ? (0,_utilities_getPlaneCubeIntersectionDimensions__WEBPACK_IMPORTED_MODULE_17__/* .getCubeSizeInView */ .H)(imageData, viewPlaneNormal, viewUp)
+            : this._getWorldDistanceViewUpAndViewRight(bounds, viewUp, viewPlaneNormal);
+        if (imageData) {
             const spacing = imageData.getSpacing();
-            widthWorld = (extent[1] - extent[0]) * spacing[0];
-            heightWorld = (extent[3] - extent[2]) * spacing[1];
-        }
-        else {
-            ({ widthWorld, heightWorld } = this._getWorldDistanceViewUpAndViewRight(bounds, viewUp, viewPlaneNormal));
+            widthWorld = Math.max(spacing[0], widthWorld - spacing[0]);
+            heightWorld = Math.max(spacing[1], heightWorld - spacing[1]);
         }
         const canvasSize = [this.sWidth, this.sHeight];
         const boundsAspectRatio = widthWorld / heightWorld;
@@ -7593,8 +7593,11 @@ class VolumeViewport extends BaseVolumeViewport/* default */.A {
                 suppressEvents: true,
             });
         };
-        this.getCurrentImageIdIndex = (volumeId, useSlabThickness = true) => {
-            const { currentStepIndex } = (0,getVolumeViewportScrollInfo/* default */.A)(this, volumeId || this.getVolumeId(), useSlabThickness);
+        this.getCurrentImageIdIndex = (volumeId = this.getVolumeId(), useSlabThickness = true) => {
+            if (!volumeId) {
+                return 0;
+            }
+            const { currentStepIndex } = (0,getVolumeViewportScrollInfo/* default */.A)(this, volumeId, useSlabThickness);
             return currentStepIndex;
         };
         this.getSliceIndex = () => {
@@ -7678,9 +7681,19 @@ class VolumeViewport extends BaseVolumeViewport/* default */.A {
         return super.addVolumes(volumeInputArray, immediate, suppressEvents);
     }
     jumpToWorld(worldPos) {
+        let targetWorldPos = worldPos;
+        const imageData = this.getImageData();
+        if (imageData?.imageData) {
+            const bounds = imageData.imageData.getBounds();
+            targetWorldPos = [
+                Math.max(bounds[0], Math.min(bounds[1], worldPos[0])),
+                Math.max(bounds[2], Math.min(bounds[3], worldPos[1])),
+                Math.max(bounds[4], Math.min(bounds[5], worldPos[2])),
+            ];
+        }
         const { focalPoint } = this.getCamera();
         const delta = [0, 0, 0];
-        esm/* vec3.sub */.eR.sub(delta, worldPos, focalPoint);
+        esm/* vec3.sub */.eR.sub(delta, targetWorldPos, focalPoint);
         const camera = this.getCamera();
         const normal = camera.viewPlaneNormal;
         const dotProd = esm/* vec3.dot */.eR.dot(delta, normal);
@@ -7701,7 +7714,7 @@ class VolumeViewport extends BaseVolumeViewport/* default */.A {
         }
         return true;
     }
-    setOrientation(orientation, immediate = true) {
+    setOrientation(orientation, immediate = true, suppressEvents = false) {
         let viewPlaneNormal, viewUp;
         if (typeof orientation === 'string') {
             if (orientation === enums.OrientationAxis.ACQUISITION) {
@@ -7728,7 +7741,7 @@ class VolumeViewport extends BaseVolumeViewport/* default */.A {
         }
         else {
             ({ viewPlaneNormal, viewUp } = orientation);
-            this.applyViewOrientation(orientation);
+            this.applyViewOrientation(orientation, true, suppressEvents);
         }
         if (immediate) {
             this.render();
@@ -18428,6 +18441,9 @@ function vtkStreamingOpenGLTexture(publicAPI, model) {
             return;
         }
         const volume = cache/* default */.Ay.getVolume(volumeId);
+        if (!volume) {
+            return;
+        }
         model._openGLRenderWindow.activateTexture(publicAPI);
         publicAPI.createTexture();
         publicAPI.bind();
@@ -19585,8 +19601,8 @@ class BaseStreamingImageVolume extends _ImageVolume__WEBPACK_IMPORTED_MODULE_9__
     }
     getLoaderImageOptions(imageId) {
         const { transferSyntaxUID: transferSyntaxUID } = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('transferSyntax', imageId) || {};
-        const imagePlaneModule = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('imagePlaneModule', imageId) || {};
-        const { rows, columns } = imagePlaneModule;
+        const targetRows = this.dimensions[1];
+        const targetCols = this.dimensions[0];
         const imageIdIndex = this.getImageIdIndex(imageId);
         const modalityLutModule = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('modalityLutModule', imageId) || {};
         const generalSeriesModule = _metaData__WEBPACK_IMPORTED_MODULE_0__.get('generalSeriesModule', imageId) || {};
@@ -19619,8 +19635,8 @@ class BaseStreamingImageVolume extends _ImageVolume__WEBPACK_IMPORTED_MODULE_9__
         }
         const targetBuffer = {
             type: this.dataType,
-            rows,
-            columns,
+            rows: targetRows,
+            columns: targetCols,
         };
         return {
             targetBuffer,
@@ -19767,12 +19783,16 @@ class BaseStreamingImageVolume extends _ImageVolume__WEBPACK_IMPORTED_MODULE_9__
 
 
 class ImageVolume {
+    get numTimePoints() {
+        return typeof this.numDimensionGroups === 'number'
+            ? this.numDimensionGroups
+            : 1;
+    }
     constructor(props) {
         this._imageIdsIndexMap = new Map();
         this._imageURIsIndexMap = new Map();
         this.cornerstoneImageMetaData = null;
         this.isPreScaled = false;
-        this.numTimePoints = null;
         this.numFrames = null;
         const { imageIds, scaling, dimensions, spacing, origin, direction, dataType, volumeId, referencedVolumeId, metadata, referencedImageIds, additionalDetails, voxelManager, numberOfComponents, } = props;
         if (!dataType) {
@@ -19852,7 +19872,10 @@ class ImageVolume {
         });
     }
     isDynamicVolume() {
-        return this.numTimePoints > 1;
+        if (this.numTimePoints) {
+            return this.numTimePoints > 1;
+        }
+        return false;
     }
     getImageIdIndex(imageId) {
         return this._imageIdsIndexMap.get(imageId);
@@ -21662,7 +21685,7 @@ class Mesh {
 /* unused harmony export default */
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(71851);
 /* harmony import */ var _eventTarget__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(10364);
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(33592);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(85343);
 /* harmony import */ var _BaseStreamingImageVolume__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(35637);
 
 
@@ -25238,7 +25261,7 @@ function createProgressive(configuration) {
 /* harmony import */ var _utils_mesh_createMesh__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(83469);
 /* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(71851);
 /* harmony import */ var _eventTarget__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(10364);
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(33592);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(85343);
 
 
 
@@ -25324,7 +25347,7 @@ async function fetchAndProcessMeshData(meshId, options, loaderOptions) {
 "use strict";
 /* unused harmony export cornerstoneStreamingDynamicImageVolumeLoader */
 /* harmony import */ var _cache__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(50584);
-/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(33592);
+/* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(85343);
 
 
 function cornerstoneStreamingDynamicImageVolumeLoader(volumeId, options) {
@@ -25480,6 +25503,183 @@ function cornerstoneStreamingImageVolumeLoader(volumeId, options) {
 
 
 
+/***/ }),
+
+/***/ 18481:
+/***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {
+
+"use strict";
+
+// UNUSED EXPORTS: decimatedVolumeLoader, default
+
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/cache/classes/StreamingImageVolume.js
+var classes_StreamingImageVolume = __webpack_require__(50180);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/generateVolumePropsFromImageIds.js
+var utilities_generateVolumePropsFromImageIds = __webpack_require__(9734);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/decimate.js
+var utilities_decimate = __webpack_require__(63470);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/utilities/VoxelManager.js
+var utilities_VoxelManager = __webpack_require__(24623);
+;// ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/decimatedVolumeModifiers/applyDecimatedVolumeModifiers.js
+function applyDecimatedVolumeModifiers_applyDecimatedVolumeModifiers(baseProps, modifiers, context) {
+    return modifiers.reduce((currentProps, modifier) => modifier.apply(currentProps, context), baseProps);
+}
+
+;// ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/decimatedVolumeModifiers/inPlaneDecimationModifier.js
+const inPlaneDecimationModifier_inPlaneDecimationModifier = {
+    name: 'InPlaneDecimationModifier',
+    apply(volumeProps, context) {
+        const [iDecimation = 1, jDecimation = iDecimation] = context.options.ijkDecimation ?? [];
+        const columnFactor = Math.max(1, Math.floor(iDecimation));
+        const rowFactor = Math.max(1, Math.floor(jDecimation));
+        if (columnFactor === 1 && rowFactor === 1) {
+            return volumeProps;
+        }
+        const [columns, rows] = volumeProps.dimensions;
+        const newColumns = Math.max(1, Math.floor(columns / columnFactor));
+        const newRows = Math.max(1, Math.floor(rows / rowFactor));
+        const newDimensions = [
+            newColumns,
+            newRows,
+            volumeProps.dimensions[2],
+        ];
+        const newSpacing = [
+            volumeProps.spacing[0] * columnFactor,
+            volumeProps.spacing[1] * rowFactor,
+            volumeProps.spacing[2],
+        ];
+        const metadata = {
+            ...volumeProps.metadata,
+            Columns: newColumns,
+            Rows: newRows,
+            PixelSpacing: [newSpacing[1], newSpacing[0]],
+        };
+        return {
+            ...volumeProps,
+            dimensions: newDimensions,
+            spacing: newSpacing,
+            metadata,
+        };
+    },
+};
+
+;// ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/decimatedVolumeModifiers/index.js
+
+
+
+;// ../../../node_modules/@cornerstonejs/core/dist/esm/loaders/decimatedVolumeLoader.js
+
+
+
+
+
+function decimatedVolumeLoader(volumeId, options) {
+    if (!options || !options.imageIds || !options.imageIds.length) {
+        throw new Error('ImageIds must be provided to create a streaming image volume ');
+    }
+    const [iDecimation = 1, jDecimation = iDecimation, kDecimation = 1] = options.ijkDecimation ?? [];
+    const columnDecimation = Math.max(1, Math.floor(iDecimation));
+    const rowDecimation = jDecimation > 1 ? Math.max(1, Math.floor(jDecimation)) : columnDecimation;
+    const kAxisDecimation = Math.max(1, Math.floor(kDecimation));
+    const hasInPlaneDecimation = columnDecimation > 1 || rowDecimation > 1;
+    const modifierOptions = {
+        ijkDecimation: [
+            columnDecimation,
+            rowDecimation,
+            kAxisDecimation,
+        ],
+    };
+    const modifiers = [inPlaneDecimationModifier];
+    function addDecimationToImageId(imageId, factor) {
+        if (factor === 1) {
+            return imageId;
+        }
+        return `${imageId}#decimation=${factor}`;
+    }
+    const expectedDecimatedCount = Math.floor(options.imageIds.length / kAxisDecimation);
+    const isAlreadyDecimated = kAxisDecimation > 1 &&
+        options.imageIds.length <= expectedDecimatedCount + 1;
+    if (kAxisDecimation > 1 && !isAlreadyDecimated) {
+        const decimatedResult = decimate(options.imageIds, kAxisDecimation);
+        const decimatedImageIds = Array.isArray(decimatedResult) &&
+            decimatedResult.length &&
+            typeof decimatedResult[0] === 'number'
+            ? decimatedResult.map((idx) => options.imageIds[idx])
+            : decimatedResult;
+        options.imageIds = decimatedImageIds;
+    }
+    if (columnDecimation > 1) {
+        options.imageIds = options.imageIds.map((imageId) => addDecimationToImageId(imageId, columnDecimation));
+    }
+    async function getStreamingImageVolume() {
+        const baseVolumeProps = generateVolumePropsFromImageIds(options.imageIds, volumeId);
+        const modifierContext = {
+            volumeId,
+            imageIds: options.imageIds,
+            options: modifierOptions,
+        };
+        const volumeProps = applyDecimatedVolumeModifiers(baseVolumeProps, modifiers, modifierContext);
+        const { dimensions, spacing, origin, direction, metadata, imageIds, dataType, numberOfComponents, } = volumeProps;
+        const streamingImageVolume = new StreamingImageVolume({
+            volumeId,
+            metadata,
+            dimensions,
+            spacing,
+            origin,
+            direction,
+            imageIds,
+            dataType,
+            numberOfComponents,
+        }, {
+            imageIds,
+            loadStatus: {
+                loaded: false,
+                loading: false,
+                cancelled: false,
+                cachedFrames: [],
+                callbacks: [],
+            },
+        });
+        if (hasInPlaneDecimation) {
+            const vtkImageData = streamingImageVolume.imageData;
+            if (vtkImageData) {
+                vtkImageData.setDimensions(streamingImageVolume.dimensions);
+                vtkImageData.setSpacing(streamingImageVolume.spacing);
+                vtkImageData.modified();
+            }
+            const newVoxelManager = VoxelManager.createImageVolumeVoxelManager({
+                dimensions: streamingImageVolume.dimensions,
+                imageIds: streamingImageVolume.imageIds,
+                numberOfComponents: numberOfComponents,
+            });
+            streamingImageVolume.voxelManager = newVoxelManager;
+            if (vtkImageData) {
+                vtkImageData.set({
+                    voxelManager: newVoxelManager,
+                });
+            }
+        }
+        return streamingImageVolume;
+    }
+    const streamingImageVolumePromise = getStreamingImageVolume();
+    return {
+        promise: streamingImageVolumePromise,
+        decache: () => {
+            streamingImageVolumePromise.then((streamingImageVolume) => {
+                streamingImageVolume.destroy();
+                streamingImageVolume = null;
+            });
+        },
+        cancel: () => {
+            streamingImageVolumePromise.then((streamingImageVolume) => {
+                streamingImageVolume.cancelLoading();
+            });
+        },
+    };
+}
+/* harmony default export */ const loaders_decimatedVolumeLoader = ((/* unused pure expression or super */ null && (decimatedVolumeLoader)));
+
+
 /***/ }),
 
 /***/ 52269:
@@ -34214,7 +34414,7 @@ class VoxelManager {
         this._set = options._set;
         this._id = options._id || '';
         this._getConstructor = options._getConstructor;
-        this.numberOfComponents = this.numberOfComponents || 1;
+        this.numberOfComponents = options.numberOfComponents || 1;
         this.scalarData = options.scalarData;
         this._getScalarData = options._getScalarData;
         this._updateScalarData = options._updateScalarData;
@@ -34952,6 +35152,24 @@ function createPositionCallback(imageData) {
 }
 
 
+/***/ }),
+
+/***/ 63470:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   A: () => (/* binding */ decimate)
+/* harmony export */ });
+function decimate(list, interleave, offset = 0) {
+    const interleaveIndices = [];
+    for (let i = offset; i < list.length; i += interleave) {
+        interleaveIndices.push(i);
+    }
+    return interleaveIndices;
+}
+
+
 /***/ }),
 
 /***/ 74268:
@@ -35282,7 +35500,7 @@ function uuidv4() {
 
 "use strict";
 /* unused harmony export version */
-const version = '4.12.6';
+const version = '4.15.29';
 
 
 /***/ }),
@@ -36686,6 +36904,8 @@ var SegmentationRepresentations;
 /* harmony export */ });
 var StrategyCallbacks;
 (function (StrategyCallbacks) {
+    StrategyCallbacks["CalculateCursorGeometry"] = "calculateCursorGeometry";
+    StrategyCallbacks["RenderCursor"] = "renderCursor";
     StrategyCallbacks["OnInteractionStart"] = "onInteractionStart";
     StrategyCallbacks["OnInteractionEnd"] = "onInteractionEnd";
     StrategyCallbacks["Preview"] = "preview";
@@ -37478,7 +37698,8 @@ function addAnnotation(annotation, annotationGroupSelector) {
         annotation.annotationUID = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.uuidv4();
     }
     const manager = getAnnotationManager();
-    if (annotationGroupSelector instanceof HTMLDivElement) {
+    if (annotationGroupSelector instanceof HTMLDivElement &&
+        (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.getEnabledElement)(annotationGroupSelector)) {
         const groupKey = manager.getGroupKey(annotationGroupSelector);
         manager.addAnnotation(annotation, groupKey);
         (0,_helpers_state__WEBPACK_IMPORTED_MODULE_1__.triggerAnnotationAddedForElement)(annotation, annotationGroupSelector);
@@ -38139,6 +38360,9 @@ function getColorLUT(index) {
 
 function getCurrentLabelmapImageIdForViewport(viewportId, segmentationId) {
     const imageIds = getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId);
+    if (!imageIds?.length) {
+        return;
+    }
     return imageIds[0];
 }
 function getCurrentLabelmapImageIdsForViewport(viewportId, segmentationId) {
@@ -39002,9 +39226,11 @@ class ToolGroup_ToolGroup {
                 const cursor = MouseCursor.getDefinedCursor('default');
                 this._setCursorForViewports(cursor);
             }
+            toolInstance.isPrimary = false;
         }
         else {
             this.setViewportsCursorByToolName(toolName);
+            toolInstance.isPrimary = true;
         }
         if (this._hasMousePrimaryButtonBinding(toolBindingsOptions)) {
             if (this.prevActivePrimaryToolName === null) {
@@ -39051,6 +39277,7 @@ class ToolGroup_ToolGroup {
         }
         this.toolOptions[toolName] = toolOptions;
         toolInstance.mode = mode;
+        toolInstance.isPrimary = false;
         if (typeof toolInstance.onSetToolPassive === 'function') {
             toolInstance.onSetToolPassive();
         }
@@ -39571,6 +39798,9 @@ AnnotationDisplayTool.toolName = 'AnnotationDisplayTool';
 
 const { DefaultHistoryMemo } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.HistoryMemo;
 class BaseTool {
+    get configurationTyped() {
+        return this.configuration;
+    }
     static { this.defaults = {
         configuration: {
             strategies: {},
@@ -39580,6 +39810,7 @@ class BaseTool {
         },
     }; }
     constructor(toolProps, defaultToolProps) {
+        this.isPrimary = false;
         const mergedDefaults = BaseTool.mergeDefaultProps(BaseTool.defaults, defaultToolProps);
         const initialProps = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.deepMerge(mergedDefaults, toolProps);
         const { configuration = {}, supportedInteractionTypes, toolGroupId, } = initialProps;
@@ -39594,6 +39825,11 @@ class BaseTool {
         }
         return _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.deepMerge(defaultProps, additionalProps);
     }
+    static isSpecifiedTargetId(desiredVolumeId) {
+        return (_viewport, { targetId }) => {
+            return targetId.includes(desiredVolumeId);
+        };
+    }
     get toolName() {
         return this.getToolName();
     }
@@ -39653,10 +39889,18 @@ class BaseTool {
             throw new Error('getTargetIdImage: targetId must start with "imageId:" or "volumeId:"');
         }
     }
-    getTargetId(viewport) {
-        const targetId = viewport.getViewReferenceId?.();
-        if (targetId) {
-            return targetId;
+    getTargetId(viewport, data) {
+        const { isPreferredTargetId } = this.configurationTyped;
+        if (isPreferredTargetId && data?.cachedStats) {
+            for (const [targetId, cachedStat] of Object.entries(data.cachedStats)) {
+                if (isPreferredTargetId(viewport, { targetId, cachedStat })) {
+                    return targetId;
+                }
+            }
+        }
+        const defaultTargetId = viewport.getViewReferenceId?.();
+        if (defaultTargetId) {
+            return defaultTargetId;
         }
         throw new Error('getTargetId: viewport must have a getViewReferenceId method');
     }
@@ -39784,7 +40028,12 @@ async function render(viewport, contourRepresentation) {
         (0,_config__WEBPACK_IMPORTED_MODULE_5__/* .getPolySeg */ .Qy)()?.canComputeRequestedRepresentation(segmentationId, _enums_SegmentationRepresentations__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Contour) &&
         !polySegConversionInProgressForViewportId.get(viewport.id)) {
         polySegConversionInProgressForViewportId.set(viewport.id, true);
-        contourData = await (0,_utilities_segmentation_computeAndAddRepresentation__WEBPACK_IMPORTED_MODULE_6__/* .computeAndAddRepresentation */ .d)(segmentationId, _enums_SegmentationRepresentations__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Contour, () => polySeg.computeContourData(segmentationId, { viewport }));
+        try {
+            contourData = await (0,_utilities_segmentation_computeAndAddRepresentation__WEBPACK_IMPORTED_MODULE_6__/* .computeAndAddRepresentation */ .d)(segmentationId, _enums_SegmentationRepresentations__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Contour, () => polySeg.computeContourData(segmentationId, { viewport }));
+        }
+        catch (error) {
+            console.warn('Unable to compute contour data for segmentationId', segmentationId, error);
+        }
         polySegConversionInProgressForViewportId.set(viewport.id, false);
     }
     else if (!contourData && !(0,_config__WEBPACK_IMPORTED_MODULE_5__/* .getPolySeg */ .Qy)()) {
@@ -44156,8 +44405,6 @@ function createBidirectionalToolData(bidirectionalData, viewport) {
 /* unused harmony exports restoreMemo, createRleMemo */
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
 /* harmony import */ var _stateManagement_segmentation_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(49906);
-/* harmony import */ var _enums_Events__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(94021);
-
 
 
 const { VoxelManager, RLEVoxelMap } = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities;
@@ -44316,7 +44563,7 @@ function createMergedLabelmapForIndex(labelmaps, segmentIndex = 1, volumeId = 'm
 /* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
 
 function getOrCreateImageVolume(referencedImageIds) {
-    if (!referencedImageIds || referencedImageIds.length <= 1) {
+    if (!referencedImageIds?.length) {
         return;
     }
     const isValidVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isValidVolume(referencedImageIds);
@@ -44349,6 +44596,9 @@ function getOrCreateImageVolume(referencedImageIds) {
 
 function getOrCreateSegmentationVolume(segmentationId) {
     const { representationData } = (0,_stateManagement_segmentation_getSegmentation__WEBPACK_IMPORTED_MODULE_1__/* .getSegmentation */ .T)(segmentationId);
+    if (!representationData.Labelmap) {
+        return;
+    }
     let { volumeId } = representationData.Labelmap;
     let segVolume;
     if (volumeId) {
@@ -44359,7 +44609,7 @@ function getOrCreateSegmentationVolume(segmentationId) {
     }
     const { imageIds: labelmapImageIds } = representationData.Labelmap;
     volumeId = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.generateVolumeId(labelmapImageIds);
-    if (!labelmapImageIds || labelmapImageIds.length === 1) {
+    if (!labelmapImageIds || labelmapImageIds.length === 0) {
         return;
     }
     const isValidVolume = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.utilities.isValidVolume(labelmapImageIds);
@@ -44397,7 +44647,10 @@ function getReferenceVolumeForSegmentationVolume(segmentationVolumeId) {
         const imageIds = segmentationVolume.imageIds;
         const image = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getImage(imageIds[0]);
         const referencedImageId = image.referencedImageId;
-        const volumeInfo = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolumeContainingImageId(referencedImageId);
+        let volumeInfo = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolumeContainingImageId(referencedImageId);
+        if (!volumeInfo?.volume) {
+            volumeInfo = _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.cache.getVolumeContainingImageId(image.imageId);
+        }
         imageVolume = volumeInfo?.volume;
     }
     return imageVolume;
@@ -44520,6 +44773,9 @@ async function getStatistics({ segmentationId, segmentIndices, mode = 'collectiv
 }
 async function calculateVolumeStatistics({ operationData, indices, unit, mode, }) {
     const strategyData = (0,_utilsForWorker__WEBPACK_IMPORTED_MODULE_1__/* .prepareVolumeStrategyDataForWorker */ .o9)(operationData);
+    if (!strategyData) {
+        return;
+    }
     const { segmentationVoxelManager, imageVoxelManager, segmentationImageData, imageData, } = strategyData;
     if (!segmentationVoxelManager || !segmentationImageData) {
         return;