@ohif/app 3.12.0-beta.85 → 3.12.0-beta.87

package/dist/{1214.bundle.f969e8b51fad410eeca4.js → 1214.bundle.82dc18225ebf452da664.js}

@@ -7205,10 +7205,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 +7841,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 +7882,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 +12179,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 +12216,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 +12230,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 +13224,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 +19162,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 +19190,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 +20427,7 @@ class SegmentationService extends src/* PubSubService */.Rc {
           segmentationId,
           segmentIndex,
           type: LABELMAP
-        }, {});
+        }, {}, false);
       }
     };
     requestAnimationFrame(animation);
@@ -20617,7 +20738,7 @@ class CornerstoneCacheService {
         Modality
       } = displaySet;
       const isParametricMap = Modality === 'PMAP';
-      const isSeg = Modality === 'SEG';
+      const isSegOrRtstruct = Modality === 'SEG' || Modality === 'RTSTRUCT';
 
       // Don't create volumes for the displaySets that have custom load
       // function (e.g., SEG, RT, since they rely on the reference volumes
@@ -20664,7 +20785,7 @@ class CornerstoneCacheService {
 
       // Parametric maps do not have image ids but they already have volume data
       // therefore a new volume should not be created.
-      if (!isParametricMap && !isSeg && (!volumeImageIds || !volume)) {
+      if (!isParametricMap && !isSegOrRtstruct && (!volumeImageIds || !volume)) {
         volumeImageIds = this._getCornerstoneVolumeImageIds(displaySet, dataSource);
         volume = await esm.volumeLoader.createAndCacheVolume(volumeId, {
           imageIds: volumeImageIds
@@ -23239,6 +23360,9 @@ function PanelSegmentation({
     setFillAlpha: ({
       type
     }, value) => {
+      commandsManager.run('activateSelectedSegmentationOfType', {
+        segmentationRepresentationType: type
+      });
       commandsManager.run('setFillAlpha', {
         type,
         value
@@ -23247,6 +23371,9 @@ function PanelSegmentation({
     setOutlineWidth: ({
       type
     }, value) => {
+      commandsManager.run('activateSelectedSegmentationOfType', {
+        segmentationRepresentationType: type
+      });
       commandsManager.run('setOutlineWidth', {
         type,
         value
@@ -23255,19 +23382,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) => {
@@ -24867,6 +25016,7 @@ const utils_utils = {
 /* harmony default export */ const src_utils = (utils_utils);
 ;// ../../../extensions/cornerstone/src/utils/setUpSegmentationEventHandlers.ts
 
+
 const setUpSegmentationEventHandlers = ({
   servicesManager,
   commandsManager
@@ -24899,7 +25049,7 @@ const setUpSegmentationEventHandlers = ({
       return;
     }
     const segmentation = segmentationService.getSegmentation(segmentationId);
-    const label = segmentation.cachedStats.info;
+    const label = segmentation.label;
     const imageIds = segmentation.representationData?.Labelmap?.imageIds ?? segmentation.representationData?.Contour?.imageIds;
 
     // Create a display set for the segmentation
@@ -24908,7 +25058,7 @@ const setUpSegmentationEventHandlers = ({
       SOPClassUID: '1.2.840.10008.5.1.4.1.1.66.4',
       SOPClassHandlerId: '@ohif/extension-cornerstone-dicom-seg.sopClassHandlerModule.dicom-seg',
       SeriesDescription: label,
-      Modality: 'SEG',
+      Modality: segmentation.representationData[dist_esm.Enums.SegmentationRepresentations.Contour] ? 'RTSTRUCT' : 'SEG',
       numImageFrames: imageIds.length,
       imageIds,
       isOverlayDisplaySet: true,

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/{2018.bundle.af575721c20ef6294415.js → 2018.bundle.7df9cb6c57005b9db237.js}

@@ -1519,7 +1519,7 @@ function modeFactory({
           props: {
             leftPanels: [ohif.leftPanel],
             leftPanelResizable: true,
-            rightPanels: [cornerstone.contourSegmentationPanel, cornerstone.labelMapSegmentationPanel],
+            rightPanels: [cornerstone.labelMapSegmentationPanel, cornerstone.contourSegmentationPanel],
             rightPanelResizable: true,
             // leftPanelClosed: true,
             viewports: [{

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) {