@ohif/app 3.7.0-beta.42 → 3.7.0-beta.43

package/dist/{204.bundle.2ca243271f4e2e584757.js → 150.bundle.94cbce497cafacd4a7d7.js}

@@ -1,6 +1,6 @@
-(self["webpackChunk"] = self["webpackChunk"] || []).push([[204],{
+(self["webpackChunk"] = self["webpackChunk"] || []).push([[150],{
 
-/***/ 65256:
+/***/ 48228:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 "use strict";
@@ -22,21 +22,33 @@ const SOPClassHandlerId = `${id}.sopClassHandlerModule.${SOPClassHandlerName}`;
 
 // EXTERNAL MODULE: ../../../node_modules/react/index.js
 var react = __webpack_require__(43001);
-// EXTERNAL MODULE: ../../../node_modules/@kitware/vtk.js/Common/Core/Math.js
-var Core_Math = __webpack_require__(32899);
 // EXTERNAL MODULE: ../../core/src/index.ts + 103 modules
 var src = __webpack_require__(20599);
+// 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 {
-  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) {
@@ -130,8 +142,12 @@ function _load(segDisplaySet, servicesManager, extensionManager, headers) {
   // 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;
+      await _loadSegments({
+        extensionManager,
+        servicesManager,
+        segDisplaySet,
+        headers
+      });
     }
     const suppressEvents = true;
     segmentationService.createSegmentationForSEGDisplaySet(segDisplaySet, null, suppressEvents).then(() => {
@@ -144,101 +160,62 @@ function _load(segDisplaySet, servicesManager, extensionManager, headers) {
   });
   return loadPromises[SOPInstanceUID];
 }
-async function _loadSegments(extensionManager, segDisplaySet, headers) {
+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 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 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 segments = _getSegments(dataset);
-  return segments;
+  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 _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) {
+function getSopClassHandlerModule(_ref3) {
   let {
     servicesManager,
     extensionManager
-  } = _ref2;
+  } = _ref3;
   const getDisplaySetsFromSeries = instances => {
     return _getDisplaySetsFromSeries(instances, servicesManager, extensionManager);
   };