@ohif/app 3.12.0-beta.30 → 3.12.0-beta.32

package/dist/{1447.bundle.7ccbf8c680ed0a7e69d5.js → 1447.bundle.5329a1fc555ff8492f45.js}

@@ -9702,8 +9702,8 @@ function AboutModalDefault() {
     name
   } = (0,browser_detect_es5/* default */.A)();
   const browser = `${name[0].toUpperCase()}${name.substr(1)} ${version}`;
-  const versionNumber = "3.12.0-beta.30";
-  const commitHash = "7783d0f558bbb7016c29513b6fe76ed069dbd75c";
+  const versionNumber = "3.12.0-beta.32";
+  const commitHash = "d41eca4ed5f7aec3a5c4e779b86436622262be38";
   const [main, beta] = versionNumber.split('-');
   return /*#__PURE__*/react.createElement(ui_next_src/* AboutModal */.VTU, {
     className: "w-[400px]"

package/dist/{2345.bundle.1fedf5750caf46ce99d9.js → 2345.bundle.db2624daf28f03ec2f90.js}

@@ -124,6 +124,8 @@ function drawLinkedTextBox(svgDrawingHelper, annotationUID, textBoxUID, textLine
 /* harmony import */ var _utilities_getPixelValueUnits__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(40634);
 /* harmony import */ var _utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(18990);
 /* harmony import */ var _utilities_math_basic__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(73262);
+/* harmony import */ var _stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(76712);
+
 
 
 
@@ -506,9 +508,10 @@ class RectangleROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .AnnotationT
                     activeHandleIndex !== undefined) {
                     activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
                 }
-                if (activeHandleCanvasCoords) {
+                const showHandlesAlways = Boolean((0,_stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_20__/* .getStyleProperty */ .h)('showHandlesAlways', {}));
+                if (activeHandleCanvasCoords || showHandlesAlways) {
                     const handleGroupUID = '0';
-                    (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_8__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, activeHandleCanvasCoords, {
+                    (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_8__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, showHandlesAlways ? canvasCoordinates : activeHandleCanvasCoords, {
                         color,
                     });
                 }

package/dist/{4019.bundle.701981ea6b7abed6a66c.js → 4019.bundle.c5b332003e3cd00868ce.js}

@@ -1466,6 +1466,14 @@ class ContourSegmentationBaseTool extends ContourBaseTool {
             InterpolationManager/* default */.A.addTool(this.getToolName());
         }
     }
+    onSetToolConfiguration() {
+        if (this.configuration.interpolation?.enabled) {
+            InterpolationManager/* default */.A.addTool(this.getToolName());
+        }
+        else {
+            InterpolationManager/* default */.A.removeTool(this.getToolName());
+        }
+    }
     isContourSegmentationTool() {
         return true;
     }

package/dist/{7412.bundle.f5de4a483672f3eabc10.js → 7412.bundle.b891b84732a843f2eeb1.js}

@@ -3031,7 +3031,7 @@ class Colorbar extends _widgets_Widget__WEBPACK_IMPORTED_MODULE_7__/* ["default"
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   r: () => (/* binding */ version)
 /* harmony export */ });
-const version = '4.0.0';
+const version = '4.3.10';
 
 
 /***/ }),
@@ -5366,6 +5366,8 @@ function _toolGroupHasActiveEnabledOrPassiveTool(toolGroup, toolName) {
 /* harmony import */ var _stateManagement_annotation_helpers_state__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(44049);
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(7001);
 /* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(29601);
+/* harmony import */ var _stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(76712);
+
 
 
 
@@ -5663,7 +5665,8 @@ class AngleTool extends _base__WEBPACK_IMPORTED_MODULE_2__/* .AnnotationTool */
                 if (!(0,_stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_14__.isAnnotationVisible)(annotationUID)) {
                     continue;
                 }
-                if (activeHandleCanvasCoords) {
+                const showHandlesAlways = Boolean((0,_stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_15__/* .getStyleProperty */ .h)('showHandlesAlways', {}));
+                if (activeHandleCanvasCoords || showHandlesAlways) {
                     const handleGroupUID = '0';
                     (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_8__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, canvasCoordinates, {
                         color,
@@ -7205,6 +7208,8 @@ async function contourAndFindLargestBidirectional(segmentation) {
 /* harmony import */ var _utilities_drawing__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(473);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(58640);
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(7001);
+/* harmony import */ var _stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(76712);
+
 
 
 
@@ -7478,7 +7483,8 @@ class LengthTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .AnnotationTool */
                     activeHandleIndex !== null) {
                     activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
                 }
-                if (activeHandleCanvasCoords) {
+                const showHandlesAlways = Boolean((0,_stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_16__/* .getStyleProperty */ .h)('showHandlesAlways', {}));
+                if (activeHandleCanvasCoords || showHandlesAlways) {
                     const handleGroupUID = '0';
                     (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_10__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, canvasCoordinates, {
                         color,
@@ -12459,6 +12465,8 @@ function defaultGetSegment(enabledElement, configuration) {
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(7001);
 /* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(29601);
 /* harmony import */ var _utilities__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(53860);
+/* harmony import */ var _stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(76712);
+
 
 
 
@@ -12757,7 +12765,8 @@ class ArrowAnnotateTool extends _base__WEBPACK_IMPORTED_MODULE_2__/* .Annotation
                 if (!(0,_stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_12__.isAnnotationVisible)(annotationUID)) {
                     continue;
                 }
-                if (activeHandleCanvasCoords) {
+                const showHandlesAlways = Boolean((0,_stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_14__/* .getStyleProperty */ .h)('showHandlesAlways', {}));
+                if (activeHandleCanvasCoords || showHandlesAlways) {
                     const handleGroupUID = '0';
                     (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_6__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, canvasCoordinates, {
                         color,
@@ -13148,6 +13157,8 @@ const segmentationRenderingEngine = new SegmentationRenderingEngine();
 /* harmony import */ var _utilities_drawing__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(473);
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(7001);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(58640);
+/* harmony import */ var _stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(76712);
+
 
 
 
@@ -13664,9 +13675,10 @@ class BidirectionalTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .Annotation
                     activeHandleIndex !== null) {
                     activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
                 }
-                if (activeHandleCanvasCoords) {
+                const showHandlesAlways = Boolean((0,_stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_17__/* .getStyleProperty */ .h)('showHandlesAlways', {}));
+                if (activeHandleCanvasCoords || showHandlesAlways) {
                     const handleGroupUID = '0';
-                    (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_9__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, activeHandleCanvasCoords, {
+                    (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_9__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, showHandlesAlways ? canvasCoordinates : activeHandleCanvasCoords, {
                         color,
                     });
                 }
@@ -15044,6 +15056,7 @@ TrackballRotateTool.toolName = 'TrackballRotate';
 
 
 
+
 class ZoomTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .BaseTool */ .oS {
     constructor(toolProps = {}, defaultToolProps = {
         supportedInteractionTypes: ['Mouse', 'Touch'],
@@ -15102,9 +15115,13 @@ class ZoomTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .BaseTool */ .oS {
                 const imageWidth = dimensions[0] * spacing[0];
                 const imageHeight = dimensions[1] * spacing[1];
                 const canvasAspect = size[0] / size[1];
+                const insetImageMultiplier = (0,_cornerstonejs_core__WEBPACK_IMPORTED_MODULE_2__.getConfiguration)().rendering
+                    ?.useLegacyCameraFOV
+                    ? 1.1
+                    : 1;
                 const displayArea = viewport.options?.displayArea;
-                const imageAreaScaleX = displayArea?.imageArea?.[0] ?? 1.1;
-                const imageAreaScaleY = displayArea?.imageArea?.[1] ?? 1.1;
+                const imageAreaScaleX = displayArea?.imageArea?.[0] ?? insetImageMultiplier;
+                const imageAreaScaleY = displayArea?.imageArea?.[1] ?? insetImageMultiplier;
                 const scaledImageWidth = imageWidth * imageAreaScaleX;
                 const scaledImageHeight = imageHeight * imageAreaScaleY;
                 const scaledImageAspect = scaledImageWidth / scaledImageHeight;
@@ -15307,6 +15324,11 @@ class InterpolationManager {
             this.toolNames.push(toolName);
         }
     }
+    static removeTool(toolName) {
+        if (this.toolNames.includes(toolName)) {
+            this.toolNames = this.toolNames.filter((name) => name !== toolName);
+        }
+    }
     static acceptAutoGenerated(annotationGroupSelector, selector = {}) {
         const { toolNames, segmentationId, segmentIndex, sliceIndex } = selector;
         for (const toolName of toolNames || InterpolationManager.toolNames) {
@@ -16811,6 +16833,8 @@ function createPresentationViewSynchronizer(synchronizerName, options) {
 /* harmony import */ var _utilities_math_ellipse__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(87009);
 /* harmony import */ var _utilities_math_basic__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(73262);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(3823);
+/* harmony import */ var _stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(76712);
+
 
 
 
@@ -17222,9 +17246,10 @@ class CircleROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .AnnotationTool
                         activeHandleCanvasCoords = canvasCoordinates;
                     }
                 }
-                if (activeHandleCanvasCoords) {
+                const showHandlesAlways = Boolean((0,_stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_22__/* .getStyleProperty */ .h)('showHandlesAlways', {}));
+                if (activeHandleCanvasCoords || showHandlesAlways) {
                     const handleGroupUID = '0';
-                    (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_8__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, activeHandleCanvasCoords, {
+                    (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_8__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, showHandlesAlways ? canvasCoordinates : activeHandleCanvasCoords, {
                         color,
                     });
                 }
@@ -23014,13 +23039,20 @@ class WindowLevelTool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .BaseTool */
             }, [Infinity, -Infinity]);
             const BitsStored = imageVolume?.metadata?.BitsStored;
             const metadataDynamicRange = BitsStored ? 2 ** BitsStored : Infinity;
-            imageDynamicRange = Math.min(calculatedDynamicRange[1] - calculatedDynamicRange[0], metadataDynamicRange);
+            const calculatedRange = calculatedDynamicRange[1] - calculatedDynamicRange[0];
+            imageDynamicRange = !Number.isFinite(calculatedRange)
+                ? metadataDynamicRange
+                : Math.min(calculatedRange, metadataDynamicRange);
         }
         else {
             imageDynamicRange = this._getImageDynamicRangeFromViewport(viewport);
         }
         const ratio = imageDynamicRange / DEFAULT_IMAGE_DYNAMIC_RANGE;
-        return ratio > 1 ? Math.round(ratio) : ratio;
+        return !Number.isFinite(ratio)
+            ? DEFAULT_IMAGE_DYNAMIC_RANGE
+            : ratio > 1
+                ? Math.round(ratio)
+                : ratio;
     }
     _getImageDynamicRangeFromViewport(viewport) {
         const { imageData, voxelManager } = viewport.getImageData();
@@ -27166,14 +27198,15 @@ function internalAddSegmentationRepresentation(viewportId, representationInput)
     };
     _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_5__/* .defaultSegmentationStateManager */ ._6.addSegmentationRepresentation(viewportId, segmentationId, representationInput.type, renderingConfig);
     if (!(0,_segmentIndex__WEBPACK_IMPORTED_MODULE_6__.getActiveSegmentIndex)(segmentationId)) {
+        let firstSegmentIndex = 1;
         const segmentation = _SegmentationStateManager__WEBPACK_IMPORTED_MODULE_5__/* .defaultSegmentationStateManager */ ._6.getSegmentation(segmentationId);
         if (segmentation) {
             const segmentKeys = Object.keys(segmentation.segments);
             if (segmentKeys.length > 0) {
-                const firstSegmentIndex = segmentKeys.map((k) => Number(k)).sort()[0];
-                (0,_segmentIndex__WEBPACK_IMPORTED_MODULE_6__.setActiveSegmentIndex)(segmentationId, firstSegmentIndex);
+                firstSegmentIndex = segmentKeys.map((k) => Number(k)).sort()[0];
             }
         }
+        (0,_segmentIndex__WEBPACK_IMPORTED_MODULE_6__.setActiveSegmentIndex)(segmentationId, firstSegmentIndex);
     }
     if (representationInput.type === _enums__WEBPACK_IMPORTED_MODULE_2__.SegmentationRepresentations.Contour) {
         (0,_utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_1__/* .triggerAnnotationRenderForViewportIds */ .t)([viewportId]);
@@ -28672,6 +28705,8 @@ function getViewportIdsWithSegmentation(segmentationId) {
 /* harmony import */ var _utilities_drawing__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(473);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(58640);
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(7001);
+/* harmony import */ var _stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(76712);
+
 
 
 
@@ -28932,7 +28967,8 @@ class HeightTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .AnnotationTool */
                     activeHandleIndex !== null) {
                     activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
                 }
-                if (activeHandleCanvasCoords) {
+                const showHandlesAlways = Boolean((0,_stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_16__/* .getStyleProperty */ .h)('showHandlesAlways', {}));
+                if (activeHandleCanvasCoords || showHandlesAlways) {
                     const handleGroupUID = '0';
                     (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_10__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, canvasCoordinates, {
                         color,
@@ -36402,6 +36438,8 @@ function updateLabelmapSegmentationImageReferences(viewportId, segmentationId) {
 /* harmony import */ var _utilities_viewport_isViewportPreScaled__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(18990);
 /* harmony import */ var _utilities_math_basic__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(73262);
 /* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(3823);
+/* harmony import */ var _stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(76712);
+
 
 
 
@@ -36848,9 +36886,10 @@ class EllipticalROITool extends _base__WEBPACK_IMPORTED_MODULE_0__/* .Annotation
                     activeHandleIndex !== null) {
                     activeHandleCanvasCoords = [canvasCoordinates[activeHandleIndex]];
                 }
-                if (activeHandleCanvasCoords) {
+                const showHandlesAlways = Boolean((0,_stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_21__/* .getStyleProperty */ .h)('showHandlesAlways', {}));
+                if (activeHandleCanvasCoords || showHandlesAlways) {
                     const handleGroupUID = '0';
-                    (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_8__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, activeHandleCanvasCoords, {
+                    (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_8__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, showHandlesAlways ? canvasCoordinates : activeHandleCanvasCoords, {
                         color,
                     });
                 }
@@ -37679,10 +37718,11 @@ class SVGMouseCursor extends ImageMouseCursor {
         }
         const urn = getCursorURN(name, pointer, color);
         let cursor = super.getDefinedCursor(urn);
+        const pointerStrokeWidth = Number((0,helpers/* getStyleProperty */.h)('pointerStrokeWidth', {}));
         if (!cursor) {
             const descriptor = getDefinedSVGCursorDescriptor(name);
             if (descriptor) {
-                cursor = createSVGMouseCursor(descriptor, urn, pointer, color, super.getDefinedCursor('default'));
+                cursor = createSVGMouseCursor(descriptor, urn, pointer, color, pointerStrokeWidth, super.getDefinedCursor('default'));
                 super.setDefinedCursor(urn, cursor);
             }
         }
@@ -37700,9 +37740,9 @@ function getCursorURN(name, pointer, color) {
     const type = pointer ? 'pointer' : 'cursor';
     return `${type}:${name}/${color}`;
 }
-function createSVGMouseCursor(descriptor, name, pointer, color, fallback) {
+function createSVGMouseCursor(descriptor, name, pointer, color, pointerStrokeWidth, fallback) {
     const { x, y } = descriptor.mousePoint;
-    return new SVGMouseCursor(createSVGIconUrl(descriptor, pointer, { color }), x, y, name, fallback);
+    return new SVGMouseCursor(createSVGIconUrl(descriptor, pointer, { color, pointerStrokeWidth }), x, y, name, fallback);
 }
 function createSVGIconUrl(descriptor, pointer, options) {
     const blob = createSVGIconBlob(descriptor, pointer, options);
@@ -37728,10 +37768,11 @@ function createSVGIconWithPointer(descriptor, options) {
     const { iconContent, iconSize, viewBox, mousePointerGroupString } = descriptor;
     const scale = iconSize / Math.max(viewBox.x, viewBox.y, 1);
     const svgSize = 16 + iconSize;
+    const pointerStrokeWidth = options.pointerStrokeWidth || 1;
     const svgString = `
     <svg data-icon="cursor" role="img" xmlns="http://www.w3.org/2000/svg"
       width="${svgSize}" height="${svgSize}" viewBox="0 0 ${svgSize} ${svgSize}">
-      <g>${mousePointerGroupString}</g>
+      <g stroke-width="${pointerStrokeWidth}">${mousePointerGroupString}</g>
       <g transform="translate(16, 16) scale(${scale})">${iconContent}</g>
     </svg>`;
     return format(svgString, options);
@@ -43927,6 +43968,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _utilities_triggerAnnotationRenderForViewportIds__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(58640);
 /* harmony import */ var _cursors_elementCursor__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(7001);
 /* harmony import */ var _stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(29601);
+/* harmony import */ var _stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(76712);
+
 
 
 
@@ -44279,7 +44322,8 @@ class CobbAngleTool extends _base__WEBPACK_IMPORTED_MODULE_3__/* .AnnotationTool
                 if (!(0,_stateManagement_annotation_annotationVisibility__WEBPACK_IMPORTED_MODULE_17__.isAnnotationVisible)(annotationUID)) {
                     continue;
                 }
-                if (activeHandleCanvasCoords) {
+                const showHandlesAlways = Boolean((0,_stateManagement_annotation_config_helpers__WEBPACK_IMPORTED_MODULE_18__/* .getStyleProperty */ .h)('showHandlesAlways', {}));
+                if (activeHandleCanvasCoords || showHandlesAlways) {
                     const handleGroupUID = '0';
                     (0,_drawingSvg__WEBPACK_IMPORTED_MODULE_11__.drawHandles)(svgDrawingHelper, annotationUID, handleGroupUID, canvasCoordinates, {
                         color,

package/dist/{7431.bundle.c5e2e2f2f4ccc2c994d7.js → 7431.bundle.dac1caef5e9f365ce247.js}

@@ -1931,6 +1931,9 @@ async function updateSurfaceData(segmentationId) {
                     segmentationId,
                     type: updateSurfaceData_SegmentationRepresentations.Surface,
                 });
+                if (!surfaceRepresentation) {
+                    return;
+                }
                 return [surfaceRepresentation].map((surfaceRepresentation) => {
                     segmentation.representationData.Surface.geometryIds.set(segmentIndex, geometryId);
                     const enabledElement = (0,esm.getEnabledElementByViewportId)(viewportId);

package/dist/{8558.bundle.700a45d1df4274c7569e.js → 8558.bundle.d52a1cb49ddc1a5f6d36.js}

@@ -150,9 +150,39 @@ const {
   DicomMetaDictionary
 } = dcmjs_es/* default.data */.Ay.data;
 const dicomlab2RGB = dcmjs_es/* default.data */.Ay.data.Colors.dicomlab2RGB;
-async function checkAndLoadContourData(instance, datasource) {
+
+/**
+ * Checks and loads contour data for RT Structure Set, handling both inline and bulk data URIs.
+ * Processes ROIContourSequence to extract contour data and resolve any bulk data references.
+ *
+ * @async
+ * @function checkAndLoadContourData
+ * @param {Object} params - Parameters object
+ * @param {Object} params.instance - Initial RT Structure instance
+ * @param {Object} params.dataSource - Data source for retrieving bulk data
+ * @param {Object} params.extensionManager - OHIF extension manager
+ * @param {Object} params.rtStructDisplaySet - RT Structure display set
+ * @param {Object} params.headers - HTTP headers for requests
+ * @returns {Promise<Object>} Promise that resolves to the processed RT Structure instance with loaded contour data
+ * @throws {Promise<string>} Rejects with error message if instance is invalid or data retrieval fails
+ */
+async function checkAndLoadContourData({
+  instance: initialInstance,
+  dataSource,
+  extensionManager,
+  rtStructDisplaySet,
+  headers
+}) {
+  let instance = initialInstance;
   if (!instance || !instance.ROIContourSequence) {
-    return Promise.reject('Invalid instance object or ROIContourSequence');
+    instance = await getRTStructInstance({
+      extensionManager,
+      rtStructDisplaySet,
+      headers
+    });
+    if (!instance || !instance.ROIContourSequence) {
+      return Promise.reject('Invalid instance object or ROIContourSequence');
+    }
   }
   const promisesMap = new Map();
   for (const ROIContour of instance.ROIContourSequence) {
@@ -170,10 +200,10 @@ async function checkAndLoadContourData(instance, datasource) {
         promisesMap.has(referencedROINumber) ? promisesMap.get(referencedROINumber).push(Promise.resolve(contourData)) : promisesMap.set(referencedROINumber, [Promise.resolve(contourData)]);
       } else if (contourData && contourData.BulkDataURI) {
         const bulkDataURI = contourData.BulkDataURI;
-        if (!datasource || !datasource.retrieve || !datasource.retrieve.bulkDataURI) {
-          return Promise.reject('Invalid datasource object or retrieve function');
+        if (!dataSource || !dataSource.retrieve || !dataSource.retrieve.bulkDataURI) {
+          return Promise.reject('Invalid dataSource object or retrieve function');
         }
-        const bulkDataPromise = datasource.retrieve.bulkDataURI({
+        const bulkDataPromise = dataSource.retrieve.bulkDataURI({
           BulkDataURI: bulkDataURI,
           StudyInstanceUID: instance.StudyInstanceUID,
           SeriesInstanceUID: instance.SeriesInstanceUID,
@@ -220,29 +250,78 @@ async function checkAndLoadContourData(instance, datasource) {
       console.error(error);
     }
   });
+  return instance;
 }
-async function loadRTStruct(extensionManager, rtStructDisplaySet, headers) {
+
+/**
+ * Retrieves and parses RT Structure Set instance from DICOM data.
+ * Uses the cornerstone utility module to load DICOM data and converts it to a naturalized dataset.
+ *
+ * @async
+ * @function getRTStructInstance
+ * @param {Object} params - Parameters object
+ * @param {Object} params.extensionManager - OHIF extension manager
+ * @param {Object} params.rtStructDisplaySet - RT Structure display set
+ * @param {Object} params.headers - HTTP headers for requests
+ * @returns {Promise<Object>} Promise that resolves to the parsed RT Structure dataset
+ */
+const getRTStructInstance = async ({
+  extensionManager,
+  rtStructDisplaySet,
+  headers
+}) => {
   const utilityModule = extensionManager.getModuleEntry('@ohif/extension-cornerstone.utilityModule.common');
+  const {
+    dicomLoaderService
+  } = utilityModule.exports;
+  const segArrayBuffer = await dicomLoaderService.findDicomDataPromise(rtStructDisplaySet, null, headers);
+  const dicomData = DicomMessage.readFile(segArrayBuffer);
+  const rtStructDataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
+  rtStructDataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
+  return rtStructDataset;
+};
+
+/**
+ * Main function to load and process RT Structure Set data.
+ * Creates a structure set object with ROI contours, metadata, and visualization properties.
+ * Handles both bulk data URI and inline contour data scenarios.
+ *
+ * @async
+ * @function loadRTStruct
+ * @param {Object} extensionManager - OHIF extension manager
+ * @param {Object} rtStructDisplaySet - RT Structure display set to process
+ * @param {Object} headers - HTTP headers for data requests
+ * @returns {Promise<Object>} Promise that resolves to a structure set object containing:
+ *   - StructureSetLabel: Label of the structure set
+ *   - SeriesInstanceUID: Series instance UID
+ *   - ROIContours: Array of ROI contour data with points and metadata
+ *   - visible: Visibility state
+ *   - ReferencedSOPInstanceUIDsSet: Set of referenced SOP instance UIDs
+ */
+async function loadRTStruct(extensionManager, rtStructDisplaySet, headers) {
   const dataSource = extensionManager.getActiveDataSource()[0];
   const {
     bulkDataURI
   } = dataSource.getConfig?.() || {};
-  const {
-    dicomLoaderService
-  } = utilityModule.exports;
 
   // Set here is loading is asynchronous.
   // If this function throws its set back to false.
   rtStructDisplaySet.isLoaded = true;
   let instance = rtStructDisplaySet.instance;
   if (!bulkDataURI || !bulkDataURI.enabled) {
-    const segArrayBuffer = await dicomLoaderService.findDicomDataPromise(rtStructDisplaySet, null, headers);
-    const dicomData = DicomMessage.readFile(segArrayBuffer);
-    const rtStructDataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
-    rtStructDataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
-    instance = rtStructDataset;
+    instance = await getRTStructInstance({
+      extensionManager,
+      rtStructDisplaySet,
+      headers
+    });
   } else {
-    await checkAndLoadContourData(instance, dataSource);
+    instance = await checkAndLoadContourData({
+      instance,
+      dataSource,
+      extensionManager,
+      rtStructDisplaySet,
+      headers
+    });
   }
   const {
     StructureSetROISequence,
@@ -298,6 +377,19 @@ async function loadRTStruct(extensionManager, rtStructDisplaySet, headers) {
   }
   return structureSet;
 }
+
+/**
+ * Sets metadata for ROI contour data and adds it to the structure set.
+ * Extracts ROI information from StructureSetROISequence and RTROIObservationsSequence,
+ * then creates a complete ROI contour data object with visualization properties.
+ *
+ * @function _setROIContourMetadata
+ * @param {Object} structureSet - The structure set object to add ROI contour to
+ * @param {Array} StructureSetROISequence - Array of structure set ROI definitions
+ * @param {Array} RTROIObservationsSequence - Array of RT ROI observations
+ * @param {Object} ROIContour - ROI contour object containing contour data
+ * @param {Array} contourPoints - Array of processed contour points
+ */
 function _setROIContourMetadata(structureSet, StructureSetROISequence, RTROIObservationsSequence, ROIContour, contourPoints) {
   const StructureSetROI = StructureSetROISequence.find(structureSetROI => structureSetROI.ROINumber === ROIContour.ReferencedROINumber);
   const ROIContourData = {
@@ -316,6 +408,15 @@ function _setROIContourMetadata(structureSet, StructureSetROISequence, RTROIObse
   }
   structureSet.ROIContours.push(ROIContourData);
 }
+
+/**
+ * Sets the display color for ROI contour data.
+ * Uses ROIDisplayColor if available, otherwise converts RecommendedDisplayCIELabValue to RGB.
+ *
+ * @function _setROIContourDataColor
+ * @param {Object} ROIContour - ROI contour object containing color information
+ * @param {Object} ROIContourData - ROI contour data object to set color on
+ */
 function _setROIContourDataColor(ROIContour, ROIContourData) {
   let {
     ROIDisplayColor,
@@ -329,6 +430,16 @@ function _setROIContourDataColor(ROIContour, ROIContourData) {
     ROIContourData.colorArray = [...ROIDisplayColor];
   }
 }
+
+/**
+ * Sets RT ROI observations metadata for ROI contour data.
+ * Finds matching RTROIObservations by ROINumber and adds observation details to contour data.
+ *
+ * @function _setROIContourRTROIObservations
+ * @param {Object} ROIContourData - ROI contour data object to add observations to
+ * @param {Array} RTROIObservationsSequence - Array of RT ROI observations
+ * @param {number} ROINumber - ROI number to match observations
+ */
 function _setROIContourRTROIObservations(ROIContourData, RTROIObservationsSequence, ROINumber) {
   const RTROIObservations = RTROIObservationsSequence.find(RTROIObservations => RTROIObservations.ReferencedROINumber === ROINumber);
   if (RTROIObservations) {
@@ -347,6 +458,15 @@ function _setROIContourRTROIObservations(ROIContourData, RTROIObservationsSequen
     };
   }
 }
+
+/**
+ * Converts a single object or array to an array.
+ * Utility function to ensure consistent array handling for DICOM sequences.
+ *
+ * @function _toArray
+ * @param {*} objOrArray - Object or array to convert
+ * @returns {Array} Array containing the input (if already array) or wrapped in array
+ */
 function _toArray(objOrArray) {
   return Array.isArray(objOrArray) ? objOrArray : [objOrArray];
 }