@ohif/app 3.12.0-beta.86 → 3.12.0-beta.88

package/dist/{1214.bundle.01574d45655d4aed6d97.js → 1214.bundle.0015f63bce964b6ef47e.js}

@@ -2315,7 +2315,7 @@ const toolNames = {
 };
 
 ;// ../../../extensions/cornerstone/src/utils/measurementServiceMappings/constants/supportedTools.js
-const supportedTools = ['Length', 'EllipticalROI', 'CircleROI', 'Bidirectional', 'ArrowAnnotate', 'Angle', 'CobbAngle', 'Probe', 'RectangleROI', 'PlanarFreehandROI', 'SplineROI', 'LivewireContour', 'UltrasoundDirectionalTool', 'UltrasoundPleuraBLineTool', 'SCOORD3DPoint', 'SegmentBidirectional'];
+const supportedTools = ['Length', 'EllipticalROI', 'CircleROI', 'Bidirectional', 'ArrowAnnotate', 'Angle', 'CobbAngle', 'Probe', 'RectangleROI', 'PlanarFreehandROI', 'SplineROI', 'LivewireContour', 'UltrasoundDirectionalTool', 'UltrasoundPleuraBLineTool', 'SegmentBidirectional'];
 /* harmony default export */ const constants_supportedTools = (supportedTools);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/annotation/index.js + 1 modules
 var annotation = __webpack_require__(47807);
@@ -4854,9 +4854,10 @@ function Probe_getMappedAnnotations(annotation, displaySetService) {
       SeriesNumber
     } = displaySet;
     const {
-      value
+      value,
+      modalityUnit
     } = targetStats;
-    const unit = 'HU';
+    const unit = modalityUnit || '';
     annotations.push({
       SeriesInstanceUID,
       SOPInstanceUID,
@@ -7205,10 +7206,17 @@ async function init({
   viewportGridService.addPresentationIdProvider('positionPresentationId', getPositionPresentationId);
   viewportGridService.addPresentationIdProvider('lutPresentationId', getLutPresentationId);
   viewportGridService.addPresentationIdProvider('segmentationPresentationId', getSegmentationPresentationId);
-  dist_esm.segmentation.config.style.setStyle({
+  segmentationService.setStyle({
     type: esm_enums.SegmentationRepresentations.Contour
   }, {
-    renderFill: false
+    // Declare these alpha values at the Contour type level so that they can be set/changed/inherited for all contour segmentations.
+    fillAlpha: 0.5,
+    fillAlphaInactive: 0.4,
+    // In general do not fill contours so that hydrated RTSTRUCTs are not filled in when active or inactive by default.
+    // However, hydrated RTSTRUCTs are filled in when active or inactive if the user chooses to fill ALL contours.
+    // Those Contours created in OHIF (i.e. using the Segmentation Panel) will override both fill properties upon creation.
+    renderFill: false,
+    renderFillInactive: false
   });
   const metadataProvider = src/* default.classes */.Ay.classes.MetadataProvider;
   esm.volumeLoader.registerVolumeLoader('cornerstoneStreamingImageVolume', loaders/* cornerstoneStreamingImageVolumeLoader */.FC);
@@ -7834,11 +7842,27 @@ function SegmentationToolConfig() {
 
 
 
-
 function getSegmentationPanelCustomization({
   commandsManager,
   servicesManager
 }) {
+  const {
+    segmentationService
+  } = servicesManager.services;
+  let contourRenderFillChangedGlobally = false;
+
+  // Listen to when the global CONTOUR type renderFill style property is changed.
+  const {
+    unsubscribe
+  } = segmentationService.subscribe(segmentationService.EVENTS.SEGMENTATION_STYLE_MODIFIED, ({
+    specifier,
+    style
+  }) => {
+    if (specifier.type === esm_enums.SegmentationRepresentations.Contour && specifier.segmentationId == null && specifier.viewportId == null && style.renderFill != null) {
+      unsubscribe();
+      contourRenderFillChangedGlobally = true;
+    }
+  });
   return {
     'panelSegmentation.customDropdownMenuContent': CustomDropdownMenuContent,
     'panelSegmentation.customSegmentStatisticsHeader': CustomSegmentStatisticsHeader,
@@ -7859,12 +7883,48 @@ function getSegmentationPanelCustomization({
         const segmentationId = await commandsManager.run('createContourForViewport', {
           viewportId
         });
-        dist_esm.segmentation.config.style.setStyle({
-          segmentationId,
-          type: esm_enums.SegmentationRepresentations.Contour
-        }, {
-          fillAlpha: 0.5,
-          renderFill: true
+        // Override the default (i.e. hydrated RTSTRUCT) style for contours if the global CONTOUR type
+        // renderFill style property has not been changed.
+        if (!contourRenderFillChangedGlobally) {
+          segmentationService.setStyle({
+            segmentationId,
+            type: esm_enums.SegmentationRepresentations.Contour
+          }, {
+            renderFill: true,
+            renderFillInactive: true
+          },
+          // Do not merge so that these created contours inherit other type-specific style properties like the fill alpha.
+          // Merging would otherwise permanently inherit the fill alpha and any inheritance from the type level would be lost.
+          false);
+        }
+
+        // If the global CONTOUR type renderFill style property is already set, do not subscribe to the SEGMENTATION_STYLE_MODIFIED event.
+        if (contourRenderFillChangedGlobally) {
+          return;
+        }
+
+        // Subscribe to the SEGMENTATION_STYLE_MODIFIED event to listen for changes to the CONTOUR type renderFill style property.
+        const {
+          unsubscribe
+        } = segmentationService.subscribe(segmentationService.EVENTS.SEGMENTATION_STYLE_MODIFIED, ({
+          specifier,
+          style
+        }) => {
+          if (specifier.type === esm_enums.SegmentationRepresentations.Contour && specifier.segmentationId == null && specifier.viewportId == null && style.renderFill != null) {
+            // We are here because the renderFill style property is globally being changed for ALL contours.
+            // When this occurs, the desire is for ALL contours to inherit the property. To make this happen,
+            // we have to clear the style property that was set for this specific segmentation
+            // when it was created above.
+            // We can now also unsubscribe because this change only needs to be made when the global CONTOUR type
+            // renderFill style property is first changed.
+
+            contourRenderFillChangedGlobally = true;
+            unsubscribe();
+            segmentationService.setStyle({
+              segmentationId,
+              type: esm_enums.SegmentationRepresentations.Contour
+            }, {}, false);
+          }
         });
       }
     },
@@ -12120,6 +12180,24 @@ function commandsModule({
         renderFill: value
       });
     },
+    /**
+     * Sets whether to render fill for inactive segmentations of a segmentation type
+     * @param props.type - The type of segmentation
+     * @param props.value - Whether to render fill for inactive segmentations
+     */
+    setRenderFillInactiveCommand: ({
+      type,
+      value
+    }) => {
+      const {
+        segmentationService
+      } = servicesManager.services;
+      segmentationService.setStyle({
+        type
+      }, {
+        renderFillInactive: value
+      });
+    },
     /**
      * Sets whether to render outline for a segmentation type
      * @param props.type - The type of segmentation
@@ -12139,11 +12217,11 @@ function commandsModule({
       });
     },
     /**
-     * Sets the fill alpha for inactive segmentations
+     * Sets whether to render outline for inactive segmentations of a segmentation type
      * @param props.type - The type of segmentation
-     * @param props.value - The alpha value to set
+     * @param props.value - Whether to render outline for inactive segmentations
      */
-    setFillAlphaInactiveCommand: ({
+    setRenderOutlineInactiveCommand: ({
       type,
       value
     }) => {
@@ -12153,9 +12231,41 @@ function commandsModule({
       segmentationService.setStyle({
         type
       }, {
-        fillAlphaInactive: value
+        renderOutlineInactive: value
       });
     },
+    /**
+     * Sets the fill alpha for inactive segmentations.
+     * If no type is provided, the fill alpha for all types will be set.
+     * @param props.type - The type of segmentation
+     * @param props.value - The alpha value to set
+     */
+    setFillAlphaInactiveCommand: ({
+      type,
+      value
+    }) => {
+      const {
+        segmentationService
+      } = servicesManager.services;
+      if (type) {
+        segmentationService.setStyle({
+          type
+        }, {
+          fillAlphaInactive: value
+        });
+      } else {
+        segmentationService.setStyle({
+          type: esm_enums.SegmentationRepresentations.Labelmap
+        }, {
+          fillAlphaInactive: value
+        });
+        segmentationService.setStyle({
+          type: esm_enums.SegmentationRepresentations.Contour
+        }, {
+          fillAlphaInactive: value
+        });
+      }
+    },
     editSegmentLabel: async ({
       segmentationId,
       segmentIndex
@@ -13115,9 +13225,15 @@ function commandsModule({
     setRenderFill: {
       commandFn: actions.setRenderFillCommand
     },
+    setRenderFillInactive: {
+      commandFn: actions.setRenderFillInactiveCommand
+    },
     setRenderOutline: {
       commandFn: actions.setRenderOutlineCommand
     },
+    setRenderOutlineInactive: {
+      commandFn: actions.setRenderOutlineInactiveCommand
+    },
     setFillAlphaInactive: {
       commandFn: actions.setFillAlphaInactiveCommand
     },
@@ -19047,7 +19163,8 @@ const SegmentationService_EVENTS = {
   // loading completed for all segments
   SEGMENTATION_LOADING_COMPLETE: 'event::segmentation_loading_complete',
   // fired when a contour annotation cut merge process is completed
-  SEGMENTATION_ANNOTATION_CUT_MERGE_PROCESS_COMPLETED: 'event::annotation_cut_merge_process_completed'
+  SEGMENTATION_ANNOTATION_CUT_MERGE_PROCESS_COMPLETED: 'event::annotation_cut_merge_process_completed',
+  SEGMENTATION_STYLE_MODIFIED: 'event::segmentation_style_modified'
 };
 const VALUE_TYPES = {};
 class SegmentationService extends src/* PubSubService */.Rc {
@@ -19074,8 +19191,13 @@ class SegmentationService extends src/* PubSubService */.Rc {
       const style = dist_esm.segmentation.config.style.getStyle(specifier);
       return style;
     };
-    this.setStyle = (specifier, style) => {
-      dist_esm.segmentation.config.style.setStyle(specifier, style);
+    this.setStyle = (specifier, style, merge = true) => {
+      dist_esm.segmentation.config.style.setStyle(specifier, style, merge);
+      this._broadcastEvent(SegmentationService_EVENTS.SEGMENTATION_STYLE_MODIFIED, {
+        specifier,
+        style,
+        merge
+      });
     };
     this.resetToGlobalStyle = () => {
       dist_esm.segmentation.config.style.resetToGlobalStyle();
@@ -20306,7 +20428,7 @@ class SegmentationService extends src/* PubSubService */.Rc {
           segmentationId,
           segmentIndex,
           type: LABELMAP
-        }, {});
+        }, {}, false);
       }
     };
     requestAnimationFrame(animation);
@@ -23239,6 +23361,9 @@ function PanelSegmentation({
     setFillAlpha: ({
       type
     }, value) => {
+      commandsManager.run('activateSelectedSegmentationOfType', {
+        segmentationRepresentationType: type
+      });
       commandsManager.run('setFillAlpha', {
         type,
         value
@@ -23247,6 +23372,9 @@ function PanelSegmentation({
     setOutlineWidth: ({
       type
     }, value) => {
+      commandsManager.run('activateSelectedSegmentationOfType', {
+        segmentationRepresentationType: type
+      });
       commandsManager.run('setOutlineWidth', {
         type,
         value
@@ -23255,19 +23383,41 @@ function PanelSegmentation({
     setRenderFill: ({
       type
     }, value) => {
+      commandsManager.run('activateSelectedSegmentationOfType', {
+        segmentationRepresentationType: type
+      });
       commandsManager.run('setRenderFill', {
         type,
         value
       });
     },
+    setRenderFillInactive: ({
+      type
+    }, value) => {
+      commandsManager.run('setRenderFillInactive', {
+        type,
+        value
+      });
+    },
     setRenderOutline: ({
       type
     }, value) => {
+      commandsManager.run('activateSelectedSegmentationOfType', {
+        segmentationRepresentationType: type
+      });
       commandsManager.run('setRenderOutline', {
         type,
         value
       });
     },
+    setRenderOutlineInactive: ({
+      type
+    }, value) => {
+      commandsManager.run('setRenderOutlineInactive', {
+        type,
+        value
+      });
+    },
     setFillAlphaInactive: ({
       type
     }, value) => {

package/dist/{1927.bundle.da6db325e08bacb0bca0.js → 1927.bundle.019331c266d306772371.js}

@@ -170,7 +170,7 @@
 /******/ 		// This function allow to reference async chunks and sibling chunks for the entrypoint
 /******/ 		__webpack_require__.u = (chunkId) => {
 /******/ 			// return url for filenames based on template
-/******/ 			return "" + chunkId + ".bundle." + {"732":"6978ac30a1e36abf06db","5858":"99a6b9de04c621694ffd","8094":"5c44190a325ac23e3e5c"}[chunkId] + ".js";
+/******/ 			return "" + chunkId + ".bundle." + {"732":"6978ac30a1e36abf06db","5858":"d5f4bf849aaeebf5025c","8094":"5c44190a325ac23e3e5c"}[chunkId] + ".js";
 /******/ 		};
 /******/ 	})();
 /******/ 	

package/dist/{2518.bundle.4fd28150fb5a21d423e6.js → 2518.bundle.644302643ac0790e7374.js}

@@ -4878,6 +4878,11 @@ const {
   Polyline: RectangleROI_TID300Polyline
 } = dcmjs_es/* utilities */.BF.TID300;
 class RectangleROI extends BaseAdapter3D {
+  static isValidMeasurement(measurement) {
+    const graphicItem = this.getGraphicItem(measurement);
+    const pointsCount = this.getPointsCount(graphicItem);
+    return this.getGraphicType(graphicItem) === "POLYLINE" && (pointsCount === 4 || pointsCount === 5);
+  }
   static getMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata) {
     const {
       state,
@@ -4885,6 +4890,7 @@ class RectangleROI extends BaseAdapter3D {
       referencedImageId,
       ReferencedFrameNumber
     } = MeasurementReport_MeasurementReport.getSetupMeasurementData(MeasurementGroup, sopInstanceUIDToImageIdMap, metadata, this.toolType);
+    const points = worldCoords.length === 5 ? worldCoords.slice(0, 4) : worldCoords;
     const areaGroup = MeasurementGroup.ContentSequence.find(g => g.ValueType === "NUM" && g.ConceptNameCodeSequence[0].CodeMeaning === "Area");
     const cachedStats = referencedImageId ? {
       [`imageId:${referencedImageId}`]: {
@@ -4896,7 +4902,7 @@ class RectangleROI extends BaseAdapter3D {
       ...state.annotation.data,
       handles: {
         ...state.annotation.data.handles,
-        points: [worldCoords[0], worldCoords[1], worldCoords[3], worldCoords[2]]
+        points: [points[0], points[1], points[3], points[2]]
       },
       cachedStats,
       frameNumber: ReferencedFrameNumber
@@ -4938,6 +4944,8 @@ _RectangleROI = RectangleROI;
 (() => {
   _RectangleROI.init("RectangleROI", RectangleROI_TID300Polyline);
   _RectangleROI.registerLegacy();
+  _RectangleROI.registerType("DCM:111030", "POLYLINE", 4);
+  _RectangleROI.registerType("DCM:111030", "POLYLINE", 5);
 })();
 
 

package/dist/{306.bundle.c671a09e1eacf6bcfc84.js → 306.bundle.f9faa2b3cdd7e86b5869.js}

@@ -7618,6 +7618,8 @@ var Surface_surfaceDisplay = __webpack_require__(67014);
 
 
 
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/segmentationEventManager.js
+var segmentationEventManager = __webpack_require__(10692);
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/removeSegmentationRepresentations.js
 
 
@@ -7626,6 +7628,7 @@ var Surface_surfaceDisplay = __webpack_require__(67014);
 
 
 
+
 function removeSegmentationRepresentation(viewportId, specifier, immediate) {
     return _removeSegmentationRepresentations(viewportId, specifier, immediate);
 }
@@ -7685,6 +7688,7 @@ function _removeRepresentationObject(viewportId, segmentationId, type, immediate
         else if (representation.type === SegmentationRepresentations.Surface) {
             surfaceDisplay.removeRepresentation(viewportId, representation.segmentationId, immediate);
         }
+        removeSegmentationListener(representation.segmentationId, representation.type);
     });
     const { viewport } = getEnabledElementByViewportId(viewportId) || {};
     if (viewport) {
@@ -7756,6 +7760,94 @@ function getLockedSegmentIndices(segmentationId) {
 
 
 
+/***/ }),
+
+/***/ 10692:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   Np: () => (/* binding */ addDefaultSegmentationListener)
+/* harmony export */ });
+/* unused harmony exports addSegmentationListener, removeSegmentationListener, removeAllSegmentationListeners */
+/* harmony import */ var _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(15327);
+/* harmony import */ var _enums__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(99737);
+/* harmony import */ var _triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(49906);
+/* harmony import */ var _utilities_debounce__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(52905);
+/* harmony import */ var _tools_displayTools_Surface_surfaceDisplay__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(67014);
+/* harmony import */ var _tools_displayTools_Contour_contourDisplay__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(25894);
+/* harmony import */ var _tools_displayTools_Labelmap_labelmapDisplay__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(684);
+/* harmony import */ var _getSegmentation__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(33283);
+
+
+
+
+
+
+
+
+const renderers = {
+    [_enums__WEBPACK_IMPORTED_MODULE_1__.SegmentationRepresentations.Labelmap]: _tools_displayTools_Labelmap_labelmapDisplay__WEBPACK_IMPORTED_MODULE_6__/* ["default"] */ .Ay,
+    [_enums__WEBPACK_IMPORTED_MODULE_1__.SegmentationRepresentations.Contour]: _tools_displayTools_Contour_contourDisplay__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A,
+    [_enums__WEBPACK_IMPORTED_MODULE_1__.SegmentationRepresentations.Surface]: _tools_displayTools_Surface_surfaceDisplay__WEBPACK_IMPORTED_MODULE_4__/* ["default"] */ .Ay,
+};
+const segmentationListeners = new Map();
+function addDefaultSegmentationListener(viewport, segmentationId, representationType) {
+    const updateFunction = renderers[representationType].getUpdateFunction(viewport);
+    if (updateFunction) {
+        addSegmentationListener(segmentationId, representationType, updateFunction);
+    }
+}
+function addSegmentationListener(segmentationId, representationType, updateFunction) {
+    if (!segmentationListeners.has(segmentationId)) {
+        segmentationListeners.set(segmentationId, new Map());
+    }
+    const listenerMap = segmentationListeners.get(segmentationId);
+    if (listenerMap.has(representationType)) {
+        removeSegmentationListener(segmentationId, representationType);
+    }
+    const listener = createDebouncedSegmentationListener(segmentationId, representationType, updateFunction);
+    _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.eventTarget.addEventListener(_enums__WEBPACK_IMPORTED_MODULE_1__.Events.SEGMENTATION_DATA_MODIFIED, listener);
+    listenerMap.set(representationType, listener);
+}
+function removeSegmentationListener(segmentationId, representationType) {
+    const listenerMap = segmentationListeners.get(segmentationId);
+    if (!listenerMap) {
+        return;
+    }
+    const listener = listenerMap.get(representationType);
+    if (!listener) {
+        return;
+    }
+    _cornerstonejs_core__WEBPACK_IMPORTED_MODULE_0__.eventTarget.removeEventListener(_enums__WEBPACK_IMPORTED_MODULE_1__.Events.SEGMENTATION_DATA_MODIFIED, listener);
+    listenerMap.delete(representationType);
+}
+function removeAllSegmentationListeners(segmentationId) {
+    const listenerMap = segmentationListeners.get(segmentationId);
+    if (!listenerMap) {
+        return;
+    }
+    for (const listener of listenerMap.values()) {
+        eventTarget.removeEventListener(Events.SEGMENTATION_DATA_MODIFIED, listener);
+    }
+    segmentationListeners.delete(segmentationId);
+}
+function createDebouncedSegmentationListener(segmentationId, representationType, updateFunction) {
+    const debouncedHandler = (0,_utilities_debounce__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A)((event) => {
+        const eventSegmentationId = event.detail?.segmentationId;
+        const segmentation = (0,_getSegmentation__WEBPACK_IMPORTED_MODULE_7__/* .getSegmentation */ .T)(eventSegmentationId);
+        if (eventSegmentationId === segmentationId &&
+            !!segmentation?.representationData?.[representationType]) {
+            updateFunction(segmentationId);
+            (0,_triggerSegmentationEvents__WEBPACK_IMPORTED_MODULE_2__.triggerSegmentationModified)(segmentationId);
+        }
+    }, 300);
+    return ((event) => {
+        debouncedHandler(event);
+    });
+}
+
+
+
 /***/ }),
 
 /***/ 98870:
@@ -12773,6 +12865,8 @@ var createLabelmapVolumeForViewport = __webpack_require__(97492);
 var enums = __webpack_require__(99737);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/enums/SegmentationRepresentations.js
 var enums_SegmentationRepresentations = __webpack_require__(18682);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentation.js
+var segmentation_getSegmentation = __webpack_require__(33283);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentationRepresentation.js
 var getSegmentationRepresentation = __webpack_require__(93210);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/tools/displayTools/Surface/surfaceDisplay.js
@@ -12789,6 +12883,8 @@ var state = __webpack_require__(85204);
 var PlanarFreehandContourSegmentationTool = __webpack_require__(37590);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/store/ToolGroupManager/index.js + 6 modules
 var ToolGroupManager = __webpack_require__(77609);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/segmentationEventManager.js
+var segmentationEventManager = __webpack_require__(10692);
 ;// ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/SegmentationRenderingEngine.js
 
 
@@ -12801,6 +12897,8 @@ var ToolGroupManager = __webpack_require__(77609);
 
 
 
+
+
 const renderers = {
     [enums_SegmentationRepresentations/* default */.A.Labelmap]: labelmapDisplay/* default */.Ay,
     [enums_SegmentationRepresentations/* default */.A.Contour]: contourDisplay/* default */.A,
@@ -12894,15 +12992,19 @@ class SegmentationRenderingEngine {
         if (!viewport) {
             return;
         }
-        const viewportRenderList = [];
         const segmentationRenderList = segmentationRepresentations.map((representation) => {
             if (representation.type === enums.SegmentationRepresentations.Contour) {
                 this._addPlanarFreeHandToolIfAbsent(viewport);
             }
             const display = renderers[representation.type];
+            const segmentation = (0,segmentation_getSegmentation/* getSegmentation */.T)(representation.segmentationId);
+            const existingRepresentation = segmentation.representationData[representation.type] !== undefined;
             try {
-                const viewportId = display.render(viewport, representation);
-                viewportRenderList.push(viewportId);
+                display.render(viewport, representation).then(() => {
+                    if (!existingRepresentation) {
+                        (0,segmentationEventManager/* addDefaultSegmentationListener */.Np)(viewport, representation.segmentationId, representation.type);
+                    }
+                });
             }
             catch (error) {
                 console.error(error);
@@ -14281,8 +14383,6 @@ var getOrCreateImageVolume = __webpack_require__(83075);
 var getStatistics = __webpack_require__(38440);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/segmentation/validateLabelmap.js
 var validateLabelmap = __webpack_require__(21345);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/getSegmentation.js
-var segmentation_getSegmentation = __webpack_require__(33283);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/triggerSegmentationEvents.js
 var triggerSegmentationEvents = __webpack_require__(49906);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/constants/COLOR_LUT.js
@@ -14353,6 +14453,8 @@ function segmentIndex_setActiveSegmentIndex(segmentationId, segmentIndex) {
 
 
 
+
+
 function internalAddSegmentationRepresentation_internalAddSegmentationRepresentation(viewportId, representationInput) {
     const { segmentationId, config } = representationInput;
     const renderingConfig = {
@@ -14360,6 +14462,10 @@ function internalAddSegmentationRepresentation_internalAddSegmentationRepresenta
         ...config,
     };
     defaultSegmentationStateManager.addSegmentationRepresentation(viewportId, segmentationId, representationInput.type, renderingConfig);
+    const { viewport } = getEnabledElementByViewportId(viewportId) || {};
+    if (viewport) {
+        addDefaultSegmentationListener(viewport, segmentationId, representationInput.type);
+    }
     if (!getActiveSegmentIndex(segmentationId)) {
         let firstSegmentIndex = 1;
         const segmentation = defaultSegmentationStateManager.getSegmentation(segmentationId);
@@ -14374,6 +14480,9 @@ function internalAddSegmentationRepresentation_internalAddSegmentationRepresenta
     if (representationInput.type === SegmentationRepresentations.Contour) {
         triggerAnnotationRenderForViewportIds([viewportId]);
     }
+    if (representationInput.type === SegmentationRepresentations.Surface) {
+        triggerSegmentationDataModified(segmentationId);
+    }
     triggerSegmentationModified(segmentationId);
 }
 function getColorLUTIndex(config) {