@cornerstonejs/tools 1.52.0 → 1.54.0

package/src/stateManagement/segmentation/config/segmentationVisibility.ts

@@ -1,66 +1,8 @@
-import { cache, Types } from '@cornerstonejs/core';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import { getSegmentationRepresentations } from '../../../stateManagement/segmentation/segmentationState';
 import { ToolGroupSpecificRepresentation } from '../../../types/SegmentationStateTypes';
+import { getUniqueSegmentIndices } from '../../../utilities/segmentation';
 import { triggerSegmentationRepresentationModified } from '../triggerSegmentationEvents';
-import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
-import { isVolumeSegmentation } from '../../../tools/segmentation/strategies/utils/stackVolumeCheck';
-
-function getUniqueSegmentIndices(segmentationId) {
-  const segmentation = SegmentationState.getSegmentation(segmentationId);
-
-  if (segmentation.type === SegmentationRepresentations.Labelmap) {
-    const labelmapData =
-      segmentation.representationData[SegmentationRepresentations.Labelmap];
-
-    const keySet = {};
-
-    if (isVolumeSegmentation(labelmapData)) {
-      const volume = cache.getVolume(segmentationId);
-      const scalarData = volume.getScalarData();
-
-      for (let i = 0; i < scalarData.length; i++) {
-        const segmentIndex = scalarData[i];
-        if (segmentIndex !== 0 && !keySet[segmentIndex]) {
-          keySet[segmentIndex] = true;
-        }
-      }
-    } else {
-      labelmapData.imageIdReferenceMap.forEach((segmentationImageId) => {
-        const image = cache.getImage(segmentationImageId);
-        const scalarData = image.getPixelData();
-
-        for (let i = 0; i < scalarData.length; i++) {
-          const segmentIndex = scalarData[i];
-          if (segmentIndex !== 0 && !keySet[segmentIndex]) {
-            keySet[segmentIndex] = true;
-          }
-        }
-      });
-    }
-
-    return Object.keys(keySet).map((it) => parseInt(it, 10));
-  } else if (segmentation.type === SegmentationRepresentations.Contour) {
-    const annotationUIDsMap =
-      segmentation.representationData.CONTOUR?.annotationUIDsMap;
-
-    const indices = new Set(annotationUIDsMap.keys());
-    const geometryIds = segmentation.representationData.CONTOUR?.geometryIds;
-
-    if (!geometryIds) {
-      throw new Error(
-        `No geometryIds found for segmentationId ${segmentationId}`
-      );
-    }
-
-    geometryIds.forEach((geometryId) => {
-      const geometry = cache.getGeometry(geometryId) as Types.IGeometry;
-      indices.add((geometry.data as Types.IContourSet).getSegmentIndex());
-    });
-
-    return Array.from(indices.values()).sort();
-  }
-}
 
 /**
  * Set the visibility of a segmentation representation for a given tool group. It fires

package/src/stateManagement/segmentation/convertStackToVolumeSegmentation.ts

@@ -2,15 +2,43 @@ import {
   volumeLoader,
   utilities as csUtils,
   eventTarget,
+  cache,
 } from '@cornerstonejs/core';
 import { Events, SegmentationRepresentations } from '../../enums';
-import addSegmentations from './addSegmentations';
 import addSegmentationRepresentations from './addSegmentationRepresentations';
 import { triggerSegmentationRender } from '../../utilities/segmentation';
-import { getSegmentation, removeSegmentation } from './segmentationState';
+import { getSegmentation } from './segmentationState';
 import { LabelmapSegmentationDataStack } from '../../types/LabelmapTypes';
 import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
 
+async function computeVolumeSegmentationFromStack({
+  imageIdReferenceMap,
+  options,
+}: {
+  imageIdReferenceMap: Map<string, string>;
+  options?: {
+    volumeId?: string;
+  };
+}): Promise<{ volumeId: string }> {
+  const segmentationImageIds = Array.from(imageIdReferenceMap.values());
+
+  const additionalDetails = {
+    imageIdReferenceMap,
+  };
+
+  const volumeId = options?.volumeId ?? csUtils.uuidv4();
+
+  await volumeLoader.createAndCacheVolumeFromImages(
+    volumeId,
+    segmentationImageIds,
+    {
+      additionalDetails,
+    }
+  );
+
+  return { volumeId };
+}
+
 /**
  * Converts a stack-based segmentation to a volume-based segmentation.
  *
@@ -32,57 +60,66 @@ async function convertStackToVolumeSegmentation({
   options?: {
     toolGroupId: string;
     volumeId?: string;
-    newSegmentationId?: string;
     removeOriginal?: boolean;
   };
 }): Promise<void> {
   const segmentation = getSegmentation(segmentationId);
-  const { toolGroupId } = options;
+
   const data = segmentation.representationData
     .LABELMAP as LabelmapSegmentationDataStack;
 
-  const imageIdReferenceMap = data.imageIdReferenceMap;
+  const { volumeId } = await computeVolumeSegmentationFromStack({
+    imageIdReferenceMap: data.imageIdReferenceMap,
+    options,
+  });
 
-  // Get the imageIds from the imageIdReferenceMap
-  const segmentationImageIds = Array.from(imageIdReferenceMap.values());
+  await updateSegmentationState({
+    segmentationId,
+    toolGroupId: options.toolGroupId,
+    options,
+    volumeId,
+  });
+}
 
-  const additionalDetails = {
-    imageIdReferenceMap,
+// This function is responsible for updating the segmentation state
+async function updateSegmentationState({
+  segmentationId,
+  toolGroupId,
+  volumeId,
+  options,
+}: {
+  segmentationId: string;
+  toolGroupId: string;
+  volumeId: string;
+  options?: {
+    removeOriginal?: boolean;
   };
+}): Promise<void> {
+  const segmentation = getSegmentation(segmentationId);
 
-  // Since segmentations are already cached and are not
-  // loaded like volumes, we can create a volume out of their images
-  const volumeId = options?.volumeId;
+  if (options?.removeOriginal) {
+    const data = segmentation.representationData
+      .LABELMAP as LabelmapSegmentationDataStack;
 
-  await volumeLoader.createAndCacheVolumeFromImages(
-    volumeId,
-    segmentationImageIds,
-    {
-      additionalDetails,
-    }
-  );
+    const imageIdReferenceMap = data.imageIdReferenceMap;
 
-  const newSegmentationId = options?.newSegmentationId ?? csUtils.uuidv4();
+    Array.from(imageIdReferenceMap.values()).forEach((imageId) => {
+      cache.removeImageLoadObject(imageId);
+    });
 
-  if (options?.removeOriginal ?? true) {
-    removeSegmentation(segmentationId);
+    segmentation.representationData.LABELMAP = {
+      volumeId,
+    };
+  } else {
+    segmentation.representationData.LABELMAP = {
+      ...segmentation.representationData.LABELMAP,
+      volumeId,
+    };
   }
 
-  await addSegmentations([
-    {
-      segmentationId: newSegmentationId,
-      representation: {
-        type: SegmentationRepresentations.Labelmap,
-        data: {
-          volumeId,
-        },
-      },
-    },
-  ]);
-
   await addSegmentationRepresentations(toolGroupId, [
     {
-      segmentationId: newSegmentationId,
+      segmentationId,
       type: SegmentationRepresentations.Labelmap,
     },
   ]);
@@ -91,8 +128,8 @@ async function convertStackToVolumeSegmentation({
   // Note: It is crucial to trigger the data modified event. This ensures that the
   // old texture is updated to the GPU, especially in scenarios where it may not be getting updated.
   eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () =>
-    triggerSegmentationDataModified(newSegmentationId)
+    triggerSegmentationDataModified(segmentationId)
   );
 }
 
-export { convertStackToVolumeSegmentation };
+export { convertStackToVolumeSegmentation, computeVolumeSegmentationFromStack };

package/src/stateManagement/segmentation/convertVolumeToStackSegmentation.ts

@@ -1,20 +1,92 @@
 import {
   Types,
   cache,
-  utilities as csUtils,
   eventTarget,
+  getRenderingEngines,
 } from '@cornerstonejs/core';
 import { Events, SegmentationRepresentations } from '../../enums';
-import addSegmentations from './addSegmentations';
 import addSegmentationRepresentations from './addSegmentationRepresentations';
 import {
   triggerSegmentationRender,
   createImageIdReferenceMap,
 } from '../../utilities/segmentation';
-import { getSegmentation, removeSegmentation } from './segmentationState';
+import { getSegmentation } from './segmentationState';
 import { LabelmapSegmentationDataVolume } from '../../types/LabelmapTypes';
 import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
 
+// This function is responsible for the conversion calculations
+export async function computeStackSegmentationFromVolume({
+  volumeId,
+}: {
+  volumeId: string;
+}): Promise<{ imageIdReferenceMap: Map<string, string> }> {
+  const segmentationVolume = cache.getVolume(volumeId) as Types.IImageVolume;
+
+  // we need to decache the segmentation Volume so that we use it
+  // for the conversion
+
+  // So here we have two scenarios that we need to handle:
+  // 1. the volume was derived from a stack and we need to decache it, this is easy
+  // since we just need purge the volume from the cache and those images will get
+  // their copy of the image back
+  // 2. It was actually a native volume and we need to decache it, this is a bit more
+  // complicated since then we need to decide on the imageIds for it to get
+  // decached to
+  const hasCachedImages = segmentationVolume.imageCacheOffsetMap.size > 0;
+  // Initialize the variable to hold the final result
+  let isAllImagesCached = false;
+
+  if (hasCachedImages) {
+    // Check if every imageId in the volume is in the _imageCache
+    isAllImagesCached = segmentationVolume.imageIds.every((imageId) =>
+      cache.getImage(imageId)
+    );
+  }
+
+  //Todo: This is a hack to get the rendering engine
+  const renderingEngine = getRenderingEngines()[0];
+  const volumeUsedInOtherViewports = renderingEngine
+    .getVolumeViewports()
+    .find((vp) => vp.hasVolumeId(volumeId));
+
+  segmentationVolume.decache(!volumeUsedInOtherViewports && isAllImagesCached);
+
+  const imageIdReferenceMap =
+    _getImageIdReferenceMapForStackSegmentation(segmentationVolume);
+
+  // check if the imageIds have been cache, if not we should actually copy
+
+  return { imageIdReferenceMap };
+}
+
+// Updated original function to call the new separate functions
+export async function convertVolumeToStackSegmentation({
+  segmentationId,
+  options,
+}: {
+  segmentationId: string;
+  options?: {
+    toolGroupId: string;
+    newSegmentationId?: string;
+    removeOriginal?: boolean;
+  };
+}): Promise<void> {
+  const segmentation = getSegmentation(segmentationId);
+
+  const data = segmentation.representationData
+    .LABELMAP as LabelmapSegmentationDataVolume;
+  const { imageIdReferenceMap } = await computeStackSegmentationFromVolume({
+    volumeId: data.volumeId,
+  });
+
+  await updateStackSegmentationState({
+    segmentationId,
+    toolGroupId: options.toolGroupId,
+    imageIdReferenceMap,
+    options,
+  });
+}
+
 /**
  * Converts a volume segmentation to a stack segmentation.
  *
@@ -27,60 +99,49 @@ import { triggerSegmentationDataModified } from './triggerSegmentationEvents';
  *
  * @returns A promise that resolves when the conversion is complete.
  */
-export async function convertVolumeToStackSegmentation({
+export async function updateStackSegmentationState({
   segmentationId,
+  toolGroupId,
+  imageIdReferenceMap,
   options,
 }: {
   segmentationId: string;
+  toolGroupId: string;
+  imageIdReferenceMap: Map<any, any>;
   options?: {
-    toolGroupId: string;
-    newSegmentationId?: string;
     removeOriginal?: boolean;
   };
 }): Promise<void> {
   const segmentation = getSegmentation(segmentationId);
 
-  const { toolGroupId } = options;
-  const data = segmentation.representationData
-    .LABELMAP as LabelmapSegmentationDataVolume;
-
-  const segmentationVolume = cache.getVolume(
-    data.volumeId
-  ) as Types.IImageVolume;
+  if (options?.removeOriginal) {
+    const data = segmentation.representationData
+      .LABELMAP as LabelmapSegmentationDataVolume;
 
-  const imageIdReferenceMap =
-    _getImageIdReferenceMapForStackSegmentation(segmentationVolume);
-
-  const newSegmentationId = options?.newSegmentationId ?? csUtils.uuidv4();
+    if (cache.getVolume(data.volumeId)) {
+      cache.removeVolumeLoadObject(data.volumeId);
+    }
 
-  if (options?.removeOriginal ?? true) {
-    removeSegmentation(segmentationId);
+    segmentation.representationData.LABELMAP = {
+      imageIdReferenceMap,
+    };
+  } else {
+    segmentation.representationData.LABELMAP = {
+      ...segmentation.representationData.LABELMAP,
+      imageIdReferenceMap,
+    };
   }
 
-  await addSegmentations([
-    {
-      segmentationId: newSegmentationId,
-      representation: {
-        type: SegmentationRepresentations.Labelmap,
-        data: {
-          imageIdReferenceMap,
-        },
-      },
-    },
-  ]);
-  // Add the segmentation representation to the toolgroup
   await addSegmentationRepresentations(toolGroupId, [
     {
-      segmentationId: newSegmentationId,
+      segmentationId,
       type: SegmentationRepresentations.Labelmap,
     },
   ]);
 
   triggerSegmentationRender(toolGroupId);
-  // Note: It is crucial to trigger the data modified event. This ensures that the
-  // old texture is updated to the GPU, especially in scenarios where it may not be getting updated.
   eventTarget.addEventListenerOnce(Events.SEGMENTATION_RENDERED, () =>
-    triggerSegmentationDataModified(newSegmentationId)
+    triggerSegmentationDataModified(segmentationId)
   );
 }
 
@@ -91,7 +152,6 @@ function _getImageIdReferenceMapForStackSegmentation(
   // segmentation converted from stack segmentation, there will be segmentationImageIds
   // otherwise, if it is empty volume segmentation derived from
   // a volume that is not a stack, there will be no segmentationImageIds
-  const segmentationImageIds = segmentationVolume.imageIds;
 
   if (segmentationVolume.additionalDetails?.imageIdReferenceMap) {
     // this means the segmentation volume is derived from a stack segmentation
@@ -104,8 +164,12 @@ function _getImageIdReferenceMapForStackSegmentation(
     // this means the segmentation volume is derived from a stack segmentation
     // and we can use the referencedImageIds from the segmentationVolume
     const referencedImageIds = segmentationVolume.referencedImageIds;
+    const segmentationImageIds = segmentationVolume.imageIds;
 
-    return createImageIdReferenceMap(referencedImageIds, segmentationImageIds);
+    return createImageIdReferenceMap(
+      referencedImageIds,
+      [...segmentationImageIds].reverse()
+    );
   } else {
     // check if the segmentation volume is derived from another volume and
     // whether if that volume has imageIds
@@ -147,7 +211,7 @@ function _getImageIdReferenceMapForStackSegmentation(
 
     return createImageIdReferenceMap(
       referencedImageIds,
-      segmentationImageIdsToUse
+      [...segmentationImageIdsToUse].reverse()
     );
   }
 }

package/src/stateManagement/segmentation/helpers/validateSegmentationInput.ts

@@ -1,31 +1,36 @@
 import * as Enums from '../../../enums';
 import { SegmentationPublicInput } from '../../../types/SegmentationStateTypes';
-import validateLabelmap from '../../../tools/displayTools/Labelmap/validateRepresentationData';
+import { validatePublic as validatePublicLabelmap } from '../../../tools/displayTools/Labelmap/validateLabelmap';
 
 /**
- * Checks if the segmentationInputArray is valid meaning it contains
- * correct representationProps for the representation type that is being used.
+ * Validates the given segmentationInputArray to ensure it contains
+ * appropriate representationProps for the representation type being used.
  *
  * @param segmentationInputArray - Array of segmentation inputs
+ * @throws If the segmentationInputArray is undefined or empty
+ * @throws If the segmentationInput.segmentationId is undefined
+ * @throws If the segmentationInput.representation is undefined
  * @internal
  */
 function validateSegmentationInput(
   segmentationInputArray: SegmentationPublicInput[]
 ): void {
-  if (!segmentationInputArray || !segmentationInputArray.length) {
-    throw new Error('The segmentationInputArray is undefined or empty array');
+  if (!segmentationInputArray || segmentationInputArray.length === 0) {
+    throw new Error(
+      'The segmentationInputArray is undefined or an empty array'
+    );
   }
 
   segmentationInputArray.forEach((segmentationInput) => {
     if (segmentationInput.segmentationId === undefined) {
       throw new Error(
-        'The segmentationInput.segmentationId is undefined, please provide a valid segmentationId'
+        'Undefined segmentationInput.segmentationId. Please provide a valid segmentationId'
       );
     }
 
     if (segmentationInput.representation === undefined) {
       throw new Error(
-        'The segmentationInput.representation is undefined, please provide a valid representation'
+        'Undefined segmentationInput.representation. Please provide a valid representation'
       );
     }
 
@@ -33,7 +38,7 @@ function validateSegmentationInput(
       segmentationInput.representation.type ===
       Enums.SegmentationRepresentations.Labelmap
     ) {
-      validateLabelmap(segmentationInput);
+      validatePublicLabelmap(segmentationInput);
     }
   });
 }

package/src/stateManagement/segmentation/index.ts

@@ -1,8 +1,10 @@
 import removeSegmentationsFromToolGroup from './removeSegmentationsFromToolGroup';
 import addSegmentations from './addSegmentations';
 import addSegmentationRepresentations from './addSegmentationRepresentations';
+import addRepresentationData from './addRepresentationData';
 import { convertStackToVolumeSegmentation } from './convertStackToVolumeSegmentation';
 import { convertVolumeToStackSegmentation } from './convertVolumeToStackSegmentation';
+// import { polySegManager } from './polySegManager';
 
 import * as activeSegmentation from './activeSegmentation';
 import * as segmentLocking from './segmentLocking';
@@ -10,17 +12,22 @@ import * as state from './segmentationState';
 import * as config from './config';
 import * as segmentIndex from './segmentIndex';
 import * as triggerSegmentationEvents from './triggerSegmentationEvents';
+import * as polySegManager from './polySeg';
 
 export {
-  state,
+  // functions
   addSegmentations,
-  activeSegmentation,
   addSegmentationRepresentations,
   removeSegmentationsFromToolGroup,
+  addRepresentationData,
+  // name spaces
+  state,
+  activeSegmentation,
   segmentLocking,
   config,
   segmentIndex,
   triggerSegmentationEvents,
   convertStackToVolumeSegmentation,
   convertVolumeToStackSegmentation,
+  polySegManager as polySeg,
 };

package/src/stateManagement/segmentation/polySeg/Contour/computeAndAddContourRepresentation.ts

@@ -0,0 +1,17 @@
+import { PolySegConversionOptions } from '../../../../types';
+
+/**
+ * Computes and adds the contour representation for a given segmentation.
+ *
+ * @param segmentationId - The ID of the segmentation.
+ * @param options - Optional parameters for computing the labelmap representation.
+ * @param options.segmentIndices - An array of segment indices to include in the labelmap representation.
+ * @param options.segmentationRepresentationUID - The UID of the segmentation representation.
+ * @returns A promise that resolves when the labelmap representation is computed and added.
+ */
+export function computeAndAddContourRepresentation(
+  segmentationId: string,
+  options: PolySegConversionOptions = {}
+) {
+  throw new Error('Not implemented yet');
+}

package/src/stateManagement/segmentation/polySeg/Labelmap/computeAndAddLabelmapRepresentation.ts

@@ -0,0 +1,25 @@
+import { SegmentationRepresentations } from '../../../../enums';
+import { computeAndAddRepresentation } from '../computeAndAddRepresentation';
+import { computeLabelmapData } from './labelmapComputationStrategies';
+import { PolySegConversionOptions } from '../../../../types';
+
+/**
+ * Computes and adds the labelmap representation for a given segmentation.
+ *
+ * @param segmentationId - The ID of the segmentation.
+ * @param options - Optional parameters for computing the labelmap representation.
+ * @param options.segmentIndices - An array of segment indices to include in the labelmap representation.
+ * @param options.segmentationRepresentationUID - The UID of the segmentation representation.
+ * @returns A promise that resolves when the labelmap representation is computed and added.
+ */
+export function computeAndAddLabelmapRepresentation(
+  segmentationId: string,
+  options: PolySegConversionOptions = {}
+) {
+  return computeAndAddRepresentation(
+    segmentationId,
+    SegmentationRepresentations.Labelmap,
+    () => computeLabelmapData(segmentationId, options),
+    () => {}
+  );
+}