@ohif/app 3.0.0 → 3.5.0

package/dist/616.bundle.bec4736d8c9513e62856.js

@@ -0,0 +1,686 @@
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[616],{
+
+/***/ 72776:
+/***/ ((__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)
+});
+
+;// 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__(32735);
+// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/Math.js
+var Core_Math = __webpack_require__(92780);
+// EXTERNAL MODULE: ../../core/src/index.ts + 101 modules
+var src = __webpack_require__(48501);
+// EXTERNAL MODULE: ../../../node_modules/dcmjs/build/dcmjs.es.js
+var dcmjs_es = __webpack_require__(22737);
+;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-seg/src/getSopClassHandlerModule.js
+
+
+
+
+const {
+  DicomMessage,
+  DicomMetaDictionary
+} = dcmjs_es["default"].data;
+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) {
+      const segments = await _loadSegments(extensionManager, segDisplaySet, headers);
+      segDisplaySet.segments = segments;
+    }
+    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(extensionManager, segDisplaySet, headers) {
+  const utilityModule = extensionManager.getModuleEntry('@ohif/extension-cornerstone.utilityModule.common');
+  const {
+    dicomLoaderService
+  } = utilityModule.exports;
+  const segArrayBuffer = await dicomLoaderService.findDicomDataPromise(segDisplaySet, null, headers);
+  const dicomData = DicomMessage.readFile(segArrayBuffer);
+  const dataset = DicomMetaDictionary.naturalizeDataset(dicomData.dict);
+  dataset._meta = DicomMetaDictionary.namifyDataset(dicomData.meta);
+  if (!Array.isArray(dataset.SegmentSequence)) {
+    dataset.SegmentSequence = [dataset.SegmentSequence];
+  }
+  const segments = _getSegments(dataset);
+  return segments;
+}
+function _segmentationExists(segDisplaySet, segmentationService) {
+  // This should be abstracted with the CornerstoneCacheService
+  return segmentationService.getSegmentation(segDisplaySet.displaySetInstanceUID);
+}
+function _getPixelData(dataset, segments) {
+  let frameSize = Math.ceil(dataset.Rows * dataset.Columns / 8);
+  let nextOffset = 0;
+  Object.keys(segments).forEach(segmentKey => {
+    const segment = segments[segmentKey];
+    segment.numberOfFrames = segment.functionalGroups.length;
+    segment.size = segment.numberOfFrames * frameSize;
+    segment.offset = nextOffset;
+    nextOffset = segment.offset + segment.size;
+    const packedSegment = dataset.PixelData[0].slice(segment.offset, nextOffset);
+    segment.pixelData = dcmjs_es["default"].data.BitArray.unpack(packedSegment);
+    segment.geometry = geometryFromFunctionalGroups(dataset, segment.functionalGroups);
+  });
+  return segments;
+}
+function geometryFromFunctionalGroups(dataset, perFrame) {
+  let pixelMeasures = dataset.SharedFunctionalGroupsSequence.PixelMeasuresSequence;
+  let planeOrientation = dataset.SharedFunctionalGroupsSequence.PlaneOrientationSequence;
+  let planePosition = perFrame[0].PlanePositionSequence; // TODO: assume sorted frames!
+
+  const geometry = {};
+
+  // NB: DICOM PixelSpacing is defined as Row then Column,
+  // unlike ImageOrientationPatient
+  let spacingBetweenSlices = pixelMeasures.SpacingBetweenSlices;
+  if (!spacingBetweenSlices) {
+    if (pixelMeasures.SliceThickness) {
+      console.log('Using SliceThickness as SpacingBetweenSlices');
+      spacingBetweenSlices = pixelMeasures.SliceThickness;
+    }
+  }
+  geometry.spacing = [pixelMeasures.PixelSpacing[1], pixelMeasures.PixelSpacing[0], spacingBetweenSlices].map(Number);
+  geometry.dimensions = [dataset.Columns, dataset.Rows, perFrame.length].map(Number);
+  let orientation = planeOrientation.ImageOrientationPatient.map(Number);
+  const columnStepToPatient = orientation.slice(0, 3);
+  const rowStepToPatient = orientation.slice(3, 6);
+  geometry.planeNormal = [];
+  Core_Math/* default.cross */.ZP.cross(columnStepToPatient, rowStepToPatient, geometry.planeNormal);
+  let firstPosition = perFrame[0].PlanePositionSequence.ImagePositionPatient.map(Number);
+  let lastPosition = perFrame[perFrame.length - 1].PlanePositionSequence.ImagePositionPatient.map(Number);
+  geometry.sliceStep = [];
+  Core_Math/* default.subtract */.ZP.subtract(lastPosition, firstPosition, geometry.sliceStep);
+  Core_Math/* default.normalize */.ZP.normalize(geometry.sliceStep);
+  geometry.direction = columnStepToPatient.concat(rowStepToPatient).concat(geometry.sliceStep);
+  geometry.origin = planePosition.ImagePositionPatient.map(Number);
+  return geometry;
+}
+function _getSegments(dataset) {
+  const segments = {};
+  dataset.SegmentSequence.forEach(segment => {
+    const cielab = segment.RecommendedDisplayCIELabValue;
+    const rgba = dcmjs_es["default"].data.Colors.dicomlab2RGB(cielab).map(x => Math.round(x * 255));
+    rgba.push(255);
+    const segmentNumber = segment.SegmentNumber;
+    segments[segmentNumber] = {
+      color: rgba,
+      functionalGroups: [],
+      offset: null,
+      size: null,
+      pixelData: null,
+      label: segment.SegmentLabel
+    };
+  });
+
+  // make a list of functional groups per segment
+  dataset.PerFrameFunctionalGroupsSequence.forEach(functionalGroup => {
+    const segmentNumber = functionalGroup.SegmentIdentificationSequence.ReferencedSegmentNumber;
+    segments[segmentNumber].functionalGroups.push(functionalGroup);
+  });
+  return _getPixelData(dataset, segments);
+}
+function getSopClassHandlerModule(_ref2) {
+  let {
+    servicesManager,
+    extensionManager
+  } = _ref2;
+  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__(60216);
+var prop_types_default = /*#__PURE__*/__webpack_require__.n(prop_types);
+// EXTERNAL MODULE: ../../ui/src/index.js + 449 modules
+var ui_src = __webpack_require__(43803);
+;// 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: 'Enter Segment Label',
+        value: {
+          label
+        },
+        noCloseButton: true,
+        onClose: () => uiDialogService.dismiss({
+          id: dialogId
+        }),
+        actions: [{
+          id: 'cancel',
+          text: 'Cancel',
+          type: 'primary'
+        }, {
+          id: 'save',
+          text: 'Confirm',
+          type: 'secondary'
+        }],
+        onSubmit: onSubmitHandler,
+        body: _ref2 => {
+          let {
+            value,
+            setValue
+          } = _ref2;
+          return /*#__PURE__*/react.createElement("div", {
+            className: "p-4 bg-primary-dark"
+          }, /*#__PURE__*/react.createElement(ui_src/* Input */.II, {
+            autoFocus: true,
+            className: "mt-2 bg-black border-primary-main",
+            type: "text",
+            containerClassName: "mr-2",
+            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: ../../../node_modules/react-i18next/dist/es/index.js + 15 modules
+var es = __webpack_require__(21572);
+;// CONCATENATED MODULE: ../../../extensions/cornerstone-dicom-seg/src/panels/PanelSegmentation.tsx
+
+
+
+
+
+function PanelSegmentation(_ref) {
+  let {
+    servicesManager,
+    commandsManager
+  } = _ref;
+  const {
+    segmentationService,
+    uiDialogService
+  } = servicesManager.services;
+  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: "flex flex-col flex-auto min-h-0 justify-between mt-1"
+  }, 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,
+    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,
+  hasUpdatedPriorsInformation: false,
+  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);
+
+;// 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() */ 569).then(__webpack_require__.bind(__webpack_require__, 33569));
+});
+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
+      }, 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);
+
+/***/ }),
+
+/***/ 78753:
+/***/ (() => {
+
+/* (ignored) */
+
+/***/ })
+
+}]);