@cornerstonejs/tools 1.53.0 → 1.54.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cornerstonejs/tools",
-  "version": "1.53.0",
+  "version": "1.54.1",
   "description": "Cornerstone3D Tools",
   "main": "src/index.ts",
   "types": "dist/types/index.d.ts",
@@ -29,12 +29,14 @@
     "webpack:watch": "webpack --mode development --progress --watch  --config ./.webpack/webpack.dev.js"
   },
   "dependencies": {
-    "@cornerstonejs/core": "^1.53.0",
+    "@cornerstonejs/core": "^1.54.1",
+    "@icr/polyseg-wasm": "0.4.0",
     "comlink": "^4.4.1",
     "lodash.clonedeep": "4.5.0",
     "lodash.get": "^4.4.2"
   },
   "peerDependencies": {
+    "@icr/polyseg-wasm": "0.4.0",
     "@kitware/vtk.js": "29.3.0",
     "@types/d3-array": "^3.0.4",
     "@types/d3-interpolate": "^3.0.1",
@@ -53,5 +55,5 @@
     "type": "individual",
     "url": "https://ohif.org/donate"
   },
-  "gitHead": "881872ffe29341443f91cead0b810871a6a1929b"
+  "gitHead": "3cea03f5216a14ff0e24802a393fab97ba7e0b7c"
 }

package/src/enums/WorkerTypes.ts

@@ -0,0 +1,16 @@
+/**
+ * Worker Types are used to define the types the worker that is getting performed
+ */
+enum ChangeTypes {
+  POLYSEG_CONTOUR_TO_LABELMAP = 'polySeg/convertContourToVolumeLabelmap',
+
+  POLYSEG_SURFACE_TO_LABELMAP = 'polySeg/convertSurfacesToVolumeLabelmap',
+
+  POLYSEG_CONTOUR_TO_SURFACE = 'polySeg/convertContourToSurface',
+
+  POLYSEG_LABELMAP_TO_SURFACE = 'polySeg/convertLabelmapToSurface',
+
+  DISPLAY_TOOL_CLIP_SURFACE = 'displayTool/clipSurface',
+}
+
+export default ChangeTypes;

package/src/enums/index.js

@@ -6,6 +6,7 @@ import SegmentationRepresentations from './SegmentationRepresentations';
 import { Swipe } from './Touch';
 import StrategyCallbacks from './StrategyCallbacks';
 import ChangeTypes from './ChangeTypes';
+import WorkerTypes from './WorkerTypes';
 
 export {
   MouseBindings,
@@ -17,4 +18,5 @@ export {
   Swipe,
   StrategyCallbacks,
   ChangeTypes,
+  WorkerTypes,
 };

package/src/eventListeners/annotations/contourSegmentation/contourSegmentationCompleted.ts

@@ -11,9 +11,9 @@ import {
 } from '../../../utilities';
 import { getViewportIdsWithToolToRender } from '../../../utilities/viewportFilters';
 import {
-  getAnnotations,
   addAnnotation,
   removeAnnotation,
+  getAllAnnotations,
   getChildAnnotations,
   addChildAnnotation,
   clearParentAnnotation,
@@ -143,22 +143,15 @@ function getValidContourSegmentationAnnotations(
   }
 
   // Get all annotations and filter all contour segmentations locally
-  const toolName = undefined;
-  const annotationsGroups = getAnnotations(toolName, FrameOfReferenceUID);
-  const toolNames = Object.keys(annotationsGroups);
-
-  return toolNames.reduce((validAnnotations, toolName) => {
-    const toolAnnotations = annotationsGroups[toolName].filter(
-      (targetAnnotation) =>
-        targetAnnotation.annotationUID &&
-        targetAnnotation.annotationUID !== sourceAnnotationUID &&
-        contourSegUtils.isContourSegmentationAnnotation(targetAnnotation) &&
-        contourSegUtils.areSameSegment(targetAnnotation, sourceAnnotation) &&
-        contourUtils.areCoplanarContours(targetAnnotation, sourceAnnotation)
-    );
-
-    return validAnnotations.concat(toolAnnotations);
-  }, []);
+  const allAnnotations = getAllAnnotations();
+  return allAnnotations.filter(
+    (targetAnnotation) =>
+      targetAnnotation.annotationUID &&
+      targetAnnotation.annotationUID !== sourceAnnotationUID &&
+      contourSegUtils.isContourSegmentationAnnotation(targetAnnotation) &&
+      contourSegUtils.areSameSegment(targetAnnotation, sourceAnnotation) &&
+      contourUtils.areCoplanarContours(targetAnnotation, sourceAnnotation)
+  ) as ContourSegmentationAnnotation[];
 }
 
 function findIntersectingContour(

package/src/eventListeners/segmentation/imageChangeEventListener.ts

@@ -93,14 +93,13 @@ function _imageChangeEventListener(evt) {
       representation.segmentationId
     );
 
-    if (!segmentation) {
+    if (!segmentation || !segmentation.representationData?.LABELMAP) {
       return;
     }
 
-    const labelmapData =
-      segmentation.representationData[Representations.Labelmap];
+    const labelmapData = segmentation.representationData.LABELMAP;
 
-    if (isVolumeSegmentation(labelmapData)) {
+    if (isVolumeSegmentation(labelmapData, viewport)) {
       return;
     }
 

package/src/eventListeners/segmentation/labelmap/onLabelmapSegmentationDataModified.ts

@@ -2,16 +2,15 @@ import {
   cache,
   getEnabledElementByIds,
   utilities as csUtils,
+  VolumeViewport,
 } from '@cornerstonejs/core';
 
-import SegmentationRepresentations from '../../../enums/SegmentationRepresentations';
 import * as SegmentationState from '../../../stateManagement/segmentation/segmentationState';
 import { SegmentationDataModifiedEventType } from '../../../types/EventTypes';
 import {
   LabelmapSegmentationDataStack,
   LabelmapSegmentationDataVolume,
 } from '../../../types/LabelmapTypes';
-import { isVolumeSegmentation } from '../../../tools/segmentation/strategies/utils/stackVolumeCheck';
 import { getToolGroup } from '../../../store/ToolGroupManager';
 
 /** A callback function that is called when the segmentation data is modified which
@@ -28,90 +27,119 @@ const onLabelmapSegmentationDataModified = function (
   const toolGroupIds =
     SegmentationState.getToolGroupIdsWithSegmentation(segmentationId);
 
-  if (type !== SegmentationRepresentations.Labelmap) {
-    throw new Error(
-      `onLabelmapSegmentationDataModifiedListener: representationType ${type} not supported yet`
-    );
-  }
+  const labelmapRepresentationData = representationData[type];
 
-  if (isVolumeSegmentation(representationData[type])) {
+  if ('volumeId' in labelmapRepresentationData) {
     // get the volume from cache, we need the openGLTexture to be updated to GPU
-    const segmentationVolume = cache.getVolume(
-      (representationData[type] as LabelmapSegmentationDataVolume).volumeId
-    );
-
-    if (!segmentationVolume) {
-      console.warn('segmentation not found in cache');
-      return;
-    }
-
-    const { imageData, vtkOpenGLTexture } = segmentationVolume;
-
-    // Update the texture for the volume in the GPU
-    let slicesToUpdate;
-    if (modifiedSlicesToUse && Array.isArray(modifiedSlicesToUse)) {
-      slicesToUpdate = modifiedSlicesToUse;
-    } else {
-      const numSlices = imageData.getDimensions()[2];
-      slicesToUpdate = [...Array(numSlices).keys()];
-    }
-
-    slicesToUpdate.forEach((i) => {
-      vtkOpenGLTexture.setUpdatedFrame(i);
+    performVolumeLabelmapUpdate({
+      modifiedSlicesToUse,
+      representationData,
+      type,
     });
+  }
 
-    // Trigger modified on the imageData to update the image
-    imageData.modified();
-  } else {
-    toolGroupIds.forEach((toolGroupId) => {
-      const toolGroupSegmentationRepresentations =
-        SegmentationState.getSegmentationRepresentations(toolGroupId);
+  if ('imageIdReferenceMap' in labelmapRepresentationData) {
+    // get the stack from cache, we need the imageData to be updated to GPU
+    performStackLabelmapUpdate({
+      toolGroupIds,
+      segmentationId,
+      representationData,
+      type,
+    });
+  }
+};
+
+function performVolumeLabelmapUpdate({
+  modifiedSlicesToUse,
+  representationData,
+  type,
+}) {
+  const segmentationVolume = cache.getVolume(
+    (representationData[type] as LabelmapSegmentationDataVolume).volumeId
+  );
+
+  if (!segmentationVolume) {
+    console.warn('segmentation not found in cache');
+    return;
+  }
 
-      const toolGroup = getToolGroup(toolGroupId);
-      const viewportsInfo = toolGroup.getViewportsInfo();
+  const { imageData, vtkOpenGLTexture } = segmentationVolume;
 
-      toolGroupSegmentationRepresentations.forEach((representation) => {
-        if (representation.segmentationId !== segmentationId) {
+  // Update the texture for the volume in the GPU
+  let slicesToUpdate;
+  if (modifiedSlicesToUse && Array.isArray(modifiedSlicesToUse)) {
+    slicesToUpdate = modifiedSlicesToUse;
+  } else {
+    const numSlices = imageData.getDimensions()[2];
+    slicesToUpdate = [...Array(numSlices).keys()];
+  }
+
+  slicesToUpdate.forEach((i) => {
+    vtkOpenGLTexture.setUpdatedFrame(i);
+  });
+
+  // Trigger modified on the imageData to update the image
+  imageData.modified();
+}
+
+function performStackLabelmapUpdate({
+  toolGroupIds,
+  segmentationId,
+  representationData,
+  type,
+}) {
+  toolGroupIds.forEach((toolGroupId) => {
+    const toolGroupSegmentationRepresentations =
+      SegmentationState.getSegmentationRepresentations(toolGroupId);
+
+    const toolGroup = getToolGroup(toolGroupId);
+    const viewportsInfo = toolGroup.getViewportsInfo();
+
+    toolGroupSegmentationRepresentations.forEach((representation) => {
+      if (representation.segmentationId !== segmentationId) {
+        return;
+      }
+
+      viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
+        const viewport = getEnabledElementByIds(
+          viewportId,
+          renderingEngineId
+        ).viewport;
+
+        if (viewport instanceof VolumeViewport) {
           return;
         }
 
-        viewportsInfo.forEach(({ viewportId, renderingEngineId }) => {
-          const viewport = getEnabledElementByIds(
-            viewportId,
-            renderingEngineId
-          ).viewport;
-
-          const actorEntry = viewport.getActor(
-            representation.segmentationRepresentationUID
-          );
+        const actorEntry = viewport.getActor(
+          representation.segmentationRepresentationUID
+        );
 
-          if (!actorEntry) {
-            return;
-          }
+        if (!actorEntry) {
+          return;
+        }
 
-          const currentImageId = viewport.getCurrentImageId();
+        const currentImageId = viewport.getCurrentImageId();
 
-          const segImageData = actorEntry.actor.getMapper().getInputData();
+        const segImageData = actorEntry.actor.getMapper().getInputData();
 
-          const { imageIdReferenceMap } = representationData[
-            type
-          ] as LabelmapSegmentationDataStack;
+        const { imageIdReferenceMap } = representationData[
+          type
+        ] as LabelmapSegmentationDataStack;
 
-          const currentSegmentationImageId =
-            imageIdReferenceMap.get(currentImageId);
+        const currentSegmentationImageId =
+          imageIdReferenceMap.get(currentImageId);
 
-          const segmentationImage = cache.getImage(currentSegmentationImageId);
-          segImageData.modified();
+        const segmentationImage = cache.getImage(currentSegmentationImageId);
+        segImageData.modified();
 
-          // update the cache with the new image data
-          csUtils.updateVTKImageDataWithCornerstoneImage(
-            segImageData,
-            segmentationImage
-          );
-        });
+        // update the cache with the new image data
+        csUtils.updateVTKImageDataWithCornerstoneImage(
+          segImageData,
+          segmentationImage
+        );
       });
     });
-  }
-};
+  });
+}
 
 export default onLabelmapSegmentationDataModified;

package/src/stateManagement/annotation/FrameOfReferenceSpecificAnnotationManager.ts

@@ -365,6 +365,17 @@ class FrameOfReferenceSpecificAnnotationManager implements IAnnotationManager {
     }
   };
 
+  /**
+   * return all annotations as a single array
+   */
+  getAllAnnotations = (): Annotations => {
+    return Object.values(this.annotations)
+      .map((frameOfReferenceSpecificAnnotations) =>
+        Object.values(frameOfReferenceSpecificAnnotations)
+      )
+      .flat(2);
+  };
+
   /**
    * A function that returns the number of all annotations in the annotation state
    *

package/src/stateManagement/annotation/annotationState.ts

@@ -59,6 +59,11 @@ function getAnnotations(
   return manager.getAnnotations(groupKey, toolName) as Annotations;
 }
 
+function getAllAnnotations(): Annotations {
+  const manager = getAnnotationManager();
+  return manager.getAllAnnotations();
+}
+
 /**
  * Removes the association between the annotation passed as parameter and its
  * parent in case it has one (eg: contour holes).
@@ -266,6 +271,7 @@ function invalidateAnnotation(annotation: Annotation): void {
 }
 
 export {
+  getAllAnnotations,
   getAnnotations,
   getParentAnnotation,
   getChildAnnotations,

package/src/stateManagement/segmentation/SegmentationStateManager.ts

@@ -5,6 +5,7 @@ import { utilities as csUtils } from '@cornerstonejs/core';
 import { SegmentationRepresentations } from '../../enums';
 import getDefaultContourConfig from '../../tools/displayTools/Contour/contourConfig';
 import getDefaultLabelmapConfig from '../../tools/displayTools/Labelmap/labelmapConfig';
+import getDefaultSurfaceConfig from '../../tools/displayTools/Surface/surfaceConfig';
 import type {
   RepresentationConfig,
   Segmentation,
@@ -19,12 +20,14 @@ import type {
 // Note: when we get other representations, we should set their default representations too.
 const defaultLabelmapConfig = getDefaultLabelmapConfig();
 const defaultContourConfig = getDefaultContourConfig();
+const defaultSurfaceConfig = getDefaultSurfaceConfig();
 
 const newGlobalConfig: SegmentationRepresentationConfig = {
   renderInactiveSegmentations: true,
   representations: {
     [SegmentationRepresentations.Labelmap]: defaultLabelmapConfig,
     [SegmentationRepresentations.Contour]: defaultContourConfig,
+    [SegmentationRepresentations.Surface]: defaultSurfaceConfig,
   },
 };
 
@@ -210,7 +213,7 @@ export default class SegmentationStateManager {
     const toolGroupSegRepresentations =
       this.getSegmentationRepresentations(toolGroupId);
 
-    const segmentationData = toolGroupSegRepresentations.find(
+    const segmentationData = toolGroupSegRepresentations?.find(
       (representation) =>
         representation.segmentationRepresentationUID ===
         segmentationRepresentationUID

package/src/stateManagement/segmentation/addRepresentationData.ts

@@ -0,0 +1,71 @@
+import { LabelmapSegmentationData } from '../../types/LabelmapTypes';
+import { ContourSegmentationData } from '../../types/ContourTypes';
+import { SurfaceSegmentationData } from '../../types/SurfaceTypes';
+import { getSegmentation } from './segmentationState';
+import SegmentationRepresentations from '../../enums/SegmentationRepresentations';
+
+type SegmentationData =
+  | LabelmapSegmentationData
+  | ContourSegmentationData
+  | SurfaceSegmentationData;
+
+type AddRepresentationData = {
+  segmentationId: string;
+  type: SegmentationRepresentations;
+  data: SegmentationData;
+};
+
+/**
+ * This will add representation data to the segmentation, for rendering.
+ * Each segmentation can have multiple representation data, for example
+ * labelmap, contour and surface representation data. For each representation
+ * the relevant data should be provided, for instance for the labelmap
+ * representation the volumeId should be provided, for contour the contour data
+ * which includes geometryIds of the contour sets, and for surface the surface
+ * data which includes geometryId of the points and cells.
+ *
+ * Note: if the representation data already exists for the segmentation, it will
+ * be overwritten.
+ *
+ * @param segmentationId - id of the segmentation
+ * @param representationData - representation data to add, it can be either
+ * labelmap, contour or surface representation data.
+ */
+function addRepresentationData({
+  segmentationId,
+  type,
+  data,
+}: AddRepresentationData) {
+  const segmentation = getSegmentation(segmentationId);
+
+  if (segmentation.representationData[type]) {
+    console.warn(
+      `Representation data of type ${type} already exists for segmentation ${segmentationId}, overwriting it.`
+    );
+
+    // update the representation data class
+  }
+
+  switch (type) {
+    case SegmentationRepresentations.Labelmap:
+      if (data) {
+        segmentation.representationData[type] =
+          data as LabelmapSegmentationData;
+      }
+      break;
+    case SegmentationRepresentations.Contour:
+      if (data) {
+        segmentation.representationData[type] = data as ContourSegmentationData;
+      }
+      break;
+    case SegmentationRepresentations.Surface:
+      if (data) {
+        segmentation.representationData[type] = data as SurfaceSegmentationData;
+      }
+      break;
+    default:
+      throw new Error(`Invalid representation type ${type}`);
+  }
+}
+
+export default addRepresentationData;

package/src/stateManagement/segmentation/addSegmentationRepresentation.ts

@@ -1,9 +1,10 @@
-import { utilities } from '@cornerstonejs/core';
+import { getRenderingEngine, utilities } from '@cornerstonejs/core';
 import type { Types } from '@cornerstonejs/core';
 import {
   SegmentationRepresentationConfig,
   RepresentationPublicInput,
   ToolGroupSpecificRepresentation,
+  RepresentationPublicInputOptions,
 } from '../../types/SegmentationStateTypes';
 import * as SegmentationConfig from './config/segmentationConfig';
 import {
@@ -13,32 +14,27 @@ import {
 } from './segmentationState';
 import { getRepresentationSpecificConfig } from './helpers/getRepresentationSpecificConfig';
 import CORNERSTONE_COLOR_LUT from '../../constants/COLOR_LUT';
+import { getToolGroup } from '../../store/ToolGroupManager';
+import { triggerAnnotationRenderForViewportIds } from '../../utilities';
+import { SegmentationRepresentations } from '../../enums';
 
 async function addSegmentationRepresentation(
   toolGroupId: string,
   representationInput: RepresentationPublicInput,
   toolGroupSpecificConfig?: SegmentationRepresentationConfig
 ): Promise<string> {
-  const { segmentationId, options = {} } = representationInput;
-  const segmentationRepresentationUID = utilities.uuidv4();
+  const { segmentationId, options = {} as RepresentationPublicInputOptions } =
+    representationInput;
+
+  const segmentationRepresentationUID =
+    representationInput.options?.segmentationRepresentationUID ||
+    utilities.uuidv4();
 
   // Todo: make segmentsHidden also an option that can get passed by
   // the user
   const segmentsHidden = new Set() as Set<number>;
 
-  const colorLUTOrIndexInput = options.colorLUTOrIndex;
-  let colorLUTIndexToUse;
-
-  if (typeof colorLUTOrIndexInput === 'number') {
-    colorLUTIndexToUse = colorLUTOrIndexInput;
-  } else {
-    const nextIndex = getNextColorLUTIndex();
-    const colorLUTToAdd = Array.isArray(colorLUTOrIndexInput)
-      ? colorLUTOrIndexInput
-      : CORNERSTONE_COLOR_LUT;
-    addColorLUT(colorLUTToAdd as Types.ColorLUT, nextIndex);
-    colorLUTIndexToUse = nextIndex;
-  }
+  const colorLUTIndexToUse = getColorLUTIndex(options);
 
   const toolGroupSpecificRepresentation: ToolGroupSpecificRepresentation = {
     segmentationId,
@@ -50,6 +46,7 @@ async function addSegmentationRepresentation(
     segmentationRepresentationSpecificConfig: {},
     segmentSpecificConfig: {},
     config: getRepresentationSpecificConfig(representationInput),
+    polySeg: options.polySeg,
   };
 
   // Update the toolGroup specific configuration
@@ -79,7 +76,33 @@ async function addSegmentationRepresentation(
     toolGroupSpecificRepresentation
   );
 
+  if (representationInput.type === SegmentationRepresentations.Contour) {
+    getToolGroup(toolGroupId)
+      .getViewportsInfo()
+      .forEach(({ viewportId, renderingEngineId }) => {
+        const renderingEngine = getRenderingEngine(renderingEngineId);
+        triggerAnnotationRenderForViewportIds(renderingEngine, [viewportId]);
+      });
+  }
+
   return segmentationRepresentationUID;
 }
 
+function getColorLUTIndex(options = {} as RepresentationPublicInputOptions) {
+  const colorLUTOrIndexInput = options.colorLUTOrIndex;
+  let colorLUTIndexToUse;
+
+  if (typeof colorLUTOrIndexInput === 'number') {
+    colorLUTIndexToUse = colorLUTOrIndexInput;
+  } else {
+    const nextIndex = getNextColorLUTIndex();
+    const colorLUTToAdd = Array.isArray(colorLUTOrIndexInput)
+      ? colorLUTOrIndexInput
+      : CORNERSTONE_COLOR_LUT;
+    addColorLUT(colorLUTToAdd as Types.ColorLUT, nextIndex);
+    colorLUTIndexToUse = nextIndex;
+  }
+  return colorLUTIndexToUse;
+}
+
 export { addSegmentationRepresentation };

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