@ohif/app 3.8.0-beta.86 → 3.8.0-beta.88

package/dist/{335.bundle.fab6af469f98e7a59bfa.js → 7.bundle.d9bef0f76f54df3ed3d0.js}

@@ -1,7 +1,7 @@
 "use strict";
-(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[335],{
+(globalThis["webpackChunk"] = globalThis["webpackChunk"] || []).push([[7],{
 
-/***/ 27335:
+/***/ 89007:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -970,11 +970,76 @@ PanelPetSUV.propTypes = {
     }).isRequired
   }).isRequired
 };
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
+var esm = __webpack_require__(92136);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/index.js
+var dist_esm = __webpack_require__(39371);
+;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/handleROIThresholding.ts
+
+const handleROIThresholding = async ({
+  segmentationId,
+  commandsManager,
+  segmentationService,
+  config = {}
+}) => {
+  const segmentation = segmentationService.getSegmentation(segmentationId);
+
+  // re-calculating the cached stats for the active segmentation
+  const updatedPerSegmentCachedStats = {};
+  segmentation.segments = await Promise.all(segmentation.segments.map(async segment => {
+    if (!segment || !segment.segmentIndex) {
+      return segment;
+    }
+    const labelmap = esm.cache.getVolume(segmentationId);
+    const segmentIndex = segment.segmentIndex;
+    const lesionStats = commandsManager.run('getLesionStats', {
+      labelmap,
+      segmentIndex
+    });
+    const suvPeak = await commandsManager.run('calculateSuvPeak', {
+      labelmap,
+      segmentIndex
+    });
+    const lesionGlyoclysisStats = lesionStats.volume * lesionStats.meanValue;
+
+    // update segDetails with the suv peak for the active segmentation
+    const cachedStats = {
+      lesionStats,
+      suvPeak,
+      lesionGlyoclysisStats
+    };
+    segment.cachedStats = cachedStats;
+    segment.displayText = [`SUV Peak: ${suvPeak.suvPeak.toFixed(2)}`, `Volume: ${lesionStats.volume.toFixed(2)} mm3`];
+    updatedPerSegmentCachedStats[segmentIndex] = cachedStats;
+    return segment;
+  }));
+  const notYetUpdatedAtSource = true;
+  const segmentations = segmentationService.getSegmentations();
+  const tmtv = commandsManager.run('calculateTMTV', {
+    segmentations
+  });
+  segmentation.cachedStats = Object.assign(segmentation.cachedStats, updatedPerSegmentCachedStats, {
+    tmtv: {
+      value: tmtv.toFixed(3),
+      config: {
+        ...config
+      }
+    }
+  });
+  segmentationService.addOrUpdateSegmentation({
+    ...segmentation
+  }, false,
+  // don't suppress events
+  notYetUpdatedAtSource);
+};
 ;// CONCATENATED MODULE: ../../../extensions/tmtv/src/Panels/PanelROIThresholdSegmentation/PanelROIThresholdExport.tsx
 
 
 
 
+
+
+
 function PanelRoiThresholdSegmentation({
   servicesManager,
   commandsManager
@@ -987,6 +1052,7 @@ function PanelRoiThresholdSegmentation({
     t
   } = (0,es/* useTranslation */.Bd)('PanelSUVExport');
   const [segmentations, setSegmentations] = (0,react.useState)(() => segmentationService.getSegmentations());
+  const [activeSegmentation, setActiveSegmentation] = (0,react.useState)(null);
 
   /**
    * Update UI based on segmentation changes (added, removed, updated)
@@ -1003,6 +1069,8 @@ function PanelRoiThresholdSegmentation({
       } = segmentationService.subscribe(evt, () => {
         const segmentations = segmentationService.getSegmentations();
         setSegmentations(segmentations);
+        const activeSegmentation = segmentations.filter(seg => seg.isActive);
+        setActiveSegmentation(activeSegmentation[0]);
       });
       subscriptions.push(unsubscribe);
     });
@@ -1012,26 +1080,50 @@ function PanelRoiThresholdSegmentation({
       });
     };
   }, []);
-  const tmtvValue = segmentations?.[0]?.cachedStats?.tmtv?.value || null;
-  const config = segmentations?.[0]?.cachedStats?.tmtv?.config || {};
-  segmentations.forEach(segmentation => {
-    const {
-      cachedStats
-    } = segmentation;
-    if (!cachedStats) {
-      return;
-    }
-
-    // segment 1
-    const suvPeak = cachedStats?.['1']?.suvPeak?.suvPeak;
-    if (Number.isNaN(suvPeak)) {
-      uiNotificationService.show({
-        title: 'SUV Peak',
-        message: 'Segmented volume does not allow SUV Peak calculation',
-        type: 'warning'
+  (0,react.useEffect)(() => {
+    const callback = async evt => {
+      const {
+        detail
+      } = evt;
+      const {
+        segmentationId
+      } = detail;
+      if (!segmentationId) {
+        return;
+      }
+      await handleROIThresholding({
+        segmentationId,
+        commandsManager,
+        segmentationService
       });
-    }
-  });
+      const segmentation = segmentationService.getSegmentation(segmentationId);
+      const {
+        cachedStats
+      } = segmentation;
+      if (!cachedStats) {
+        return;
+      }
+
+      // segment 1
+      const suvPeak = cachedStats?.['1']?.suvPeak?.suvPeak;
+      if (Number.isNaN(suvPeak)) {
+        uiNotificationService.show({
+          title: 'SUV Peak',
+          message: 'Segmented volume does not allow SUV Peak calculation',
+          type: 'warning'
+        });
+      }
+    };
+    esm.eventTarget.addEventListenerDebounced(dist_esm.Enums.Events.SEGMENTATION_DATA_MODIFIED, callback, 300);
+    return () => {
+      esm.eventTarget.removeEventListenerDebounced(dist_esm.Enums.Events.SEGMENTATION_DATA_MODIFIED, callback);
+    };
+  }, []);
+  if (!activeSegmentation) {
+    return null;
+  }
+  const tmtvValue = activeSegmentation.cachedStats?.tmtv?.value || null;
+  const config = activeSegmentation.cachedStats?.tmtv?.config || {};
   const actions = [{
     label: 'Export CSV',
     onClick: () => {
@@ -1043,7 +1135,7 @@ function PanelRoiThresholdSegmentation({
     },
     disabled: tmtvValue === null
   }, {
-    label: 'Create RT Report',
+    label: 'Export RT Report',
     onClick: () => {
       commandsManager.runCommand('createTMTVRTReport');
     },
@@ -1054,7 +1146,7 @@ function PanelRoiThresholdSegmentation({
   }, /*#__PURE__*/react.createElement("div", {
     className: "invisible-scrollbar overflow-y-auto overflow-x-hidden"
   }, tmtvValue !== null ? /*#__PURE__*/react.createElement("div", {
-    className: "bg-secondary-dark mt-1 flex items-baseline justify-between px-2 py-1"
+    className: "bg-secondary-dark flex items-baseline justify-between px-2 py-1"
   }, /*#__PURE__*/react.createElement("span", {
     className: "text-base font-bold uppercase tracking-widest text-white"
   }, 'TMTV:'), /*#__PURE__*/react.createElement("div", {
@@ -1157,12 +1249,8 @@ function getPanelModule({
   }];
 }
 /* harmony default export */ const src_getPanelModule = (getPanelModule);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/tools/dist/esm/index.js + 18 modules
-var esm = __webpack_require__(24542);
 ;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/measurementServiceMappings/constants/supportedTools.js
 /* harmony default export */ const supportedTools = (['RectangleROIStartEndThreshold']);
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 328 modules
-var dist_esm = __webpack_require__(73868);
 ;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/measurementServiceMappings/utils/getSOPInstanceAttributes.js
 
 function getSOPInstanceAttributes(imageId) {
@@ -1171,7 +1259,7 @@ function getSOPInstanceAttributes(imageId) {
   }
 }
 function _getUIDFromImageID(imageId) {
-  const instance = dist_esm.metaData.get('instance', imageId);
+  const instance = esm.metaData.get('instance', imageId);
   return {
     SOPInstanceUID: instance.SOPInstanceUID,
     SeriesInstanceUID: instance.SeriesInstanceUID,
@@ -1274,7 +1362,7 @@ function init({
     displaySetService,
     cornerstoneViewportService
   } = servicesManager.services;
-  (0,esm.addTool)(esm.RectangleROIStartEndThresholdTool);
+  (0,dist_esm.addTool)(dist_esm.RectangleROIStartEndThresholdTool);
   const {
     RectangleROIStartEndThreshold
   } = measurementServiceMappings_measurementServiceMappingsFactory(measurementService, displaySetService, cornerstoneViewportService);
@@ -1298,7 +1386,7 @@ function getRoiStats(referencedVolume, annotations) {
     baseValue
   } = _getStrategyFn('max');
   let value = baseValue;
-  const boundsIJK = esm.utilities.rectangleROITool.getBoundsIJKFromRectangleAnnotations(annotations, referencedVolume);
+  const boundsIJK = dist_esm.utilities.rectangleROITool.getBoundsIJKFromRectangleAnnotations(annotations, referencedVolume);
   const [[iMin, iMax], [jMin, jMax], [kMin, kMax]] = boundsIJK;
   for (let i = iMin; i <= iMax; i++) {
     for (let j = jMin; j <= jMax; j++) {
@@ -1322,7 +1410,7 @@ function getThresholdValues(annotationUIDs, referencedVolumes, config) {
   const {
     weight
   } = config;
-  const annotations = annotationUIDs.map(annotationUID => esm.annotation.state.getAnnotation(annotationUID));
+  const annotations = annotationUIDs.map(annotationUID => dist_esm.annotation.state.getAnnotation(annotationUID));
   const ptValue = getRoiStats(referencedVolumes[0], annotations);
   return {
     ctLower: -Infinity,
@@ -1345,110 +1433,6 @@ function _getStrategyFn(statistic) {
   };
 }
 /* harmony default export */ const getThresholdValue = (getThresholdValues);
-;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/calculateSUVPeak.ts
-
-
-/**
- * This method calculates the SUV peak on a segmented ROI from a reference PET
- * volume. If a rectangle annotation is provided, the peak is calculated within that
- * rectangle. Otherwise, the calculation is performed on the entire volume which
- * will be slower but same result.
- * @param viewport Viewport to use for the calculation
- * @param labelmap Labelmap from which the mask is taken
- * @param referenceVolume PET volume to use for SUV calculation
- * @param toolData [Optional] list of toolData to use for SUV calculation
- * @param segmentIndex The index of the segment to use for masking
- * @returns
- */
-function calculateSuvPeak(labelmap, referenceVolume, annotations, segmentIndex = 1) {
-  if (referenceVolume.metadata.Modality !== 'PT') {
-    return;
-  }
-  const labelmapData = labelmap.getScalarData();
-  const referenceVolumeData = referenceVolume.getScalarData();
-  if (labelmapData.length !== referenceVolumeData.length) {
-    throw new Error('labelmap and referenceVolume must have the same number of pixels');
-  }
-  const {
-    dimensions,
-    imageData: labelmapImageData
-  } = labelmap;
-  const {
-    imageData: referenceVolumeImageData
-  } = referenceVolume;
-  let boundsIJK;
-  // Todo: using the first annotation for now
-  if (annotations?.length && annotations[0].data?.cachedStats) {
-    const {
-      projectionPoints
-    } = annotations[0].data.cachedStats;
-    const pointsToUse = [].concat(...projectionPoints); // cannot use flat() because of typescript compiler right now
-
-    const rectangleCornersIJK = pointsToUse.map(world => {
-      const ijk = gl_matrix_esm/* vec3.fromValues */.eR.fromValues(0, 0, 0);
-      referenceVolumeImageData.worldToIndex(world, ijk);
-      return ijk;
-    });
-    boundsIJK = esm.utilities.boundingBox.getBoundingBoxAroundShape(rectangleCornersIJK, dimensions);
-  }
-  let max = 0;
-  let maxIJK = [0, 0, 0];
-  let maxLPS = [0, 0, 0];
-  const callback = ({
-    pointIJK,
-    pointLPS
-  }) => {
-    const offset = referenceVolumeImageData.computeOffsetIndex(pointIJK);
-    const value = labelmapData[offset];
-    if (value !== segmentIndex) {
-      return;
-    }
-    const referenceValue = referenceVolumeData[offset];
-    if (referenceValue > max) {
-      max = referenceValue;
-      maxIJK = pointIJK;
-      maxLPS = pointLPS;
-    }
-  };
-  esm.utilities.pointInShapeCallback(labelmapImageData, () => true, callback, boundsIJK);
-  const direction = labelmapImageData.getDirection().slice(0, 3);
-
-  /**
-   * 2. Find the bottom and top of the great circle for the second sphere (1cc sphere)
-   * V = (4/3)πr3
-   */
-  const radius = Math.pow(1 / (4 / 3 * Math.PI), 1 / 3) * 10;
-  const diameter = radius * 2;
-  const secondaryCircleWorld = gl_matrix_esm/* vec3.create */.eR.create();
-  const bottomWorld = gl_matrix_esm/* vec3.create */.eR.create();
-  const topWorld = gl_matrix_esm/* vec3.create */.eR.create();
-  referenceVolumeImageData.indexToWorld(maxIJK, secondaryCircleWorld);
-  gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(bottomWorld, secondaryCircleWorld, direction, -diameter / 2);
-  gl_matrix_esm/* vec3.scaleAndAdd */.eR.scaleAndAdd(topWorld, secondaryCircleWorld, direction, diameter / 2);
-  const suvPeakCirclePoints = [bottomWorld, topWorld];
-
-  /**
-   * 3. Find the Mean and Max of the 1cc sphere centered on the suv Max of the previous
-   * sphere
-   */
-  let count = 0;
-  let acc = 0;
-  const suvPeakMeanCallback = ({
-    value
-  }) => {
-    acc += value;
-    count += 1;
-  };
-  esm.utilities.pointInSurroundingSphereCallback(referenceVolumeImageData, suvPeakCirclePoints, suvPeakMeanCallback);
-  const mean = acc / count;
-  return {
-    max,
-    maxIJK,
-    maxLPS,
-    mean
-  };
-}
-/* harmony default export */ const calculateSUVPeak = (calculateSuvPeak);
 ;// CONCATENATED MODULE: ../../../extensions/tmtv/src/utils/calculateTMTV.ts
 
 
@@ -1464,7 +1448,7 @@ function calculateSuvPeak(labelmap, referenceVolume, annotations, segmentIndex =
  */
 function calculateTMTV(labelmaps, segmentIndex = 1) {
   const volumeId = 'mergedLabelmap';
-  const mergedLabelmap = esm.utilities.segmentation.createMergedLabelmapForIndex(labelmaps, segmentIndex, volumeId);
+  const mergedLabelmap = dist_esm.utilities.segmentation.createMergedLabelmapForIndex(labelmaps, segmentIndex, volumeId);
   const {
     imageData,
     spacing
@@ -1558,7 +1542,22 @@ function dicomRTAnnotationExport(annotations) {
 
 const commandsModule_metadataProvider = core_src.classes.MetadataProvider;
 const RECTANGLE_ROI_THRESHOLD_MANUAL_TOOL_IDS = ['RectangleROIStartEndThreshold', 'RectangleROIThreshold'];
-const LABELMAP = esm.Enums.SegmentationRepresentations.Labelmap;
+const LABELMAP = dist_esm.Enums.SegmentationRepresentations.Labelmap;
+const workerManager = (0,esm.getWebWorkerManager)();
+const options = {
+  maxWorkerInstances: 1,
+  autoTerminateOnIdle: {
+    enabled: true,
+    idleTimeThreshold: 3000
+  }
+};
+
+// Register the task
+const workerFn = () => {
+  return new Worker(new URL(/* worker import */ __webpack_require__.p + __webpack_require__.u(584), __webpack_require__.b), {
+    name: 'suv-peak-worker' // name used by the browser to name the worker
+  });
+};
 const commandsModule = ({
   servicesManager,
   commandsManager,
@@ -1584,7 +1583,7 @@ const commandsModule = ({
     const {
       element
     } = getEnabledElement(activeViewportId) || {};
-    const enabledElement = dist_esm.getEnabledElement(element);
+    const enabledElement = esm.getEnabledElement(element);
     return enabledElement;
   }
   function _getMatchedViewportsToolGroupIds() {
@@ -1607,7 +1606,7 @@ const commandsModule = ({
   }
   function _getAnnotationsSelectedByToolNames(toolNames) {
     return toolNames.reduce((allAnnotationUIDs, toolName) => {
-      const annotationUIDs = esm.annotation.selection.getAnnotationsSelectedByToolName(toolName);
+      const annotationUIDs = dist_esm.annotation.selection.getAnnotationsSelectedByToolName(toolName);
       return allAnnotationUIDs.concat(annotationUIDs);
     }, []);
   }
@@ -1711,7 +1710,7 @@ const commandsModule = ({
       config,
       segmentIndex
     }) => {
-      const segmentation = esm.segmentation.state.getSegmentation(segmentationId);
+      const segmentation = dist_esm.segmentation.state.getSegmentation(segmentationId);
       const {
         representationData
       } = segmentation;
@@ -1728,7 +1727,7 @@ const commandsModule = ({
       } = representationData[LABELMAP];
       const {
         referencedVolumeId
-      } = dist_esm.cache.getVolume(segVolumeId);
+      } = esm.cache.getVolume(segVolumeId);
       const annotationUIDs = _getAnnotationsSelectedByToolNames(RECTANGLE_ROI_THRESHOLD_MANUAL_TOOL_IDS);
       if (annotationUIDs.length === 0) {
         uiNotificationService.show({
@@ -1738,9 +1737,9 @@ const commandsModule = ({
         });
         return;
       }
-      const labelmapVolume = dist_esm.cache.getVolume(segmentationId);
-      let referencedVolume = dist_esm.cache.getVolume(referencedVolumeId);
-      const ctReferencedVolume = dist_esm.cache.getVolume(ctVolumeId);
+      const labelmapVolume = esm.cache.getVolume(segmentationId);
+      let referencedVolume = esm.cache.getVolume(referencedVolumeId);
+      const ctReferencedVolume = esm.cache.getVolume(ctVolumeId);
 
       // check if viewport is
 
@@ -1750,7 +1749,7 @@ const commandsModule = ({
       if (!labelmapVolume) {
         throw new Error('No Reference labelmap found');
       }
-      const annotation = esm.annotation.state.getAnnotation(annotationUIDs[0]);
+      const annotation = dist_esm.annotation.state.getAnnotation(annotationUIDs[0]);
       const {
         metadata: {
           enabledElement: {
@@ -1770,8 +1769,8 @@ const commandsModule = ({
         // 3. We throw an error
         const displaySetInstanceUIDs = viewportGridService.getDisplaySetsUIDsForViewport(viewport.id);
         displaySetInstanceUIDs.forEach(displaySetInstanceUID => {
-          const volume = dist_esm.cache.getVolumes().find(volume => volume.volumeId.includes(displaySetInstanceUID));
-          if (dist_esm.utilities.isEqual(volume.dimensions, labelmapVolume.dimensions) && dist_esm.utilities.isEqual(volume.spacing, labelmapVolume.spacing)) {
+          const volume = esm.cache.getVolumes().find(volume => volume.volumeId.includes(displaySetInstanceUID));
+          if (esm.utilities.isEqual(volume.dimensions, labelmapVolume.dimensions) && esm.utilities.isEqual(volume.spacing, labelmapVolume.spacing)) {
             referencedVolume = volume;
           }
         });
@@ -1782,7 +1781,7 @@ const commandsModule = ({
         ctLower,
         ctUpper
       } = getThresholdValue(annotationUIDs, [referencedVolume, ctReferencedVolume], config);
-      return esm.utilities.segmentation.rectangleROIThresholdVolumeByRange(annotationUIDs, labelmapVolume, [{
+      return dist_esm.utilities.segmentation.rectangleROIThresholdVolumeByRange(annotationUIDs, labelmapVolume, [{
         volume: referencedVolume,
         lower: ptLower,
         upper: ptUpper
@@ -1795,17 +1794,40 @@ const commandsModule = ({
         segmentIndex
       });
     },
-    calculateSuvPeak: ({
+    calculateSuvPeak: async ({
       labelmap,
       segmentIndex
     }) => {
+      // if we put it in the top, it will appear in other modes
+      workerManager.registerWorker('suv-peak-worker', workerFn, options);
       const {
         referencedVolumeId
       } = labelmap;
-      const referencedVolume = dist_esm.cache.getVolume(referencedVolumeId);
+      const referencedVolume = esm.cache.getVolume(referencedVolumeId);
       const annotationUIDs = _getAnnotationsSelectedByToolNames(RECTANGLE_ROI_THRESHOLD_MANUAL_TOOL_IDS);
-      const annotations = annotationUIDs.map(annotationUID => esm.annotation.state.getAnnotation(annotationUID));
-      const suvPeak = calculateSUVPeak(labelmap, referencedVolume, annotations, segmentIndex);
+      const annotations = annotationUIDs.map(annotationUID => dist_esm.annotation.state.getAnnotation(annotationUID));
+      const labelmapProps = {
+        dimensions: labelmap.dimensions,
+        origin: labelmap.origin,
+        direction: labelmap.direction,
+        spacing: labelmap.spacing,
+        scalarData: labelmap.scalarData,
+        metadata: labelmap.metadata
+      };
+      const referenceVolumeProps = {
+        dimensions: referencedVolume.dimensions,
+        origin: referencedVolume.origin,
+        direction: referencedVolume.direction,
+        spacing: referencedVolume.spacing,
+        scalarData: referencedVolume.scalarData,
+        metadata: referencedVolume.metadata
+      };
+      const suvPeak = await workerManager.executeTask('suv-peak-worker', 'calculateSuvPeak', {
+        labelmapProps,
+        referenceVolumeProps,
+        annotations,
+        segmentIndex
+      });
       return {
         suvPeak: suvPeak.mean,
         suvMax: suvPeak.max,
@@ -1821,7 +1843,7 @@ const commandsModule = ({
         scalarData,
         spacing
       } = labelmap;
-      const referencedScalarData = dist_esm.cache.getVolume(labelmap.referencedVolumeId).getScalarData();
+      const referencedScalarData = esm.cache.getVolume(labelmap.referencedVolumeId).getScalarData();
       let segmentationMax = -Infinity;
       let segmentationMin = Infinity;
       let segmentationValues = [];
@@ -1909,7 +1931,7 @@ const commandsModule = ({
       // merge labelmap will through an error if labels maps are not the same size
       // or same direction or ....
       try {
-        mergedLabelmap = esm.utilities.segmentation.createMergedLabelmapForIndex(labelmapVolumes);
+        mergedLabelmap = dist_esm.utilities.segmentation.createMergedLabelmapForIndex(labelmapVolumes);
       } catch (e) {
         console.error('commandsModule::getTotalLesionGlycolysis', e);
         return;
@@ -1923,7 +1945,7 @@ const commandsModule = ({
       if (!referencedVolumeId) {
         console.error('commandsModule::getTotalLesionGlycolysis:No referencedVolumeId found');
       }
-      const ptVolume = dist_esm.cache.getVolume(referencedVolumeId);
+      const ptVolume = esm.cache.getVolume(referencedVolumeId);
       const mergedLabelData = mergedLabelmap.getScalarData();
       if (mergedLabelData.length !== ptVolume.getScalarData().length) {
         console.error('commandsModule::getTotalLesionGlycolysis:Labelmap and ptVolume are not the same size');
@@ -1954,7 +1976,7 @@ const commandsModule = ({
       } = viewport.getCamera();
       const selectedAnnotationUIDs = _getAnnotationsSelectedByToolNames(RECTANGLE_ROI_THRESHOLD_MANUAL_TOOL_IDS);
       const annotationUID = selectedAnnotationUIDs[0];
-      const annotation = esm.annotation.state.getAnnotation(annotationUID);
+      const annotation = dist_esm.annotation.state.getAnnotation(annotationUID);
       const {
         handles
       } = annotation.data;
@@ -1990,7 +2012,7 @@ const commandsModule = ({
       } = _getActiveViewportsEnabledElement();
       const selectedAnnotationUIDs = _getAnnotationsSelectedByToolNames(RECTANGLE_ROI_THRESHOLD_MANUAL_TOOL_IDS);
       const annotationUID = selectedAnnotationUIDs[0];
-      const annotation = esm.annotation.state.getAnnotation(annotationUID);
+      const annotation = dist_esm.annotation.state.getAnnotation(annotationUID);
 
       // get the current slice Index
       const sliceIndex = viewport.getCurrentImageIdIndex();
@@ -2003,7 +2025,7 @@ const commandsModule = ({
     },
     createTMTVRTReport: () => {
       // get all Rectangle ROI annotation
-      const stateManager = esm.annotation.state.getAnnotationManager();
+      const stateManager = dist_esm.annotation.state.getAnnotationManager();
       const annotations = [];
       Object.keys(stateManager.annotations).forEach(frameOfReferenceUID => {
         const forAnnotations = stateManager.annotations[frameOfReferenceUID];
@@ -2177,7 +2199,7 @@ const commandsModule = ({
 
 const ROI_STAT = 'roi_stat';
 const RANGE = 'range';
-const options = [{
+const ROIThresholdConfiguration_options = [{
   value: ROI_STAT,
   label: 'Max',
   placeHolder: 'Max'
@@ -2204,8 +2226,8 @@ function ROIThresholdConfiguration({
     label: t('Strategy'),
     closeMenuOnSelect: true,
     className: "border-primary-main mr-2 bg-black text-white ",
-    options: options,
-    placeholder: options.find(option => option.value === config.strategy).placeHolder,
+    options: ROIThresholdConfiguration_options,
+    placeholder: ROIThresholdConfiguration_options.find(option => option.value === config.strategy).placeHolder,
     value: config.strategy,
     onChange: ({
       value
@@ -2402,63 +2424,15 @@ function RectangleROIOptions({
   });
   const handleROIThresholding = (0,react.useCallback)(() => {
     const segmentationId = selectedSegmentationId;
-    const segmentation = segmentationService.getSegmentation(segmentationId);
-    const activeSegmentIndex = esm.segmentation.segmentIndex.getActiveSegmentIndex(segmentationId);
+    const activeSegmentIndex = dist_esm.segmentation.segmentIndex.getActiveSegmentIndex(segmentationId);
 
     // run the threshold based on the active segment index
     // Todo: later find a way to associate each rectangle with a segment (e.g., maybe with color?)
-    const labelmap = runCommand('thresholdSegmentationByRectangleROITool', {
+    runCommand('thresholdSegmentationByRectangleROITool', {
       segmentationId,
       config,
       segmentIndex: activeSegmentIndex
     });
-
-    // re-calculating the cached stats for the active segmentation
-    const updatedPerSegmentCachedStats = {};
-    segmentation.segments = segmentation.segments.map(segment => {
-      if (!segment || !segment.segmentIndex) {
-        return segment;
-      }
-      const segmentIndex = segment.segmentIndex;
-      const lesionStats = runCommand('getLesionStats', {
-        labelmap,
-        segmentIndex
-      });
-      const suvPeak = runCommand('calculateSuvPeak', {
-        labelmap,
-        segmentIndex
-      });
-      const lesionGlyoclysisStats = lesionStats.volume * lesionStats.meanValue;
-
-      // update segDetails with the suv peak for the active segmentation
-      const cachedStats = {
-        lesionStats,
-        suvPeak,
-        lesionGlyoclysisStats
-      };
-      segment.cachedStats = cachedStats;
-      segment.displayText = [`SUV Peak: ${suvPeak.suvPeak.toFixed(2)}`, `Volume: ${lesionStats.volume.toFixed(2)} mm3`];
-      updatedPerSegmentCachedStats[segmentIndex] = cachedStats;
-      return segment;
-    });
-    const notYetUpdatedAtSource = true;
-    const segmentations = segmentationService.getSegmentations();
-    const tmtv = runCommand('calculateTMTV', {
-      segmentations
-    });
-    segmentation.cachedStats = Object.assign(segmentation.cachedStats, updatedPerSegmentCachedStats, {
-      tmtv: {
-        value: tmtv.toFixed(3),
-        config: {
-          ...config
-        }
-      }
-    });
-    segmentationService.addOrUpdateSegmentation({
-      ...segmentation
-    }, false,
-    // don't suppress events
-    notYetUpdatedAtSource);
   }, [selectedSegmentationId, config]);
   (0,react.useEffect)(() => {
     const segmentations = segmentationService.getSegmentations();
@@ -2496,23 +2470,6 @@ function RectangleROIOptions({
       });
     };
   }, []);
-  (0,react.useEffect)(() => {
-    const {
-      unsubscribe
-    } = segmentationService.subscribe(segmentationService.EVENTS.SEGMENTATION_REMOVED, () => {
-      const segmentations = segmentationService.getSegmentations();
-      if (segmentations.length > 0) {
-        setSelectedSegmentationId(segmentations[0].id);
-        handleROIThresholding();
-      } else {
-        setSelectedSegmentationId(null);
-        handleROIThresholding();
-      }
-    });
-    return () => {
-      unsubscribe();
-    };
-  }, []);
   return /*#__PURE__*/react.createElement("div", {
     className: "invisible-scrollbar mb-2 flex flex-col overflow-y-auto overflow-x-hidden"
   }, /*#__PURE__*/react.createElement(PanelROIThresholdSegmentation_ROIThresholdConfiguration, {

package/dist/{722.bundle.a91ce7b563b901b25db0.js → 722.bundle.05e8759e64d484f4554d.js}

@@ -22,8 +22,8 @@ __webpack_require__.d(enums_namespaceObject, {
   s: () => (enums_Events)
 });
 
-// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 328 modules
-var esm = __webpack_require__(73868);
+// EXTERNAL MODULE: ../../../node_modules/@cornerstonejs/core/dist/esm/index.js + 28 modules
+var esm = __webpack_require__(92136);
 // EXTERNAL MODULE: ../../../node_modules/gl-matrix/esm/index.js + 1 modules
 var gl_matrix_esm = __webpack_require__(44753);
 ;// CONCATENATED MODULE: ../../../node_modules/@cornerstonejs/streaming-image-volume-loader/dist/esm/helpers/getVolumeInfo.js