@ohif/app 3.7.0-beta.79 → 3.7.0-beta.80

package/dist/150.bundle.1fff6b0c3496b6367f58.js

@@ -1,742 +0,0 @@
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[150],{
-
-/***/ 48228:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  "default": () => (/* binding */ cornerstone_dicom_seg_src),
-  hydrateSEGDisplaySet: () => (/* reexport */ _hydrateSEG/* default */.Z)
-});
-
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-seg/package.json
-const package_namespaceObject = JSON.parse('{"u2":"@ohif/extension-cornerstone-dicom-seg"}');
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-seg/src/id.js
-
-const id = package_namespaceObject.u2;
-const SOPClassHandlerName = 'dicom-seg';
-const SOPClassHandlerId = `${id}.sopClassHandlerModule.${SOPClassHandlerName}`;
-
-// EXTERNAL MODULE: ../../../node_modules/react/index.js
-var react = __webpack_require__(43001);
-// EXTERNAL MODULE: ../../core/src/index.ts + 75 modules
-var src = __webpack_require__(34491);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 337 modules
-var esm = __webpack_require__(45754);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/adapters/dist/adapters.es.js
-var adapters_es = __webpack_require__(91202);
-// EXTERNAL MODULE: ../../../node_modules/dcmjs/build/dcmjs.es.js
-var dcmjs_es = __webpack_require__(67540);
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-seg/src/utils/dicomlabToRGB.ts
-
-
-/**
- * Converts a CIELAB color to an RGB color using the dcmjs library.
- * @param cielab - The CIELAB color to convert.
- * @returns The RGB color as an array of three integers between 0 and 255.
- */
-function dicomlabToRGB(cielab) {
-  const rgb = dcmjs_es["default"].data.Colors.dicomlab2RGB(cielab).map(x => Math.round(x * 255));
-  return rgb;
-}
-
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-seg/src/getSopClassHandlerModule.js
-
-
-
-
-
-const sopClassUids = ['1.2.840.10008.5.1.4.1.1.66.4'];
-let loadPromises = {};
-function _getDisplaySetsFromSeries(instances, servicesManager, extensionManager) {
-  const instance = instances[0];
-  const {
-    StudyInstanceUID,
-    SeriesInstanceUID,
-    SOPInstanceUID,
-    SeriesDescription,
-    SeriesNumber,
-    SeriesDate,
-    SOPClassUID,
-    wadoRoot,
-    wadoUri,
-    wadoUriRoot
-  } = instance;
-  const displaySet = {
-    Modality: 'SEG',
-    loading: false,
-    isReconstructable: true,
-    // by default for now since it is a volumetric SEG currently
-    displaySetInstanceUID: src.utils.guid(),
-    SeriesDescription,
-    SeriesNumber,
-    SeriesDate,
-    SOPInstanceUID,
-    SeriesInstanceUID,
-    StudyInstanceUID,
-    SOPClassHandlerId: SOPClassHandlerId,
-    SOPClassUID,
-    referencedImages: null,
-    referencedSeriesInstanceUID: null,
-    referencedDisplaySetInstanceUID: null,
-    isDerivedDisplaySet: true,
-    isLoaded: false,
-    isHydrated: false,
-    segments: {},
-    sopClassUids,
-    instance,
-    instances: [instance],
-    wadoRoot,
-    wadoUriRoot,
-    wadoUri,
-    isOverlayDisplaySet: true
-  };
-  const referencedSeriesSequence = instance.ReferencedSeriesSequence;
-  if (!referencedSeriesSequence) {
-    throw new Error('ReferencedSeriesSequence is missing for the SEG');
-  }
-  const referencedSeries = referencedSeriesSequence[0];
-  displaySet.referencedImages = instance.ReferencedSeriesSequence.ReferencedInstanceSequence;
-  displaySet.referencedSeriesInstanceUID = referencedSeries.SeriesInstanceUID;
-  displaySet.getReferenceDisplaySet = () => {
-    const {
-      displaySetService
-    } = servicesManager.services;
-    const referencedDisplaySets = displaySetService.getDisplaySetsForSeries(displaySet.referencedSeriesInstanceUID);
-    if (!referencedDisplaySets || referencedDisplaySets.length === 0) {
-      throw new Error('Referenced DisplaySet is missing for the SEG');
-    }
-    const referencedDisplaySet = referencedDisplaySets[0];
-    displaySet.referencedDisplaySetInstanceUID = referencedDisplaySet.displaySetInstanceUID;
-
-    // Todo: this needs to be able to work with other reference volumes (other than streaming) such as nifti, etc.
-    displaySet.referencedVolumeURI = referencedDisplaySet.displaySetInstanceUID;
-    const referencedVolumeId = `cornerstoneStreamingImageVolume:${displaySet.referencedVolumeURI}`;
-    displaySet.referencedVolumeId = referencedVolumeId;
-    return referencedDisplaySet;
-  };
-  displaySet.load = async _ref => {
-    let {
-      headers
-    } = _ref;
-    return await _load(displaySet, servicesManager, extensionManager, headers);
-  };
-  return [displaySet];
-}
-function _load(segDisplaySet, servicesManager, extensionManager, headers) {
-  const {
-    SOPInstanceUID
-  } = segDisplaySet;
-  const {
-    segmentationService
-  } = servicesManager.services;
-  if ((segDisplaySet.loading || segDisplaySet.isLoaded) && loadPromises[SOPInstanceUID] && _segmentationExists(segDisplaySet, segmentationService)) {
-    return loadPromises[SOPInstanceUID];
-  }
-  segDisplaySet.loading = true;
-
-  // We don't want to fire multiple loads, so we'll wait for the first to finish
-  // and also return the same promise to any other callers.
-  loadPromises[SOPInstanceUID] = new Promise(async (resolve, reject) => {
-    if (!segDisplaySet.segments || Object.keys(segDisplaySet.segments).length === 0) {
-      await _loadSegments({
-        extensionManager,
-        servicesManager,
-        segDisplaySet,
-        headers
-      });
-    }
-    const suppressEvents = true;
-    segmentationService.createSegmentationForSEGDisplaySet(segDisplaySet, null, suppressEvents).then(() => {
-      segDisplaySet.loading = false;
-      resolve();
-    }).catch(error => {
-      segDisplaySet.loading = false;
-      reject(error);
-    });
-  });
-  return loadPromises[SOPInstanceUID];
-}
-async function _loadSegments(_ref2) {
-  let {
-    extensionManager,
-    servicesManager,
-    segDisplaySet,
-    headers
-  } = _ref2;
-  const utilityModule = extensionManager.getModuleEntry('@ohif/extension-cornerstone.utilityModule.common');
-  const {
-    segmentationService
-  } = servicesManager.services;
-  const {
-    dicomLoaderService
-  } = utilityModule.exports;
-  const arrayBuffer = await dicomLoaderService.findDicomDataPromise(segDisplaySet, null, headers);
-  const cachedReferencedVolume = esm.cache.getVolume(segDisplaySet.referencedVolumeId);
-  if (!cachedReferencedVolume) {
-    throw new Error('Referenced Volume is missing for the SEG, and stack viewport SEG is not supported yet');
-  }
-  const {
-    imageIds
-  } = cachedReferencedVolume;
-
-  // Todo: what should be defaults here
-  const tolerance = 0.001;
-  const skipOverlapping = true;
-  esm.eventTarget.addEventListener(adapters_es/* Enums */.Yb.Events.SEGMENTATION_LOAD_PROGRESS, evt => {
-    const {
-      percentComplete
-    } = evt.detail;
-    segmentationService._broadcastEvent(segmentationService.EVENTS.SEGMENT_LOADING_COMPLETE, {
-      percentComplete
-    });
-  });
-  const results = await adapters_es/* adaptersSEG */.ok.Cornerstone3D.Segmentation.generateToolState(imageIds, arrayBuffer, esm.metaData, {
-    skipOverlapping,
-    tolerance,
-    eventTarget: esm.eventTarget,
-    triggerEvent: esm.triggerEvent
-  });
-  results.segMetadata.data.forEach((data, i) => {
-    if (i > 0) {
-      data.rgba = dicomlabToRGB(data.RecommendedDisplayCIELabValue);
-    }
-  });
-  Object.assign(segDisplaySet, results);
-}
-function _segmentationExists(segDisplaySet, segmentationService) {
-  // This should be abstracted with the CornerstoneCacheService
-  return segmentationService.getSegmentation(segDisplaySet.displaySetInstanceUID);
-}
-function getSopClassHandlerModule(_ref3) {
-  let {
-    servicesManager,
-    extensionManager
-  } = _ref3;
-  const getDisplaySetsFromSeries = instances => {
-    return _getDisplaySetsFromSeries(instances, servicesManager, extensionManager);
-  };
-  return [{
-    name: 'dicom-seg',
-    sopClassUids,
-    getDisplaySetsFromSeries
-  }];
-}
-/* harmony default export */ const src_getSopClassHandlerModule = (getSopClassHandlerModule);
-// EXTERNAL MODULE: ../../../node_modules/prop-types/index.js
-var prop_types = __webpack_require__(3827);
-var prop_types_default = /*#__PURE__*/__webpack_require__.n(prop_types);
-// EXTERNAL MODULE: ../../ui/src/index.js + 458 modules
-var ui_src = __webpack_require__(88344);
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-seg/src/panels/callInputDialog.tsx
-
-
-function callInputDialog(uiDialogService, label, callback) {
-  const dialogId = 'enter-segment-label';
-  const onSubmitHandler = _ref => {
-    let {
-      action,
-      value
-    } = _ref;
-    switch (action.id) {
-      case 'save':
-        callback(value.label, action.id);
-        break;
-      case 'cancel':
-        callback('', action.id);
-        break;
-    }
-    uiDialogService.dismiss({
-      id: dialogId
-    });
-  };
-  if (uiDialogService) {
-    uiDialogService.create({
-      id: dialogId,
-      centralize: true,
-      isDraggable: false,
-      showOverlay: true,
-      content: ui_src/* Dialog */.Vq,
-      contentProps: {
-        title: 'Segment',
-        value: {
-          label
-        },
-        noCloseButton: true,
-        onClose: () => uiDialogService.dismiss({
-          id: dialogId
-        }),
-        actions: [{
-          id: 'cancel',
-          text: 'Cancel',
-          type: ui_src/* ButtonEnums.type */.LZ.U.secondary
-        }, {
-          id: 'save',
-          text: 'Confirm',
-          type: ui_src/* ButtonEnums.type */.LZ.U.primary
-        }],
-        onSubmit: onSubmitHandler,
-        body: _ref2 => {
-          let {
-            value,
-            setValue
-          } = _ref2;
-          return /*#__PURE__*/react.createElement(ui_src/* Input */.II, {
-            label: "Enter the segment label",
-            labelClassName: "text-white text-[14px] leading-[1.2]",
-            autoFocus: true,
-            className: "border-primary-main bg-black",
-            type: "text",
-            value: value.label,
-            onChange: event => {
-              event.persist();
-              setValue(value => ({
-                ...value,
-                label: event.target.value
-              }));
-            },
-            onKeyPress: event => {
-              if (event.key === 'Enter') {
-                onSubmitHandler({
-                  value,
-                  action: {
-                    id: 'save'
-                  }
-                });
-              }
-            }
-          });
-        }
-      }
-    });
-  }
-}
-/* harmony default export */ const panels_callInputDialog = (callInputDialog);
-// EXTERNAL MODULE: ./state/index.js + 1 modules
-var state = __webpack_require__(62657);
-// EXTERNAL MODULE: ../../../node_modules/react-i18next/dist/es/index.js + 15 modules
-var es = __webpack_require__(69190);
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-seg/src/panels/PanelSegmentation.tsx
-
-
-
-
-
-
-function PanelSegmentation(_ref) {
-  let {
-    servicesManager,
-    commandsManager
-  } = _ref;
-  const {
-    segmentationService,
-    uiDialogService
-  } = servicesManager.services;
-  const [appConfig] = (0,state/* useAppConfig */.M)();
-  const disableEditing = appConfig?.disableEditing;
-  const {
-    t
-  } = (0,es/* useTranslation */.$G)('PanelSegmentation');
-  const [selectedSegmentationId, setSelectedSegmentationId] = (0,react.useState)(null);
-  const [segmentationConfiguration, setSegmentationConfiguration] = (0,react.useState)(segmentationService.getConfiguration());
-  const [segmentations, setSegmentations] = (0,react.useState)(() => segmentationService.getSegmentations());
-  const [isMinimized, setIsMinimized] = (0,react.useState)({});
-  const onToggleMinimizeSegmentation = (0,react.useCallback)(id => {
-    setIsMinimized(prevState => ({
-      ...prevState,
-      [id]: !prevState[id]
-    }));
-  }, [setIsMinimized]);
-
-  // Only expand the last segmentation added to the list and collapse the rest
-  (0,react.useEffect)(() => {
-    const lastSegmentationId = segmentations[segmentations.length - 1]?.id;
-    if (lastSegmentationId) {
-      setIsMinimized(prevState => ({
-        ...prevState,
-        [lastSegmentationId]: false
-      }));
-    }
-  }, [segmentations, setIsMinimized]);
-  (0,react.useEffect)(() => {
-    // ~~ Subscription
-    const added = segmentationService.EVENTS.SEGMENTATION_ADDED;
-    const updated = segmentationService.EVENTS.SEGMENTATION_UPDATED;
-    const removed = segmentationService.EVENTS.SEGMENTATION_REMOVED;
-    const subscriptions = [];
-    [added, updated, removed].forEach(evt => {
-      const {
-        unsubscribe
-      } = segmentationService.subscribe(evt, () => {
-        const segmentations = segmentationService.getSegmentations();
-        setSegmentations(segmentations);
-        setSegmentationConfiguration(segmentationService.getConfiguration());
-      });
-      subscriptions.push(unsubscribe);
-    });
-    return () => {
-      subscriptions.forEach(unsub => {
-        unsub();
-      });
-    };
-  }, []);
-  const onSegmentationClick = segmentationId => {
-    segmentationService.setActiveSegmentationForToolGroup(segmentationId);
-  };
-  const onSegmentationDelete = segmentationId => {
-    segmentationService.remove(segmentationId);
-  };
-  const getToolGroupIds = segmentationId => {
-    const toolGroupIds = segmentationService.getToolGroupIdsWithSegmentation(segmentationId);
-    return toolGroupIds;
-  };
-  const onSegmentClick = (segmentationId, segmentIndex) => {
-    segmentationService.setActiveSegmentForSegmentation(segmentationId, segmentIndex);
-    const toolGroupIds = getToolGroupIds(segmentationId);
-    toolGroupIds.forEach(toolGroupId => {
-      // const toolGroupId =
-      segmentationService.setActiveSegmentationForToolGroup(segmentationId, toolGroupId);
-      segmentationService.jumpToSegmentCenter(segmentationId, segmentIndex, toolGroupId);
-    });
-  };
-  const onSegmentEdit = (segmentationId, segmentIndex) => {
-    const segmentation = segmentationService.getSegmentation(segmentationId);
-    const segment = segmentation.segments[segmentIndex];
-    const {
-      label
-    } = segment;
-    panels_callInputDialog(uiDialogService, label, (label, actionId) => {
-      if (label === '') {
-        return;
-      }
-      segmentationService.setSegmentLabelForSegmentation(segmentationId, segmentIndex, label);
-    });
-  };
-  const onSegmentationEdit = segmentationId => {
-    const segmentation = segmentationService.getSegmentation(segmentationId);
-    const {
-      label
-    } = segmentation;
-    panels_callInputDialog(uiDialogService, label, (label, actionId) => {
-      if (label === '') {
-        return;
-      }
-      segmentationService.addOrUpdateSegmentation({
-        id: segmentationId,
-        label
-      }, false,
-      // suppress event
-      true // notYetUpdatedAtSource
-      );
-    });
-  };
-
-  const onSegmentColorClick = (segmentationId, segmentIndex) => {
-    // Todo: Implement color picker later
-    return;
-  };
-  const onSegmentDelete = (segmentationId, segmentIndex) => {
-    // segmentationService.removeSegmentFromSegmentation(
-    //   segmentationId,
-    //   segmentIndex
-    // );
-    console.warn('not implemented yet');
-  };
-  const onToggleSegmentVisibility = (segmentationId, segmentIndex) => {
-    const segmentation = segmentationService.getSegmentation(segmentationId);
-    const segmentInfo = segmentation.segments[segmentIndex];
-    const isVisible = !segmentInfo.isVisible;
-    const toolGroupIds = getToolGroupIds(segmentationId);
-
-    // Todo: right now we apply the visibility to all tool groups
-    toolGroupIds.forEach(toolGroupId => {
-      segmentationService.setSegmentVisibility(segmentationId, segmentIndex, isVisible, toolGroupId);
-    });
-  };
-  const onToggleSegmentationVisibility = segmentationId => {
-    segmentationService.toggleSegmentationVisibility(segmentationId);
-  };
-  const _setSegmentationConfiguration = (0,react.useCallback)((segmentationId, key, value) => {
-    segmentationService.setConfiguration({
-      segmentationId,
-      [key]: value
-    });
-  }, [segmentationService]);
-  return /*#__PURE__*/react.createElement("div", {
-    className: "mt-1 flex min-h-0 flex-auto flex-col justify-between"
-  }, segmentations?.length ? /*#__PURE__*/react.createElement(ui_src/* SegmentationGroupTable */.cX, {
-    title: t('Segmentations'),
-    showAddSegmentation: false,
-    segmentations: segmentations,
-    isMinimized: isMinimized,
-    activeSegmentationId: selectedSegmentationId || '',
-    onSegmentationClick: onSegmentationClick,
-    onSegmentationDelete: onSegmentationDelete,
-    onSegmentationEdit: onSegmentationEdit,
-    onSegmentClick: onSegmentClick,
-    onSegmentEdit: onSegmentEdit,
-    disableEditing: disableEditing,
-    onSegmentColorClick: onSegmentColorClick,
-    onSegmentDelete: onSegmentDelete,
-    onToggleSegmentVisibility: onToggleSegmentVisibility,
-    onToggleSegmentationVisibility: onToggleSegmentationVisibility,
-    onToggleMinimizeSegmentation: onToggleMinimizeSegmentation,
-    segmentationConfig: {
-      initialConfig: segmentationConfiguration
-    },
-    setRenderOutline: value => _setSegmentationConfiguration(selectedSegmentationId, 'renderOutline', value),
-    setOutlineOpacityActive: value => _setSegmentationConfiguration(selectedSegmentationId, 'outlineOpacity', value),
-    setRenderFill: value => _setSegmentationConfiguration(selectedSegmentationId, 'renderFill', value),
-    setRenderInactiveSegmentations: value => _setSegmentationConfiguration(selectedSegmentationId, 'renderInactiveSegmentations', value),
-    setOutlineWidthActive: value => _setSegmentationConfiguration(selectedSegmentationId, 'outlineWidthActive', value),
-    setFillAlpha: value => _setSegmentationConfiguration(selectedSegmentationId, 'fillAlpha', value),
-    setFillAlphaInactive: value => _setSegmentationConfiguration(selectedSegmentationId, 'fillAlphaInactive', value)
-  }) : null);
-}
-PanelSegmentation.propTypes = {
-  commandsManager: prop_types_default().shape({
-    runCommand: (prop_types_default()).func.isRequired
-  }),
-  servicesManager: prop_types_default().shape({
-    services: prop_types_default().shape({
-      segmentationService: prop_types_default().shape({
-        getSegmentation: (prop_types_default()).func.isRequired,
-        getSegmentations: (prop_types_default()).func.isRequired,
-        toggleSegmentationVisibility: (prop_types_default()).func.isRequired,
-        subscribe: (prop_types_default()).func.isRequired,
-        EVENTS: (prop_types_default()).object.isRequired
-      }).isRequired
-    }).isRequired
-  }).isRequired
-};
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-seg/src/getHangingProtocolModule.ts
-const segProtocol = {
-  id: '@ohif/seg',
-  // Don't store this hanging protocol as it applies to the currently active
-  // display set by default
-  // cacheId: null,
-  name: 'Segmentations',
-  // Just apply this one when specifically listed
-  protocolMatchingRules: [],
-  toolGroupIds: ['default'],
-  // -1 would be used to indicate active only, whereas other values are
-  // the number of required priors referenced - so 0 means active with
-  // 0 or more priors.
-  numberOfPriorsReferenced: 0,
-  // Default viewport is used to define the viewport when
-  // additional viewports are added using the layout tool
-  defaultViewport: {
-    viewportOptions: {
-      viewportType: 'stack',
-      toolGroupId: 'default',
-      allowUnmatchedView: true
-    },
-    displaySets: [{
-      id: 'segDisplaySetId',
-      matchedDisplaySetsIndex: -1
-    }]
-  },
-  displaySetSelectors: {
-    segDisplaySetId: {
-      seriesMatchingRules: [{
-        attribute: 'Modality',
-        constraint: {
-          equals: 'SEG'
-        }
-      }]
-    }
-  },
-  stages: [{
-    name: 'Segmentations',
-    viewportStructure: {
-      layoutType: 'grid',
-      properties: {
-        rows: 1,
-        columns: 1
-      }
-    },
-    viewports: [{
-      viewportOptions: {
-        allowUnmatchedView: true
-      },
-      displaySets: [{
-        id: 'segDisplaySetId'
-      }]
-    }]
-  }]
-};
-function getHangingProtocolModule() {
-  return [{
-    name: segProtocol.id,
-    protocol: segProtocol
-  }];
-}
-/* harmony default export */ const src_getHangingProtocolModule = (getHangingProtocolModule);
-
-// EXTERNAL MODULE: ../../../extensions/cornerstone-dicom-seg/src/utils/_hydrateSEG.ts
-var _hydrateSEG = __webpack_require__(28417);
-;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-seg/src/index.tsx
-function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-
-
-
-
-
-
-const Component = /*#__PURE__*/react.lazy(() => {
-  return __webpack_require__.e(/* import() */ 451).then(__webpack_require__.bind(__webpack_require__, 4451));
-});
-const OHIFCornerstoneSEGViewport = props => {
-  return /*#__PURE__*/react.createElement(react.Suspense, {
-    fallback: /*#__PURE__*/react.createElement("div", null, "Loading...")
-  }, /*#__PURE__*/react.createElement(Component, props));
-};
-
-/**
- * You can remove any of the following modules if you don't need them.
- */
-const extension = {
-  /**
-   * Only required property. Should be a unique value across all extensions.
-   * You ID can be anything you want, but it should be unique.
-   */
-  id: id,
-  /**
-   * PanelModule should provide a list of panels that will be available in OHIF
-   * for Modes to consume and render. Each panel is defined by a {name,
-   * iconName, iconLabel, label, component} object. Example of a panel module
-   * is the StudyBrowserPanel that is provided by the default extension in OHIF.
-   */
-  getPanelModule: _ref => {
-    let {
-      servicesManager,
-      commandsManager,
-      extensionManager
-    } = _ref;
-    const wrappedPanelSegmentation = () => {
-      return /*#__PURE__*/react.createElement(PanelSegmentation, {
-        commandsManager: commandsManager,
-        servicesManager: servicesManager,
-        extensionManager: extensionManager
-      });
-    };
-    return [{
-      name: 'panelSegmentation',
-      iconName: 'tab-segmentation',
-      iconLabel: 'Segmentation',
-      label: 'Segmentation',
-      component: wrappedPanelSegmentation
-    }];
-  },
-  getViewportModule(_ref2) {
-    let {
-      servicesManager,
-      extensionManager
-    } = _ref2;
-    const ExtendedOHIFCornerstoneSEGViewport = props => {
-      return /*#__PURE__*/react.createElement(OHIFCornerstoneSEGViewport, _extends({
-        servicesManager: servicesManager,
-        extensionManager: extensionManager,
-        commandsManager: commandsManager
-      }, props));
-    };
-    return [{
-      name: 'dicom-seg',
-      component: ExtendedOHIFCornerstoneSEGViewport
-    }];
-  },
-  /**
-   * SopClassHandlerModule should provide a list of sop class handlers that will be
-   * available in OHIF for Modes to consume and use to create displaySets from Series.
-   * Each sop class handler is defined by a { name, sopClassUids, getDisplaySetsFromSeries}.
-   * Examples include the default sop class handler provided by the default extension
-   */
-  getSopClassHandlerModule: src_getSopClassHandlerModule,
-  getHangingProtocolModule: src_getHangingProtocolModule
-};
-/* harmony default export */ const cornerstone_dicom_seg_src = (extension);
-
-
-/***/ }),
-
-/***/ 28417:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-"use strict";
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   Z: () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
-async function _hydrateSEGDisplaySet(_ref) {
-  let {
-    segDisplaySet,
-    viewportId: targetViewportId,
-    servicesManager
-  } = _ref;
-  const {
-    segmentationService,
-    hangingProtocolService,
-    viewportGridService
-  } = servicesManager.services;
-  const displaySetInstanceUID = segDisplaySet.referencedDisplaySetInstanceUID;
-  let segmentationId = null;
-
-  // We need the hydration to notify panels about the new segmentation added
-  const suppressEvents = false;
-  segmentationId = await segmentationService.createSegmentationForSEGDisplaySet(segDisplaySet, segmentationId, suppressEvents);
-  segmentationService.hydrateSegmentation(segDisplaySet.displaySetInstanceUID);
-  const {
-    viewports
-  } = viewportGridService.getState();
-  const updatedViewports = hangingProtocolService.getViewportsRequireUpdate(targetViewportId, displaySetInstanceUID);
-
-  // Todo: fix this after we have a better way for stack viewport segmentations
-
-  // check every viewport in the viewports to see if the displaySetInstanceUID
-  // is being displayed, if so we need to update the viewport to use volume viewport
-  // (if already is not using it) since Cornerstone3D currently only supports
-  // volume viewport for segmentation
-  viewports.forEach((viewport, viewportId) => {
-    if (targetViewportId === viewportId) {
-      return;
-    }
-    const shouldDisplaySeg = segmentationService.shouldRenderSegmentation(viewport.displaySetInstanceUIDs, segDisplaySet.displaySetInstanceUID);
-    if (shouldDisplaySeg) {
-      updatedViewports.push({
-        viewportId,
-        displaySetInstanceUIDs: viewport.displaySetInstanceUIDs,
-        viewportOptions: {
-          // Note: This is a hack to get the grid to re-render the OHIFCornerstoneViewport component
-          // Used for segmentation hydration right now, since the logic to decide whether
-          // a viewport needs to render a segmentation lives inside the CornerstoneViewportService
-          // so we need to re-render (force update via change of the needsRerendering) so that React
-          // does the diffing and decides we should render this again (although the id and element has not changed)
-          // so that the CornerstoneViewportService can decide whether to render the segmentation or not.
-          needsRerendering: true,
-          initialImageOptions: {
-            preset: 'middle'
-          }
-        }
-      });
-    }
-  });
-
-  // Do the entire update at once
-  viewportGridService.setDisplaySetsForViewports(updatedViewports);
-  return true;
-}
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_hydrateSEGDisplaySet);
-
-/***/ }),
-
-/***/ 78753:
-/***/ (() => {
-
-/* (ignored) */
-
-/***/ })
-
-}]);