@ohif/app 3.12.0-beta.76 → 3.12.0-beta.78

package/dist/{3409.bundle.04c822ec34d5d6c9b0af.js → 7948.bundle.8c0bd83ffaacabc3dcbd.js}

@@ -1,5 +1,5 @@
 "use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[3409],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[7948],{
 
 /***/ 38007:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
@@ -25,8 +25,8 @@ var useSegmentations = __webpack_require__(73421);
 var useViewportSegmentations = __webpack_require__(79063);
 // EXTERNAL MODULE: ../../../node_modules/react/index.js
 var react = __webpack_require__(86326);
-// EXTERNAL MODULE: ../../ui-next/src/index.ts + 3072 modules
-var src = __webpack_require__(42606);
+// EXTERNAL MODULE: ../../ui-next/src/index.ts + 3073 modules
+var src = __webpack_require__(1246);
 ;// ../../../extensions/cornerstone/src/hooks/useViewportHover.ts
 
 
@@ -117,7 +117,7 @@ var useViewportRendering = __webpack_require__(47488);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   c: () => (/* binding */ useActiveViewportSegmentationRepresentations)
 /* harmony export */ });
-/* harmony import */ var _ohif_ui_next__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(42606);
+/* harmony import */ var _ohif_ui_next__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1246);
 /* harmony import */ var _useViewportSegmentations__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(79063);
 
 
@@ -496,8 +496,8 @@ __webpack_require__.d(__webpack_exports__, {
 var react = __webpack_require__(86326);
 // EXTERNAL MODULE: ../../core/src/index.ts + 69 modules
 var src = __webpack_require__(42356);
-// EXTERNAL MODULE: ../../ui-next/src/index.ts + 3072 modules
-var ui_next_src = __webpack_require__(42606);
+// EXTERNAL MODULE: ../../ui-next/src/index.ts + 3073 modules
+var ui_next_src = __webpack_require__(1246);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 1 modules
 var esm = __webpack_require__(15327);
 ;// ../../../extensions/cornerstone/src/components/ViewportDataOverlaySettingMenu/utils.ts
@@ -1322,7 +1322,7 @@ function useViewportRendering(viewportId, options) {
         return colormap;
       }
       const actorEntries = viewport.getActors();
-      const actorEntry = actorEntries?.find(entry => entry.referencedId.includes(activeDisplaySetInstanceUID));
+      const actorEntry = actorEntries?.find(entry => entry.referencedId?.includes(activeDisplaySetInstanceUID));
       if (!actorEntry) {
         return colorbarProperties?.colormaps?.find(c => c.Name === 'Grayscale') || colorbarProperties?.colormaps?.[0];
       }
@@ -1657,7 +1657,7 @@ function useViewportSegmentations({
 
 /***/ }),
 
-/***/ 23409:
+/***/ 37948:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -1718,6 +1718,7 @@ __webpack_require__.d(__webpack_exports__, {
   usePositionPresentationStore: () => (/* reexport */ usePositionPresentationStore/* usePositionPresentationStore */.q),
   useSegmentationPresentationStore: () => (/* reexport */ useSegmentationPresentationStore/* useSegmentationPresentationStore */.v),
   useSegmentations: () => (/* reexport */ useSegmentations/* useSegmentations */.j),
+  useSelectedSegmentationsForViewportStore: () => (/* reexport */ useSelectedSegmentationsForViewportStore),
   useSynchronizersStore: () => (/* reexport */ useSynchronizersStore/* useSynchronizersStore */.U),
   utils: () => (/* reexport */ src_utils)
 });
@@ -1807,8 +1808,8 @@ function destroy() {
 var ai_dist_esm = __webpack_require__(75165);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/polymorphic-segmentation/dist/esm/index.js + 14 modules
 var polymorphic_segmentation_dist_esm = __webpack_require__(56983);
-// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 139 modules
-var default_src = __webpack_require__(11447);
+// EXTERNAL MODULE: ../../../extensions/default/src/index.ts + 141 modules
+var default_src = __webpack_require__(39548);
 // EXTERNAL MODULE: ../../../extensions/cornerstone/src/state.ts
 var state = __webpack_require__(71353);
 ;// ../../../extensions/cornerstone/src/utils/getViewportEnabledElement.ts
@@ -2246,6 +2247,10 @@ function initCornerstoneTools(configuration = {}) {
   (0,dist_esm.addTool)(ai_dist_esm/* LabelmapSlicePropagationTool */.Bj);
   (0,dist_esm.addTool)(ai_dist_esm/* MarkerLabelmapTool */.pY);
   (0,dist_esm.addTool)(dist_esm.RegionSegmentPlusTool);
+  (0,dist_esm.addTool)(dist_esm.LivewireContourSegmentationTool);
+  (0,dist_esm.addTool)(dist_esm.SculptorTool);
+  (0,dist_esm.addTool)(dist_esm.SplineContourSegmentationTool);
+  (0,dist_esm.addTool)(dist_esm.LabelMapEditWithContourTool);
   // Modify annotation tools to use dashed lines on SR
   const annotationStyle = {
     textBoxFontSize: '15px',
@@ -2302,7 +2307,11 @@ const toolNames = {
   SegmentLabel: dist_esm.SegmentLabelTool.toolName,
   LabelmapSlicePropagation: ai_dist_esm/* LabelmapSlicePropagationTool */.Bj.toolName,
   MarkerLabelmap: ai_dist_esm/* MarkerLabelmapTool */.pY.toolName,
-  RegionSegmentPlus: dist_esm.RegionSegmentPlusTool.toolName
+  RegionSegmentPlus: dist_esm.RegionSegmentPlusTool.toolName,
+  LivewireContourSegmentation: dist_esm.LivewireContourSegmentationTool.toolName,
+  SculptorTool: dist_esm.SculptorTool.toolName,
+  SplineContourSegmentation: dist_esm.SplineContourSegmentationTool.toolName,
+  LabelMapEditWithContourTool: dist_esm.LabelMapEditWithContourTool.toolName
 };
 
 ;// ../../../extensions/cornerstone/src/utils/measurementServiceMappings/constants/supportedTools.js
@@ -6325,7 +6334,7 @@ function interleaveCenterLoader({
   // the imageIds and save them in AllRequests for later use
   const AllRequests = [];
   volumes.forEach(volume => {
-    const requests = volume.getImageLoadRequests();
+    const requests = volume.getImageLoadRequests?.() ?? [];
     if (!requests.length || !requests[0] || !requests[0].imageId) {
       return;
     }
@@ -6621,7 +6630,7 @@ function interleaveTopToBottom({
   // the imageIds and save them in AllRequests for later use
   const AllRequests = [];
   volumes.forEach(volume => {
-    const requests = volume.getImageLoadRequests();
+    const requests = volume.getImageLoadRequests?.() ?? [];
     if (!requests?.[0]?.imageId) {
       return;
     }
@@ -7171,6 +7180,7 @@ async function init({
     toolbarService
   } = servicesManager.services;
   toolbarService.registerEventForToolbarUpdate(colorbarService, [colorbarService.EVENTS.STATE_CHANGED]);
+  toolbarService.registerEventForToolbarUpdate(segmentationService, [segmentationService.EVENTS.SEGMENTATION_MODIFIED, segmentationService.EVENTS.SEGMENTATION_REPRESENTATION_MODIFIED, segmentationService.EVENTS.ANNOTATION_CUT_MERGE_PROCESS_COMPLETED]);
   window.services = servicesManager.services;
   window.extensionManager = extensionManager;
   window.commandsManager = commandsManager;
@@ -7446,16 +7456,85 @@ function _showCPURenderingModal(uiModalService, hangingProtocolService) {
     inheritsFrom: 'ohif.overlayItem.instanceNumber'
   }]
 });
-// EXTERNAL MODULE: ../../ui-next/src/index.ts + 3072 modules
-var ui_next_src = __webpack_require__(42606);
+// EXTERNAL MODULE: ../../ui-next/src/index.ts + 3073 modules
+var ui_next_src = __webpack_require__(1246);
 // EXTERNAL MODULE: ../../../node_modules/react-i18next/dist/es/index.js + 15 modules
 var es = __webpack_require__(99993);
+;// ../../../extensions/cornerstone/src/components/ExportSegmentationSubMenuItem.tsx
+
+
+
+
+const ExportSegmentationSubMenuItem = ({
+  segmentationId,
+  segmentationRepresentationType,
+  allowExport,
+  actions
+}) => {
+  const {
+    t
+  } = (0,es/* useTranslation */.Bd)('SegmentationTable');
+  return /*#__PURE__*/react.createElement(react.Fragment, null, segmentationRepresentationType === esm_enums.SegmentationRepresentations.Labelmap && /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuSub */.lvB, null, /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuSubTrigger */.nVd, {
+    className: "pl-1"
+  }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Export, {
+    className: "text-foreground"
+  }), /*#__PURE__*/react.createElement("span", {
+    className: "pl-2"
+  }, t('Download & Export'))), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuPortal */.dce, null, /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuSubContent */.M56, null, /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuLabel */.lpj, {
+    className: "flex items-center pl-0"
+  }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Download, {
+    className: "h-5 w-5"
+  }), /*#__PURE__*/react.createElement("span", {
+    className: "pl-1"
+  }, t('Download'))), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
+    onClick: e => {
+      e.preventDefault();
+      actions.downloadCSVSegmentationReport(segmentationId);
+    },
+    disabled: !allowExport
+  }, t('CSV Report')), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
+    onClick: e => {
+      e.preventDefault();
+      actions.onSegmentationDownload(segmentationId);
+    },
+    disabled: !allowExport
+  }, t('DICOM SEG')), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
+    onClick: e => {
+      e.preventDefault();
+      actions.onSegmentationDownloadRTSS(segmentationId);
+    },
+    disabled: !allowExport
+  }, t('DICOM RTSS')), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuSeparator */.mBJ, null), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuLabel */.lpj, {
+    className: "flex items-center pl-0"
+  }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Export, {
+    className: "h-5 w-5"
+  }), /*#__PURE__*/react.createElement("span", {
+    className: "pl-1 pt-1"
+  }, t('Export'))), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
+    onClick: e => {
+      e.preventDefault();
+      actions.storeSegmentation(segmentationId);
+    },
+    disabled: !allowExport
+  }, t('DICOM SEG'))))), segmentationRepresentationType === esm_enums.SegmentationRepresentations.Contour && /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
+    onClick: e => {
+      e.preventDefault();
+      actions.onSegmentationDownloadRTSS(segmentationId);
+    },
+    disabled: !allowExport
+  }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Export, {
+    className: "text-foreground"
+  }), /*#__PURE__*/react.createElement("span", {
+    className: "pl-2"
+  }, t('Download DICOM RTSS')))));
+};
 ;// ../../../extensions/cornerstone/src/customizations/CustomDropdownMenuContent.tsx
 
 
 
 
 
+
 /**
  * Custom dropdown menu component for segmentation panel that uses context for data
  */
@@ -7473,7 +7552,9 @@ const CustomDropdownMenuContent = () => {
     onSegmentationDelete,
     exportOptions,
     activeSegmentation,
-    activeSegmentationId
+    activeSegmentationId,
+    segmentationRepresentationType,
+    disableEditing
   } = (0,ui_next_src/* useSegmentationTableContext */.dQ$)('CustomDropdownMenu');
 
   // Try to get segmentation data from expanded context first, fall back to table context
@@ -7527,8 +7608,11 @@ const CustomDropdownMenuContent = () => {
   };
   return /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuContent */.SQm, {
     align: "start"
-  }, /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
-    onClick: () => onSegmentationAdd(segmentationId)
+  }, !disableEditing && /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
+    onClick: () => onSegmentationAdd({
+      segmentationId,
+      segmentationRepresentationType
+    })
   }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Add, {
     className: "text-foreground"
   }), /*#__PURE__*/react.createElement("span", {
@@ -7545,49 +7629,12 @@ const CustomDropdownMenuContent = () => {
     className: "text-foreground"
   }), /*#__PURE__*/react.createElement("span", {
     className: "pl-2"
-  }, t('Rename'))), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuSub */.lvB, null, /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuSubTrigger */.nVd, {
-    className: "pl-1"
-  }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Export, {
-    className: "text-foreground"
-  }), /*#__PURE__*/react.createElement("span", {
-    className: "pl-2"
-  }, t('Download & Export'))), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuPortal */.dce, null, /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuSubContent */.M56, null, /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuLabel */.lpj, {
-    className: "flex items-center pl-0"
-  }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Download, {
-    className: "h-5 w-5"
-  }), /*#__PURE__*/react.createElement("span", {
-    className: "pl-1"
-  }, t('Download'))), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
-    onClick: e => {
-      e.preventDefault();
-      actions.downloadCSVSegmentationReport(segmentationId);
-    },
-    disabled: !allowExport
-  }, t('CSV Report')), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
-    onClick: e => {
-      e.preventDefault();
-      actions.onSegmentationDownload(segmentationId);
-    },
-    disabled: !allowExport
-  }, t('DICOM SEG')), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
-    onClick: e => {
-      e.preventDefault();
-      actions.onSegmentationDownloadRTSS(segmentationId);
-    },
-    disabled: !allowExport
-  }, t('DICOM RTSS')), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuSeparator */.mBJ, null), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuLabel */.lpj, {
-    className: "flex items-center pl-0"
-  }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Export, {
-    className: "h-5 w-5"
-  }), /*#__PURE__*/react.createElement("span", {
-    className: "pl-1 pt-1"
-  }, t('Export'))), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
-    onClick: e => {
-      e.preventDefault();
-      actions.storeSegmentation(segmentationId);
-    },
-    disabled: !allowExport
-  }, t('DICOM SEG'))))), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuSeparator */.mBJ, null), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
+  }, t('Rename'))), /*#__PURE__*/react.createElement(ExportSegmentationSubMenuItem, {
+    segmentationId: segmentationId,
+    segmentationRepresentationType: segmentationRepresentationType,
+    allowExport: allowExport,
+    actions: actions
+  }), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuSeparator */.mBJ, null), /*#__PURE__*/react.createElement(ui_next_src/* DropdownMenuItem */._26, {
     onClick: () => onSegmentationDelete(segmentationId)
   }, /*#__PURE__*/react.createElement(ui_next_src/* Icons */.FI1.Delete, {
     className: "text-red-600"
@@ -7707,11 +7754,83 @@ const CustomSegmentStatisticsHeader = ({
     className: "bg-input"
   }));
 };
+;// ../../../extensions/cornerstone/src/components/SegmentationToolConfig.tsx
+
+
+
+function SegmentationToolConfig() {
+  const {
+    commandsManager
+  } = (0,src/* useSystem */.Jg)();
+
+  // Get initial states based on current configuration
+  const [previewEdits, setPreviewEdits] = (0,react.useState)(false);
+  const [segmentLabelEnabled, setSegmentLabelEnabled] = (0,react.useState)(false);
+  const [toggleSegmentEnabled, setToggleSegmentEnabled] = (0,react.useState)(false);
+  const [useCenterAsSegmentIndex, setUseCenterAsSegmentIndex] = (0,react.useState)(false);
+  const handlePreviewEditsChange = checked => {
+    setPreviewEdits(checked);
+    commandsManager.run('toggleSegmentPreviewEdit', {
+      toggle: checked
+    });
+  };
+  const handleToggleSegmentEnabledChange = checked => {
+    setToggleSegmentEnabled(checked);
+    commandsManager.run('toggleSegmentSelect', {
+      toggle: checked
+    });
+  };
+  const handleUseCenterAsSegmentIndexChange = checked => {
+    setUseCenterAsSegmentIndex(checked);
+    commandsManager.run('toggleUseCenterSegmentIndex', {
+      toggle: checked
+    });
+  };
+  const handleSegmentLabelEnabledChange = checked => {
+    setSegmentLabelEnabled(checked);
+    commandsManager.run('toggleSegmentLabel', {
+      enabled: checked
+    });
+  };
+  return /*#__PURE__*/react.createElement("div", {
+    className: "bg-muted flex flex-col gap-2 border-b border-b-[2px] border-black px-2 py-3"
+  }, /*#__PURE__*/react.createElement("div", {
+    className: "flex items-center gap-2"
+  }, /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
+    checked: previewEdits,
+    onCheckedChange: handlePreviewEditsChange
+  }), /*#__PURE__*/react.createElement("span", {
+    className: "text-foreground text-base"
+  }, "Preview edits before creating")), /*#__PURE__*/react.createElement("div", {
+    className: "flex items-center gap-2"
+  }, /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
+    checked: useCenterAsSegmentIndex,
+    onCheckedChange: handleUseCenterAsSegmentIndexChange
+  }), /*#__PURE__*/react.createElement("span", {
+    className: "text-foreground text-base"
+  }, "Use center as segment index")), /*#__PURE__*/react.createElement("div", {
+    className: "flex items-center gap-2"
+  }, /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
+    checked: toggleSegmentEnabled,
+    onCheckedChange: handleToggleSegmentEnabledChange
+  }), /*#__PURE__*/react.createElement("span", {
+    className: "text-foreground text-base"
+  }, "Hover on segment border to activate")), /*#__PURE__*/react.createElement("div", {
+    className: "flex items-center gap-2"
+  }, /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
+    checked: segmentLabelEnabled,
+    onCheckedChange: handleSegmentLabelEnabledChange
+  }), /*#__PURE__*/react.createElement("span", {
+    className: "text-foreground text-base"
+  }, "Show segment name on hover")));
+}
 ;// ../../../extensions/cornerstone/src/customizations/segmentationPanelCustomization.tsx
 
 
 
 
+
+
 function getSegmentationPanelCustomization({
   commandsManager,
   servicesManager
@@ -7721,14 +7840,29 @@ function getSegmentationPanelCustomization({
     'panelSegmentation.customSegmentStatisticsHeader': CustomSegmentStatisticsHeader,
     'panelSegmentation.disableEditing': false,
     'panelSegmentation.showAddSegment': true,
-    'panelSegmentation.onSegmentationAdd': () => {
+    'panelSegmentation.onSegmentationAdd': async ({
+      segmentationRepresentationType = esm_enums.SegmentationRepresentations.Labelmap
+    }) => {
       const {
         viewportGridService
       } = servicesManager.services;
       const viewportId = viewportGridService.getState().activeViewportId;
-      commandsManager.run('createLabelmapForViewport', {
-        viewportId
-      });
+      if (segmentationRepresentationType === esm_enums.SegmentationRepresentations.Labelmap) {
+        commandsManager.run('createLabelmapForViewport', {
+          viewportId
+        });
+      } else if (segmentationRepresentationType === esm_enums.SegmentationRepresentations.Contour) {
+        const segmentationId = await commandsManager.run('createContourForViewport', {
+          viewportId
+        });
+        dist_esm.segmentation.config.style.setStyle({
+          segmentationId,
+          type: esm_enums.SegmentationRepresentations.Contour
+        }, {
+          fillAlpha: 0.5,
+          renderFill: true
+        });
+      }
     },
     'panelSegmentation.tableMode': 'collapsed',
     'panelSegmentation.readableText': {
@@ -7749,67 +7883,11 @@ function getSegmentationPanelCustomization({
       lesionGlycolysis: 'Lesion Glycolysis',
       center: 'Center'
     },
-    'segmentationToolbox.config': () => {
-      // Get initial states based on current configuration
-      const [previewEdits, setPreviewEdits] = (0,react.useState)(false);
-      const [segmentLabelEnabled, setSegmentLabelEnabled] = (0,react.useState)(false);
-      const [toggleSegmentEnabled, setToggleSegmentEnabled] = (0,react.useState)(false);
-      const [useCenterAsSegmentIndex, setUseCenterAsSegmentIndex] = (0,react.useState)(false);
-      const handlePreviewEditsChange = checked => {
-        setPreviewEdits(checked);
-        commandsManager.run('toggleSegmentPreviewEdit', {
-          toggle: checked
-        });
-      };
-      const handleToggleSegmentEnabledChange = checked => {
-        setToggleSegmentEnabled(checked);
-        commandsManager.run('toggleSegmentSelect', {
-          toggle: checked
-        });
-      };
-      const handleUseCenterAsSegmentIndexChange = checked => {
-        setUseCenterAsSegmentIndex(checked);
-        commandsManager.run('toggleUseCenterSegmentIndex', {
-          toggle: checked
-        });
-      };
-      const handleSegmentLabelEnabledChange = checked => {
-        setSegmentLabelEnabled(checked);
-        commandsManager.run('toggleSegmentLabel', {
-          enabled: checked
-        });
-      };
-      return /*#__PURE__*/react.createElement("div", {
-        className: "bg-muted flex flex-col gap-2 border-b border-b-[2px] border-black px-2 py-3"
-      }, /*#__PURE__*/react.createElement("div", {
-        className: "flex items-center gap-2"
-      }, /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
-        checked: previewEdits,
-        onCheckedChange: handlePreviewEditsChange
-      }), /*#__PURE__*/react.createElement("span", {
-        className: "text-foreground text-base"
-      }, "Preview edits before creating")), /*#__PURE__*/react.createElement("div", {
-        className: "flex items-center gap-2"
-      }, /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
-        checked: useCenterAsSegmentIndex,
-        onCheckedChange: handleUseCenterAsSegmentIndexChange
-      }), /*#__PURE__*/react.createElement("span", {
-        className: "text-foreground text-base"
-      }, "Use center as segment index")), /*#__PURE__*/react.createElement("div", {
-        className: "flex items-center gap-2"
-      }, /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
-        checked: toggleSegmentEnabled,
-        onCheckedChange: handleToggleSegmentEnabledChange
-      }), /*#__PURE__*/react.createElement("span", {
-        className: "text-foreground text-base"
-      }, "Hover on segment border to activate")), /*#__PURE__*/react.createElement("div", {
-        className: "flex items-center gap-2"
-      }, /*#__PURE__*/react.createElement(ui_next_src/* Switch */.dOG, {
-        checked: segmentLabelEnabled,
-        onCheckedChange: handleSegmentLabelEnabledChange
-      }), /*#__PURE__*/react.createElement("span", {
-        className: "text-foreground text-base"
-      }, "Show segment name on hover")));
+    'labelMapSegmentationToolbox.config': () => {
+      return /*#__PURE__*/react.createElement(SegmentationToolConfig, null);
+    },
+    'contourSegmentationToolbox.config': () => {
+      return /*#__PURE__*/react.createElement(SegmentationToolConfig, null);
     }
   };
 }
@@ -9031,10 +9109,10 @@ function getCustomizationModule({
   }];
 }
 /* harmony default export */ const src_getCustomizationModule = (getCustomizationModule);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/utilities/contourSegmentation/logicalOperators.js + 1 modules
+var logicalOperators = __webpack_require__(21536);
 // EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/labelmap-interpolation/dist/esm/index.js + 2 modules
 var labelmap_interpolation_dist_esm = __webpack_require__(7927);
-// EXTERNAL MODULE: ../../i18n/src/index.js + 210 modules
-var i18n_src = __webpack_require__(68523);
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
 var gl_matrix_esm = __webpack_require__(3823);
 ;// ../../../extensions/cornerstone/src/utils/imageSliceSync/toggleImageSliceSync.ts
@@ -9222,11 +9300,59 @@ function groupViewportsByModality(viewportGridService, displaySetService) {
 }
 // EXTERNAL MODULE: ../../../extensions/cornerstone/src/stores/useSynchronizersStore.ts
 var useSynchronizersStore = __webpack_require__(68578);
+// EXTERNAL MODULE: ../../../node_modules/zustand/esm/index.mjs + 1 modules
+var zustand_esm = __webpack_require__(78713);
+// EXTERNAL MODULE: ../../../node_modules/zustand/esm/middleware.mjs
+var middleware = __webpack_require__(21978);
+;// ../../../extensions/cornerstone/src/stores/useSelectedSegmentationsForViewportStore.ts
+
+
+const PRESENTATION_TYPE_ID = 'selectedSegmentationsForViewportId';
+const DEBUG_STORE = false;
+
+/**
+ * Represents the state and actions for managing selected segmentations for a viewport by representation type.
+ */
+
+/**
+ * Creates the Selected Segmentations For Viewport store.
+ *
+ * @param set - The zustand set function.
+ * @returns The selected segmentations for viewport store state and actions.
+ */
+const createSelectedSegmentationsForViewportStore = set => ({
+  selectedSegmentationsForViewport: {},
+  type: PRESENTATION_TYPE_ID,
+  /**
+   * Sets the selected segmentations for a given viewport id.
+   */
+  setSelectedSegmentationsForViewport: (key, value) => set(state => ({
+    selectedSegmentationsForViewport: {
+      ...state.selectedSegmentationsForViewport,
+      [key]: value
+    }
+  }), false, 'setSelectedSegmentationsForViewport'),
+  /**
+   * Clears all selected segmentations for all viewports.
+   */
+  clearSelectedSegmentationsForViewportStore: () => set({
+    selectedSegmentationsForViewport: {}
+  }, false, 'clearSelectedSegmentationsForViewportStore')
+});
+
+/**
+ * Zustand store for managing selected segmentations for a viewport by representation type.
+ * Applies devtools middleware when DEBUG_STORE is enabled.
+ */
+const useSelectedSegmentationsForViewportStore = (0,zustand_esm/* create */.vt)()(DEBUG_STORE ? (0,middleware/* devtools */.lt)(createSelectedSegmentationsForViewportStore, {
+  name: 'SelectedSegmentationsForViewportStore'
+}) : createSelectedSegmentationsForViewportStore);
 ;// ../../../extensions/cornerstone/src/stores/index.ts
 
 
 
 
+
 // EXTERNAL MODULE: ../../../node_modules/html2canvas/dist/html2canvas.esm.js
 var html2canvas_esm = __webpack_require__(91037);
 ;// ../../../extensions/cornerstone/src/utils/CornerstoneViewportDownloadForm.tsx
@@ -9731,7 +9857,7 @@ function getUpdatedViewportsForSegmentation({
   });
   const targetViewportId = viewport.viewportOptions.viewportId;
   const updatedViewports = hangingProtocolService.getViewportsRequireUpdate(targetViewportId, displaySetInstanceUIDs[0], isHangingProtocolLayout);
-  return updatedViewports.filter(v => v.viewportOptions?.viewportType !== 'volume3d');
+  return updatedViewports;
 }
 const getTargetViewport = ({
   viewportId,
@@ -10113,6 +10239,66 @@ let EasingFunctionEnum = /*#__PURE__*/function (EasingFunctionEnum) {
   return EasingFunctionEnum;
 }({});
 const EasingFunctionMap = new Map([[EasingFunctionEnum.EASE, ease], [EasingFunctionEnum.EASE_IN, easeIn], [EasingFunctionEnum.EASE_OUT, easeOut], [EasingFunctionEnum.EASE_IN_OUT, easeInOut], [EasingFunctionEnum.LINEAR, linear]]);
+// EXTERNAL MODULE: ../../i18n/src/index.js + 210 modules
+var i18n_src = __webpack_require__(68523);
+;// ../../../extensions/cornerstone/src/utils/createSegmentationForViewport.ts
+
+
+
+function _createDefaultSegments(createInitialSegment) {
+  return createInitialSegment ? {
+    1: {
+      label: `${i18n_src/* default */.A.t('Tools:Segment')} 1`,
+      active: true
+    }
+  } : {};
+}
+/**
+ * Creates a segmentation for the active viewport
+ *
+ * The created segmentation will be registered as a display set and also added
+ * as a segmentation representation to the viewport.
+ */
+async function createSegmentationForViewport(servicesManager, {
+  viewportId,
+  options = {},
+  segmentationType
+}) {
+  const {
+    viewportGridService,
+    displaySetService,
+    segmentationService
+  } = servicesManager.services;
+  const {
+    viewports
+  } = viewportGridService.getState();
+  const targetViewportId = viewportId;
+  const viewport = viewports.get(targetViewportId);
+
+  // Todo: add support for multiple display sets
+  const displaySetInstanceUID = options.displaySetInstanceUID || viewport.displaySetInstanceUIDs[0];
+  const segs = segmentationService.getSegmentations();
+  const label = options.label || `${i18n_src/* default */.A.t('Tools:Segmentation')} ${segs.length + 1}`;
+  const segmentationId = options.segmentationId || `${esm.utilities.uuidv4()}`;
+  const displaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
+  const segmentationCreationOptions = {
+    label,
+    segmentationId,
+    segments: _createDefaultSegments(options.createInitialSegment)
+  };
+
+  // This will create the segmentation and register it as a display set
+  const generatedSegmentationId = await (segmentationType === esm_enums.SegmentationRepresentations.Labelmap ? segmentationService.createLabelmapForDisplaySet(displaySet, segmentationCreationOptions) : segmentationService.createContourForDisplaySet(displaySet, segmentationCreationOptions));
+
+  // Also add the segmentation representation to the viewport
+  await segmentationService.addSegmentationRepresentation(viewportId, {
+    segmentationId,
+    type: segmentationType
+  });
+  return generatedSegmentationId;
+}
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/stateManagement/segmentation/index.js + 9 modules
+var segmentation = __webpack_require__(55126);
 ;// ../../../extensions/cornerstone/src/commandsModule.ts
 
 
@@ -10138,6 +10324,15 @@ const EasingFunctionMap = new Map([[EasingFunctionEnum.EASE, ease], [EasingFunct
 
 
 
+
+
+
+const {
+  add,
+  intersect,
+  subtract,
+  copy
+} = dist_esm.utilities.contourSegmentation;
 const {
   DefaultHistoryMemo
 } = esm.utilities.HistoryMemo;
@@ -10324,13 +10519,21 @@ function commandsModule({
       if (!displaySet) {
         return;
       }
+      const viewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
+      if (!viewport) {
+        return;
+      }
       if (displaySet.isOverlayDisplaySet) {
         // update the previously stored segmentationPresentation with the new viewportId
         // presentation so that when we put the referencedDisplaySet back in the viewport
         // it will have the correct segmentation representation hydrated
+
+        const segmentationType =
+        // Todo: check if PMAP modality should be handled such as SEG
+        displaySet.Modality !== 'SEG' ? esm_enums.SegmentationRepresentations.Contour : viewport.type === esm.Enums.ViewportType.VOLUME_3D ? esm_enums.SegmentationRepresentations.Surface : esm_enums.SegmentationRepresentations.Labelmap;
         commandsManager.runCommand('updateStoredSegmentationPresentation', {
           displaySet,
-          type: displaySet.Modality === 'SEG' ? esm_enums.SegmentationRepresentations.Labelmap : esm_enums.SegmentationRepresentations.Contour
+          type: segmentationType
         });
       }
       const referencedDisplaySetInstanceUID = displaySet.referencedDisplaySetInstanceUID;
@@ -11040,7 +11243,8 @@ function commandsModule({
       value,
       itemId,
       toolName,
-      toolGroupIds = []
+      toolGroupIds = [],
+      bindings
     }) => {
       // Sometimes it is passed as value (tools with options), sometimes as itemId (toolbar buttons)
       toolName = toolName || itemId || value;
@@ -11048,13 +11252,17 @@ function commandsModule({
       toolGroupIds.forEach(toolGroupId => {
         actions.setToolActive({
           toolName,
-          toolGroupId
+          toolGroupId,
+          bindings
         });
       });
     },
     setToolActive: ({
       toolName,
-      toolGroupId = null
+      toolGroupId = null,
+      bindings = [{
+        mouseButton: dist_esm.Enums.MouseBindings.Primary
+      }]
     }) => {
       const {
         viewports
@@ -11077,9 +11285,7 @@ function commandsModule({
 
       // Set the new toolName to be active
       toolGroup.setToolActive(toolName, {
-        bindings: [{
-          mouseButton: dist_esm.Enums.MouseBindings.Primary
-        }]
+        bindings
       });
     },
     // capture viewport
@@ -11593,42 +11799,27 @@ function commandsModule({
       viewportId,
       options = {}
     }) => {
-      const {
-        viewportGridService,
-        displaySetService,
-        segmentationService
-      } = servicesManager.services;
-      const {
-        viewports
-      } = viewportGridService.getState();
-      const targetViewportId = viewportId;
-      const viewport = viewports.get(targetViewportId);
-
-      // Todo: add support for multiple display sets
-      const displaySetInstanceUID = options.displaySetInstanceUID || viewport.displaySetInstanceUIDs[0];
-      const segs = segmentationService.getSegmentations();
-      const label = options.label || `${i18n_src/* default */.A.t('Tools:Segmentation')} ${segs.length + 1}`;
-      const segmentationId = options.segmentationId || `${esm.utilities.uuidv4()}`;
-      const displaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
-
-      // This will create the segmentation and register it as a display set
-      const generatedSegmentationId = await segmentationService.createLabelmapForDisplaySet(displaySet, {
-        label,
-        segmentationId,
-        segments: options.createInitialSegment ? {
-          1: {
-            label: `${i18n_src/* default */.A.t('Tools:Segment')} 1`,
-            active: true
-          }
-        } : {}
+      return createSegmentationForViewport(servicesManager, {
+        viewportId,
+        options,
+        segmentationType: esm_enums.SegmentationRepresentations.Labelmap
       });
-
-      // Also add the segmentation representation to the viewport
-      await segmentationService.addSegmentationRepresentation(viewportId, {
-        segmentationId,
-        type: dist_esm.Enums.SegmentationRepresentations.Labelmap
+    },
+    /**
+     * Creates a contour for the active viewport
+     *
+     * The created contour will be registered as a display set and also added
+     * as a segmentation representation to the viewport.
+     */
+    createContourForViewport: async ({
+      viewportId,
+      options = {}
+    }) => {
+      return createSegmentationForViewport(servicesManager, {
+        viewportId,
+        options,
+        segmentationType: esm_enums.SegmentationRepresentations.Contour
       });
-      return generatedSegmentationId;
     },
     /**
      * Sets the active segmentation for a viewport
@@ -11648,12 +11839,13 @@ function commandsModule({
      * @param props.segmentationId - The ID of the segmentation to add the segment to
      */
     addSegmentCommand: ({
-      segmentationId
+      segmentationId,
+      config
     }) => {
       const {
         segmentationService
       } = servicesManager.services;
-      segmentationService.addSegment(segmentationId);
+      segmentationService.addSegment(segmentationId, config);
     },
     /**
      * Sets the active segment and jumps to its center
@@ -12463,6 +12655,193 @@ function commandsModule({
         newAnnotation,
         deleting
       });
+    },
+    activateSelectedSegmentationOfType: ({
+      segmentationRepresentationType
+    }) => {
+      const {
+        segmentationService,
+        viewportGridService
+      } = servicesManager.services;
+      const activeViewportId = viewportGridService.getActiveViewportId();
+      const {
+        selectedSegmentationsForViewport
+      } = useSelectedSegmentationsForViewportStore.getState();
+      const segmentationId = selectedSegmentationsForViewport[activeViewportId]?.get(segmentationRepresentationType);
+      if (!segmentationId) {
+        return;
+      }
+      segmentationService.setActiveSegmentation(activeViewportId, segmentationId);
+    },
+    setDynamicCursorSizeForSculptorTool: ({
+      value: isDynamicCursorSize
+    }) => {
+      const viewportId = viewportGridService.getActiveViewportId();
+      const toolGroup = toolGroupService.getToolGroupForViewport(viewportId);
+      const sculptorToolInstance = toolGroup.getToolInstance(toolNames.SculptorTool);
+      const oldConfiguration = sculptorToolInstance.configuration;
+      sculptorToolInstance.configuration = {
+        ...oldConfiguration,
+        updateCursorSize: isDynamicCursorSize ? 'dynamic' : ''
+      };
+    },
+    setInterpolationToolConfiguration: ({
+      value: interpolateContours,
+      toolNames
+    }) => {
+      const viewportId = viewportGridService.getActiveViewportId();
+      const toolGroup = toolGroupService.getToolGroupForViewport(viewportId);
+
+      // Set the interpolation configuration for the active tool.
+      const activeTool = toolGroupService.getActiveToolForViewport(viewportId);
+      const interpolationConfig = {
+        interpolation: {
+          enabled: interpolateContours,
+          showInterpolationPolyline: true
+        }
+      };
+      toolGroup.setToolConfiguration(activeTool, interpolationConfig);
+
+      // Now set the interpolation configuration for the other tools specified.
+      if (toolNames) {
+        Object.values(toolGroup.getToolInstances()).forEach(toolInstance => {
+          if (toolNames?.includes(toolInstance.toolName)) {
+            toolGroup.setToolConfiguration(toolInstance.toolName, interpolationConfig);
+          }
+        });
+      }
+    },
+    setSimplifiedSplineForSplineContourSegmentationTool: ({
+      value: simplifiedSpline
+    }) => {
+      const viewportId = viewportGridService.getActiveViewportId();
+      const toolGroup = toolGroupService.getToolGroupForViewport(viewportId);
+      Object.values(toolGroup.getToolInstances()).forEach(toolInstance => {
+        if (toolInstance instanceof dist_esm.SplineContourSegmentationTool) {
+          const oldConfiguration = toolInstance.configuration;
+          toolInstance.configuration = {
+            ...oldConfiguration,
+            simplifiedSpline
+          };
+        }
+      });
+    },
+    removeSmallContours: ({
+      areaThreshold: threshold
+    }) => {
+      const viewportId = viewportGridService.getActiveViewportId();
+      const activeSegmentation = segmentationService.getActiveSegmentation(viewportId);
+      const activeSegment = segmentationService.getActiveSegment(viewportId);
+      if (!activeSegmentation || !activeSegment) {
+        return;
+      }
+      const {
+        removeContourIslands
+      } = segmentation.utilities;
+      removeContourIslands(activeSegmentation.segmentationId, activeSegment.segmentIndex, {
+        threshold
+      });
+      const renderingEngine = cornerstoneViewportService.getRenderingEngine();
+      renderingEngine.render();
+    },
+    applyLogicalContourOperation: ({
+      segmentAInfo,
+      segmentBInfo,
+      resultSegmentInfo,
+      logicalOperation
+    }) => {
+      switch (logicalOperation) {
+        case logicalOperators/* LogicalOperation */.Dp.Union:
+          add(segmentAInfo, segmentBInfo, resultSegmentInfo);
+          break;
+        case logicalOperators/* LogicalOperation */.Dp.Intersect:
+          intersect(segmentAInfo, segmentBInfo, resultSegmentInfo);
+          break;
+        case logicalOperators/* LogicalOperation */.Dp.Subtract:
+          subtract(segmentAInfo, segmentBInfo, resultSegmentInfo);
+          break;
+        default:
+          throw new Error('Unsupported logical operation');
+          break;
+      }
+    },
+    copyContourSegment: ({
+      sourceSegmentInfo,
+      targetSegmentInfo
+    }) => {
+      if (!targetSegmentInfo) {
+        targetSegmentInfo = {
+          segmentationId: sourceSegmentInfo.segmentationId,
+          segmentIndex: segmentationService.getNextAvailableSegmentIndex(sourceSegmentInfo.segmentationId)
+        };
+        segmentationService.addSegment(targetSegmentInfo.segmentationId, {
+          segmentIndex: targetSegmentInfo.segmentIndex
+        });
+      }
+      copy(sourceSegmentInfo, targetSegmentInfo);
+    },
+    smoothContours: () => {
+      const viewportId = viewportGridService.getActiveViewportId();
+      const activeSegmentation = segmentationService.getActiveSegmentation(viewportId);
+      const activeSegment = segmentationService.getActiveSegment(viewportId);
+      if (!activeSegmentation || !activeSegment) {
+        return;
+      }
+      const {
+        smoothContours
+      } = segmentation.utilities;
+      smoothContours(activeSegmentation.segmentationId, activeSegment.segmentIndex);
+      const renderingEngine = cornerstoneViewportService.getRenderingEngine();
+      renderingEngine.render();
+    },
+    removeContourHoles: () => {
+      const viewportId = viewportGridService.getActiveViewportId();
+      const activeSegmentation = segmentationService.getActiveSegmentation(viewportId);
+      const activeSegment = segmentationService.getActiveSegment(viewportId);
+      if (!activeSegmentation || !activeSegment) {
+        return;
+      }
+      const {
+        removeContourHoles
+      } = segmentation.utilities;
+      removeContourHoles(activeSegmentation.segmentationId, activeSegment.segmentIndex);
+      const renderingEngine = cornerstoneViewportService.getRenderingEngine();
+      renderingEngine.render();
+    },
+    decimateContours: () => {
+      const viewportId = viewportGridService.getActiveViewportId();
+      const activeSegmentation = segmentationService.getActiveSegmentation(viewportId);
+      const activeSegment = segmentationService.getActiveSegment(viewportId);
+      if (!activeSegmentation || !activeSegment) {
+        return;
+      }
+      const {
+        decimateContours
+      } = segmentation.utilities;
+      decimateContours(activeSegmentation.segmentationId, activeSegment.segmentIndex);
+      const renderingEngine = cornerstoneViewportService.getRenderingEngine();
+      renderingEngine.render();
+    },
+    convertContourHoles: () => {
+      const viewportId = viewportGridService.getActiveViewportId();
+      const activeSegmentation = segmentationService.getActiveSegmentation(viewportId);
+      const activeSegment = segmentationService.getActiveSegment(viewportId);
+      if (!activeSegmentation || !activeSegment) {
+        return;
+      }
+      const targetSegmentInfo = {
+        segmentationId: activeSegmentation.segmentationId,
+        segmentIndex: segmentationService.getNextAvailableSegmentIndex(activeSegmentation.segmentationId)
+      };
+      segmentationService.addSegment(targetSegmentInfo.segmentationId, {
+        segmentIndex: targetSegmentInfo.segmentIndex
+      });
+      const {
+        convertContourHoles
+      } = segmentation.utilities;
+      convertContourHoles(activeSegmentation.segmentationId, activeSegment.segmentIndex, targetSegmentInfo.segmentationId, targetSegmentInfo.segmentIndex);
+      const renderingEngine = cornerstoneViewportService.getRenderingEngine();
+      renderingEngine.render();
     }
   };
   const definitions = {
@@ -12684,6 +13063,9 @@ function commandsModule({
     createLabelmapForViewport: {
       commandFn: actions.createLabelmapForViewport
     },
+    createContourForViewport: {
+      commandFn: actions.createContourForViewport
+    },
     setActiveSegmentation: {
       commandFn: actions.setActiveSegmentation
     },
@@ -12784,7 +13166,18 @@ function commandsModule({
     endRecordingForAnnotationGroup: actions.endRecordingForAnnotationGroup,
     toggleSegmentLabel: actions.toggleSegmentLabel,
     jumpToMeasurementViewport: actions.jumpToMeasurementViewport,
-    initializeSegmentLabelTool: actions.initializeSegmentLabelTool
+    initializeSegmentLabelTool: actions.initializeSegmentLabelTool,
+    activateSelectedSegmentationOfType: actions.activateSelectedSegmentationOfType,
+    setDynamicCursorSizeForSculptorTool: actions.setDynamicCursorSizeForSculptorTool,
+    setSimplifiedSplineForSplineContourSegmentationTool: actions.setSimplifiedSplineForSplineContourSegmentationTool,
+    removeSmallContours: actions.removeSmallContours,
+    applyLogicalContourOperation: actions.applyLogicalContourOperation,
+    copyContourSegment: actions.copyContourSegment,
+    smoothContours: actions.smoothContours,
+    removeContourHoles: actions.removeContourHoles,
+    decimateContours: actions.decimateContours,
+    convertContourHoles: actions.convertContourHoles,
+    setInterpolationToolConfiguration: actions.setInterpolationToolConfiguration
   };
   return {
     actions,
@@ -17335,8 +17728,8 @@ const ViewportColorbarsContainer = /*#__PURE__*/(0,react.memo)(function Viewport
 
 
 /* harmony default export */ const components_ViewportColorbar = (ViewportColorbar_ViewportColorbarsContainer);
-// EXTERNAL MODULE: ../../core/src/hooks/index.ts + 3 modules
-var src_hooks = __webpack_require__(69419);
+// EXTERNAL MODULE: ../../core/src/hooks/index.ts + 5 modules
+var src_hooks = __webpack_require__(85490);
 // EXTERNAL MODULE: ../../core/src/services/ToolBarService/ToolbarService.ts
 var ToolbarService = __webpack_require__(93813);
 ;// ../../../extensions/cornerstone/src/components/AdvancedRenderingControls/AdvancedRenderingControls.tsx
@@ -18653,7 +19046,9 @@ const SegmentationService_EVENTS = {
   // fired when the active segment is loaded in SEG or RTSTRUCT
   SEGMENT_LOADING_COMPLETE: 'event::segment_loading_complete',
   // loading completed for all segments
-  SEGMENTATION_LOADING_COMPLETE: 'event::segmentation_loading_complete'
+  SEGMENTATION_LOADING_COMPLETE: 'event::segmentation_loading_complete',
+  // fired when a contour annotation cut merge process is completed
+  ANNOTATION_CUT_MERGE_PROCESS_COMPLETED: 'event::annotation_cut_merge_process_completed'
 };
 const VALUE_TYPES = {};
 class SegmentationService extends src/* PubSubService */.Rc {
@@ -18744,6 +19139,14 @@ class SegmentationService extends src/* PubSubService */.Rc {
         segmentationId
       });
     };
+    this._onAnnotationCutMergeProcessCompletedFromSource = evt => {
+      const {
+        segmentationId
+      } = evt.detail;
+      this._broadcastEvent(this.EVENTS.ANNOTATION_CUT_MERGE_PROCESS_COMPLETED, {
+        segmentationId
+      });
+    };
     this._segmentationIdToColorLUTIndexMap = new Map();
     this.servicesManager = servicesManager;
     this._segmentationGroupStatsMap = new Map();
@@ -18895,6 +19298,21 @@ class SegmentationService extends src/* PubSubService */.Rc {
    * @returns A promise that resolves to the created segmentation ID.
    */
   async createLabelmapForDisplaySet(displaySet, options) {
+    return this._createSegmentationForDisplaySet(displaySet, LABELMAP, options);
+  }
+  async createContourForDisplaySet(displaySet, options) {
+    return this._createSegmentationForDisplaySet(displaySet, CONTOUR, options);
+  }
+
+  /**
+   * Private method to create segmentation for a display set with the specified type
+   *
+   * @param displaySet - The display set to create the segmentation for
+   * @param segmentationType - The type of segmentation (SegmentationRepresentations enum)
+   * @param options - Optional parameters for creating the segmentation
+   * @returns A promise that resolves to the created segmentation ID
+   */
+  async _createSegmentationForDisplaySet(displaySet, segmentationType, options) {
     // Todo: random does not makes sense, make this better, like
     // labelmap 1, 2, 3 etc
     const segmentationId = options?.segmentationId ?? `${esm.utilities.uuidv4()}`;
@@ -18913,7 +19331,7 @@ class SegmentationService extends src/* PubSubService */.Rc {
     const segmentationPublicInput = {
       segmentationId,
       representation: {
-        type: LABELMAP,
+        type: segmentationType,
         data: {
           imageIds: segImageIds,
           // referencedVolumeId: this._getVolumeIdForDisplaySet(displaySet),
@@ -19267,6 +19685,15 @@ class SegmentationService extends src/* PubSubService */.Rc {
   hasCustomStyles(specifier) {
     return dist_esm.segmentation.config.style.hasCustomStyle(specifier);
   }
+  getNextAvailableSegmentIndex(segmentationId) {
+    const csSegmentation = this.getCornerstoneSegmentation(segmentationId);
+    // grab the next available segment index based on the object keys,
+    // so basically get the highest segment index value + 1
+
+    const segmentKeys = Object.keys(csSegmentation.segments);
+    return segmentKeys.length === 0 ? 1 : Math.max(...segmentKeys.map(Number)) + 1;
+  }
+
   /**
    * Adds a new segment to the specified segmentation.
    * @param segmentationId - The ID of the segmentation to add the segment to.
@@ -19288,10 +19715,7 @@ class SegmentationService extends src/* PubSubService */.Rc {
     const csSegmentation = this.getCornerstoneSegmentation(segmentationId);
     let segmentIndex = config.segmentIndex;
     if (!segmentIndex) {
-      // grab the next available segment index based on the object keys,
-      // so basically get the highest segment index value + 1
-      const segmentKeys = Object.keys(csSegmentation.segments);
-      segmentIndex = segmentKeys.length === 0 ? 1 : Math.max(...segmentKeys.map(Number)) + 1;
+      segmentIndex = this.getNextAvailableSegmentIndex(segmentationId);
     }
 
     // update the segmentation
@@ -19838,6 +20262,7 @@ class SegmentationService extends src/* PubSubService */.Rc {
     esm.eventTarget.addEventListener(dist_esm.Enums.Events.SEGMENTATION_REPRESENTATION_ADDED, this._onSegmentationRepresentationModifiedFromSource);
     esm.eventTarget.addEventListener(dist_esm.Enums.Events.SEGMENTATION_REPRESENTATION_REMOVED, this._onSegmentationRepresentationModifiedFromSource);
     esm.eventTarget.addEventListener(dist_esm.Enums.Events.SEGMENTATION_ADDED, this._onSegmentationAddedFromSource);
+    esm.eventTarget.addEventListener(dist_esm.Enums.Events.ANNOTATION_CUT_MERGE_PROCESS_COMPLETED, this._onAnnotationCutMergeProcessCompletedFromSource);
   }
   getCornerstoneSegmentation(segmentationId) {
     return dist_esm.segmentation.state.getSegmentation(segmentationId);
@@ -21446,6 +21871,10 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
     const displaySet = displaySetService.getDisplaySetByUID(displaySetUIDs[0]);
     const displaySetModality = displaySet?.Modality;
 
+    // seems like a hack but we need the actor to be ready first before
+    // we set the properties
+    const timeoutViewportCallback = callback => setTimeout(callback, 0);
+
     // filter overlay display sets (e.g. segmentation) since they will get handled below via the segmentation service
     const filteredVolumeInputArray = volumeInputArray.map((volumeInput, index) => {
       return {
@@ -21511,10 +21940,18 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
           // care of the background overlay display set first then the addOverlayFn will add the
           // SEG displaySet
           const sampleImageId = imageIds[0];
-          const backgroundDisplaySet = displaySetService.getDisplaySetsBy(displaySet => !displaySet.isOverlayDisplaySet && displaySet.images.some(image => image.imageId === sampleImageId));
+          const backgroundDisplaySet = displaySetService.getDisplaySetsBy(displaySet => !displaySet.isOverlayDisplaySet && displaySet.images?.some(image => image.imageId === sampleImageId));
           if (backgroundDisplaySet.length !== 1) {
             throw new Error('Background display set not found');
           }
+          if (viewport.type === esm.Enums.ViewportType.VOLUME_3D) {
+            timeoutViewportCallback(() => {
+              viewportGridService.setDisplaySetsForViewport({
+                viewportId: viewport.id,
+                displaySetInstanceUIDs: [backgroundDisplaySet[0].displaySetInstanceUID]
+              });
+            });
+          }
         }
       });
     }
@@ -21533,14 +21970,12 @@ class CornerstoneViewportService extends src/* PubSubService */.Rc {
       properties,
       volumeId
     }) => {
-      setTimeout(() => {
-        // seems like a hack but we need the actor to be ready first before
-        // we set the properties
+      timeoutViewportCallback(() => {
         viewport.setProperties(properties, volumeId);
         viewport.render();
-      }, 0);
+      });
     });
-    this.setPresentations(viewport.id, presentations, viewportInfo);
+    this.setPresentations(viewport.id, presentations);
     if (!presentations.positionPresentation) {
       const imageIndex = this._getInitialImageIndexForViewport(viewportInfo);
       if (imageIndex !== undefined) {
@@ -22522,14 +22957,130 @@ function getSopClassHandlerModule(params) {
 var useActiveViewportSegmentationRepresentations = __webpack_require__(9234);
 // EXTERNAL MODULE: ../../../extensions/cornerstone/src/hooks/useMeasurements.ts
 var useMeasurements = __webpack_require__(19214);
+;// ../../../extensions/cornerstone/src/components/SegmentationUtilityButton.tsx
+function SegmentationUtilityButton_extends() { return SegmentationUtilityButton_extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, SegmentationUtilityButton_extends.apply(null, arguments); }
+
+
+
+/**
+ * A button that represents a segmentation utility.
+ * It is implicitly the PopoverTrigger for the options Popover panel that is
+ * opened in the PanelSegmentation component. It in essence is the PopoverTrigger
+ * because typically this button has the associated options to display in the Popover.
+ * Furthermore it also typically has a command for toggling the activeSegmentationUtility
+ * value in the UIStateStore that triggers the fetching of its options.
+
+ * @param props - The props for the button.
+ * @param props.className - The class name for the button.
+ * @param props.isActive - Whether the button is active
+ * @param props.id - The id of the button.
+ */
+function SegmentationUtilityButton(props) {
+  const {
+    className,
+    isActive,
+    id
+  } = props;
+  const activeSegmentationUtility = (0,default_src.useUIStateStore)(store => store.uiState.activeSegmentationUtility);
+  const toolButtonClassName = (0,ui_next_src.cn)('w-7 h-7 text-primary hover:text-primary hover:!bg-primary/30', className, isActive && 'bg-primary/30');
+  const handleMouseDownCapture = (0,react.useCallback)(event => {
+    if (activeSegmentationUtility === id) {
+      // If this active button is clicked, prevent the default Popover
+      // behaviour of closing the Popover on a pointer/mouse down.
+      // Not doing this will cause the Popover to close and then reopen again.
+      // Why? Because propagating this event will cause PanelSegmentation to
+      // close the Popover by clearing the activeSegmentationUtility. Then
+      // this button will set the activeSegmentationUtility again and the
+      // Popover will reopen.
+      event.preventDefault();
+      event.stopPropagation();
+    }
+  }, [activeSegmentationUtility, id]);
+  return /*#__PURE__*/react.createElement("div", {
+    onPointerDownCapture: handleMouseDownCapture
+  }, /*#__PURE__*/react.createElement(ui_next_src/* ToolButton */.T0e, SegmentationUtilityButton_extends({}, props, {
+    className: toolButtonClassName
+  })));
+}
+/* harmony default export */ const components_SegmentationUtilityButton = (SegmentationUtilityButton);
+;// ../../../extensions/cornerstone/src/utils/segmentationExportUtils.ts
+
+/**
+ * Checks if a labelmap segmentation has exportable data
+ * A label map is exportable if it has any pixel data and
+ * it is referenced by a display set that is reconstructable.
+ *
+ * @param labelmap - The labelmap representation data
+ * @param displaySetService - The display set service instance
+ * @returns boolean - Whether the labelmap has exportable data
+ */
+const hasExportableLabelMapData = (labelmap, displaySetService) => {
+  if (!labelmap) {
+    return false;
+  }
+  const imageIds = labelmap?.imageIds;
+  if (!imageIds?.length) {
+    return false;
+  }
+  const hasPixelData = imageIds.some(imageId => {
+    const pixelData = esm.cache.getImage(imageId)?.getPixelData();
+    if (!pixelData) {
+      return false;
+    }
+    for (let i = 0; i < pixelData.length; i++) {
+      if (pixelData[i] !== 0) {
+        return true;
+      }
+    }
+  });
+  if (!hasPixelData) {
+    return false;
+  }
+  const referencedImageIds = labelmap?.referencedImageIds;
+  if (!referencedImageIds) {
+    return false;
+  }
+  const firstImageId = referencedImageIds[0];
+  const instance = esm.metaData.get('instance', firstImageId);
+  if (!instance) {
+    return false;
+  }
+  const SOPInstanceUID = instance.SOPInstanceUID || instance.SopInstanceUID;
+  const SeriesInstanceUID = instance.SeriesInstanceUID;
+  const displaySet = displaySetService.getDisplaySetForSOPInstanceUID(SOPInstanceUID, SeriesInstanceUID);
+  return displaySet?.isReconstructable;
+};
+
+/**
+ * Checks if a contour segmentation has exportable data
+ * A contour is exportable if it has any contour annotation/geometry data.
+ *
+ * @param contour - The contour representation data
+ * @returns boolean - Whether the contour has exportable data
+ */
+const hasExportableContourData = contour => {
+  if (!contour) {
+    return false;
+  }
+  const contourAnnotationUIDsMap = contour?.annotationUIDsMap;
+  if (!contourAnnotationUIDsMap) {
+    return false;
+  }
+  return contourAnnotationUIDsMap.size > 0;
+};
 ;// ../../../extensions/cornerstone/src/panels/PanelSegmentation.tsx
 
 
 
 
 
+
+
+
+
 function PanelSegmentation({
-  children
+  children,
+  segmentationRepresentationType
 }) {
   const {
     commandsManager,
@@ -22537,12 +23088,56 @@ function PanelSegmentation({
   } = (0,src/* useSystem */.Jg)();
   const {
     customizationService,
-    displaySetService
+    displaySetService,
+    viewportGridService,
+    toolbarService,
+    segmentationService
   } = servicesManager.services;
+  const {
+    activeViewportId
+  } = viewportGridService.getState();
+  const utilitiesSectionMap = {
+    [esm_enums.SegmentationRepresentations.Labelmap]: toolbarService.sections.labelMapSegmentationUtilities,
+    [esm_enums.SegmentationRepresentations.Contour]: toolbarService.sections.contourSegmentationUtilities
+  };
+  const selectedSegmentationsForViewportMap = useSelectedSegmentationsForViewportStore(store => store.selectedSegmentationsForViewport[activeViewportId]);
+  const selectedSegmentationIdForType = segmentationRepresentationType ? selectedSegmentationsForViewportMap?.get(segmentationRepresentationType) : segmentationService?.getActiveSegmentation(activeViewportId)?.segmentationId;
+  const buttonSection = utilitiesSectionMap[segmentationRepresentationType];
+  const {
+    activeToolOptions: activeUtilityOptions
+  } = (0,src/* useActiveToolOptions */.KP)({
+    buttonSectionId: buttonSection
+  });
   const {
     segmentationsWithRepresentations,
     disabled
   } = (0,useActiveViewportSegmentationRepresentations/* useActiveViewportSegmentationRepresentations */.c)();
+  const setUIState = (0,default_src.useUIStateStore)(store => store.setUIState);
+
+  // useEffect for handling clicks on any of the non-active viewports.
+  // The ViewportGrid stops the propagation of pointer/mouse events
+  // for non-active viewports so the Popover below
+  // is not closed when clicking on any of the non-active viewports.
+  (0,react.useEffect)(() => {
+    setUIState('activeSegmentationUtility', null);
+    toolbarService.refreshToolbarState({
+      viewportId: activeViewportId
+    });
+  }, [activeViewportId, setUIState, toolbarService]);
+
+  // The callback for handling clicks outside of the Popover and, the SegmentationUtilityButton
+  // that triggered it to open. Clicks outside those components must close the Popover.
+  // The Popover is made visible whenever the options associated with the
+  // activeSegmentationUtility exist. Thus clearing the activeSegmentationUtility
+  // clears the associated options and will keep the Popover closed.
+  const handlePopoverOpenChange = (0,react.useCallback)(open => {
+    if (!open) {
+      setUIState('activeSegmentationUtility', null);
+      toolbarService.refreshToolbarState({
+        viewportId: activeViewportId
+      });
+    }
+  }, [activeViewportId, setUIState, toolbarService]);
 
   // Extract customization options
   const segmentationTableMode = customizationService.getCustomization('panelSegmentation.tableMode');
@@ -22563,6 +23158,9 @@ function PanelSegmentation({
       commandsManager.run('addSegment', {
         segmentationId
       });
+      commandsManager.run('setActiveSegmentation', {
+        segmentationId
+      });
     },
     onSegmentClick: (segmentationId, segmentIndex) => {
       commandsManager.run('setActiveSegmentAndCenter', {
@@ -22593,6 +23191,14 @@ function PanelSegmentation({
         segmentIndex
       });
     },
+    onSegmentCopy: segmentationRepresentationType === esm_enums.SegmentationRepresentations.Contour ? (segmentationId, segmentIndex) => {
+      commandsManager.run('copyContourSegment', {
+        sourceSegmentInfo: {
+          segmentationId,
+          segmentIndex
+        }
+      });
+    } : undefined,
     onToggleSegmentVisibility: (segmentationId, segmentIndex, type) => {
       commandsManager.run('toggleSegmentVisibility', {
         segmentationId,
@@ -22684,6 +23290,8 @@ function PanelSegmentation({
   };
 
   // Generate export options
+  // Map each segmentation to an export option for it.
+  // A segmentation is exportable if it has any labelmap or contour data.
   const exportOptions = segmentationsWithRepresentations.map(({
     segmentation
   }) => {
@@ -22692,49 +23300,24 @@ function PanelSegmentation({
       segmentationId
     } = segmentation;
     const {
-      Labelmap
+      Labelmap,
+      Contour
     } = representationData;
-    if (!Labelmap) {
+    if (!Labelmap && !Contour) {
       return {
         segmentationId,
         isExportable: true
       };
     }
-
-    // Check if any segments have anything drawn in any of the viewports
-    const hasAnySegmentData = (() => {
-      const imageIds = Labelmap.imageIds;
-      if (!imageIds?.length) return false;
-      for (const imageId of imageIds) {
-        const pixelData = esm.cache.getImage(imageId)?.getPixelData();
-        if (!pixelData) continue;
-        for (let i = 0; i < pixelData.length; i++) {
-          if (pixelData[i] !== 0) return true;
-        }
-      }
-      return false;
-    })();
-    if (!hasAnySegmentData) {
-      return {
-        segmentationId,
-        isExportable: false
-      };
-    }
-    const referencedImageIds = Labelmap.referencedImageIds;
-    const firstImageId = referencedImageIds[0];
-    const instance = esm.metaData.get('instance', firstImageId);
-    if (!instance) {
+    if (!hasExportableLabelMapData(Labelmap, displaySetService) && !hasExportableContourData(Contour)) {
       return {
         segmentationId,
         isExportable: false
       };
     }
-    const SOPInstanceUID = instance.SOPInstanceUID || instance.SopInstanceUID;
-    const SeriesInstanceUID = instance.SeriesInstanceUID;
-    const displaySet = displaySetService.getDisplaySetForSOPInstanceUID(SOPInstanceUID, SeriesInstanceUID);
     return {
       segmentationId,
-      isExportable: displaySet?.isReconstructable
+      isExportable: true
     };
   });
 
@@ -22743,14 +23326,29 @@ function PanelSegmentation({
     disabled,
     data: segmentationsWithRepresentations,
     mode: segmentationTableMode,
-    title: 'Segmentations',
+    title: `${segmentationRepresentationType ? `${segmentationRepresentationType} ` : ''}Segmentations`,
     exportOptions,
     disableEditing,
     onSegmentationAdd,
     showAddSegment,
     renderInactiveSegmentations: handlers.getRenderInactiveSegmentations(),
+    segmentationRepresentationType,
+    selectedSegmentationIdForType,
     ...handlers
   };
+  const renderUtilitiesToolbar = () => {
+    if (!buttonSection) {
+      return null;
+    }
+    return /*#__PURE__*/react.createElement(ui_next_src/* IconPresentationProvider */.TNf, {
+      size: "large",
+      IconContainer: components_SegmentationUtilityButton
+    }, /*#__PURE__*/react.createElement("div", {
+      className: "flex flex-wrap gap-[3px] bg-transparent pb-[2px] pl-[8px] pt-[6px]"
+    }, /*#__PURE__*/react.createElement(default_src.Toolbar, {
+      buttonSection: buttonSection
+    })));
+  };
   const renderSegments = () => {
     return /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Segments, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.SegmentStatistics.Header, null, /*#__PURE__*/react.createElement(CustomSegmentStatisticsHeader, null)), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.SegmentStatistics.Body, null));
   };
@@ -22758,11 +23356,20 @@ function PanelSegmentation({
   // Render content based on mode
   const renderModeContent = () => {
     if (tableProps.mode === 'collapsed') {
-      return /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Collapsed, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Collapsed.Header, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Collapsed.DropdownMenu, null, /*#__PURE__*/react.createElement(CustomDropdownMenuContent, null)), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Collapsed.Selector, null), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Collapsed.Info, null)), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Collapsed.Content, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.AddSegmentRow, null), renderSegments()));
+      return /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Collapsed, null, renderUtilitiesToolbar(), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Collapsed.Header, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Collapsed.DropdownMenu, null, /*#__PURE__*/react.createElement(CustomDropdownMenuContent, null)), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Collapsed.Selector, null), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Collapsed.Info, null)), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Collapsed.Content, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.AddSegmentRow, null), renderSegments()));
     }
-    return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Expanded, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Expanded.Header, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Expanded.DropdownMenu, null, /*#__PURE__*/react.createElement(CustomDropdownMenuContent, null)), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Expanded.Label, null), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Expanded.Info, null)), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Expanded.Content, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.AddSegmentRow, null), renderSegments())));
+    return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Expanded, null, renderUtilitiesToolbar(), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Expanded.Header, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Expanded.DropdownMenu, null, /*#__PURE__*/react.createElement(CustomDropdownMenuContent, null)), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Expanded.Label, null), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Expanded.Info, null)), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Expanded.Content, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.AddSegmentRow, null), renderSegments())));
   };
-  return /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h, tableProps, children, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Config, null), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.AddSegmentationRow, null), renderModeContent());
+  return /*#__PURE__*/react.createElement(ui_next_src/* Popover */.AMh, {
+    open: !!activeUtilityOptions,
+    onOpenChange: handlePopoverOpenChange
+  }, /*#__PURE__*/react.createElement(ui_next_src/* PopoverAnchor */.dTQ, null, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h, tableProps, children, /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.Config, null), /*#__PURE__*/react.createElement(ui_next_src/* SegmentationTable */.R4h.AddSegmentationRow, null), renderModeContent())), activeUtilityOptions && /*#__PURE__*/react.createElement(ui_next_src/* PopoverContent */.hlN, {
+    side: "left",
+    align: "start",
+    className: "w-auto"
+  }, /*#__PURE__*/react.createElement(ui_next_src/* ToolSettings */.k_3, {
+    options: activeUtilityOptions
+  })));
 }
 // EXTERNAL MODULE: ../../../node_modules/lodash.debounce/index.js
 var lodash_debounce = __webpack_require__(62051);
@@ -23756,51 +24363,60 @@ function PanelMeasurement(props) {
 
 
 
+
+
+
 const getPanelModule = ({
   commandsManager,
   servicesManager,
   extensionManager
 }) => {
-  const wrappedPanelSegmentation = ({
-    configuration
-  }) => {
+  const {
+    toolbarService
+  } = servicesManager.services;
+  const toolSectionMap = {
+    [esm_enums.SegmentationRepresentations.Labelmap]: toolbarService.sections.labelMapSegmentationToolbox,
+    [esm_enums.SegmentationRepresentations.Contour]: toolbarService.sections.contourSegmentationToolbox
+  };
+  const wrappedPanelSegmentation = props => {
     return /*#__PURE__*/react.createElement(PanelSegmentation, {
       commandsManager: commandsManager,
       servicesManager: servicesManager,
       extensionManager: extensionManager,
       configuration: {
-        ...configuration
-      }
+        ...props?.configuration
+      },
+      segmentationRepresentationType: props?.segmentationRepresentationType
     });
   };
-  const wrappedPanelSegmentationNoHeader = ({
-    configuration
-  }) => {
+  const wrappedPanelSegmentationNoHeader = props => {
     return /*#__PURE__*/react.createElement(PanelSegmentation, {
       commandsManager: commandsManager,
       servicesManager: servicesManager,
       extensionManager: extensionManager,
       configuration: {
-        ...configuration
-      }
+        ...props?.configuration
+      },
+      segmentationRepresentationType: props?.segmentationRepresentationType
     });
   };
-  const wrappedPanelSegmentationWithTools = ({
-    configuration
-  }) => {
+  const wrappedPanelSegmentationWithTools = props => {
     const {
-      toolbarService
-    } = servicesManager.services;
+      t
+    } = (0,es/* useTranslation */.Bd)('SegmentationTable');
+    const tKey = `${props.segmentationRepresentationType ?? 'Segmentation'} tools`;
+    const tValue = t(tKey);
     return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement(default_src.Toolbox, {
-      buttonSectionId: toolbarService.sections.segmentationToolbox,
-      title: "Segmentation Tools"
+      buttonSectionId: toolSectionMap[props.segmentationRepresentationType],
+      title: tValue
     }), /*#__PURE__*/react.createElement(PanelSegmentation, {
       commandsManager: commandsManager,
       servicesManager: servicesManager,
       extensionManager: extensionManager,
       configuration: {
-        ...configuration
-      }
+        ...props?.configuration
+      },
+      segmentationRepresentationType: props?.segmentationRepresentationType
     }));
   };
   return [{
@@ -23829,11 +24445,23 @@ const getPanelModule = ({
     label: 'Segmentation',
     component: wrappedPanelSegmentationNoHeader
   }, {
-    name: 'panelSegmentationWithTools',
+    name: 'panelSegmentationWithToolsLabelMap',
     iconName: 'tab-segmentation',
     iconLabel: 'Segmentation',
-    label: 'Segmentation',
-    component: wrappedPanelSegmentationWithTools
+    label: i18n_src/* default */.A.t('SegmentationTable:Labelmap'),
+    component: props => wrappedPanelSegmentationWithTools({
+      ...props,
+      segmentationRepresentationType: esm_enums.SegmentationRepresentations.Labelmap
+    })
+  }, {
+    name: 'panelSegmentationWithToolsContour',
+    iconName: 'tab-contours',
+    iconLabel: 'Segmentation',
+    label: i18n_src/* default */.A.t('SegmentationTable:Contour'),
+    component: props => wrappedPanelSegmentationWithTools({
+      ...props,
+      segmentationRepresentationType: esm_enums.SegmentationRepresentations.Contour
+    })
   }];
 };
 /* harmony default export */ const src_getPanelModule = (getPanelModule);
@@ -24047,6 +24675,39 @@ function setupSegmentationModifiedHandler({
     unsubscribe
   };
 }
+
+/**
+ * Sets up auto tab switching for when the first segmentation is added into the viewer.
+ */
+function setUpSelectedSegmentationsForViewportHandler({
+  segmentationService
+}) {
+  const selectedSegmentationsForViewportEvents = [segmentationService.EVENTS.SEGMENTATION_MODIFIED, segmentationService.EVENTS.SEGMENTATION_REPRESENTATION_MODIFIED];
+  const unsubscribeSelectedSegmentationsForViewportEvents = selectedSegmentationsForViewportEvents.map(eventName => segmentationService.subscribe(eventName, event => {
+    const {
+      viewportId
+    } = event;
+    if (!viewportId) {
+      return;
+    }
+    const {
+      selectedSegmentationsForViewport,
+      setSelectedSegmentationsForViewport
+    } = useSelectedSegmentationsForViewportStore.getState();
+    const representations = segmentationService.getSegmentationRepresentations(viewportId);
+    const activeRepresentation = representations.find(representation => representation.active);
+    const typeToSegmentationIdMap = selectedSegmentationsForViewport[viewportId] ?? new Map();
+    if (activeRepresentation) {
+      typeToSegmentationIdMap.set(activeRepresentation.type, activeRepresentation.segmentationId);
+    } else {
+      typeToSegmentationIdMap.clear();
+    }
+    setSelectedSegmentationsForViewport(viewportId, typeToSegmentationIdMap);
+  })).map(subscription => subscription.unsubscribe);
+  return {
+    unsubscribeSelectedSegmentationsForViewportEvents
+  };
+}
 ;// ../../../extensions/cornerstone/src/utils/promptHydrationDialog.ts
 const HydrationType = {
   SEG: 'SEG',
@@ -24201,13 +24862,15 @@ function _askHydrate(uiViewportDialogService, customizationService, viewportId,
 
 
 
+
 const utils_utils = {
   handleSegmentChange: handleSegmentChange,
   isReferenceViewable: isReferenceViewable,
   setupSegmentationDataModifiedHandler: setupSegmentationDataModifiedHandler,
   setupSegmentationModifiedHandler: setupSegmentationModifiedHandler,
   promptHydrationDialog: utils_promptHydrationDialog,
-  getCenterExtent: getCenterExtent
+  getCenterExtent: getCenterExtent,
+  createSegmentationForViewport: createSegmentationForViewport
 };
 /* harmony default export */ const src_utils = (utils_utils);
 ;// ../../../extensions/cornerstone/src/utils/setUpSegmentationEventHandlers.ts
@@ -24245,7 +24908,7 @@ const setUpSegmentationEventHandlers = ({
     }
     const segmentation = segmentationService.getSegmentation(segmentationId);
     const label = segmentation.cachedStats.info;
-    const imageIds = segmentation.representationData.Labelmap.imageIds;
+    const imageIds = segmentation.representationData?.Labelmap?.imageIds ?? segmentation.representationData?.Contour?.imageIds;
 
     // Create a display set for the segmentation
     const segmentationDisplaySet = {
@@ -24264,7 +24927,12 @@ const setUpSegmentationEventHandlers = ({
     };
     displaySetService.addDisplaySets(segmentationDisplaySet);
   });
-  const unsubscriptions = [unsubscribeSegmentationDataModifiedHandler, unsubscribeSegmentationModifiedHandler, unsubscribeSegmentationCreated];
+  const {
+    unsubscribeSelectedSegmentationsForViewportEvents
+  } = setUpSelectedSegmentationsForViewportHandler({
+    segmentationService
+  });
+  const unsubscriptions = [unsubscribeSegmentationDataModifiedHandler, unsubscribeSegmentationModifiedHandler, unsubscribeSegmentationCreated, ...unsubscribeSelectedSegmentationsForViewportEvents];
   return {
     unsubscriptions
   };
@@ -24675,7 +25343,7 @@ const cornerstoneExtension = {
     });
     unsubscriptions.push(...segmentationUnsubscriptions);
     toolbarService.registerEventForToolbarUpdate(cornerstoneViewportService, [cornerstoneViewportService.EVENTS.VIEWPORT_DATA_CHANGED]);
-    toolbarService.registerEventForToolbarUpdate(segmentationService, [segmentationService.EVENTS.SEGMENTATION_REMOVED, segmentationService.EVENTS.SEGMENTATION_MODIFIED]);
+    toolbarService.registerEventForToolbarUpdate(segmentationService, [segmentationService.EVENTS.SEGMENTATION_REMOVED, segmentationService.EVENTS.SEGMENTATION_MODIFIED, segmentationService.EVENTS.ANNOTATION_CUT_MERGE_PROCESS_COMPLETED]);
     toolbarService.registerEventForToolbarUpdate(esm.eventTarget, [dist_esm.Enums.Events.TOOL_ACTIVATED]);
 
     // Configure the interleaved/HTJ2K loader
@@ -24714,6 +25382,7 @@ const cornerstoneExtension = {
     useSynchronizersStore/* useSynchronizersStore */.U.getState().clearSynchronizersStore();
     default_src.useToggleOneUpViewportGridStore.getState().clearToggleOneUpViewportGridStore();
     useSegmentationPresentationStore/* useSegmentationPresentationStore */.v.getState().clearSegmentationPresentationStore();
+    useSelectedSegmentationsForViewportStore.getState().clearSelectedSegmentationsForViewportStore();
     segmentationService.removeAllSegmentations();
   },
   /**