@ohif/app 3.7.0-beta.10 → 3.7.0-beta.100

package/dist/616.bundle.07fe93ec26097c150193.js

@@ -1,685 +0,0 @@
-(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 + 452 modules
-var ui_src = __webpack_require__(28619);
-;// 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: "bg-black border-primary-main",
-            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: ../../../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) */
-
-/***/ })
-
-}]);