Merge pull request #12 from gradienthealth/gradienthealth/Segmentatio…

…n-modifications

Gradienthealth/segmentation modifications

.github/workflows/deploy_ghpages.yml

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

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

@@ -18,6 +18,7 @@ import {
   getUpdatedViewportsForSegmentation,
   getTargetViewport,
 } from './utils/hydrationUtils';
+import generateLabelmaps2DFromImageIdMap from './utils/generateLabelmaps2DFromImageIdMap';
 
 const { datasetToBlob } = dcmjs.data;
 
@@ -77,17 +78,6 @@ const commandsModule = ({
       // Todo: add support for multiple display sets
       const displaySetInstanceUID = viewport.displaySetInstanceUIDs[0];
 
-      const displaySet = displaySetService.getDisplaySetByUID(displaySetInstanceUID);
-
-      if (!displaySet.isReconstructable) {
-        uiNotificationService.show({
-          title: 'Segmentation',
-          message: 'Segmentation is not supported for non-reconstructible displaysets yet',
-          type: 'error',
-        });
-        return;
-      }
-
       updateViewportsForSegmentationRendering({
         viewportId,
         servicesManager,
@@ -238,14 +228,23 @@ const commandsModule = ({
      */
     generateSegmentation: ({ segmentationId, options = {} }) => {
       const segmentation = cornerstoneToolsSegmentation.state.getSegmentation(segmentationId);
+      const segmentationLabelmapData = segmentation.representationData.LABELMAP;
+
+      let referencedImages, labelmapObj;
+      if (segmentation.representationData.LABELMAP.referencedVolumeId) {
+        const { referencedVolumeId } = segmentationLabelmapData;
 
-      const { referencedVolumeId } = segmentation.representationData.LABELMAP;
+        const segmentationVolume = cache.getVolume(segmentationId);
+        const referencedVolume = cache.getVolume(referencedVolumeId);
+        referencedImages = referencedVolume.getCornerstoneImages();
 
-      const segmentationVolume = cache.getVolume(segmentationId);
-      const referencedVolume = cache.getVolume(referencedVolumeId);
-      const referencedImages = referencedVolume.getCornerstoneImages();
+        labelmapObj = generateLabelMaps2DFrom3D(segmentationVolume);
+      } else {
+        const { imageIdReferenceMap } = segmentationLabelmapData;
 
-      const labelmapObj = generateLabelMaps2DFrom3D(segmentationVolume);
+        ({ referencedImages, labelmapObj } =
+          generateLabelmaps2DFromImageIdMap(imageIdReferenceMap));
+      }
 
       // Generate fake metadata as an example
       labelmapObj.metadata = [];

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

@@ -142,21 +142,24 @@ async function _loadSegments({ extensionManager, servicesManager, segDisplaySet,
     '@ohif/extension-cornerstone.utilityModule.common'
   );
 
-  const { segmentationService, uiNotificationService } = servicesManager.services;
+  const { segmentationService, uiNotificationService, displaySetService } =
+    servicesManager.services;
 
   const { dicomLoaderService } = utilityModule.exports;
   const arrayBuffer = await dicomLoaderService.findDicomDataPromise(segDisplaySet, null, headers);
 
-  const cachedReferencedVolume = cache.getVolume(segDisplaySet.referencedVolumeId);
+  const referencedDisplaySet = displaySetService.getDisplaySetByUID(
+    segDisplaySet.referencedDisplaySetInstanceUID
+  );
+  let imageIds;
 
-  if (!cachedReferencedVolume) {
-    throw new Error(
-      'Referenced Volume is missing for the SEG, and stack viewport SEG is not supported yet'
-    );
+  if (referencedDisplaySet.isReconstructable) {
+    const cachedReferencedVolume = cache.getVolume(segDisplaySet.referencedVolumeId);
+    imageIds = cachedReferencedVolume.imageIds || cachedReferencedVolume._imageIds;
+  } else {
+    imageIds = referencedDisplaySet.instances.map(instance => instance.imageId);
   }
 
-  const { imageIds } = cachedReferencedVolume;
-
   // Todo: what should be defaults here
   const tolerance = 0.001;
   const skipOverlapping = true;

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

@@ -47,6 +47,16 @@ export default function PanelSegmentation({
     };
   }, []);
 
+  const setSegmentationActive = segmentationId => {
+    const isSegmentationActive = segmentations.find(seg => seg.id === segmentationId)?.isActive;
+
+    if (isSegmentationActive) {
+      return;
+    }
+
+    segmentationService.setActiveSegmentationForToolGroup(segmentationId);
+  };
+
   const getToolGroupIds = segmentationId => {
     const toolGroupIds = segmentationService.getToolGroupIdsWithSegmentation(segmentationId);
 
@@ -62,10 +72,12 @@ export default function PanelSegmentation({
   };
 
   const onSegmentationDelete = (segmentationId: string) => {
+    setSegmentationActive(segmentationId);
     segmentationService.remove(segmentationId);
   };
 
   const onSegmentAdd = segmentationId => {
+    setSegmentationActive(segmentationId);
     segmentationService.addSegment(segmentationId);
   };
 
@@ -75,13 +87,13 @@ export default function PanelSegmentation({
     const toolGroupIds = getToolGroupIds(segmentationId);
 
     toolGroupIds.forEach(toolGroupId => {
-      // const toolGroupId =
       segmentationService.setActiveSegmentationForToolGroup(segmentationId, toolGroupId);
       segmentationService.jumpToSegmentCenter(segmentationId, segmentIndex, toolGroupId);
     });
   };
 
   const onSegmentEdit = (segmentationId, segmentIndex) => {
+    setSegmentationActive(segmentationId);
     const segmentation = segmentationService.getSegmentation(segmentationId);
 
     const segment = segmentation.segments[segmentIndex];
@@ -97,6 +109,7 @@ export default function PanelSegmentation({
   };
 
   const onSegmentationEdit = segmentationId => {
+    setSegmentationActive(segmentationId);
     const segmentation = segmentationService.getSegmentation(segmentationId);
     const { label } = segmentation;
 
@@ -117,6 +130,7 @@ export default function PanelSegmentation({
   };
 
   const onSegmentColorClick = (segmentationId, segmentIndex) => {
+    setSegmentationActive(segmentationId);
     const segmentation = segmentationService.getSegmentation(segmentationId);
 
     const segment = segmentation.segments[segmentIndex];
@@ -144,10 +158,12 @@ export default function PanelSegmentation({
   };
 
   const onSegmentDelete = (segmentationId, segmentIndex) => {
+    setSegmentationActive(segmentationId);
     segmentationService.removeSegment(segmentationId, segmentIndex);
   };
 
   const onToggleSegmentVisibility = (segmentationId, segmentIndex) => {
+    setSegmentationActive(segmentationId);
     const segmentation = segmentationService.getSegmentation(segmentationId);
     const segmentInfo = segmentation.segments[segmentIndex];
     const isVisible = !segmentInfo.isVisible;
@@ -165,10 +181,12 @@ export default function PanelSegmentation({
   };
 
   const onToggleSegmentLock = (segmentationId, segmentIndex) => {
+    setSegmentationActive(segmentationId);
     segmentationService.toggleSegmentLocked(segmentationId, segmentIndex);
   };
 
   const onToggleSegmentationVisibility = segmentationId => {
+    setSegmentationActive(segmentationId);
     segmentationService.toggleSegmentationVisibility(segmentationId);
   };
 
@@ -183,12 +201,14 @@ export default function PanelSegmentation({
   );
 
   const onSegmentationDownload = segmentationId => {
+    setSegmentationActive(segmentationId);
     commandsManager.runCommand('downloadSegmentation', {
       segmentationId,
     });
   };
 
   const storeSegmentation = async segmentationId => {
+    setSegmentationActive(segmentationId);
     const datasources = extensionManager.getActiveDataSource();
 
     const displaySetInstanceUIDs = await createReportAsync({
@@ -216,6 +236,7 @@ export default function PanelSegmentation({
   };
 
   const onSegmentationDownloadRTSS = segmentationId => {
+    setSegmentationActive(segmentationId);
     commandsManager.runCommand('downloadRTSS', {
       segmentationId,
     });

extensions/cornerstone-dicom-seg/src/utils/generateLabelmaps2DFromImageIdMap.ts

@@ -0,0 +1,44 @@
+import { cache } from '@cornerstonejs/core';
+
+const generateLabelmaps2DFromImageIdMap = imageIdReferenceMap => {
+  const labelmaps2D = [],
+    referencedImages = [],
+    segmentsOnLabelmap3D = new Set();
+  Array.from(imageIdReferenceMap.entries()).forEach((entry, index) => {
+    referencedImages.push(cache.getImage(entry[0]));
+
+    const segmentationImage = cache.getImage(entry[1]);
+    const { rows, columns } = segmentationImage;
+    const pixelData = segmentationImage.getPixelData();
+    const segmentsOnLabelmap = [];
+
+    for (let i = 0; i < pixelData.length; i++) {
+      const segment = pixelData[i];
+      if (!segmentsOnLabelmap.includes(segment) && segment !== 0) {
+        segmentsOnLabelmap.push(segment);
+      }
+    }
+
+    if (segmentsOnLabelmap.length) {
+      labelmaps2D[index] = {
+        segmentsOnLabelmap,
+        pixelData,
+        rows,
+        columns,
+      };
+
+      segmentsOnLabelmap.forEach(segmentIndex => {
+        segmentsOnLabelmap3D.add(segmentIndex);
+      });
+    }
+  });
+
+  const labelmapObj = {
+    segmentsOnLabelmap: Array.from(segmentsOnLabelmap3D),
+    labelmaps2D,
+  };
+
+  return { referencedImages, labelmapObj };
+};
+
+export default generateLabelmaps2DFromImageIdMap;

extensions/cornerstone-dicom-seg/src/utils/hydrationUtils.ts

@@ -1,4 +1,4 @@
-import { Enums, cache } from '@cornerstonejs/core';
+import { Enums, cache, eventTarget } from '@cornerstonejs/core';
 
 /**
  * Updates the viewports in preparation for rendering segmentations.
@@ -25,8 +25,12 @@ async function updateViewportsForSegmentationRendering({
   servicesManager: any;
   referencedDisplaySetInstanceUID?: string;
 }) {
-  const { cornerstoneViewportService, segmentationService, viewportGridService } =
-    servicesManager.services;
+  const {
+    cornerstoneViewportService,
+    segmentationService,
+    viewportGridService,
+    displaySetService,
+  } = servicesManager.services;
 
   const viewport = getTargetViewport({ viewportId, viewportGridService });
   const targetViewportId = viewport.viewportOptions.viewportId;
@@ -42,7 +46,7 @@ async function updateViewportsForSegmentationRendering({
 
   // create Segmentation callback which needs to be waited until
   // the volume is created (if coming from stack)
-  const createSegmentationForVolume = async () => {
+  const createSegmentation = async () => {
     const segmentationId = await loadFn();
     segmentationService.hydrateSegmentation(segmentationId);
   };
@@ -53,25 +57,38 @@ async function updateViewportsForSegmentationRendering({
     volumeId.includes(referencedDisplaySetInstanceUID)
   );
 
+  const referencedDisplaySet = displaySetService.getDisplaySetByUID(
+    referencedDisplaySetInstanceUID
+  );
+
   updatedViewports.forEach(async viewport => {
     viewport.viewportOptions = {
       ...viewport.viewportOptions,
-      viewportType: 'volume',
+      viewportType: referencedDisplaySet.isReconstructable ? 'volume' : 'stack',
       needsRerendering: true,
     };
     const viewportId = viewport.viewportId;
 
     const csViewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
     const prevCamera = csViewport.getCamera();
 
-    // only run the createSegmentationForVolume for the targetViewportId
+    // only run the createSegmentation for the targetViewportId when volume cache is available
     // since the rest will get handled by cornerstoneViewportService
     if (volumeExists && viewportId === targetViewportId) {
-      await createSegmentationForVolume();
+      await createSegmentation();
       return;
     }
+    // TODO: Read from _imageCache and create segmentation when applicable
+
+    const newViewportEvent = referencedDisplaySet.isReconstructable
+      ? Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME
+      : Enums.Events.STACK_VIEWPORT_NEW_STACK;
 
-    const createNewSegmentationWhenVolumeMounts = async evt => {
+    const eventTriggerer = referencedDisplaySet.isReconstructable
+      ? csViewport.element
+      : eventTarget;
+
+    const createNewSegmentationOnNewViewport = async evt => {
       const isTheActiveViewportVolumeMounted = evt.detail.volumeActors?.find(ac =>
         ac.uid.includes(referencedDisplaySetInstanceUID)
       );
@@ -82,25 +99,19 @@ async function updateViewportsForSegmentationRendering({
       const volumeViewport = cornerstoneViewportService.getCornerstoneViewport(viewportId);
       volumeViewport.setCamera(prevCamera);
 
-      volumeViewport.element.removeEventListener(
-        Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME,
-        createNewSegmentationWhenVolumeMounts
-      );
+      eventTriggerer.removeEventListener(newViewportEvent, createNewSegmentationOnNewViewport);
 
-      if (!isTheActiveViewportVolumeMounted) {
+      if (referencedDisplaySet.isReconstructable && !isTheActiveViewportVolumeMounted) {
         // it means it is one of those other updated viewports so just update the camera
         return;
       }
 
       if (viewportId === targetViewportId) {
-        await createSegmentationForVolume();
+        await createSegmentation();
       }
     };
 
-    csViewport.element.addEventListener(
-      Enums.Events.VOLUME_VIEWPORT_NEW_VOLUME,
-      createNewSegmentationWhenVolumeMounts
-    );
+    eventTriggerer.addEventListener(newViewportEvent, createNewSegmentationOnNewViewport);
   });
 
   // Set the displaySets for the viewports that require to be updated
@@ -174,7 +185,7 @@ function getUpdatedViewportsForSegmentation({
         viewportId,
         displaySetInstanceUIDs: viewport.displaySetInstanceUIDs,
         viewportOptions: {
-          viewportType: 'volume',
+          viewportType: viewport.viewportType,
           needsRerendering: true,
         },
       });

extensions/cornerstone-dicom-seg/src/viewports/OHIFCornerstoneSEGViewport.tsx

@@ -109,7 +109,7 @@ function OHIFCornerstoneSEGViewport(props) {
         {...props}
         displaySets={[referencedDisplaySet, segDisplaySet]}
         viewportOptions={{
-          viewportType: 'volume',
+          viewportType: referencedDisplaySet.isReconstructable ? 'volume' : 'stack',
           toolGroupId: toolGroupId,
           orientation: viewportOptions.orientation,
           viewportId: viewportOptions.viewportId,