Gradienthealth/segmentation mode sheet integration

.github/workflows/deploy_ghpages.yml

@@ -2,7 +2,7 @@ name: Deploy viewer to github pages
 
 on:
   push:
-    branches: [ "gradienthealth/Stack-Segmentation" ]
+    branches: [ "gradienthealth/segmentation_mode_sheet_integration" ]
   #pull_request:
     #branches: [ "main" ]
 
@@ -24,7 +24,7 @@ jobs:
           uses: actions/checkout@v3
           with:
             repository: gradienthealth/cornerstone3D-beta
-            ref: gradienthealth/stack-segmentation-support-with-zip-image-loader
+            ref: gradienthealth/segmentation_mode_sheet_integration
             path: ./cornerstone3D
 
         - name: Build cornerstone3D
@@ -37,7 +37,7 @@ jobs:
           uses: actions/checkout@v3
           with:
             repository: gradienthealth/GradientExtensionsAndModes
-            ref: gradienthealth/Segmentation-with-DicomJSON
+            ref: gradienthealth/segmentation_mode_sheet_integration
             path: ./GradientExtensionsAndModes
 
         #- name: Build GradientExtensionsAndModes

extensions/cornerstone-dicom-seg/src/commandsModule.ts

@@ -19,6 +19,7 @@ import {
   getTargetViewport,
 } from './utils/hydrationUtils';
 import generateLabelmaps2DFromImageIdMap from './utils/generateLabelmaps2DFromImageIdMap';
+import getSegmentLabel from './utils/getSegmentLabel';
 
 const { datasetToBlob } = dcmjs.data;
 
@@ -100,7 +101,7 @@ const commandsModule = ({
             toolGroupId,
             segmentIndex: 1,
             properties: {
-              label: 'Segment 1',
+              label: getSegmentLabel(segmentationService.getSegmentation(segmentationId)),
             },
           });
 
@@ -318,28 +319,45 @@ const commandsModule = ({
      * @returns {Object|void} Returns the naturalized report if successfully stored,
      * otherwise throws an error.
      */
-    storeSegmentation: async ({ segmentationId, dataSource }) => {
-      const promptResult = await createReportDialogPrompt(uiDialogService, {
-        extensionManager,
-      });
-
-      if (promptResult.action !== 1 && promptResult.value) {
-        return;
-      }
-
+    storeSegmentation: async ({ segmentationId, dataSource, skipLabelDialog = false }) => {
       const segmentation = segmentationService.getSegmentation(segmentationId);
 
       if (!segmentation) {
         throw new Error('No segmentation found');
       }
+      const { label, displaySetInstanceUID } = segmentation;
+
+      const displaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
+      const shouldOverWrite = displaySet && displaySet.Modality === 'SEG';
+
+      let promptResult: { action?: number; value?: string } = {};
+
+      if (!(skipLabelDialog || shouldOverWrite)) {
+        promptResult = await createReportDialogPrompt(uiDialogService, {
+          extensionManager,
+        });
+
+        if (promptResult.action !== 1 && !promptResult.value) {
+          return;
+        }
+      }
 
-      const { label } = segmentation;
       const SeriesDescription = promptResult.value || label || 'Research Derived Series';
+      segmentation.label = SeriesDescription;
 
       const generatedData = actions.generateSegmentation({
         segmentationId,
         options: {
           SeriesDescription,
+          // Use SeriesInstanceUID, SOPInstanceUID, SeriesNumber, Manufacturer and SeriesDate
+          // if displaySet of the segmentation already exists.
+          // Study level and patient metadata will be used automatically.
+          ...(shouldOverWrite && {
+            SeriesInstanceUID: displaySet.SeriesInstanceUID,
+            SOPInstanceUID: displaySet.instances[0].SOPInstanceUID,
+            SeriesNumber: displaySet.SeriesNumber,
+            Manufacturer: displaySet.instances[0].Manufacturer,
+          }),
         },
       });
 
@@ -358,8 +376,6 @@ const commandsModule = ({
       // add the information for where we stored it to the instance as well
       naturalizedReport.wadoRoot = dataSource.getConfig().wadoRoot;
 
-      DicomMetadataStore.addInstances([naturalizedReport], true);
-
       return naturalizedReport;
     },
     /**

extensions/cornerstone-dicom-seg/src/getSopClassHandlerModule.js

@@ -192,6 +192,7 @@ async function _loadSegments({ extensionManager, servicesManager, segDisplaySet,
     }
   });
 
+  /* Skip the warning message as it is annoying on auto segmentations loading.
   if (!usedRecommendedDisplayCIELabValue) {
     // Display a notification about the non-utilization of RecommendedDisplayCIELabValue
     uiNotificationService.show({
@@ -201,7 +202,7 @@ async function _loadSegments({ extensionManager, servicesManager, segDisplaySet,
       type: 'warning',
       duration: 5000,
     });
-  }
+  }*/
 
   Object.assign(segDisplaySet, results);
 }

extensions/cornerstone-dicom-seg/src/panels/PanelSegmentation.tsx

@@ -1,19 +1,40 @@
 import { createReportAsync } from '@ohif/extension-default';
-import React, { useEffect, useState, useCallback } from 'react';
+import React, { useEffect, useState, useCallback, useReducer } from 'react';
 import PropTypes from 'prop-types';
 import { SegmentationGroupTable, LegacyButtonGroup, LegacyButton } from '@ohif/ui';
 
 import callInputDialog from './callInputDialog';
 import callColorPickerDialog from './colorPickerDialog';
 import { useTranslation } from 'react-i18next';
+import getSegmentLabel from '../utils/getSegmentLabel';
+
+const savedStatusReducer = (state, action) => {
+  return {
+    ...state,
+    ...action.payload,
+  };
+};
+
+const SAVED_STATUS_ICON = {
+  SAVED: 'notifications-success',
+  MODIFIED: 'notifications-warning',
+  ERROR: 'notifications-error',
+};
 
 export default function PanelSegmentation({
   servicesManager,
   commandsManager,
   extensionManager,
   configuration,
 }) {
-  const { segmentationService, viewportGridService, uiDialogService } = servicesManager.services;
+  const {
+    segmentationService,
+    viewportGridService,
+    uiDialogService,
+    displaySetService,
+    userAuthenticationService,
+    CropDisplayAreaService,
+  } = servicesManager.services;
 
   const { t } = useTranslation('PanelSegmentation');
 
@@ -23,6 +44,7 @@ export default function PanelSegmentation({
   );
 
   const [segmentations, setSegmentations] = useState(() => segmentationService.getSegmentations());
+  const [savedStatusStates, dispatch] = useReducer(savedStatusReducer, {});
 
   useEffect(() => {
     // ~~ Subscription
@@ -47,7 +69,78 @@ export default function PanelSegmentation({
     };
   }, []);
 
+  useEffect(() => {
+    let changedSegmentations: any[] = [],
+      timerId;
+    const timoutInSeconds = 5;
+
+    const { unsubscribe } = segmentationService.subscribe(
+      segmentationService.EVENTS.SEGMENTATION_DATA_MODIFIED,
+      ({ segmentation }) => {
+        clearTimeout(timerId);
+        dispatch({ payload: { [segmentation.id]: SAVED_STATUS_ICON.MODIFIED } });
+
+        if (
+          !changedSegmentations.find(
+            changedSegmentation => changedSegmentation.id === segmentation.id
+          )
+        ) {
+          changedSegmentations.push(segmentation);
+        }
+
+        timerId = setTimeout(() => {
+          const datasources = extensionManager.getActiveDataSource();
+
+          const promises = changedSegmentations.map(segmentation =>
+            createReportAsync({
+              servicesManager: servicesManager,
+              getReport: () =>
+                commandsManager.runCommand('storeSegmentation', {
+                  segmentationId: segmentation.id,
+                  dataSource: datasources[0],
+                  skipLabelDialog: true,
+                }),
+              reportType: 'Segmentation',
+              showLoadingModal: false,
+              throwErrors: true,
+            })
+          );
+
+          Promise.allSettled(promises).then(results => {
+            const payload = results.reduce((acc, result, index) => {
+              if (result.value) {
+                changedSegmentations[index].displaySetInstanceUID = result.value[0];
+                displaySetService.getDisplaySetByUID(result.value[0])?.getReferenceDisplaySet();
+              }
+
+              return {
+                ...acc,
+                [changedSegmentations[index].id]:
+                  result.status === 'fulfilled' ? SAVED_STATUS_ICON.SAVED : SAVED_STATUS_ICON.ERROR,
+              };
+            }, {});
+
+            dispatch({ payload });
+
+            const savedSegmentations = Object.keys(payload).filter(
+              id => payload[id] === SAVED_STATUS_ICON.SAVED
+            );
+            changedSegmentations = changedSegmentations.filter(
+              cs => !savedSegmentations.includes(cs.id)
+            );
+          });
+        }, timoutInSeconds * 1000);
+      }
+    );
+
+    return () => {
+      unsubscribe();
+    };
+  }, []);
+
   const setSegmentationActive = segmentationId => {
+    setReferencedDisplaySet(segmentationId);
+
     const isSegmentationActive = segmentations.find(seg => seg.id === segmentationId)?.isActive;
 
     if (isSegmentationActive) {
@@ -57,6 +150,31 @@ export default function PanelSegmentation({
     segmentationService.setActiveSegmentationForToolGroup(segmentationId);
   };
 
+  // Set referenced displaySet of the segmentation to the viewport
+  // if it is not displayed in any of the viewports.
+  const setReferencedDisplaySet = segmentationId => {
+    const segDisplayset = displaySetService.getDisplaySetByUID(segmentationId);
+    if (!segDisplayset) {
+      return;
+    }
+
+    const referencedDisplaySetInstanceUID = segDisplayset.referencedDisplaySetInstanceUID;
+    const { viewports, activeViewportId } = viewportGridService.getState();
+    let referencedImageLoaded = false;
+    viewports.forEach(viewport => {
+      if (viewport.displaySetInstanceUIDs.includes(referencedDisplaySetInstanceUID)) {
+        referencedImageLoaded = true;
+      }
+    });
+
+    if (!referencedImageLoaded) {
+      viewportGridService.setDisplaySetsForViewport({
+        viewportId: activeViewportId,
+        displaySetInstanceUIDs: [referencedDisplaySetInstanceUID],
+      });
+    }
+  };
+
   const getToolGroupIds = segmentationId => {
     const toolGroupIds = segmentationService.getToolGroupIdsWithSegmentation(segmentationId);
 
@@ -68,6 +186,7 @@ export default function PanelSegmentation({
   };
 
   const onSegmentationClick = (segmentationId: string) => {
+    setReferencedDisplaySet(segmentationId);
     segmentationService.setActiveSegmentationForToolGroup(segmentationId);
   };
 
@@ -78,10 +197,12 @@ export default function PanelSegmentation({
 
   const onSegmentAdd = segmentationId => {
     setSegmentationActive(segmentationId);
-    segmentationService.addSegment(segmentationId);
+    const label = getSegmentLabel(segmentations.find(seg => seg.id === segmentationId));
+    segmentationService.addSegment(segmentationId, { properties: { label } });
   };
 
   const onSegmentClick = (segmentationId, segmentIndex) => {
+    setReferencedDisplaySet(segmentationId);
     segmentationService.setActiveSegment(segmentationId, segmentIndex);
 
     const toolGroupIds = getToolGroupIds(segmentationId);
@@ -210,16 +331,25 @@ export default function PanelSegmentation({
   const storeSegmentation = async segmentationId => {
     setSegmentationActive(segmentationId);
     const datasources = extensionManager.getActiveDataSource();
+    let displaySetInstanceUIDs;
+
+    try {
+      displaySetInstanceUIDs = await createReportAsync({
+        servicesManager,
+        getReport: () =>
+          commandsManager.runCommand('storeSegmentation', {
+            segmentationId,
+            dataSource: datasources[0],
+          }),
+        reportType: 'Segmentation',
+        throwErrors: true,
+      });
 
-    const displaySetInstanceUIDs = await createReportAsync({
-      servicesManager,
-      getReport: () =>
-        commandsManager.runCommand('storeSegmentation', {
-          segmentationId,
-          dataSource: datasources[0],
-        }),
-      reportType: 'Segmentation',
-    });
+      dispatch({ payload: { [segmentationId]: SAVED_STATUS_ICON.SAVED } });
+    } catch (error) {
+      console.warn(error.message);
+      dispatch({ payload: { [segmentationId]: SAVED_STATUS_ICON.ERROR } });
+    }
 
     // Show the exported report in the active viewport as read only (similar to SR)
     if (displaySetInstanceUIDs) {
@@ -242,13 +372,18 @@ export default function PanelSegmentation({
     });
   };
 
+  const params = new URLSearchParams(window.location.search);
+  const showAddSegmentation = params.get('disableAddSegmentation') !== 'true';
+
   return (
     <>
       <div className="ohif-scrollbar flex min-h-0 flex-auto select-none flex-col justify-between overflow-auto">
         <SegmentationGroupTable
           title={t('Segmentations')}
           segmentations={segmentations}
+          savedStatusStates={savedStatusStates}
           disableEditing={configuration.disableEditing}
+          showAddSegmentation={showAddSegmentation}
           activeSegmentationId={selectedSegmentationId || ''}
           onSegmentationAdd={onSegmentationAdd}
           onSegmentationClick={onSegmentationClick}
@@ -292,6 +427,7 @@ export default function PanelSegmentation({
           setFillAlphaInactive={value =>
             _setSegmentationConfiguration(selectedSegmentationId, 'fillAlphaInactive', value)
           }
+          CropDisplayAreaService={CropDisplayAreaService}
         />
       </div>
     </>